def plot_hebbsom_links_distances_activations(X, Y, mdl, predictions, distances, activities, saveplot = False):
"""plot the hebbian link matrix, and all node distances and activities for all inputs"""
hebblink_log = np.log(mdl.hebblink_filter.T + 1.0)
fig = pl.figure()
fig.suptitle("Debugging SOM: hebbian links, distances, activities (%s)" % (mdl.__class__.__name__))
gs = gridspec.GridSpec(4, 1)
# pl.plot(X, Y, "k.", alpha=0.5)
# pl.subplot(numplots, 1, numplots-1)
ax1 = fig.add_subplot(gs[0])
ax1.set_title('hebbian associative links')
# im1 = ax1.imshow(mdl.hebblink_filter, interpolation="none", cmap=pl.get_cmap("gray"))
im1 = ax1.pcolormesh(hebblink_log, cmap=pl.get_cmap("gray"))
ax1.set_xlabel("in (e)")
ax1.set_ylabel("out (p)")
cbar = fig.colorbar(mappable = im1, ax=ax1, orientation="horizontal")
ax2 = fig.add_subplot(gs[1])
ax2.set_title('distances over time')
distarray = np.array(distances)
# print("distarray.shape", distarray.shape)
pcm = ax2.pcolormesh(distarray.T)
cbar = fig.colorbar(mappable = pcm, ax=ax2, orientation="horizontal")
# pl.subplot(numplots, 1, numplots)
ax3 = fig.add_subplot(gs[2])
ax3.set_title('activations propagated via hebbian links')
actarray = np.array(activities)
# print("actarray.shape", actarray.shape)
pcm = ax3.pcolormesh(actarray.T)
cbar = fig.colorbar(mappable = pcm, ax=ax3, orientation="horizontal")
ax4 = fig.add_subplot(gs[3])
ax4.set_title('flattened link table')
ax4.plot(hebblink_log.flatten())
# print("hebblink_log", hebblink_log)
if saveplot:
filename = "plot_hebbsom_links_distances_activations_%s.jpg" % (mdl.__class__.__name__,)
savefig(fig, filename)
fig.show()
python类colorbar()的实例源码
def _plot_features(out_dir, signal, sampling_rate, logmel, delta, delta_delta, specgram, filename):
try:
os.makedirs(out_dir)
except:
pass
sampling_interval = 1.0 / sampling_rate
times = np.arange(len(signal)) * sampling_interval
pylab.clf()
plt.rcParams['font.size'] = 18
pylab.figure(figsize=(len(signal) / 2000, 16))
ax1 = pylab.subplot(511)
pylab.plot(times, signal)
pylab.title("Waveform")
pylab.xlabel("Time [sec]")
pylab.ylabel("Amplitude")
pylab.xlim([0, len(signal) * sampling_interval])
ax2 = pylab.subplot(512)
specgram = np.log(specgram)
pylab.pcolormesh(np.arange(0, specgram.shape[0]), np.arange(0, specgram.shape[1]) * 8000 / specgram.shape[1], specgram.T, cmap=pylab.get_cmap("jet"))
pylab.title("Spectrogram")
pylab.xlabel("Time [sec]")
pylab.ylabel("Frequency [Hz]")
pylab.colorbar()
ax3 = pylab.subplot(513)
pylab.pcolormesh(np.arange(0, logmel.shape[0]), np.arange(1, 41), logmel.T, cmap=pylab.get_cmap("jet"))
pylab.title("Log mel filter bank features")
pylab.xlabel("Frame")
pylab.ylabel("Filter number")
pylab.colorbar()
ax4 = pylab.subplot(514)
pylab.pcolormesh(np.arange(0, delta.shape[0]), np.arange(1, 41), delta.T, cmap=pylab.get_cmap("jet"))
pylab.title("Deltas")
pylab.xlabel("Frame")
pylab.ylabel("Filter number")
pylab.colorbar()
ax5 = pylab.subplot(515)
pylab.pcolormesh(np.arange(0, delta_delta.shape[0]), np.arange(1, 41), delta_delta.T, cmap=pylab.get_cmap("jet"))
pylab.title("Delta-deltas")
pylab.xlabel("Frame")
pylab.ylabel("Filter number")
pylab.colorbar()
pylab.tight_layout()
pylab.savefig(os.path.join(out_dir, filename), bbox_inches="tight")
def make_mutual_info_plot(fn):
M.rcParams.update({'font.size': 11})
angleList = N.array([f/f.max() for f in read.extract_arr_from_h5(fn, "/history/angle", n=-1)])
mutualInfoList = read.extract_arr_from_h5(fn, "/history/mutual_info", n=-1)
quatList = read.extract_arr_from_h5(fn, "/history/quaternion", n=-1)
quatSwitchPos = N.where(quatList[:-1]-quatList[1:] != 0)[0] + 1
angsort = N.argsort(angleList[-1])
misort = N.argsort(mutualInfoList.mean(axis=0))
blkPositions = [0] + list(quatSwitchPos) + [-1]
for bp in range(len(blkPositions)-1):
(start, end) = (blkPositions[bp], blkPositions[bp+1])
curr_blk = angleList[start:end]
curr_blk2 = mutualInfoList[start:end] / N.log(quatSize[quatList[0]])
# curr_blk2 = mutualInfoList[start:end] / N.log(quatSize[quatList[bp]])
if len(curr_blk) == 0:
pass
else:
angsort = N.argsort(curr_blk[-1])
angleList[start:end] = curr_blk[:,angsort]
for n,l in enumerate(curr_blk2):
misort = N.argsort(l)
mutualInfoList[start+n] = l[misort]
P.ioff()
fig, ax = P.subplots(2, 1, sharex=True, figsize=(7, 10))
fig.subplots_adjust(hspace=0.1)
im0 = ax[0].imshow(angleList.transpose(), aspect='auto', interpolation=None, cmap=P.cm.OrRd)
ax[0].set_xlabel("iteration")
ax[0].set_ylabel("each pattern's most likely orientation\n(sorted by final orientation in each block)")
(e_min, e_max) = (1, len(angleList[0]))
e_int = 0.1*(e_max-e_min)
ax[0].plot([0, 0], [e_min, e_max], 'k-')
ax[0].text(1, e_max-e_int, "quat%d"%quatList[0], size=8, rotation=-0, ha='left', va='center', color='w', bbox=dict(boxstyle="larrow,pad=0.1",facecolor='0.1') )
for n,qs in enumerate(quatSwitchPos):
ax[0].plot([qs, qs], [e_min, e_max], 'k-')
ax[0].text(qs-1, e_max+(-n-1)*e_int, "quat%d"%quatList[qs], size=8, rotation=-0, ha='right', va='center', color='w', bbox=dict(boxstyle="rarrow,pad=0.1",facecolor='0.1') )
div0 = make_axes_locatable(ax[0])
cax0 = div0.append_axes("right", size="5%", pad=0.05)
cbar0 = P.colorbar(im0, cax=cax0)
ax[0].set_ylim(e_min, e_max)
ax[0].set_xlim(0, len(angleList)-1)
(e_min, e_max) = (1, len(mutualInfoList[0]))
e_int = 0.1*(e_max-e_min)
im1 = ax[1].imshow(mutualInfoList.transpose(), vmax=.2, aspect='auto', cmap=P.cm.YlGnBu)
ax[1].set_xlabel("iteration")
ax[1].set_ylabel("average mutual-information per dataset\n(sorted by average information)")
ax[1].plot([0, 0], [e_min, e_max], 'k-')
ax[1].text(1, e_max-e_int, "quat%d"%quatList[0], size=8, rotation=-0, ha='left', va='center', color='w', bbox=dict(boxstyle="larrow,pad=0.1",facecolor='0.1') )
for n,qs in enumerate(quatSwitchPos):
ax[1].plot([qs, qs], [e_min, e_max], 'k-')
ax[1].text(qs-1, e_max+(-n-1)*e_int, "quat%d"%quatList[qs], size=8, rotation=-0, ha='right', va='center', color='w', bbox=dict(boxstyle="rarrow,pad=0.1",facecolor='0.1') )
div1 = make_axes_locatable(ax[1])
cax1 = div1.append_axes("right", size="5%", pad=0.05)
cbar1 = P.colorbar(im1, cax=cax1)
ax[1].set_ylim(e_min, e_max)
ax[1].set_xlim(0, len(mutualInfoList)-1)
img_name = "mutual_info_plot.pdf"
P.savefig(img_name, bbox_inches='tight')
print("Image has been saved as %s" % img_name)
P.close(fig)
def densityPlot(targ_ra, targ_dec, data, iso, g_radius, nbhd, type):
"""Stellar density plot"""
mag_g = data[mag_g_dred_flag]
mag_r = data[mag_r_dred_flag]
if type == 'stars':
filter = star_filter(data)
plt.title('Stellar Density')
elif type == 'galaxies':
filter = galaxy_filter(data)
plt.title('Galactic Density')
elif type == 'blue_stars':
filter = blue_star_filter(data)
plt.title('Blue Stellar Density')
iso_filter = (iso.separation(mag_g, mag_r) < 0.1)
# projection of image
proj = ugali.utils.projector.Projector(targ_ra, targ_dec)
x, y = proj.sphereToImage(data[filter & iso_filter]['RA'], data[filter & iso_filter]['DEC']) # filter & iso_filter
bound = 0.5 #1.
steps = 100.
bins = np.linspace(-bound, bound, steps)
signal = np.histogram2d(x, y, bins=[bins, bins])[0]
sigma = 0.01 * (0.25 * np.arctan(0.25*g_radius*60. - 1.5) + 1.3) # full range, arctan
convolution = scipy.ndimage.filters.gaussian_filter(signal, sigma/(bound/steps))
plt.pcolormesh(bins, bins, convolution.T, cmap='Greys')
plt.xlim(bound, -bound)
plt.ylim(-bound, bound)
plt.gca().set_aspect('equal')
plt.xlabel(r'$\Delta \alpha$ (deg)')
plt.ylabel(r'$\Delta \delta$ (deg)')
ax = plt.gca()
divider = make_axes_locatable(ax)
cax = divider.append_axes('right', size = '5%', pad=0)
plt.colorbar(cax=cax)
def hessPlot(targ_ra, targ_dec, data, iso, g_radius, nbhd):
"""Hess plot"""
mag_g = data[mag_g_dred_flag]
mag_r = data[mag_r_dred_flag]
filter_s = star_filter(data)
plt.title('Hess')
c1 = SkyCoord(targ_ra, targ_dec, unit='deg')
r_near = 2.*g_radius # annulus begins at 3*g_radius away from centroid
r_far = np.sqrt(5.)*g_radius # annulus has same area as inner area
inner = (c1.separation(SkyCoord(data['RA'], data['DEC'], unit='deg')).deg < g_radius)
outer = (c1.separation(SkyCoord(data['RA'], data['DEC'], unit='deg')).deg > r_near) & (c1.separation(SkyCoord(data['RA'], data['DEC'], unit='deg')).deg < r_far)
xbins = np.arange(-0.5, 1.1, 0.1)
ybins = np.arange(16., 24.5, 0.5)
foreground = np.histogram2d(mag_g[inner & filter_s] - mag_r[inner & filter_s], mag_g[inner & filter_s], bins=[xbins, ybins])
background = np.histogram2d(mag_g[outer & filter_s] - mag_r[outer & filter_s], mag_g[outer & filter_s], bins=[xbins, ybins])
fg = foreground[0].T
bg = background[0].T
fg_abs = np.absolute(fg)
bg_abs = np.absolute(bg)
mask_abs = fg_abs + bg_abs
mask_abs[mask_abs == 0.] = np.nan # mask signficiant zeroes
signal = fg - bg
signal = np.ma.array(signal, mask=np.isnan(mask_abs)) # mask nan
cmap = matplotlib.cm.viridis
cmap.set_bad('w', 1.)
plt.pcolormesh(xbins, ybins, signal, cmap=cmap)
plt.colorbar()
ugali.utils.plotting.drawIsochrone(iso, lw=2, c='k', zorder=10, label='Isocrhone')
plt.axis([-0.5, 1.0, 16, 24])
plt.gca().invert_yaxis()
plt.gca().set_aspect(1./4.)
plt.xlabel('g-r (mag)')
plt.ylabel('g (mag)')
#ax = plt.gca()
#divider = make_axes_locatable(ax)
#cax = divider.append_axes('right', size = '5%', pad=0)
#plt.colorbar(cax=cax)
def drawMembership(self, ax=None, radius=None, zidx=0, mc_source_id=1):
if not ax: ax = plt.gca()
import ugali.analysis.scan
filename = self.config.mergefile
logger.debug("Opening %s..."%filename)
f = pyfits.open(filename)
distance_modulus = f[2].data['DISTANCE_MODULUS'][zidx]
for ii, name in enumerate(self.config.params['isochrone']['infiles']):
logger.info('%s %s'%(ii, name))
isochrone = ugali.isochrone.Isochrone(self.config, name)
mag = isochrone.mag + distance_modulus
ax.scatter(isochrone.color,mag, color='0.5', s=800, zorder=0)
pix = ang2pix(self.nside, self.glon, self.glat)
likelihood_pix = ugali.utils.skymap.superpixel(pix,self.nside,self.config.params['coords']['nside_likelihood'])
config = self.config
scan = ugali.analysis.scan.Scan(self.config,likelihood_pix)
likelihood = scan.likelihood
distance_modulus_array = [self.config.params['scan']['distance_modulus_array'][zidx]]
likelihood.precomputeGridSearch(distance_modulus_array)
likelihood.gridSearch()
p = likelihood.membershipGridSearch()
sep = ugali.utils.projector.angsep(self.glon, self.glat, likelihood.catalog.lon, likelihood.catalog.lat)
radius = self.radius if radius is None else radius
cut = (sep < radius)
catalog = likelihood.catalog.applyCut(cut)
p = p[cut]
cut_mc_source_id = (catalog.mc_source_id == mc_source_id)
ax.scatter(catalog.color[cut_mc_source_id], catalog.mag[cut_mc_source_id], c='gray', s=100, edgecolors='none')
sc = ax.scatter(catalog.color, catalog.mag, c=p, edgecolors='none')
ax.set_xlim(likelihood.roi.bins_color[0], likelihood.roi.bins_color[-1])
ax.set_ylim(likelihood.roi.bins_mag[-1], likelihood.roi.bins_mag[0])
ax.set_xlabel('Color (mag)')
ax.set_ylabel('Magnitude (mag)')
try: ax.cax.colorbar(sc)
except: pylab.colorbar(sc)
def plotDistance(self):
filename = self.config.mergefile
logger.debug("Opening %s..."%filename)
f = pyfits.open(filename)
pixels,values = f[1].data['PIXEL'],2*f[1].data['LOG_LIKELIHOOD']
if values.ndim == 1: values = values.reshape(-1,1)
distances = f[2].data['DISTANCE_MODULUS']
if distances.ndim == 1: distances = distances.reshape(-1,1)
ts_map = healpy.UNSEEN * numpy.ones(healpy.nside2npix(self.nside))
ndim = len(distances)
nrows = int(numpy.sqrt(ndim))
ncols = ndim // nrows + (ndim%nrows > 0)
fig = pylab.figure()
axes = AxesGrid(fig, 111, nrows_ncols = (nrows, ncols),axes_pad=0,
label_mode='1', cbar_mode='single',cbar_pad=0,cbar_size='5%',
share_all=True,add_all=False)
images = []
for i,val in enumerate(values.T):
ts_map[pixels] = val
im = healpy.gnomview(ts_map,**self.gnom_kwargs)
pylab.close()
images.append(im)
data = numpy.array(images); mask = (data == healpy.UNSEEN)
images = numpy.ma.array(data=data,mask=mask)
vmin = numpy.ma.min(images)
vmax = numpy.ma.max(images)
for i,val in enumerate(values.T):
ax = axes[i]
im = ax.imshow(images[i],origin='bottom',vmin=vmin,vmax=vmax)
ax.cax.colorbar(im)
#ax.annotate(r"$\mu = %g$"%distances[i],**self.label_kwargs)
ax.annotate(r"$d = %.0f$ kpc"%mod2dist(distances[i]),**self.label_kwargs)
ax.axis["left"].major_ticklabels.set_visible(False)
ax.axis["bottom"].major_ticklabels.set_visible(False)
fig.add_axes(ax)
fig.add_axes(ax.cax)
return fig,axes
def drawKernelHist(ax, kernel):
ext = kernel.extension
theta = kernel.theta
lon, lat = kernel.lon, kernel.lat
xmin,xmax = -5*ext,5*ext
ymin,ymax = -5*ext,5*ext,
x = np.linspace(xmin,xmax,100)+kernel.lon
y = np.linspace(ymin,ymax,100)+kernel.lat
xx,yy = np.meshgrid(x,y)
zz = kernel.pdf(xx,yy)
im = ax.imshow(zz)#,extent=[xmin,xmax,ymin,ymax])
hax,vax = draw_slices(ax,zz,color='k')
mc_lon,mc_lat = kernel.sample(1e5)
hist,xedges,yedges = np.histogram2d(mc_lon,mc_lat,bins=[len(x),len(y)],
range=[[x.min(),x.max()],[y.min(),y.max()]])
xbins,ybins = np.arange(hist.shape[0])+0.5,np.arange(hist.shape[1])+0.5
vzz = zz.sum(axis=0)
hzz = zz.sum(axis=1)
vmc = hist.sum(axis=0)
hmc = hist.sum(axis=1)
vscale = vzz.max()/vmc.max()
hscale = hzz.max()/hmc.max()
kwargs = dict(marker='.',ls='',color='r')
hax.errorbar(hmc*hscale, ybins, xerr=np.sqrt(hmc)*hscale,**kwargs)
vax.errorbar(xbins, vmc*vscale,yerr=np.sqrt(vmc)*vscale,**kwargs)
ax.set_ylim(0,len(y))
ax.set_xlim(0,len(x))
#try: ax.cax.colorbar(im)
#except: pylab.colorbar(im)
#a0 = np.array([0.,0.])
#a1 =kernel.a*np.array([np.sin(np.deg2rad(theta)),-np.cos(np.deg2rad(theta))])
#ax.plot([a0[0],a1[0]],[a0[1],a1[1]],'-ob')
#
#b0 = np.array([0.,0.])
#b1 =kernel.b*np.array([np.cos(np.radians(theta)),np.sin(np.radians(theta))])
#ax.plot([b0[0],b1[0]],[b0[1],b1[1]],'-or')
label_kwargs = dict(xy=(0.05,0.05),xycoords='axes fraction', xytext=(0, 0),
textcoords='offset points',ha='left', va='bottom',size=10,
bbox={'boxstyle':"round",'fc':'1'}, zorder=10)
norm = zz.sum() * (x[1]-x[0])**2
ax.annotate("Sum = %.2f"%norm,**label_kwargs)
#ax.set_xlabel(r'$\Delta$ LON (deg)')
#ax.set_ylabel(r'$\Delta$ LAT (deg)')
###################################################
def satellitePopulation(config, n,
range_distance_modulus=[16.5, 24.],
range_stellar_mass=[1.e2, 1.e5],
mode='mask',
plot=False):
"""
Create a population of n randomly placed satellites within a survey mask or catalog specified in the config file.
Satellites are uniformly placed in distance modulus, and uniformly generated in log(stellar_mass) (M_sol).
The ranges can be set by the user.
Returns the simulated area (deg^2) as well as the
lon (deg), lat (deg), distance modulus, stellar mass (M_sol), and half-light radius (deg) for each satellite
"""
if type(config) == str:
config = ugali.utils.config.Config(config)
if mode == 'mask':
mask_1 = ugali.utils.skymap.readSparseHealpixMap(config.params['mask']['infile_1'], 'MAGLIM')
mask_2 = ugali.utils.skymap.readSparseHealpixMap(config.params['mask']['infile_2'], 'MAGLIM')
input = (mask_1 > 0.) * (mask_2 > 0.)
elif mode == 'catalog':
catalog = ugali.observation.catalog.Catalog(config)
input = numpy.array([catalog.lon, catalog.lat])
lon, lat, simulation_area = ugali.utils.skymap.randomPositions(input,
config.params['coords']['nside_likelihood_segmentation'],
n=n)
distance_modulus = numpy.random.uniform(range_distance_modulus[0], range_distance_modulus[1], n)
stellar_mass = 10**numpy.random.uniform(numpy.log10(range_stellar_mass[0]), numpy.log10(range_stellar_mass[1]), n)
half_light_radius_physical = ugali.analysis.kernel.halfLightRadius(stellar_mass) # kpc
half_light_radius = numpy.degrees(numpy.arcsin(half_light_radius_physical \
/ ugali.utils.projector.distanceModulusToDistance(distance_modulus)))
if plot:
pylab.figure()
#pylab.scatter(lon, lat, c=distance_modulus, s=500 * half_light_radius)
#pylab.colorbar()
pylab.scatter(lon, lat, edgecolors='none')
xmin, xmax = pylab.xlim() # Reverse azimuthal axis
pylab.xlim([xmax, xmin])
pylab.title('Random Positions in Survey Footprint')
pylab.xlabel('Longitude (deg)')
pylab.ylabel('Latitude (deg)')
pylab.figure()
pylab.scatter(stellar_mass, ugali.utils.projector.distanceModulusToDistance(distance_modulus),
c=(60. * half_light_radius), s=500 * half_light_radius, edgecolors='none')
pylab.xscale('log')
pylab.yscale('log')
pylab.xlim([0.5 * range_stellar_mass[0], 2. * range_stellar_mass[1]])
pylab.colorbar()
pylab.title('Half-light Radius (arcmin)')
pylab.xlabel('Stellar Mass (arcmin)')
pylab.ylabel('Distance (kpc)')
return simulation_area, lon, lat, distance_modulus, stellar_mass, half_light_radius
############################################################
def plot_matrix(self):
""" Plot distance matrix and dendrogram using matplotlib.
Returns
-------
matplotlib figure
"""
# Compute and plot first dendrogram for all nodes.
fig = pylab.figure(figsize=(8, 8))
ax1 = fig.add_axes([0.09, 0.1, 0.2, 0.6])
Z1 = scipy.cluster.hierarchy.dendrogram(
self.linkage, orientation='left', labels=self.labels)
ax1.set_xticks([])
ax1.set_yticks([])
# Compute and plot second dendrogram.
ax2 = fig.add_axes([0.3, 0.71, 0.6, 0.2])
Z2 = scipy.cluster.hierarchy.dendrogram(self.linkage, labels=self.labels)
ax2.set_xticks([])
ax2.set_yticks([])
# Plot distance matrix.
axmatrix = fig.add_axes([0.3, 0.1, 0.6, 0.6])
idx1 = Z1['leaves']
idx2 = Z2['leaves']
D = self.mat.copy()
if isinstance(D, pd.DataFrame):
D = D.as_matrix()
D = D[idx1, :]
D = D[:, idx2]
im = axmatrix.matshow(
D, aspect='auto', origin='lower', cmap=pylab.cm.YlGnBu)
axmatrix.set_xticks([])
axmatrix.set_yticks([])
# Plot colorbar.
axcolor = fig.add_axes([0.91, 0.1, 0.02, 0.6])
pylab.colorbar(im, cax=axcolor)
module_logger.info(
'Use matplotlib.pyplot.show() to render figure.')
return fig
