def plot_freq_histogram(freqs_array, x_label, bins='FD', savefig=False, save_path_and_name='./histo_fig.pdf'):
    """ Plots a histogram of frequencies.

    :param freqs_array: array-like. list of frequencies.
    :param x_label: string. Sets the label of x-axis
    :param bins: float. select the number of bins. Exception: string 'FD' for Freedman-Diaconis rule (default)
    :param savefig: boolean. True if you want to save the figure.
    :param save_path_and_name: string. path + fig-name where you want to save the file. Default is './histo_fig.pdf'.
    Don't forget the '.pdf' at the end of the save_path_and_name string!!
    """
    q75, q25 = np.percentile(abs(freqs_array), [75, 25])

    inch_factor = 2.54
    sns.set_context("poster")
    sns.axes_style('white')
    sns.set_style("ticks")
    fig, ax = plt.subplots(figsize=(20./inch_factor, 15./inch_factor))

    if bins == 'FD':
        ax.hist(freqs_array, bins=int(2 * (q75 - q25) * len(freqs_array) ** (-1. / 3.)),
                facecolor='cornflowerblue', alpha=0.8, lw=1.5)  # Freedman-Diaconis rule for binwidth
    else:
        ax.hist(freqs_array, bins=bins, color='cornflowerblue', alpha=0.8)

    # Plot Cosmetics

    ax.set_ylabel('Counts', fontsize=16)
    ax.set_xlabel(x_label + ' [Hz]', fontsize=14)
    ax.tick_params(axis='both', which='major', labelsize=12)
    ax.set_title('Distribution of %s' % x_label, fontsize=16)
    sns.despine(fig=fig, ax=ax, offset=10)
    fig.tight_layout()
    if savefig:
        fig.savefig(save_path_and_name)
        plt.close()
示例#2
0
def plot_dfs_histogram(dfs_array, binwidth='FD'):
    """ Plots a histogram of the difference frequencies

    :param binwidth: select the size of the binwidth. use 'FD' for Freedman-Diaconis rule
    :param dfs_array: array-like. list of difference frequencies.
    """
    q75, q25 = np.percentile(abs(dfs_array), [75, 25])

    inch_factor = 2.54
    sns.set_context("poster")
    sns.axes_style('white')
    sns.set_style("ticks")
    fig, ax = plt.subplots(figsize=(15./inch_factor, 10./inch_factor))

    if binwidth == 'FD':
        ax.hist(dfs_array, bins=int(2*(q75-q25) * len(dfs_array)**(-1./3.)),
                facecolor='cornflowerblue', alpha=0.8)  # Freedman-Diaconis rule for binwidth
    else:
        ax.hist(dfs_array, bins=binwidth, color='cornflowerblue', alpha=0.8)

    # Plot Cosmetics

    ax.set_ylabel('Counts', fontsize=16)
    ax.set_xlabel('Possible Beat-Frequencies [Hz]', fontsize=14)
    ax.tick_params(axis='both', which='major', labelsize=12)
    ax.set_title('Distribution of Beat-Frequencies', fontsize=16)
    sns.despine(fig=fig, ax=ax, offset=10)
    fig.tight_layout()
    fig.savefig('figures/histo_of_dfs.pdf')
    plt.close()
示例#3
0
def fishtype_barplot(data):
    """ This function creates a bar plot showing the distribution of wave-fishes vs. pulse-fishes.

    :param data: dictionary with fish-type as keys and array of EODfs as values.
    """

    # Read the keys of the dictionary and use them to get the count of pulse- and wave-type fishes.
    keys = np.array(data.keys())
    bool_wave = np.array(['wave' in e for e in keys], dtype=bool)
    bool_pulse = np.array(['puls' in e for e in keys], dtype=bool)

    count_wave = len(data[keys[bool_wave][0]])
    count_pulse = len(data[keys[bool_pulse][0]])

    inch_factor = 2.54
    sns.set_context("poster")
    sns.axes_style('white')
    sns.set_style("ticks")
    fig, ax = plt.subplots(figsize=(10./inch_factor, 10./inch_factor))
    width = 0.5
    ax.bar(1-width/2., count_wave, width=width, facecolor='cornflowerblue', alpha=0.8)
    ax.bar(2-width/2., count_pulse, width=width, facecolor='salmon', alpha=0.8)
    ax.set_xticks([1, 2])
    ax.set_xticklabels(['Wave-type', 'Pulse-type'])
    ax.tick_params(axis='both', which='major', labelsize=14)
    ax.set_ylabel('Number of Fishes', fontsize=14)
    ax.set_title('Distribution of Fish-types', fontsize=16)
    sns.despine(fig=fig, ax=ax, offset=10)
    fig.tight_layout()
    fig.savefig('figures/fishtype_barplot.pdf')
    plt.close()
示例#4
0
def create_histo(data):
    """
    gets a list of data and creates an histogram of this data.

    :param data: dictionary with fishtype as keys and np.array with EOD-Frequencies as values.
    """
    print 'creating histogramm ...'

    inch_factor = 2.54
    sns.set_context("poster")
    sns.axes_style('white')
    sns.set_style("ticks")
    fig, ax = plt.subplots(figsize=(15./inch_factor, 10./inch_factor))
    colors = ['salmon', 'cornflowerblue']

    for enu, curr_fishtype in enumerate(data.keys()):
        if len(data[curr_fishtype]) >= 4:
            hist, bins = np.histogram(data[curr_fishtype], bins=len(data[curr_fishtype])//4)
            width = 0.7 * (bins[1] - bins[0])
            center = (bins[:-1] + bins[1:]) / 2
            ax.bar(center, hist, align='center', width=width, alpha=0.8, facecolor=colors[enu], label=curr_fishtype)

    ax.set_ylabel('Counts', fontsize=14)
    ax.set_xlabel('Frequency [Hz]', fontsize=14)
    ax.set_xticks(np.arange(0, max(np.hstack(data.values()))+100, 250))
    ax.tick_params(axis='both', which='major', labelsize=12)
    ax.set_title('Distribution of EOD-Frequencies', fontsize=16)
    ax.legend(frameon=False, loc='best', fontsize=12)
    sns.despine(fig=fig, ax=ax, offset=10)
    fig.tight_layout()
    fig.savefig('figures/histo_of_eod_freqs.pdf')
    plt.close()
示例#5
0
def plotPosInRangeMultifly(ax, frameRange, xPos, yPos, angle, flyID, fly, currCmap, imagePx):
    # Plot trajectories of multi-fly tracking data (obtained with Ctrax)
    cNorm  = colors.Normalize(vmin=-0.5*len(frameRange), vmax=1*len(frameRange))
    scalarMap = plt.cm.ScalarMappable(norm=cNorm, cmap=currCmap)

    for ind, frame in enumerate(frameRange):
        currCol = scalarMap.to_rgba(len(frameRange) - ind)

        if fly == -1:
            # iterate over all available flies
            ax.plot(xPos[frame], yPos[frame], marker='.', markersize=10, linestyle='none', alpha=0.5,
                    color=currCol)

            for fly in flyID[frame]:
                plotBodyAngle(ax, xPos[frame][flyID[frame] == fly], yPos[frame][flyID[frame] == fly],
                              angle[frame][flyID[frame] == fly], currCol, 0.5, 20)

        else:
            # just plot trace of specified fly
            ax.plot(xPos[frame][flyID[frame] == fly], yPos[frame][flyID[frame] == fly],
                    marker='.', markersize=6, linestyle='none', alpha=0.5, color=currCol)

            plotBodyAngle(ax, xPos[frame][flyID[frame] == fly], yPos[frame][flyID[frame] == fly],
                          angle[frame][flyID[frame] == fly], currCol, 0.5, 20)

    ax.set_aspect('equal')
    sns.despine(right=True, offset=0)  # trim=True)
    sns.axes_style({'axes.linewidth': 1, 'axes.edgecolor': '.8', })

    plt.xlim([imagePx[0] / 2.0 - 500, imagePx[0] / 2.0 + 500])
    plt.ylim([imagePx[1] / 2.0 - 500, imagePx[1] / 2.0 + 500])
示例#6
0
def plot_teh(damage,title,subplot):
    plt.subplot(subplot)
    h5 = read_csv(5,damage)
    h4 = read_csv(4,damage)
    h3 = read_csv(3,damage)
    h2 = read_csv(2,damage)
    h1 = read_csv(1,damage)
  
    xlist = [z for z in range(len(h5))]
    ph5 = plt.plot(xlist,h5,'-o',label='h5',marker = 'v',markersize=8,color='blue')
    ph4 = plt.plot(xlist,h4,'-o',label='h4',marker = 'o',markersize=8,color='green')
    ph3 = plt.plot(xlist,h3,'-o',label='h3',marker = 'D',markersize=8,color='orange')
    ph2 = plt.plot(xlist,h2,'-o',label='h2',marker = '*',markersize=8,color='red')
    ph1 = plt.plot(xlist,h1,'-o',label='h1',marker = 's',markersize=8,color='black')

    #plt.legend(loc='upper left', handlelength=5, borderpad=1.2, labelspacing=1.2)
    #plt.legend()
    plt.legend(loc='upper right', fontsize = 'xx-large')
    plt.tick_params(axis='both',which='major', labelsize='large')
    plt.title(title,size = 'xx-large',weight='bold')
    plt.xlabel('Rank',size='xx-large',weight='bold')
    plt.ylabel('Transfer Entropy',size='xx-large',weight='bold')
    sns.axes_style("darkgrid", {"axes.facecolor": ".9"})
    plt.ylim(ymin=0.0,ymax = 1.0)
    plt.xlim(xmin=0.0,xmax = len(h5))
    plt.margins(0.2)
    plt.tight_layout(pad=2.5)

    return
def plot_chart(dictionary):
	x = np.array(list(dictionary.keys()))
	y = np.array(list(dictionary.values()))

	sns.axes_style('white')
	sns.set_style('white')

	COLORS = 'Greens_d'

	(f, ax) = plt.subplots(1)

	b = sns.barplot(
		x,
		y,
		ci = None,
		palette = COLORS,
		hline = 0,
		ax = ax,
		x_order = x)
	
	#labels
	_TITLE = "Registrants by MSB Activities"
	ax.set_title(_TITLE)
	_XLABEL = "MSB Activities"
	ax.set_xlabel(_XLABEL)
	_YLABEL = "No of Registrants"
	ax.set_ylabel(_YLABEL)
	b.set_xticklabels(x, rotation = 90)
	#create margin at bottom for better layout
	plt.subplots_adjust(bottom=0.35)

	plt.show()
示例#8
0
def plot_hist_algo(wave_hist_algor, pulse_hist_algor, multi_wave_hist_algor):
    inch_factor = 2.54
    sns.set_context("poster")
    sns.axes_style('white')
    # sns.set_style("ticks")

    fig4= plt.figure(figsize=(35./ inch_factor, 20./ inch_factor))
    ax1 = fig4.add_subplot(2, 3, (1, 4))
    dafr = pd.DataFrame([wave_hist_algor, multi_wave_hist_algor, pulse_hist_algor]) #turn
    dafr = dafr.transpose()
    dafr.columns = ['wave', 'multi-wave', 'pulse']
    sns.violinplot(data=dafr,  ax=ax1, col=("blue", "green", "red"))
    ax1.set_ylabel('psd_proportion')
    ax1.set_xlabel('EOD-type')
    ax1.set_title('Fishsorting based on PSD')

    wave_psd_data = np.load('wave_psd_data.npy')
    wave_hist_data = wave_psd_data[1][:len(wave_psd_data[0][wave_psd_data[0]<1500])]
    ax3 = fig4.add_subplot(2, 3, (2, 5))
    n, bin, patch = ax3.hist(wave_hist_data, 50, color='blue', alpha=0.7, normed=True)
    # ax3.set_ylim([0, max(n)+10])
    ax3.set_ylabel('counts in histogram bin')
    ax3.set_xlabel('amplitude of PSD')
    ax3.set_title('Histogram of pulsefish PSD')

    pulse_psd_data = np.load('pulse_psd_data.npy')
    pulse_hist_data = pulse_psd_data[1][:len(pulse_psd_data[0][pulse_psd_data[0]<1500])]
    ax2 = fig4.add_subplot(2, 3, (3, 6))
    ax2.hist(pulse_hist_data, 50, color='red', alpha=0.7, normed=True)
    # ax2.set_ylim([0, max(n)+10])
    ax2.set_ylabel('counts in histogram bin')
    ax2.set_xlabel('amplitude of PSD')
    ax2.set_title('Histogram of pulsefish PSD')

    fig4.tight_layout()
示例#9
0
def draw_bwin_analysis_plot(filename, t_trace, eod_trace, no_of_peaks, cvs, mean_ampl):
    fs = 20
    inch_factor = 2.54
    sns.set_context("poster")
    sns.axes_style('white')
    sns.set_style("ticks")

    fig = plt.figure(figsize=(40. / inch_factor, 35. / inch_factor), num='Fish No. '+filename[-10:-8])

    ax1 = fig.add_subplot(5, 1, 1)
    ax2 = fig.add_subplot(5, 1, 2)
    ax3 = fig.add_subplot(5, 1, 3)
    ax4 = fig.add_subplot(5, 1, 4)
    ax5 = fig.add_subplot(5, 1, 5)

    # ax2 plots the Number of detected EOD-cycles
    window_nr = np.arange(len(no_of_peaks)) * 0.2
    ax2.plot(window_nr, no_of_peaks, 'o', ms=10, color='grey', mew=2., mec='black', alpha=0.6)
    ax2.set_ylabel('No. of detected\nEOD-cycles', fontsize=fs)

    # ax3 plots the Amplitude Coefficient of Variation
    ax3.plot(window_nr, cvs, 'o', ms=10, color='grey', mew=2., mec='black', alpha=0.6)
    ax3.set_ylabel('Soundtrace Amplitude\nVariation Coefficient', fontsize=fs)

    # ax4 plots the Mean Amplitude of each Window
    ax4.plot(window_nr, mean_ampl, 'o', ms=10, color='grey', mew=2., mec='black', alpha=0.6)
    ax4.set_ylabel('Mean Window\nAmplitude [a.u]', fontsize=fs)

    ax = np.array([ax1, ax2, ax3, ax4, ax5])
    return ax
示例#10
0
def analyseCCFs(ccf_G2):
	amp=np.empty(len(ccf_G2))
	rv=np.empty(len(ccf_G2))
	fwhm=np.empty(len(ccf_G2))
	mjd=np.empty(len(ccf_G2))
	combined_ccfs=[]
	for i in range(0,len(ccf_G2)):
		h=fits.open(ccf_G2[i])
		crval1=h[0].header['CRVAL1']
		cdelt1=h[0].header['CDELT1']
		mjd[i]=h[0].header['MJD-OBS']
		data=h[0].data
		
		# prepare the plotting array
		fig = pl.figure(i+1,figsize=(15,15))
		fig.clf()
		fig.suptitle('%s CCFs' % (ccf_G2[i]))
		seaborn.axes_style("darkgrid")
		montage_dim=int(ceil(sqrt(len(data))))
		c=0
		for j in range(0,montage_dim):
			for k in range(0,montage_dim):
				ax = fig.add_subplot(montage_dim, montage_dim, c+1, xticks=[], yticks=[])		
				if c < len(data):
					# try fitting a Gaussian to the ccf
					# tweak y values to help the fit
					# only fit those that are not 0s
					x=np.arange(0,len(data[c]))
					xn=(x+cdelt1)+crval1
					t_data=data[c]-max(data[c])	
					ax.plot(xn,t_data,'b.')
					ax.set_title('order %d' % (c+1))
					if max(data[c]) > 0 and np.std(data[c]) > 0:
						p0=estimateGaussianParams(t_data,xn)
						try:
							coeff,cov=curve_fit(Gaussian,xn,t_data,p0)
							yfit = Gaussian(xn, *coeff)
							print ('[%d/%d] x0=%.4f ' % (c+1,len(data),coeff[1]))
							ax.plot(xn,yfit,'r--')
							if c == len(data)-1:
								amp[i]=coeff[0]
								rv[i]=coeff[1]
								fwhm[i]=coeff[2]
								combined_ccfs.append(data[c])
						except RuntimeError:
							print ('[%d/%d] fit did not converge ' % (c+1,len(data)))
							if c == len(data)-1:
								print ('[%d/%d] FINAL FIT DID NOT CONVERGE! ' % (c+1,len(data)))
								combined_ccfs.append(data[c])
					else:
						print('[%d/%d] Cannot fit zeros' % (c+1,len(data)))
					c+=1
					#print("[%d/%d]" % (c,len(data)))
		# plot the montage of CCFs
		fig.savefig('%s.png' % (ccf_G2[i]),dpi=300)
	return mjd,rv_corr,amp,fwhm,combined_ccfs
def plot_colormaps_each(maps, Working_Directory, name_for_saving_figures, pp, matched_pixels, unique_clrs):
    
    Trial_Directories = [f for f in os.listdir(os.path.join(Working_Directory)) if os.path.isdir(os.path.join(Working_Directory, f)) and f.find('Figures')<0 and f.find('DataFrames')<0] #Get only directories
    
    ## To find num z planes in each trial directory
    num_z_planes = np.zeros((np.size(Trial_Directories)), dtype=np.int)
    for jj in xrange(0, np.size(Trial_Directories, axis = 0)):
        Image_Directory = os.path.join(Working_Directory, Trial_Directories[jj],'C=1')+filesep    
        tif = TIFF.open(Image_Directory +'T=1.tif', mode='r') #Open multitiff 
        count = 1        
        for image in tif.iter_images():
            num_z_planes[jj] = count
            count = count+1
    
    count = 0     
    count_trial1 = 0
    for ii in xrange(0, np.size(Trial_Directories, axis = 0)):       
        count_subplot = 1
        for jj in xrange(0, num_z_planes[ii]):
            name_for_saving_figures1 = name_for_saving_figures + ' ' + Trial_Directories[ii] + ' Z=' + str(jj+1)
            with sns.axes_style("darkgrid"):           
                fig2 = plt.subplot(2,2,count_subplot)
                plt.imshow(maps[:,:,count,:])
                plt.title(name_for_saving_figures1)
                plt.axis('off')
            count = count+1
            count_subplot = count_subplot + 1
            
            # If there are more than 6 panel, save and start new figure
            if count_subplot == 5:
                fig2 = plt.gcf()
                pp.savefig(fig2)
                plt.close()
                count_subplot = 1
                    
        #Plot boxplots for each trial
        if count_subplot <= 4:
            with sns.axes_style("darkgrid"):
                fig2 = plt.subplot(2,2,count_subplot)
                fig2 = plot_boxplot(fig2, matched_pixels[:,count_trial1:count_trial1+num_z_planes[ii]], unique_clrs)
#                plt.tight_layout()            
                fig2 = plt.gcf()
                pp.savefig(fig2)
                plt.close()
            count_trial1 = count_trial1 + num_z_planes[ii]
            
        else:
            with sns.axes_style("darkgrid"):
                fig3 = plt.figure()
                fig3 = plot_boxplot(fig3, matched_pixels[:,count_trial1:count_trial1+num_z_planes[ii]], unique_clrs)
#                plt.tight_layout()            
                fig3 = plt.gcf()
                pp.savefig(fig3)
                plt.close()
            count_trial1 = count_trial1 + num_z_planes[ii]
def plot_BIC(all_results, size=4.6, dpi=300, ext='png', plot_dir=None):
    """ Plots BIC and SABIC curves
    
    Args:
        all_results: a dimensional structure all_results object
        dpi: the final dpi for the image
        ext: the extension for the saved figure
        plot_dir: the directory to save the figure. If none, do not save
    """
    all_colors = [sns.color_palette('Blues_d',3)[0:3],
              sns.color_palette('Reds_d',3)[0:3],
              sns.color_palette('Greens_d',3)[0:3],
              sns.color_palette('Oranges_d',3)[0:3]]
    height= size*.75/len(all_results)
    with sns.axes_style('white'):
        fig, axes = plt.subplots(1, len(all_results), figsize=(size, height))
    for i, results in enumerate([all_results[key] for key in ['task','survey']]):
        ax1 = axes[i]
        name = results.ID.split('_')[0].title()
        EFA = results.EFA
        # Plot BIC and SABIC curves
        colors = all_colors[i]
        with sns.axes_style('white'):
            x = list(EFA.results['cscores_metric-BIC'].keys())
            # score keys
            keys = [k for k in EFA.results.keys() if 'cscores' in k]
            for key in keys:
                metric = key.split('-')[-1]
                BIC_scores = [EFA.results[key][i] for i in x]
                BIC_c = EFA.results['c_metric-%s' % metric]
                ax1.plot(x, BIC_scores,  'o-', c=colors[0], lw=size/6, label=metric,
                         markersize=height*2)
                ax1.plot(BIC_c, BIC_scores[BIC_c-1], '.', color='white',
                         markeredgecolor=colors[0], markeredgewidth=height/2, 
                         markersize=height*4)
            if i==0:
                if len(keys)>1:
                    ax1.set_ylabel('Score', fontsize=height*3)
                    leg = ax1.legend(loc='center right',
                                     fontsize=height*3, markerscale=0)
                    beautify_legend(leg, colors=colors)
                else:
                    ax1.set_ylabel(metric, fontsize=height*4)
            ax1.set_xlabel('# Factors', fontsize=height*4)
            ax1.set_xticks(x)
            ax1.set_xticklabels(x)
            ax1.tick_params(labelsize=height*2, pad=size/4, length=0)
            ax1.set_title(name, fontsize=height*4, y=1.01)
            ax1.grid(linewidth=size/8)
            [i.set_linewidth(size*.1) for i in ax1.spines.values()]
    if plot_dir is not None:
        save_figure(fig, path.join(plot_dir, 'BIC_curves.%s' % ext),
                    {'bbox_inches': 'tight', 'dpi': dpi})
        plt.close()
示例#13
0
def plotpopulations():
    import seaborn as sns
    import matplotlib as mpl
    sns.axes_style("darkgrid")
    sns.set_context("notebook", font_scale=1, rc={"lines.linewidth": 2.5})
    mpl.rc('font', **{'family': 'serif', 'serif': ['Computer Modern'], 'size': 46});
    mpl.rc('text', usetex=True)
    dspath = dir + 'ALL/'
    individual_names_file = 'integrated_call_samples_v3.20130502.ALL.panel'
    All = pd.read_table(dspath + individual_names_file, sep='\t');
    plt.figure(figsize=(10, 4.5), dpi=200);
    All['pop'].value_counts().plot(kind='bar')
def plot_NMF_maps(Working_Directory, name_for_saving_figures, name_for_saving_files, \
    NMF_components, maps, colors_NMF, matched_pixels, stimulus_on_time, stimulus_off_time, flag, unique_clrs):
    

    # To save as pdf create file
    Figure_PDFDirectory = Working_Directory+filesep+'Figures'+filesep
    if not os.path.exists(Figure_PDFDirectory):
        os.makedirs(Figure_PDFDirectory)           
    pp = PdfPages(Figure_PDFDirectory+name_for_saving_files+'_NMF.pdf')
               
    sns.set_context("poster")  
    
    ########### Plot components ##################
    fig2 = plt.figure()
    sns.set_context("talk", font_scale=1.25)
    with sns.axes_style("darkgrid"):
        ax1 = plt.subplot(221)
        plot_NMF_components(NMF_components,ax1,stimulus_on_time, stimulus_off_time, colors_NMF)
    
    #Plot mean projection   
    with sns.axes_style("white"):  
        fig2 = plt.subplot(223)        
        if len(maps.shape)==3:
            plt.imshow(maps)
        else:
            image(np.amax(maps,2))
            
        plt.axis('off')
        plt.title('Max projection')
    
    
    ########### Plot Boxplot of number of pixels ##################        
    with sns.axes_style("white"):
        fig2 = plt.subplot(222)
        fig2 = plot_boxplot(fig2, matched_pixels, colors_NMF[0:np.size(NMF_components,1)])
    
    plt.tight_layout()
    fig2 = plt.gcf()
    pp.savefig(fig2)
    plt.close()
    
    ################  Plot color maps individually #######################
    if flag == 0:
        plot_colormaps_ind(maps, Working_Directory, name_for_saving_figures, pp)
    elif flag == 1:
        plot_colormaps_each(maps, Working_Directory, name_for_saving_figures, pp,matched_pixels,colors_NMF[0:np.size(NMF_components,1)])
    elif flag == 2:
        plot_colormaps_all( maps, Working_Directory, pp, matched_pixels, colors_NMF[0:np.size(NMF_components,1)])
        plot_colormaps_all_z_plane_wise(maps, Working_Directory, pp,matched_pixels, colors_NMF[0:np.size(NMF_components,1)])
    

    pp.close()
def plot_ica_maps(Working_Directory, name_for_saving_figures, name_for_saving_files, \
ica_components_plot, maps, colors_ica, matched_pixels, stimulus_on_time, stimulus_off_time, flag):
    
     
    # To save as pdf create file
    Figure_PDFDirectory = Working_Directory+filesep+'Figures'+filesep
    if not os.path.exists(Figure_PDFDirectory):
        os.makedirs(Figure_PDFDirectory)           
    pp = PdfPages(Figure_PDFDirectory+name_for_saving_files+'_ICA.pdf')
               
    sns.set_context("poster")  
    
    ########### Plot components ##################
    fig2 = plt.figure()
    sns.set_context("talk", font_scale=1.25)
    with sns.axes_style("darkgrid"):
        ax1 = plt.subplot(221)
        plot_ica_components(ica_components_plot,colors_ica, ax1,stimulus_on_time, stimulus_off_time)
                   
    ########### Plot Boxplot of number of pixels ##################        
    with sns.axes_style("white"):
        fig2 = plt.subplot(222)
        fig2 = plot_boxplot(fig2, matched_pixels, colors_ica)
    
    #Plot mean projection   
    with sns.axes_style("white"):  
        if len(maps.shape)==3:
            temp = maps
        else:
            temp = (np.mean(maps, axis=2))
        
        fig2 = plt.subplot(223)
        plt.imshow(temp.astype(np.float16))
        plt.axis('off')
        plt.title('Mean projection')
    
    plt.tight_layout()
    fig2 = plt.gcf()
    pp.savefig(fig2)
    plt.close()
    
#    ##  Plot color maps individually #######################
    if flag == 0:
        plot_colormaps_ind(maps, Working_Directory, name_for_saving_figures, pp)
    elif flag == 1:
        plot_colormaps_each(maps, Working_Directory, name_for_saving_figures, pp,matched_pixels, colors_ica)
    elif flag == 2:
        plot_colormaps_all(maps, Working_Directory, pp, matched_pixels, colors_ica)
        plot_colormaps_all_z_plane_wise(maps, Working_Directory, pp, matched_pixels, colors_ica)
    

    pp.close()
def plotSparseMatrix(figsize,aspectRatio,matrixToPlot,titleString):
    fig = plt.figure(figsize=figsize)
    fig.set_canvas(plt.gcf().canvas)
    sns.set_style('ticks')
    ax = fig.add_subplot(111)

    ax.spy(matrixToPlot)
    ax.set_aspect(aspectRatio)
    ax.set_title(titleString)

    sns.axes_style({'axes.linewidth': 1, 'axes.edgecolor': '.8'})
    myAxisTheme(ax)

    return fig
示例#17
0
def plotMoonDataFit(moon_ang,median_counts,xfit,yfit,moon_phase):
	action=os.getcwd().split('/')[-1]
	fig,ax=pl.subplots(1,figsize=(10,10))
	seaborn.axes_style("darkgrid")
	ax.semilogy(moon_ang,median_counts,'r.')
	ax.semilogy(xfit,yfit,'k--')
	ax.set_xlabel('Moon Distance (deg)')
	ax.set_ylabel('Median ADU (image)')
	#ax.set_yticks(np.arange(0,max(yfit),2000))
	ax.set_title('Moon Avoidance Test (%s - %d%% illuminated)' % (action, int(np.average(moon_phase)*100)))
	ax.set_xlim(0,180)
	ax.set_ylim(100,10000)
	ax.grid(True,which='both')
	fig.savefig("%s/MoonAvoidance_%s.png" % (outdir,action), dpi=300)
	return action
示例#18
0
def plot_ais(filename,damage):
    x = []
    s40 = []
    s35 = []
    s30 = []
    s25 = []
    s20 = []
    s15 = []
    s10 = []

    with open(filename,'r') as csvfile:
        plots = csv.reader(csvfile, delimiter =',')
        for row in plots:
            x.append(row[0])
            s40.append(row[1])
            s35.append(row[2])
            s30.append(row[3])
            s25.append(row[4])
            s20.append(row[5])
            s15.append(row[6])
            s10.append(row[7])

    xlist = [z for z in range(len(x))]
    plt.figure(figsize=(15,15))
    ps40 = plt.plot(xlist,s40,'-o',label='step40')
    ps35 = plt.plot(xlist,s35,'-o',label='step35')
    ps30 = plt.plot(xlist,s30,'-o',label='step30')
    ps25 = plt.plot(xlist,s25,'-o',label='step25')
    ps20 = plt.plot(xlist,s20,'-o',label='step20')
    ps15 = plt.plot(xlist,s15,'-o',label='step15')
    ps10 = plt.plot(xlist,s10,'-o',label='step10')
    plt.xticks(xlist,x,rotation='vertical')
    #plt.legend(loc='upper left', handlelength=5, borderpad=1.2, labelspacing=1.2)
    #plt.legend()
    plt.legend(loc='upper right',fontsize='xx-large')
    d_title = 'AI for %s_Normal with varying max step size and history length of 5.'%(damage)
    plt.title(d_title)
    plt.xlabel('Node')
    plt.ylabel('Active Information')
    sns.axes_style("darkgrid", {"axes.facecolor": ".9"})
    plt.ylim(ymin=0.0)
    plt.margins(0.2)
    #plt.subplots_adjust(bottom=0.25)
    plt.tight_layout(pad=2.5)
    plt.savefig("ai-all-stepd-h5-%s-normal.pdf"%(damage))
    plt.show()

    return
示例#19
0
 def decode_uniform_samples_from_latent_space(_):
     fig, ax = plt.subplots()
     nx = ny = 20
     extent_x = extent_y = [-3, 3]
     extent = numpy.array(extent_x + extent_y)
     x_values = numpy.linspace(*(extent_x + [nx]))
     y_values = numpy.linspace(*(extent_y + [nx]))
     full_extent = extent * (nx + 1) / float(nx)
     canvas = numpy.empty((28 * ny, 28 * nx))
     for ii, yi in enumerate(x_values):
         for j, xi in enumerate(y_values):
             n = ii * nx + j + 1
             sys.stdout.write("\rsampling p(X|z), sample %d/%d" % (n, nx*ny))
             sys.stdout.flush()
             np_z = numpy.array([[xi, yi]])
             x_mean = sess.run(prior_model(latent=numpy.reshape(np_z, newshape=(1, LATENT_DIM)))[0])
             canvas[(nx - ii - 1) * 28:(nx - ii) * 28, j * 28:(j + 1) * 28] = x_mean[0].reshape(28, 28)
     with seaborn.axes_style('ticks'):
         seaborn.set_context(context='notebook', font_scale=1.75)
         fig, ax = plt.subplots(figsize=(12, 9))
     ax.imshow(canvas, extent=full_extent)
     ax.xaxis.set_ticks(numpy.linspace(*(extent_x + [nx])))
     ax.yaxis.set_ticks(numpy.linspace(*(extent_y + [ny])))
     ax.set_xlabel('z_1')
     ax.set_ylabel('z_2')
     ax.set_title('P(X|z); decoding latent space; (CONV, BNAE, IND_ERROR) = (%d,%d,%d)' % (CONV, BNAE, IND_ERROR))
     plt.show()
     plt.savefig(os.path.join(FLAGS.viz_dir, 'P(X|z).png'))
     return fig, ax
 def scale_plot(input_data, data_colors=None, cluster_colors=None,
                cluster_sizes=None, dissimilarity='euclidean', filey=None):
     """ Plot MDS of data and clusters """
     if data_colors is None:
         data_colors = 'r'
     if cluster_colors is None:
         cluster_colors='b'
     if cluster_sizes is None:
         cluster_sizes = 2200
         
     # scale
     mds = MDS(dissimilarity=dissimilarity)
     mds_out = mds.fit_transform(input_data)
     
     with sns.axes_style('white'):
         f=plt.figure(figsize=(14,14))
         plt.scatter(mds_out[n_clusters:,0], mds_out[n_clusters:,1], 
                     s=75, color=data_colors)
         plt.scatter(mds_out[:n_clusters,0], mds_out[:n_clusters,1], 
                     marker='*', s=cluster_sizes, color=cluster_colors,
                     edgecolor='black', linewidth=2)
         # plot cluster number
         offset = .011
         font_dict = {'fontsize': 17, 'color':'white'}
         for i,(x,y) in enumerate(mds_out[:n_clusters]):
             if i<9:
                 plt.text(x-offset,y-offset,i+1, font_dict)
             else:
                 plt.text(x-offset*2,y-offset,i+1, font_dict)
     if filey is not None:
         plt.title(path.basename(filey)[:-4], fontsize=20)
         save_figure(f, filey)
         plt.close()
def plot_retest_data(retest_data, size=4.6, save_dir=None):
    colors = [sns.color_palette('Reds_d',3)[0], sns.color_palette('Blues_d',3)[0]]
    f = plt.figure(figsize=(size,size*.75))
    # plot boxes
    with sns.axes_style('white'):
        box_ax = f.add_axes([.15,.1,.8,.5]) 
        sns.boxplot(x='icc3.k', y='Measure Category', ax=box_ax, data=retest_data,
                    palette={'Survey': colors[0], 'Task': colors[1]}, saturation=1,
                    width=.5, linewidth=size/4)
    box_ax.text(0, 1, '%s Task measures' % Task_N, color=colors[1], fontsize=size*2)
    box_ax.text(0, 1.2, '%s Survey measures' % Survey_N, color=colors[0], fontsize=size*2)
    box_ax.set_ylabel('Measure category', fontsize=size*2, labelpad=size)
    box_ax.set_xlabel('Intraclass correlation coefficient', fontsize=size*2, labelpad=size)
    box_ax.tick_params(labelsize=size*1.5, pad=size, length=2)
    [i.set_linewidth(size/5) for i in box_ax.spines.values()]

    # plot distributions
    dist_ax = f.add_axes([.15,.6,.8,.4]) 
    dist_ax.set_xlim(*box_ax.get_xlim())
    dist_ax.set_xticklabels('')
    dist_ax.tick_params(length=0)
    for i, (name, g) in enumerate(retest_data.groupby('Measure Category')):
        sns.kdeplot(g['icc3.k'], color=colors[i], ax=dist_ax, linewidth=size/3, 
                    shade=True, legend=False)
    dist_ax.set_ylim((0, dist_ax.get_ylim()[1]))
    dist_ax.axis('off')
    if save_dir:
        plt.savefig(save_dir, dpi=dpi, bbox_inches='tight')
示例#22
0
文件: plotUtils.py 项目: tarlen5/pisa
def make_scatter_plot(frame, name, **kwargs):
    """
    Makes a scatter plot of column name in frame.
    """

    column_x = frame[name]
    if name == 'deltam31': column_x*=100.0

    params = []
    exclude = set(['hypo','llh','mctrue'])
    params = list(set(frame.columns).difference(exclude))

    figs = []
    # Plot correlation scatter plot for all other systematics
    for p in params:
        if p == name: continue
        column_y = frame[p]
        if p == 'deltam31': column_y*=100.0
        if 'theta' in p: column_y = np.rad2deg(column_y)

        with sns.axes_style("whitegrid"):
            sns.jointplot(column_x, column_y, size=8, color='b',
                          **kwargs)
            plt.tight_layout()
            figs.append(plt.gcf())

    return figs
示例#23
0
def plot(tx=True, descriptions=False, edges=True,
         subset=None, figsize=(10,12), height=None,
         title=None, edge_color=None, tx_markersize=None):
    """Draw a plot of the basic map. Arguments are
    booleans, indicating whether tx points should be drawn,
    and whether edges should be drawn.

    tx point are drawn in zorder 2
    edges are drawn in zorder 1
    """
    if height is not None:
        # Preserve 10,12 aspect ratio
        figsize = ((5/6)*height, height)

    with sns.axes_style("white"):
        fig, ax = sns.plt.subplots(figsize=figsize)
        if edges:
            _edges(ax, color=edge_color)
        if tx:
            _tx_points(ax, descriptions=descriptions,
                       markersize=tx_markersize)

    adjust_lims(ax, subset)
    clear_ticks(ax)

    if title is not None:
        ax.set_title(title)

    return ax
示例#24
0
文件: mixedfx.py 项目: sgagnon/lyman
    def plot_boxes(self, peaks):
        """Draw a boxplot to show the distribution of copes at peaks."""
        cope_data = nib.load(self.inputs.cope_file).get_data()
        peak_spheres = self._peaks_to_spheres(peaks).get_data()
        peak_dists = np.zeros((cope_data.shape[-1], len(peaks)))
        for i, peak in enumerate(peaks, 1):
            sphere_mean = cope_data[peak_spheres == i].mean(axis=(0))
            peak_dists[:, i - 1] = sphere_mean

        with sns.axes_style("whitegrid"):
            f, ax = plt.subplots(figsize=(9, float(len(peaks)) / 3 + 0.33))

        try:
            # seaborn >= 0.6
            sns.boxplot(data=peak_dists, palette="husl", orient="h", ax=ax)
            labels = np.arange(len(peaks)) + 1
        except TypeError:
            # seaborn < 0.6
            pal = sns.husl_palette(peak_dists.shape[1])[::-1]
            sns.boxplot(peak_dists[:, ::-1], color=pal, ax=ax, vert=False)
            labels = np.arange(len(peaks))[::-1] + 1

        sns.despine(left=True, bottom=True)
        ax.axvline(0, c=".3", ls="--")
        ax.set(yticklabels=labels, ylabel="Local Maximum", xlabel="COPE Value")

        out_fname = op.realpath("peak_boxplot.png")
        self.out_files.append(out_fname)
        f.savefig(out_fname, bbox_inches="tight")
        plt.close(f)
    def plot_facet_grid(self, my_jira_df, my_filename_without_path, my_chart_title, my_output_path, my_relative_output_path, my_png_list):
        with sns.axes_style("white"):
            '''g = sns.FacetGrid(
                    my_jira_df,
                    row="IssueType",
                    col="From",
                    margin_titles=True,
                    size=2.5,
                    hue = 'To')'''
            g = sns.FacetGrid(
                    my_jira_df,
                    row="To",
                    col="From",
                    margin_titles=True,
                    size=2.5,
                    hue='IssueType')
            g.map(plt.scatter,
                  "WeekNum",
                  "DayDiff",
                  color="#334488",
                  edgecolor="white",
                  lw=.5)
            g.set_axis_labels("Week Number", "Days in State")
            g.set(xticks=list(range(0, 101, 20)), yticks=list(range(0, 1001, 100)))
            g.fig.subplots_adjust(wspace=.02, hspace=.02)

        self.save_file(my_filename_without_path, my_chart_title, my_output_path, my_relative_output_path, my_png_list, g)
def find_LowHighTide_Amplitudes(time_array, wl_array, tau=12.42/24., prc=1./24., order=1, plot=False, log=False, datetime_fmt='%d.%m.%Y %H:%M', plot_title="",
                                axeslabel_fontsize=18., title_fontsize=20., axesvalues_fontsize=18., annotation_fontsize=18., legend_fontsize=18.):
    """
        This script should be used with data which has no missing regions. Although it will work with all data, but
        may produce inaccuraces. Missing values should be represented by np.nan in wl_array.


        time_array    - numpy array with datetime objects
        wl_array      - numpy array with measured values of waterlevel. Must have same lenght as time_array
        tau           - float, signal period in days
        prc           - indicates presicion value +- for comparing time diffrerence between found extremums
                        with tidal_cycle
        order         -  integer for scipy.signal.argrelextrema()
        plot          - boolean flag to show plot
        log           - boolean flag to show log

        # tidal cycle is aproximately 12h25min. Each timestep is 10 min => tidal cycle is 74.5 timesteps
        # therefore, maxima and minima will be filtered in a range of 73 to 76 timesteps from each other
        # for safety reasons lets take 720min
    """

    if len(time_array) != len(wl_array):
        raise ValueError('time and waterlevel arays should have equal lenght.\nGot: len(time)={0}, len(wl)={1}'.format( len(time_array), len(wl_array)))
    

    local_maximums = scipy.signal.argrelextrema(wl_array, np.greater_equal, order=order, mode='clip')[0]
    local_minimums = scipy.signal.argrelextrema(wl_array, np.less_equal, order=order, mode='clip')[0]
    
    local_maximums = remove_regions_from_extremums(local_maximums, log=log)
    local_minimums = remove_regions_from_extremums(local_minimums, log=log)

    errors_high = check_extremums_dt(local_maximums, time_array, tau=tau, prc=prc, log=log)
    errors_low = check_extremums_dt(local_minimums, time_array, tau=tau, prc=prc , log=log)
    
    if plot:
        with sns.axes_style("whitegrid"):
            plot_extremums(time_array, wl_array, local_minimums, local_maximums, time_errors_high=errors_high, time_errors_low=errors_low,
                        date_xaxis=True, dt=[tau, prc], plot_title=plot_title,
                        axeslabel_fontsize=axeslabel_fontsize, title_fontsize=title_fontsize, axesvalues_fontsize=axesvalues_fontsize,
                        annotation_fontsize=annotation_fontsize, legend_fontsize=legend_fontsize)

    #####################
    # now create list for return....
    LOW_TIDE = list()
    for v in local_minimums:
        t = time_array[v]
        w = wl_array[v]

        DateTime = datetime.strftime(num2date(t), datetime_fmt)
        LOW_TIDE.append([DateTime, w])
    
    HIGH_TIDE = list()
    for v in local_maximums:
        t = time_array[v]
        w = wl_array[v]

        DateTime = datetime.strftime(num2date(t), datetime_fmt)
        HIGH_TIDE.append([DateTime, w])

    return LOW_TIDE, HIGH_TIDE
示例#27
0
文件: seaborn1.py 项目: EnriqueU/M-L
def seaborn_join():
    data = np.random.multivariate_normal([0, 0], [[5, 2], [2, 2]], size=2000)
    data = pd.DataFrame(data, columns=['x', 'y']) 
    with sns.axes_style('white'):
        sns.jointplot("x", "y", data, kind='hex')
    
    plt.show()
示例#28
0
def get_heatmap(data_mat, name_for_saving_files,  pp,stimulus_on_time, stimulus_off_time,delta_ff, f0_start, f0_end):
    
    #Plot heatmap for validation 
    A1 = np.reshape(data_mat, (np.size(data_mat,0)*np.size(data_mat,1), np.size(data_mat,2)))
    if delta_ff == 1:
        delta_ff_A1 = np.zeros(np.shape(A1))
        for ii in xrange(0,np.size(A1,0)):
            delta_ff_A1[ii,:] = (A1[ii,:]-np.mean(A1[ii,f0_start:f0_end]))/(np.std(A1[ii,f0_start:f0_end])+0.1)
        B = np.argsort(np.mean(delta_ff_A1, axis=1))  
        print np.max(delta_ff_A1)
    else:
        B = np.argsort(np.mean(A1, axis=1)) 
        print np.max(A1)

    with sns.axes_style("white"):
        C = A1[B,:][-2000:,:]

        fig2 = plt.imshow(C,aspect='auto', cmap='jet', vmin = np.min(C), vmax = np.max(C))
        
        plot_vertical_lines_onset(stimulus_on_time)
        plot_vertical_lines_offset(stimulus_off_time)
        plt.title(name_for_saving_files)
        plt.colorbar()
        fig2 = plt.gcf()
        pp.savefig(fig2)
        plt.close()
    def plot_kmeans_components(self, fig1, gs, kmeans_clusters, clrs, plot_title='Hb', num_subplots=1,
                               flag_separate=1, gridspecs=[0, 0]):
        with sns.axes_style('darkgrid'):
            if flag_separate:
                ax1 = fig1.add_subplot(2, 1, num_subplots)
            else:
                ax1 = eval('fig1.add_subplot(gs' + gridspecs + ')')

            plt.gca().set_color_cycle(clrs)
            for ii in xrange(0, size(kmeans_clusters, 1)):
                plt.plot(kmeans_clusters[:, ii], lw=4, label=str(ii))

            plt.locator_params(axis='y', nbins=4)
            sns.axlabel("Time (seconds)", "a.u")
            ax1.legend(prop={'size': 14}, loc='center left', bbox_to_anchor=(1, 0.5), ncol=1, fancybox=True,
                       shadow=True)

            plt.title(plot_title, fontsize=14)

            plt.ylim((min(kmeans_clusters) - 0.0001,
                      max(kmeans_clusters) + 0.0001))
            plt.xlim((0, size(kmeans_clusters, 0)))
            plt.axhline(y=0, linestyle='-', color='k', linewidth=1)
            self.plot_vertical_lines_onset()
            self.plot_vertical_lines_offset()
	def plot_seaborn( self ):

		# https://stanford.edu/~mwaskom/software/seaborn/tutorial/distributions.html

		data = pd.read_csv( 'movement.csv' ).as_matrix()

		# 1/2 3/4 5/6 7/8
		x_column = 3
		y_column = 4

		limit = 100
		data = data[
			  ( data[:,0] == 0)
			& ( data[:,x_column] > -limit )
			& ( data[:,x_column] < limit )
			& ( data[:,y_column] > -limit )
			& ( data[:,y_column] < limit )
		]

		x = data[:,x_column]
		y = data[:,y_column]

		with sns.axes_style( 'white' ):
			sns.jointplot( x=x, y=y, kind='kde' )  # scatter, reg, resid, hex, kde

		sns.plt.show()
示例#31
0
def visualize_cluster_MRFs(cluster_MRFs, directory, args):

    print('> Save sensor network result figures ... ')

    bc_path = os.path.join(  # betweenness centrality csv
        directory, 'bc_matrix(thres=' + str(args.threshold) + ').csv')
    hm_path = os.path.join(  # betweenness centrality heatmap
        directory, 'bc_heatmap(thres=' + str(args.threshold) + ').png')

    ncol = len(COLUMNS_FOR_MODELING_SHORT)
    gp_labels = COLUMNS_FOR_MODELING_SHORT
    BC_array = np.zeros((args.nc, ncol))

    for k, MRF in cluster_MRFs.items():
        # average over diagonal blocks
        MRF_intra_time_list = []
        for i in range(args.ws):
            MRF_intra_time_list.append(MRF[ncol * i:ncol * (i + 1),
                                           ncol * i:ncol * (i + 1)])
        MRF_intra_time = np.mean(MRF_intra_time_list, axis=0)
        # save betweenness centrality scores and graphs
        gp_path = os.path.join(  # networkx graph 
            directory, 'graph_k={}(thres={}).png'.format(k, args.threshold))
        bc_list = _calculate_bc_and_draw_graph(
            MRF_intra_time,
            labels=gp_labels,
            threshold=args.threshold,
            weighted=True,
            title='Graph between Sensors (k={})'.format(k),
            save_to=gp_path)
        BC_array[k, :] = bc_list

    # SAVE betweenness centrality values
    BC_df = pd.DataFrame(BC_array, columns=gp_labels)
    BC_df.to_csv(bc_path)
    # SAVE betweenness centrality heatmap
    with sns.axes_style("white"):
        plt.subplots(figsize=(6, 6))
        sns.heatmap(BC_df, square=True, annot=BC_df)
        plt.savefig(hm_path)
        plt.close('all')

    if args.ws > 1:
        # for each cluster,
        # we will draw cross time graph with timedelta d
        for k, MRF in cluster_MRFs.items():
            for d in range(1, args.ws):  # d: timedelta
                # average over diagonal blocks according to the timedelta
                MRF_cross_time_list = []
                for i in range(args.ws - d):
                    MRF_cross_time_list.append(
                        MRF[ncol * i:ncol * (i + 1),
                            ncol * (i + d):ncol * (i + d + 1)])
                MRF_cross_time = np.mean(MRF_cross_time_list, axis=0)
                gp_crosstime_path = os.path.join(  # networkx graph 
                    directory,
                    'graph_corss_timedelta={}_k={}(thres={}).png'.format(
                        d, k, args.threshold))
                gp_crosstime_labels = \
                    ['{}\n({})'.format(c, t) for t, c in
                        product(['t', 't+{}'.format(d)], COLUMNS_FOR_MODELING_SHORT)]
                _draw_cross_time_graph(
                    MRF_cross_time,
                    labels=gp_crosstime_labels,
                    threshold=args.threshold,
                    weighted=True,
                    title='Cross-time Graph (timedelta={}, k={})'.format(d, k),
                    save_to=gp_crosstime_path)
示例#32
0
def bcm_obj(s_rt_wt, w_min, w_max, reso, para, obj_select=None, nonlinear_select=None, ori_w=0):
    """
    Parameter: 
    s_rt_wt: input data, num of samples * dimension
    w_min: mininum range of objective function landscape
    w_max: maximun range of objective function landscape
    reso: resolution of weights grid
    para: parameters for training local learnin rule 
    ori_w: for laplace data, plot the original weights
    obj_select: str, type of objective function if specified, sweep across all combination if none
    Nolinear_select: str, type of nonlinearity if specified, sweep across all combination if none
    """

    w = np.linspace(w_min, w_max, reso)
    wx, wy = np.meshgrid(w, w)
    w = np.vstack((wx.ravel(), wy.ravel()))
    obj_choice = ['QBCM', 'kurtosis']
    nonlinear_choice = ['Relu', 'Sigmoid', 'None']

    # parameter passed through para
    p = para[0]
    ny = para[1]
    tau = para[2]
    batch = para[3]
    n_epoch = para[4]
    decay = para[5]
    eta = para[6]

    # Plot a gallery of images
    # if nolinearty and objective defined, train for a specific case, otherwise, train all the combinations
    if obj_select == None:
        n_row = len(obj_choice)
    else:
        n_row = 1
        obj_index = obj_choice.index(obj_select)

    if nonlinear_select == None:
        n_col = len(nonlinear_choice)
    else:
        n_col = 1
        nonlinear_index = nonlinear_choice.index(nonlinear_select)

    fig, ax = plt.subplots(n_row, n_col, figsize=(12, 6), sharex=True, sharey=True)
    ori_w = ori_w * (w_max ** 0.5)

    for i in range(n_row):
        for j in range(n_col):
            if (n_row + n_col) > 2:
                obj_type = obj_choice[i]
                nonlinear = nonlinear_choice[j]
                para_index = i * n_col + j
            else:
                obj_type = obj_select
                nonlinear = nonlinear_select
                para_index = obj_index * len(nonlinear_choice) + nonlinear_index

            obj_landscape = obj(s_rt_wt, w, obj_type=obj_type, nonlinear=nonlinear)
            title_set = [obj_type, nonlinear]

            nbins = 20
            levels = np.percentile(obj_landscape, np.linspace(0, 100, nbins))

            with sns.axes_style('white'):
                if (n_row + n_col) > 2:
                    g = ax[i, j]
                else:
                    g = ax

                c = g.contour(wx, wy, obj_landscape.reshape(wx.shape), levels=levels, zorder=-10,
                              cmap=plt.cm.get_cmap('viridis'))
                g.plot(s_rt_wt[:, 0], s_rt_wt[:, 1], '.k', ms=4)
                g.set_aspect(1)

            plt.grid('on', rasterized= True)
            plt.colorbar(c, ax=g)
            plt_title = ['Uniform', str((i+1)*(j+1)),'.pdf']
            plt.savefig(''.join(plt_title))

            # Training with BCM local learning rule

            bcm_data = bcm(eta=eta[para_index], n_epoch=n_epoch[para_index], batch=batch, ny=ny, tau=tau, thres=0, p=p,
                           random_state=None, nonlinear=nonlinear, obj_type=obj_type,
                           decay=decay[para_index])

            bcm_data.fit(s_rt_wt)
            bcm_data_w = np.vstack(bcm_data.w_track)

            if len(ori_w) > 1:
                g.plot([0, ori_w[0][0]], [0, ori_w[0][1]], rasterized= True, color = '0.3')
                g.plot([0, ori_w[1][0]], [0, ori_w[1][1]], rasterized= True, color = '0.3')

            g.plot(bcm_data_w[:, 0], bcm_data_w[:, 1], 'm', rasterized= True)
            g.plot(bcm_data_w[-1, 0], bcm_data_w[-1, 1], 'y*', ms=15, rasterized= True)
            g.plot(bcm_data_w[:, 2], bcm_data_w[:, 3], 'b', rasterized= True)
            g.set_title(title_set)
            g.plot(bcm_data_w[-1, 2], bcm_data_w[-1, 3], 'y*', ms=15, rasterized= True)
示例#33
0
from kalman3D import estimate_pose
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
import sys
from pathlib import Path
import seaborn as sns

sns.set()
sns.axes_style("white")
sns.set_style("whitegrid", {
    "xtick.major.size": 0,
    "ytick.major.size": 0,
    'grid.linestyle': '--'
})
sns.set_context("paper", font_scale=1, rc={"grid.linewidth": .5})
sns.set_palette("colorblind")

directory = '~/Research-Files/Videos/Discharges and Modes/A1+A2/'
dev_run = True


def batch_kalman(directory, dev_run):
    print('What is dev_run? It is: {}'.format(dev_run))

    if dev_run == True:
        dpi = 150
        print('dpi is 150')
    else:
        dpi = 300
示例#34
0
    def plot_phrase_stats(self, DF2=None):

        ind_var_name = "session"
        for data_label in [
                'error_unc', 'error_unc', 'error_cor', 'clicks_char',
                'chars_min'
        ]:

            var_name_dict = {
                'sel_min': "Selections/Min",
                'words_min': "Words/Min",
                'chars_min': "Characters/Min",
                'clicks_char': "Clicks/Character",
                'clicks_word': "Clicks/Word",
                'clicks_sel': "Clicks/Selection",
                'error_unc': "Uncorrected Error Rate (%)",
                'error_cor': "Corrections/Selections (%)"
            }

            dep_var_name = var_name_dict[data_label]

            DF = self.DF
            pd.set_option('display.max_columns', 500)

            fig, ax = plt.subplots()
            fig.set_size_inches(10, 8)
            sns.set(font_scale=1.4, rc={"lines.linewidth": 3})
            sns.set_style({'font.serif': 'Helvetica'})

            if DF2 is not None:
                sns.lineplot(x=ind_var_name,
                             y=data_label,
                             color="rosybrown",
                             data=DF2,
                             ci="sd",
                             ax=ax)

                sns.lineplot(x=ind_var_name,
                             y=data_label,
                             color="brown",
                             data=DF2,
                             ax=ax)

            sns.lineplot(x=ind_var_name,
                         y=data_label,
                         color="cadetblue",
                         data=DF,
                         ci="sd",
                         ax=ax)

            sns.lineplot(x=ind_var_name,
                         y=data_label,
                         color="darkslategrey",
                         data=DF,
                         ax=ax)

            ax.set(xlabel=ind_var_name, ylabel=dep_var_name)

            plt.legend(title='Key:',
                       labels=[
                           'Row Col (SD)', '       (95% CI)', 'Nomon (SD)',
                           '     (95% CI)'
                       ])

            plt.title("Webcam Double Switch: " + dep_var_name + " vs. " +
                      ind_var_name)
            sns.axes_style("darkgrid")
            plt.show()
def plot_preprocess_data(Working_Directory, name_for_saving_files, data,
                         stimulus_on_time, stimulus_off_time, time_baseline):

    #### Plot subset of data to view ########

    # To save as pdf create file
    start_time = time.time()
    print 'Plotting centered data...in ' + Working_Directory
    text_file = open(Working_Directory + "log.txt", "a")
    text_file.write("Plotting centered data in %s \n" % Working_Directory)

    #Save some data wide statistics to text file

    print 'Data Statistics :'
    print 'Series Mean :' + str(data.seriesMean().first())
    text_file = open(Working_Directory + "log.txt", "a")
    text_file.write("Series Mean : %s \n" % str(data.seriesMean().first()))

    print 'Series Std :' + str(data.seriesStdev().first())
    text_file = open(Working_Directory + "log.txt", "a")
    text_file.write("Series Std : %s \n" % str(data.seriesStdev().first()))

    from numpy import random
    signal = random.randn(data.index.shape[0])
    print 'Series Corrrelation :' + str(data.correlate(signal).first())
    text_file = open(Working_Directory + "log.txt", "a")
    text_file.write("Series Corrrelation : %s \n" %
                    str(data.correlate(signal).first()))

    ## Plot some data related figures
    Figure_PDFDirectory = Working_Directory + filesep + 'Figures' + filesep
    if not os.path.exists(Figure_PDFDirectory):
        os.makedirs(Figure_PDFDirectory)
    pp = PdfPages(Figure_PDFDirectory + name_for_saving_files +
                  '_PreprocessedData.pdf')

    with sns.axes_style("darkgrid"):
        fig2 = plt.figure()
        examples = data.center().subset(nsamples=100, thresh=1)
        if np.size(examples) != 0:
            plt.plot(examples.T[:, :])
            plot_vertical_lines_onset(stimulus_on_time)
            plot_vertical_lines_offset(stimulus_off_time)
            plt.tight_layout()
            fig2 = plt.gcf()
            pp.savefig(fig2)
            plt.close()

    with sns.axes_style("darkgrid"):
        fig3 = plt.figure()

        examples = data.zscore(time_baseline).subset(nsamples=100, thresh=2)
        if np.size(examples) != 0:
            plt.plot(examples.T[:, :])
            plot_vertical_lines_onset(stimulus_on_time)
            plot_vertical_lines_offset(stimulus_off_time)
            plt.tight_layout()
            fig2 = plt.gcf()
            pp.savefig(fig3)
            plt.close()

        fig4 = plt.figure()
        plt.plot(data.center().max())
        plt.plot(data.center().mean())
        plt.plot(data.center().min())
        plot_vertical_lines_onset(stimulus_on_time)
        plot_vertical_lines_offset(stimulus_off_time)
        plt.tight_layout()
        fig2 = plt.gcf()
        pp.savefig(fig4)

        plt.close()
        pp.close()

        print 'Plotting centered data took ' + str(
            int(time.time() - start_time)) + ' seconds'
        text_file.write("Plotting centered data took %s seconds \n" %
                        str(int(time.time() - start_time)))
示例#36
0
print mean_squared_error(Y_predicted, Y_test)

coeffs = zip(X_test.columns.values, clf.coef_)

import matplotlib
import seaborn

predvsact = pd.DataFrame(zip(Y_predicted, Y_test))
predvsact.columns = ['predicted', 'actual']

clean_data['predicted_log(ROI)'] = clf.predict(clean_data[features])
clean_data['log(ROI)'] = [np.log(value) for value in clean_data['ROI-total']]
clean_data['resid'] = clean_data['log(ROI)'] - clean_data['predicted_log(ROI)']

import matplotlib.pyplot as plt
with seaborn.axes_style('white'):
    plot = clean_data.plot(kind='scatter',
                           x='predicted_log(ROI)',
                           y='log(ROI)',
                           alpha=0.5,
                           figsize=(10, 6))
    seaborn.despine()
    plot.set_title("How well does our model predict ROI?")
    plot.set_xlim([-1, 5])
    plot.set_ylim([-1, 5])
    plot.set_xlabel('predicted_log(ROI)')
    plot.set_ylabel('log(ROI)')
    plt.plot(clean_data['log(ROI)'], clean_data['log(ROI)'], 'r')

with seaborn.axes_style('white'):
    plot = clean_data.plot(kind='scatter',
示例#37
0
print(electronics_data.info())

#Five point summary

print(electronics_data.describe()['Rating'].T)

#Find the minimum and maximum ratings
print('Minimum rating is: %d' % (electronics_data.Rating.min()))
print('Maximum rating is: %d' % (electronics_data.Rating.max()))

#Check for missing values
print('Number of missing values across columns: \n',
      electronics_data.isnull().sum())

# Check the distribution of the rating
with sns.axes_style('white'):
    g = sns.factorplot("Rating",
                       data=electronics_data,
                       aspect=2.0,
                       kind='count')
    g.set_ylabels("Total number of ratings")

print("Total data ")
print("-" * 50)
print("\nTotal no of ratings :", electronics_data.shape[0])
print("Total No of Users   :", len(np.unique(electronics_data.userId)))
print("Total No of products  :", len(np.unique(electronics_data.productId)))

#Dropping the Timestamp column

electronics_data.drop(['timestamp'], axis=1, inplace=True)
示例#38
0
#    if i>5:
#        plt.xlabel('t (Gyr)')
#    if np.mod(i,3)==0:
#        plt.ylabel('SFR (M$\odot$/yr)')
#    plt.legend(loc=4, fontsize=10, frameon=True, facecolor='w')
#    plt.xlim(1e-4,1e3)
#plt.tight_layout()
#cbar_ax = fig.add_axes([0.2, 0.25, 0.6, 0.03])
#colorbar = fig.colorbar(s, orientation='horizontal',cax=cbar_ax)
#colorbar.set_label('Phase')
#plt.show()

#==============================================================================
# Plotting quantities in Aldo table
#==============================================================================
with sns.axes_style("ticks"):
    fig, axes = plt.subplots(figsize=(9, 8), nrows=2, ncols=2)
    for (m, c) in zip(M_today.astype('str'),
                      ['m', 'b', 'g', 'orange', 'firebrick']):
        for i, (ax, col, ylab) in enumerate(
                zip(axes.ravel(), ['lgMs', 'lgMh', 'SFR', 'SFR'], [
                    'log M$_*$(M$_\odot$)', 'log M$_{halo}$(M$_\odot$)',
                    'log SFR(M$_\odot$/yr)', 'log sSFR(yr$^{-1}$)'
                ])):
            if i == 2:
                ax.plot(Data[m].t,
                        np.log10(Data[m][col]),
                        c=c,
                        label='log M$_{today}$ = %s' % m,
                        alpha=0.7)
            elif i == 3:
if __name__ == "__main__":
    if load_run_data_flag:
        args, grid_results_dict = load_run_data(result_dir_to_load)
    else:
        grid_results_dict = run_simulations(args, local_mode)
    l2_grid = grid_results_dict['l2_grid']
    gam_grid = grid_results_dict['gam_grid']
    loss_avg = grid_results_dict['loss_avg']
    loss_std = grid_results_dict['loss_std']

    ci_factor = 1.96 / np.sqrt(args.n_reps)  # 95% confidence interval factor
    max_deviate = 100. * np.max(loss_std * ci_factor / loss_avg)
    print('Max 95% CI relative to mean: ', max_deviate, '%')

    # fig, ax = plt.subplots(figsize=(7, 7))
    with sns.axes_style("white"):

        yticklabels = np.around(l2_grid * 1e5, decimals=3)
        yticklabels = np.round(yticklabels).astype(int)
        xticklabels = np.around(gam_grid, decimals=3)
        ax = sns.heatmap(loss_avg,
                         cmap="YlGnBu",
                         xticklabels=xticklabels,
                         yticklabels=yticklabels,
                         annot=True,
                         annot_kws={"size": 8})
        ax.set_yticklabels(ax.get_yticklabels(), rotation=0)
        plt.xlabel(r'Guidance Discount Factor $\gamma$')
        plt.ylabel(r'$L_2$ Regularization Factor [1e-5')
        if save_PDF:
            save_fig(args.run_name)
示例#40
0
from PyQt5 import QtCore
from PyQt5.QtCore import pyqtSlot
from PyQt5.Qt import Qt

# Matplotlib stuff
import matplotlib as mpl
import numpy as np
from matplotlib.figure import Figure
import seaborn as sns
import h5py
import ast
import copy
sns.set_style('ticks')
sns.set_context('paper')
sns.axes_style({
    'font.family': ['monospace'],
    'font.sans-serif': ['monospace']
})
sns.set(font='sans-serif', style='ticks')
#sns.set_palette('husl')
sns.set_palette('deep')

import yaml

# and here http://www.boxcontrol.net/embedding-matplotlib-plot-on-pyqt5-gui.html

from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
from matplotlib.backend_bases import key_press_handler

fig_dict = '''{
                    'type': 'shade',
    PMTdiff=np.append(PMTdiff,pmt_diffs)
    LAPPDt=np.append(LAPPDt,lappd_ts)
    PMTt=np.append(PMTt,pmt_ts)
    mut = np.append(mut,muon_time)

mutimebinedges = np.arange(-5.0, 20.0, 25.0/NBINS)
ltimebinedges = np.arange(-40.0, 30.0, 70.0/NBINS)
ptimebinedges = np.arange(-40.0, 30.0, 70.0/NBINS)
lbinedges = np.arange(-40.0, 40.0, 80.0/NBINS)
pbinedges = np.arange(-40.0, 40.0, 80.0/NBINS)
#Make this into a numpy histogram and we do a fit to the histogram itself
pmt_timehist, pmt_binedges = np.histogram(PMTdiff,bins=pbinedges)
lappd_timehist, lappd_binedges = np.histogram(LAPPDdiff,bins=lbinedges)

sns.set_style("whitegrid")
sns.axes_style("darkgrid")

xkcd_colors = ['light eggplant', 'black', 'slate blue', 'warm pink', 'green', 'grass']
sns.set_palette(sns.xkcd_palette(xkcd_colors))
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
plt.hist(LAPPDt,bins=ltimebinedges)
plt.ylabel("Entries")
plt.xlabel("LAPPD hit times (ns)")
plt.title("LAPPD hit times after being loaded with DigitBuilder and \n" +\
        "saved to PhaseIITreeMaker",fontsize=30)
plt.show()

xkcd_colors = ['light eggplant', 'black', 'slate blue', 'warm pink', 'green', 'grass']
sns.set_palette(sns.xkcd_palette(xkcd_colors))
fig = plt.figure()
示例#42
0
def plot_theil(methods, res_path, save_plot, obj_func):

    theil, poly, save_plot = path_4_plot(res_path, save_plot, 'valid', methods, obj_func, poly_type=18, proc_sim=False, theil=True)

    s_scl_msk = _soil_canal(poly)

    # tl = {m: {} for m in methods}
    # for m in methods:
    #     for ts, d_u in theil[m].items():
    #         tl[m][ts] = []
    #         for p in range(len(poly)):
    #             tl[m][ts].append([i[p] for i in list(d_u.values())])

    for name, l_poly in s_scl_msk.items():
        N = len(l_poly)
        name = name[0]+name[name.index(',')+2]
        for ts in theil[methods[0]]:
            xticks = [f'Poly{p}' for p in l_poly]

            plt.ioff()
            with sns.axes_style("white"):
                sns.set_style("ticks")
                sns.set_context("talk")

                # plot details
                bar_width = 0.15
                epsilon = .005
                line_width = 1
                opacity = 0.7

                def _plt_bar(bar_pos, m, ind):
                    if ind == 0:
                        slabel = f'{m} Us'
                        clabel = f'{m} Uc'
                    else:
                        slabel = None
                        clabel = None

                    poly_ind = [np.where(poly == p)[0][0] for p in l_poly]
                    u_data = {u: np.take(theil[m][ts][u], poly_ind) for u in theil[m][ts]}

                    plt.bar(bar_pos, u_data['Um'], bar_width,
                                              color=clr_marker(mtd_clr=True)[m],
                                              label=f'{m} Um')
                    plt.bar(bar_pos, u_data['Us'], bar_width - epsilon,
                                              bottom=u_data['Um'],
                                              alpha=opacity,
                                              color='white',
                                              edgecolor=clr_marker(mtd_clr=True)[m],
                                              linewidth=line_width,
                                              hatch='//',
                                              label=slabel)
                    plt.bar(bar_pos, u_data['Uc'], bar_width - epsilon,
                                               bottom=u_data['Um'] + u_data['Us'],
                                               alpha=opacity,
                                               color='white',
                                               edgecolor=clr_marker(mtd_clr=True)[m],
                                               linewidth=line_width,
                                               hatch='0',
                                               label=clabel)

                bar_position = {m: np.arange(N)+i*bar_width for i, m in enumerate(methods)}

                for m in methods:
                    _plt_bar(bar_position[m], m, ind=methods.index(m))
                pos_tick = []
                for i in range(N):
                    pos_tick.append(np.average([v[i] for m, v in bar_position.items()]))

                plt.xticks(pos_tick, xticks, rotation=45, fontsize=6)
                plt.legend(bbox_to_anchor=(0.98, 1.1), fontsize=5)
                plt.ylabel('Errors')
                sns.despine()
                plt.savefig(save_plot+f'{ts}_{name}', dpi=500)
                plt.clf()
示例#43
0
def trim_load_param(fname, load_params):
    '''
    Opens the directed csv file and returns the arrays we want

    Returns: X_t, U_t, dX_t, objv_t, Ts_t, time, terminal
    '''

    # Grab params
    delta_state = load_params['delta_state']
    include_tplus1 = load_params['include_tplus1']
    takeoff_points = load_params['takeoff_points']
    trim_0_dX = load_params['trim_0_dX']
    find_move = load_params['find_move']
    trime_large_dX = load_params['trime_large_dX']
    bound_inputs = load_params['bound_inputs']
    input_stack = load_params['stack_states']
    collision_flag = load_params['collision_flag']
    shuffle_here = load_params['shuffle_here']
    timestep_flags = load_params['timestep_flags']
    battery = load_params['battery']
    fastLog = load_params['fastLog']
    contFreq = load_params['contFreq']
    bat_trim = load_params['trim_high_vbat']
    zero_yaw = load_params['zero_yaw']

    with open(fname, "rb") as csvfile:
        # laod data
        new_data = np.loadtxt(csvfile, delimiter=",")

        # zero yaw to starting condition
        if zero_yaw:
            new_data[:, 5] = new_data[:, 5] - new_data[0, 5]
            # raise NotImplementedError("Need to implement Yaw zeroing with wrap around of angles")

        ########### THESE BARS SEPARATE TRIMMING ACTIONS #########################
        # For now, remove the last 4 columns becausee they're PWMS
        if np.shape(new_data)[1] == 20:
            new_data = new_data[:, :16]

        if bat_trim > 0:
            vbat = new_data[:, -1]
            new_data = new_data[vbat < bat_trim, :]

        # add pwm latency calculations
        pwm_rec = new_data[:, 9:13]
        pwm_com = new_data[:, 16:]
        # for each pwm in pwm_com
        # find the earliest next index in the pwm_rec
        # for each command record the delta index in a new array
        #    this new array should be of length Uchange?

        # Finds the points where the input changes
        if fastLog:
            Uchange = np.where(new_data[:-1, 9:13] != new_data[1:, 9:13])
            Uchange = np.unique(Uchange)
            # print(np.shape(Uchange))
            # print(Uchange)

            # If control freq is faster, sample twice in the interval for each unique PWM point
            if contFreq > 1:
                if contFreq == 2:  # training for twice control rate
                    dT = Uchange[1:] - Uchange[:-1]
                    add = Uchange[1:] - np.round(dT / 2)
                    Uchange = np.concatenate([Uchange, add])
                    Uchange = np.sort(Uchange).astype(int)
                    new_data = new_data[Uchange, :]

                if contFreq == 3:  # training for three times control rate (150Hz when sampled at 50)
                    dT = Uchange[1:] - Uchange[:-1]
                    add = Uchange[1:] - np.round(dT / 3)
                    add2 = Uchange[1:] - np.round(2 * dT / 3)
                    Uchange = np.concatenate([Uchange, add, add2])
                    Uchange = np.sort(Uchange).astype(int)
                    new_data = new_data[Uchange, :]

            # Else sample each unique point once
            else:
                new_data = new_data[Uchange, :]

        ###########################################################################
        # adding to make the input horizontally stacked set of inputs, rather than only the last input because of spinup time
        if input_stack > 1:
            n, du = np.shape(new_data[:, 9:13])
            _, dx = np.shape(new_data[:, :9])
            U = np.zeros((n - input_stack + 1, du * input_stack))
            X = np.zeros((n - input_stack + 1, dx * input_stack))
            for i in range(input_stack, n + 1, 1):
                U[i - input_stack, :] = np.flip(new_data[i - input_stack:i,
                                                         9:13],
                                                axis=0).reshape(1, -1)
                X[i - input_stack, :] = np.flip(new_data[i -
                                                         input_stack:i, :9],
                                                axis=0).reshape(1, -1)

            if delta_state:
                # Starts after the data that has requesit U values
                dX = X[1:, :dx] - X[:-1, :dx]
                X = X[:-1, :]
                U = U[:-1, :]
                if battery:
                    batt = np.array(new_data[input_stack - 1:-1, -1, None])
                    X = np.hstack((X, batt))

                Time = new_data[input_stack - 1:, 13]
                Ts = (
                    Time[1:] - Time[:-1]
                ) / 1000000  # converts deltaT to ms for easy check if data was dropped
                Objv = new_data[input_stack - 1:-1, 14]
                Time = Time[:-1]
            else:  # next state predictions
                dX = X[1:, :dx]  # -X[:-1,:]
                X = X[:-1, :]
                U = U[:-1, :]
                if battery:
                    batt = np.array(new_data[input_stack - 1:-1, -1, None])
                    X = np.hstack((X, batt))
                Time = new_data[input_stack - 1:, 13]
                Ts = (
                    Time[1:] - Time[:-1]
                ) / 1000000  # converts deltaT to ms for easy check if data was dropped
                Objv = new_data[input_stack - 1:-1, 14]
                Time = Time[:-1]

        ###########################################################################

        else:
            if delta_state:
                X = new_data[1:-2, :9]
                U = new_data[1:-2, 9:13]
                if battery:
                    batt = new_data[1:-2, -1, None]
                    X = np.hstack((X, batt))
                Time = new_data[1:-2, 13]
                Objv = new_data[1:-2, 14]

                # Reduces by length one for training
                dX = X[1:, :] - X[:-1, :]
                X = X[:-1, :]
                U = U[:-1, :]
                Ts = (
                    Time[1:] - Time[:-1]
                ) / 1000000  # converts deltaT to ms for easy check if data was dropped
                Objv = Objv[:-1]
                Time = Time[:-1]
            else:
                X = new_data[1:-2, :9]
                U = new_data[1:-2, 9:13]
                if battery:
                    batt = new_data[1:-2, -1, None]
                    X = np.hstack((X, batt))
                Time = new_data[1:-2, 13]
                Objv = new_data[1:-2, 14]

                # Reduces by length one for training
                dX = X[1:, :]  # -X[:-1,:]
                X = X[:-1, :]
                U = U[:-1, :]
                Ts = (
                    Time[1:] - Time[:-1]
                ) / 1000000  # converts deltaT to ms for easy check if data was dropped
                Objv = Objv[:-1]
                Time = Time[:-1]

        ###########################################################################

        # trim some points from takeoff is so desired
        if takeoff_points > 0 and not fastLog:
            takeoff_num = takeoff_points
            X = X[takeoff_num:, :]
            U = U[takeoff_num:, :]
            dX = dX[takeoff_num:, :]
            Objv = Objv[takeoff_num:]
            Ts = Ts[takeoff_num:]
            Time = Time[takeoff_num:]

        ###########################################################################

        if (bound_inputs != []):
            low_bound = bound_inputs[0]
            up_bound = bound_inputs[1]

            # Remove data where U = 0
            X = X[np.array(np.all(U != 0, axis=1)), :]
            dX = dX[np.array(np.all(U != 0, axis=1)), :]
            Objv = Objv[np.array(np.all(U != 0, axis=1))]
            Ts = Ts[np.array(np.all(U != 0, axis=1))]
            Time = Time[np.array(np.all(U != 0, axis=1))]
            U = U[np.array(np.all(U != 0, axis=1)), :]

            # # Remove other values
            Uflag = ~((U[:, 0] > up_bound) | (U[:, 1] > up_bound) |
                      (U[:, 2] > up_bound) | (U[:, 3] > up_bound) |
                      (U[:, 0] < low_bound) | (U[:, 1] < low_bound) |
                      (U[:, 2] < low_bound) | (U[:, 3] < low_bound))
            # print(Uflag)
            X = X[Uflag, :]
            U = U[Uflag, :]
            dX = dX[Uflag, :]
            Objv = Objv[Uflag]
            Ts = Ts[Uflag]
            Time = Time[Uflag]

        ###########################################################################
        # timestep flag of 0 removes points where a 0 timestep is recorded.
        #   looks for data where all timesteps are 0. Can change true to false if
        #   that is so. Then removes all points higher than the second point
        if timestep_flags != []:
            for trim in timestep_flags:
                if np.mean(Ts) < 1:
                    print(
                        '~NOTE: heavy trimming may occur, timestamps may be corrupted'
                    )
                if trim == 0 and True:
                    # Remove data where Ts = 0
                    X = X[np.array(np.where(Ts > 1)).flatten(), :]
                    U = U[np.array(np.where(Ts > 1)).flatten(), :]
                    dX = dX[np.array(np.where(Ts > 1)).flatten(), :]
                    Objv = Objv[np.array(np.where(Ts > 1)).flatten()]
                    Ts = Ts[np.array(np.where(Ts > 1)).flatten()]
                    Time = Time[np.array(np.where(Ts > 1)).flatten()]
                else:
                    # Remove data where the timestep is wrong
                    # Remove data if timestep above 10ms
                    X = X[np.array(np.where(Ts < trim)).flatten(), :]
                    U = U[np.array(np.where(Ts < trim)).flatten(), :]
                    dX = dX[np.array(np.where(Ts < trim)).flatten(), :]
                    Objv = Objv[np.array(np.where(Ts < trim)).flatten()]
                    Ts = Ts[np.array(np.where(Ts < trim)).flatten()]
                    Time = Time[np.array(np.where(Ts < trim)).flatten()]

        ###########################################################################

        # for if the data may include collisions. Check to match this with the
        #   emergency off command when you were collecting data
        if collision_flag and delta_state:
            # Remove all data for a set of flags
            # YPR step in (-7.5,7.5) deg
            # omega step in (-100,100) deg/s^2
            # accel step in (-10,10) m.s^2
            # STATE FLAGS

            # Create flag for collisions!
            collision_flag = (((X[:, 6] < -8)) | ((X[:, 7] < -8)) |
                              ((X[:, 8] < -8)) | (abs(dX[:, 0]) > 75) |
                              (abs(dX[:, 1]) > 75) | (abs(dX[:, 2]) > 75))

            if len(np.where(collision_flag == True)[0]) > 0:
                idx_coll1 = min(np.where(collision_flag == True)[0])
            else:
                idx_coll1 = len(Ts)

            X = X[:idx_coll1, :]
            dX = dX[:idx_coll1, :]
            Objv = Objv[:idx_coll1]
            Ts = Ts[:idx_coll1]
            Time = Time[:idx_coll1]
            U = U[:idx_coll1, :]

        ###########################################################################

        # trims large change is state as we think they are non-physical and a
        #   result of the sensor fusion. Note, this could make prediction less stable
        if trime_large_dX and delta_state:
            # glag = (
            #     ((dX[:,0] > -40) & (dX[:,0] < 40)) &
            #     ((dX[:,1] > -40) & (dX[:,1] < 40)) &
            #     ((dX[:,2] > -40) & (dX[:,2] < 40)) &
            #     ((dX[:,3] > -10) & (dX[:,3] < 10)) &
            #     ((dX[:,4] > -10) & (dX[:,4] < 10)) &
            #     ((dX[:,5] > -10) & (dX[:,5] < 10)) &
            #     ((dX[:,6] > -8) & (dX[:,6] < 8)) &
            #     ((dX[:,7] > -8) & (dX[:,7] < 8)) &
            #     ((dX[:,8] > -8) & (dX[:,8] < 8))
            # )
            glag = (((dX[:, 3] > -7.5) &
                     (dX[:, 3] < 7.5)) & ((dX[:, 4] > -7.5) & (dX[:, 4] < 7.5))
                    & ((dX[:, 5] > -7.5) &
                       (dX[:, 5] < 7.5)) & ((dX[:, 6] > -8) & (dX[:, 6] < 8)) &
                    ((dX[:, 7] > -8) & (dX[:, 7] < 8)) & ((dX[:, 8] > -8) &
                                                          (dX[:, 8] < 8)))
            #
            X = X[glag, :]
            dX = dX[glag, :]
            Objv = Objv[glag]
            Ts = Ts[glag]
            Time = Time[glag]
            U = U[glag, :]

        ###########################################################################
        # removes tuples with 0 change in an angle (floats should surely always change)
        if trim_0_dX and delta_state:
            Objv = Objv[np.all(dX[:, 3:6] != 0, axis=1)]
            Ts = Ts[np.all(dX[:, 3:6] != 0, axis=1)]
            Time = Time[np.all(dX[:, 3:6] != 0, axis=1)]
            X = X[np.all(dX[:, 3:6] != 0, axis=1)]
            U = U[np.all(dX[:, 3:6] != 0, axis=1)]
            dX = dX[np.all(dX[:, 3:6] != 0, axis=1)]
        ###########################################################################

        # We do this again when training.
        if shuffle_here:
            # SHUFFLES DATA
            shuff = np.random.permutation(len(Time))
            X = X[shuff, :]
            dX = dX[shuff, :]
            Objv = Objv[shuff]
            Ts = Ts[shuff]
            Time = Time[shuff]
            U = U[shuff, :]

        if find_move:
            # move_idx = np.argmax(np.all(dX[:,3:5] > 0.005, axis=1))
            move_idx = np.argmax(Objv != -1)
            move_idx = int(2 * move_idx / 3)

        ###########################################################################

        # Can be used to plot trimmed data
        if False:
            font = {'size': 18}

            matplotlib.rc('font', **font)
            matplotlib.rc('lines', linewidth=2.5)

            # plt.tight_layout()

            with sns.axes_style("darkgrid"):
                ax1 = plt.subplot(311)
                ax2 = plt.subplot(312)
                ax3 = plt.subplot(313)

            ax1.plot(X[:, 3:5])
            ax2.plot(U[:, :4])
            ax3.plot(X[:, 6:9])
            plt.show()

        # Make time counting up from first point
        if len(Time) > 0:
            Time -= min(Time[move_idx:])
            Time /= 1000000

        # end of traj marker
        terminals = np.zeros(len(Time))
        if len(terminals) > 0: terminals[-1] = 1

        return np.array(X), np.array(U), np.array(dX), np.array(
            Objv), np.array(Ts), np.array(Time), terminals
def draw_meta_or_not_curve_figure(dump_file_path):
    data_dict = defaultdict(dict)
    for mode in ["meta", "vanilla"]:
        json_file_path = "/home1/machen/meta_perturbations_black_box_attack/logs/AblationStudy_meta_or_not@CIFAR-10-cw_loss-l2-untargeted-mse/meta_mode_{}_WRN-28-10-drop_result.json".format(
            mode)

        with open(json_file_path, "r") as file_obj:
            data_txt = file_obj.read().replace(
                '"not_done_loss": NaN, "not_done_prob": NaN,', "")
            json_data = json.loads(data_txt.strip())
            data_dict[mode]["is_finetune"] = [
                is_finetune for iter, is_finetune in sorted(
                    json_data["logits_error_finetune_iteration"].items(),
                    key=lambda e: int(e[0]))
            ]
            data_dict[mode]["MSE_error"] = [
                MSE_error for iter, MSE_error in sorted(
                    json_data["logits_error_iteration"].items(),
                    key=lambda e: int(e[0]))
            ]
    # plt.style.use('seaborn-whitegrid')
    with sns.axes_style("whitegrid", rc={"legend.framealpha": 0.5}):
        plt.figure(figsize=(10, 8))
        colors = {
            "deep_benign_images": 'm',
            "vanilla": "b",
            "meta": 'r',
            "uninitial": 'y'
        }
        xtick_max = 125
        for mode, data_info in data_dict.items():
            x = np.arange(xtick_max) + 1
            y = np.array(data_info["MSE_error"][:xtick_max])
            is_finetune_list = data_info["is_finetune"][:xtick_max]
            if mode == "meta":
                simulator_name = "Simulator Attack"
            elif mode == "vanilla":
                simulator_name = "Vanilla Simulator"
            elif mode == "deep_benign_images":
                simulator_name = "Simulator$_{benign}$"
            else:
                simulator_name = "Rnd_init Simulator"
            line, = plt.plot(
                x,
                y,
                label=r"$\ell_2$ norm attack of {}".format(simulator_name),
                color=colors[mode],
                linestyle="-")
        first_finetune = True
        for x_, is_finetune in enumerate(is_finetune_list):
            if is_finetune == 1:
                if first_finetune:
                    plt.axvline(x=x_ + 1,
                                color='#778899',
                                linestyle='--',
                                linewidth=1,
                                label="fine-tune iterations")
                    first_finetune = False
                else:
                    plt.axvline(x=x_ + 1,
                                color='#778899',
                                linestyle='--',
                                linewidth=1)

        plt.xlim(min(x.tolist()), max(x.tolist()))
        plt.ylim(0, 20)
        plt.gcf().subplots_adjust(bottom=0.15)
        # xtick = [0, 5000, 10000]
        plt.xticks([1, 10] + np.arange(25, xtick_max + 1, 25).tolist(),
                   fontsize=22)
        plt.yticks([0, 5, 10, 15, 20], fontsize=22)
        plt.xlabel("attack iterations", fontsize=25)
        plt.ylabel("MSE of the outputs", fontsize=25)
        plt.legend(loc='upper right',
                   prop={'size': 22},
                   fancybox=True,
                   framealpha=0.5)
        # legend = plt.legend(loc='upper right', prop={'size': 15}, shadow=True, facecolor="white")
        # legend.get_frame().set_facecolor('#E6E6FA')
        plt.savefig(dump_file_path, dpi=200)
示例#45
0
def jointplot():
    x, y = np.random.multivariate_normal([1, 2], [[1, 2], [1, 2]], 1000).T
    with sns.axes_style("white"):
        return sns.jointplot(x=x, y=y, kind="hex", color="k")
symlist = ['o', 'p', '*', 's', '+', 'x', 'D', 'v', '-', '^']

rc('font', **{'family': 'sans-serif', 'sans-serif': ['Computer Modern Roman']})
params = {
    'axes.labelsize': 12,
    'font.size': 16,
    'legend.fontsize': 16,
    'text.usetex': True,
    'figure.figsize': (8, 6)
}
plt.rcParams.update(params)

sns.set_context("poster")
sns.set_palette("colorblind")
sns.set_style("white")
sns.axes_style()

###############################################################################
#    Data Generation    (you can skip the understanding)
###############################################################################


def rand_gauss(n=100, mu=[1, 1], sigmas=[0.1, 0.1]):
    """ Sample n points from a Gaussian variable with center mu,
    and std deviation sigma
    """
    d = len(mu)
    res = np.random.randn(n, d)
    return np.array(res * sigmas + mu)

示例#47
0
def plot_categorized_rmse(
    benchmarks: List[Benchmark],
    benchmark_results: List[BenchmarkResult],
    output_directory: str,
    file_type: Literal["png", "pdf"] = "png",
):
    """Plots the RMSE in each benchmarked property partitioned by the assigned
    statistics category.

    Parameters
    ----------
    benchmarks
        The benchmarks which have been performed.
    benchmark_results
        The analyzed outputs of the benchmarks.
    output_directory
        The directory in which to save the plots.
    file_type
        The file type to use for the plots.
    """
    import pandas
    import seaborn
    from matplotlib import pyplot

    # Reshape the statistics into a uniform data frame.
    data_rows = [{
        "Data Type": f"{statistic.property_type}-{statistic.n_components}",
        "Name": benchmark.name,
        "Value": statistic.value,
        "Lower CI": numpy.abs(statistic.lower_95_ci - statistic.value),
        "Upper CI": numpy.abs(statistic.upper_95_ci - statistic.value),
        "Category": statistic.category,
    } for benchmark, result in zip(benchmarks, benchmark_results)
                 for statistic in result.data_set_result.statistic_entries
                 if statistic.statistic_type == StatisticType.RMSE
                 and statistic.category is not None]

    plot_data = pandas.DataFrame(data_rows)

    if len(plot_data) == 0:
        return

    # Extract the unique data types (e.g. property types) which will be plotted
    # in separate figures.
    data_types = plot_data["Data Type"].unique()

    os.makedirs(os.path.join(output_directory, "categorized-rmse"),
                exist_ok=True)

    for data_type in data_types:

        # Extract a data frame containing only the data type which should
        # be included in this figure.
        type_plot_data = plot_data[plot_data["Data Type"] == data_type]

        categories = sorted(type_plot_data["Category"].unique(),
                            key=sort_categories_key,
                            reverse=True)
        category_indices = [x * 2 for x in range(1, len(categories) + 1)]

        n_categories = len(categories)

        with seaborn.axes_style("white"):

            figure, axis = pyplot.subplots(figsize=(5.0, 1.5 +
                                                    (0.5 * n_categories)))

            shifts = numpy.linspace(-0.5, 0.5, len(benchmarks))

            # Plot the data for each benchmark.
            for index, benchmark in enumerate(benchmarks):

                benchmark_plot_data = type_plot_data[type_plot_data["Name"] ==
                                                     benchmark.name]

                # Plot the error bars and with the circle marker on top.
                axis.barh(
                    benchmark_plot_data["Category"].replace(
                        categories, category_indices).values - shifts[index],
                    benchmark_plot_data["Value"],
                    xerr=[
                        benchmark_plot_data["Lower CI"],
                        benchmark_plot_data["Upper CI"],
                    ],
                    height=1.0 / max(len(benchmarks) - 1, 1),
                    label=benchmark.name,
                )

            # Add a simple legend.
            axis.legend()

            # Add title and axis names
            axis.set_yticks(category_indices)
            axis.set_yticklabels(categories)

            axis.set_xlim(left=0.0)
            axis.set_ylim(0.5, (len(categories) + 1) * 2.0 - 0.5)

            axis.set_xlabel("RMSE")

        # Save the figure.
        figure.savefig(
            os.path.join(
                output_directory,
                "categorized-rmse",
                f"{camel_to_kebab_case(data_type)}.{file_type}",
            ),
            bbox_inches="tight",
        )
        pyplot.close(figure)
示例#48
0
#     plt.xlim(Xmin, Xmax)
#     plt.ylim(Ymin, Ymax)
#     plt.xlabel(Xlabel)  # 横轴名
#     plt.ylabel(Ylabel)  # 纵轴名
#     plt.title(Title)
# 按照固定区间长度绘制频率分布直方图
# bins_interval 区间的长度
# margin        设定的左边和右边空留的大小
# def probability_distribution(data, bins_interval, margin):
#     bins = np.arange(min(data), max(data) , bins_interval)
#     plt.xlim(min(data) - margin, max(data) + margin)
#     plt.title("Probability-distribution")
#     plt.xlabel('Interval')
#     plt.ylabel('Probability')
#     #频率分布normed=True,频次分布normed=False
#     plt.hist(x=data, bins=bins, histtype='bar')

# seaborn.set(style='white')
with seaborn.axes_style("dark"):
    seaborn.jointplot(x=width_ratios,
                      y=height_ratios,
                      kind="scatter",
                      color='k',
                      s=10).set_axis_labels("relative width",
                                            "relative height")

# plt.figure(2)
# temp=(area_ratios.tolist())
# probability_distribution(temp,0.001,0)
plt.show()
示例#49
0
* DIS and NOX
* INDUS vs NOX
* LSTAT vs RM
* LSTAT vs PRICE
* RM vs PRICE

Try adding some opacity or `alpha` to the scatter plots using keyword arguments under `joint_kws`.

#### Distance from Employment vs. Pollution

**Challenge**: 

Compare DIS (Distance from employment) with NOX (Nitric Oxide Pollution) using Seaborn's `.jointplot()`. Does pollution go up or down as the distance increases?
"""

with sns.axes_style('darkgrid'):
    sns.jointplot(x=data['DIS'],
                  y=data['NOX'],
                  height=8,
                  kind='scatter',
                  color='deeppink',
                  joint_kws={'alpha': 0.5})

plt.show()
"""We see that pollution goes down as we go further and further out of town. This makes intuitive sense. However, even at the same distance of 2 miles to employment centres, we can get very different levels of pollution. By the same token, DIS of 9 miles and 12 miles have very similar levels of pollution.

#### Proportion of Non-Retail Industry 🏭🏭🏭 versus Pollution 

**Challenge**: 

Compare INDUS (the proportion of non-retail industry i.e., factories) with NOX (Nitric Oxide Pollution) using Seaborn's `.jointplot()`. Does pollution go up or down as there is a higher proportion of industry?
示例#50
0
def plt_param_ranges(labelnames,
                     dims,
                     runs_sort,
                     num_plt,
                     synth_data=None,
                     save_fig=''):
    # fig, (ax1) = plt.subplots(1, 1, figsize=(3,3))
    fig, (ax1) = plt.subplots(1, 1, figsize=(2.5, 1.5))

    #     pal = sns.set_palette(param_colors.get(m_name))

    # Hide the right and top spiness
    ax1.spines['right'].set_visible(False)
    ax1.spines['top'].set_visible(False)

    # Only show ticks on the left and bottom spines
    ax1.yaxis.set_ticks_position('left')
    ax1.xaxis.set_ticks_position('bottom')

    major_ticks = np.arange(-2, 2.1, 1)
    ax1.set_yticks(major_ticks)

    #data handling
    df_param = pd.DataFrame(runs_sort[1][:num_plt])
    df_param.columns = labelnames
    df_param_log = df_param.apply(np.log10)
    df_melt = df_param_log.melt(var_name='param', value_name='vals')

    df_error = pd.DataFrame(runs_sort[0][:num_plt], columns=['error'])
    mses_df = df_error['error'].copy()
    mses_df = pd.concat([mses_df] * 5, ignore_index=True)
    df_plot = pd.concat([df_melt, mses_df], axis=1)

    pal = sns.light_palette("purple", reverse=True, as_cmap=True)
    #     cmap    = sns.light_palette("seagreen", reverse=False, as_cmap=True )
    # Normalize to the range of possible values from df["c"]
    norm = matplotlib.colors.Normalize(vmin=df_error['error'].min(),
                                       vmax=df_error['error'].max())
    # create a color dictionary (value in c : color from colormap)
    colors = {}
    for cval in df_plot["error"]:
        colors.update({cval: pal(norm(cval))})

    with sns.axes_style("whitegrid"):
        plt.bar(range(0, len(labelnames)),
                height=dims[0],
                bottom=dims[1],
                align='center',
                tick_label=labelnames,
                color='#dcdcdc',
                alpha=0.8)
        ax1 = sns.swarmplot(x='param',
                            y='vals',
                            data=df_plot,
                            hue='error',
                            palette=colors,
                            size=5)  #size 3
        ax1.set_xticklabels(labelnames, rotation=90)
#         plt.xlabel('Parameters', fontsize=20, fontweight='medium')

    plt.grid(color='#606060', which='major', axis='y', linestyle='solid')
    if synth_data.any:
        #         synth_data['param']=synth_data.index
        #         synth_data.melt(var_name='param', value_name='vals')
        print(synth_data)
        ax1 = sns.swarmplot(data=synth_data,
                            color='black',
                            size=8,
                            alpha=1,
                            marker='*')
    ax1.set_ylabel('')
    ax1.set_xlabel('')

    plt.gca().legend_.remove()
    divider = make_axes_locatable(plt.gca())
    ax_cb = divider.new_horizontal(size="5%", pad=0.05)
    fig.add_axes(ax_cb)
    cb1 = matplotlib.colorbar.ColorbarBase(ax_cb, cmap=pal, norm=norm)
    if save_fig:
        plt.savefig(fig_folder + save_fig, dpi=300, bbox_inches='tight')
    plt.show()
示例#51
0
    df = df[df["Index"] <= min(max(list(indexCutoff)), indexOveride)]

df = df[df["condition"] != "GINR"]
df = df[df["condition"] != "GIPJ"]
df2 = df[df["variable"] == "NAD"].copy()
df2 = df2.rename(columns={"value": "NAD"})
df2 = df2.replace({
    'condition': {
        "contAIC": "AIC",
        "GIAIC": "GI+AIC",
        "GINRAIC": "GI+NR+AIC",
        "GIPJAIC": "GI+PJ34+AIC"
    }
})

with sns.axes_style(style="ticks"):
    plt.figure()
    bp = sns.barplot(x="condition", y="NAD", hue="Index", data=df2)
    bp.get_figure().savefig(os.path.join(fig_dir, 'fig4NAD.png'))

df2 = df[df["variable"] == "PGC1a_deacet"].copy()
df2 = df2.rename(columns={"value": "PGC1a_deacet"})
df2 = df2.replace({
    'condition': {
        "contAIC": "AIC",
        "GIAIC": "GI+AIC",
        "GINRAIC": "GI+NR+AIC",
        "GIPJAIC": "GI+PJ34+AIC"
    }
})
示例#52
0
def correlation_reduction_worker(corrMatrix,
                                 target,
                                 threshold,
                                 reductionMetrics=''):
    '''
    This function works to drop vars over threshold and heat map a pre and post correlation matrix of any sorts.
    The threshold can also be specify through the scenario file by "custom_correlationReduction_thresh"
    Parameters:
               corrMatrix - correlation matrix
                   target - dataframe containing variables' correlation with your target variable
                threshold - your threshold for variable reduction
         reductionMetrics - one of four correlation reduction metrics:
                            Pearson, Spearmans, EuclideanDistances or LogisticRegression
    Returns:
              droppedInfo - dataFrame of variables that were dicarded
                  corrmat - post correlation matrix of any sorts
    Writes:
              droppedInfo - dataFrame of variables that were dicarded
                  corrmat - post correlation matrix of any sorts
    '''

    drop = []
    seaborn.set(context="paper", font="monospace")
    corrmat = abs(corrMatrix.copy(deep=True))

    # Set up the matplotlib figure
    f, ax = plt.subplots(figsize=(10, 8))
    ax.set_yticks([])
    # Draw the heatmap using seaborn
    mask = np.zeros_like(corrmat, dtype=np.bool)
    mask[np.triu_indices_from(mask)] = True

    with seaborn.axes_style("white"):
        seaborn.heatmap(corrmat,
                        vmax=1,
                        mask=mask,
                        square=True,
                        xticklabels=20,
                        yticklabels=20,
                        cmap='Blues')
        ax.set_title(
            "{0} - Original Correlation Matrix".format(reductionMetrics))

    if not os.path.isfile('../outputs/variable_reduction/{}_Original.png'.
                          format(reductionMetrics)):
        f.savefig('../outputs/variable_reduction/{}_Original.png'.format(
            reductionMetrics))

    # Correlation Threshold
    mid = target.drop(target.index[0], 1).T
    mid['target_abs'] = abs(mid[target.index[0]])
    mid.sort_values('target_abs', inplace=True, ascending=False)
    order = list(mid.index)
    corrMatrix = corrMatrix.reindex(order, axis=1)
    corrMatrix = corrMatrix.reindex(order)
    column_list = corrMatrix.keys()  ###
    for col in column_list:  ###
        # This is a temporary drop list that'll be emptied in each iteration, we use it to store the dropped vars and apply to corrMatrix drop
        drop_tmp = []
        if col in corrMatrix.keys(
        ):  # corrMatrix does inplace drop of columns and rows in each iteration, need to check whether col is still in corrMatrix
            for i in range(len(corrMatrix)):  # Iterating through all the vars
                if col != corrMatrix.keys(
                )[i]:  # Make sure col is not compared with itself
                    if abs(corrMatrix[col]
                           [i]) > threshold:  # Correlation Threshold Checking
                        # This is a cumulative drop list that'll be used as the output to show the summary of drop vars
                        # Append [dropped_var, col, corr(dropped_var, target), corr(col, target)]
                        drop.append([
                            corrMatrix.keys()[i], col,
                            target[corrMatrix.keys()[i]].values[0],
                            target[col].values[0]
                        ])
                        drop_tmp.append(
                            corrMatrix.keys()[i])  # Append dropped_var
            corrMatrix.drop(drop_tmp, axis=1, inplace=True)  # Drop columns
            corrMatrix.drop(drop_tmp, axis=0, inplace=True)  # Drop rows
    corrmat = abs(corrMatrix.copy(deep=True))

    droppedInfo = pd.DataFrame(drop,
                               columns=[
                                   'discarded_variable', 'correlated_to',
                                   'discarded_variable_correlation_to_target',
                                   'correlated_to_correlation_to_target'
                               ])

    # Set up the matplotlib figure
    f, ax = plt.subplots(figsize=(10, 8))
    ax.set_yticks([])
    # Draw the heatmap using seaborn
    mask = np.zeros_like(corrmat, dtype=np.bool)
    mask[np.triu_indices_from(mask)] = True

    with seaborn.axes_style("white"):
        seaborn.heatmap(corrmat,
                        vmax=1,
                        mask=mask,
                        square=True,
                        xticklabels=20,
                        yticklabels=20,
                        cmap='Blues')
        ax.set_title("{} - Post Reduction Correlation Matrix - {}".format(
            reductionMetrics, threshold))

    f.savefig(
        '../outputs/variable_reduction/{}_Post_Reduction_Correlation_Matrix_{}.png'
        .format(reductionMetrics,
                str(threshold).replace('.', '')))

    return corrmat, droppedInfo
示例#53
0
    "tdse_projection_plots_{}".format("n_level" if nlevel else "full"))
if not iap:
    save_folder += "_20fs"
if not os.path.isdir(save_folder):
    os.mkdir(save_folder)

for iint, ii_name in zip((ints_15, ints_13, ints_13_15),
                         ("15", "13", "13_15")):
    iint = np.array(iint)
    np.savez(os.path.join(
        save_folder,
        "detector_brightness_dependence_{}_harm_on_ir_wavelength.npz".format(
            ii_name)),
             ints=iint,
             wavelengths=np.arange(790, 806))
    with sns.axes_style("whitegrid"), context:
        if printing:
            f, ax = plt.subplots(1, 1, figsize=(32, 16))
        else:
            f, ax = plt.subplots(1, 1, figsize=(16, 8))

        ax.plot(np.arange(790, 806), iint, linewidth=2)
        ax.axhline(1, color="tab:red", linestyle="--")
        ax.set_xlabel(r"Intensity [$W/cm^2$]")
        ax.set_title("Detector Brightness dependence on the IR wavelength")
        ax.set_ylim(0, 1.5)
        f.tight_layout()
        if printing:
            f.savefig(os.path.join(
                save_folder,
                "detector_brightness_dependence_{}_harm_on_ir_wavelength.pdf".
示例#54
0
import cantera as ct
from matplotlib import animation
import sys
import statistics
import itertools

max_cpus = multiprocessing.cpu_count()

# set up the LSR grid, for the smaller, more interesting one
carbon_range = (-7.5, -5.5)
oxygen_range = (-5.25, -3.25)
grid_size = 9
mesh  = np.mgrid[carbon_range[0]:carbon_range[1]:grid_size*1j,
                 oxygen_range[0]:oxygen_range[1]:grid_size*1j]

with sns.axes_style("whitegrid"):
    plt.axis('square')
    plt.xlim(carbon_range)
    plt.ylim(oxygen_range)
    plt.yticks(np.arange(-5.25,-3,0.5))
plt.show()

# just to double-check
experiments = mesh.reshape((2,-1)).T

with sns.axes_style("whitegrid"):
    plt.axis('square')
    plt.xlim(carbon_range)
    plt.ylim(oxygen_range)
    plt.yticks(np.arange(-5.25,-3,0.5))
    plt.plot(*experiments.T, marker='o', linestyle='none')
示例#55
0
def prettyPlotAgainst(states,
                      rewards,
                      title="Representation",
                      fit_pca=False,
                      cmap='coolwarm'):
    """
    State dimensions are plotted one against the other (it creates a matrix of 2d representation)
    using rewards for coloring, the diagonal is a distribution plot, and the scatter plots have a density outline.
    :param states: (np.ndarray)
    :param rewards: (np.ndarray)
    :param title: (str)
    :param fit_pca: (bool)
    :param cmap: (str)
    """
    with sns.axes_style('white'):
        n = states.shape[1]
        fig, ax_mat = plt.subplots(n,
                                   n,
                                   figsize=(10, 10),
                                   sharex=False,
                                   sharey=False)
        fig.subplots_adjust(hspace=0.2, wspace=0.2)

        if fit_pca:
            title += " (PCA)"
            states = PCA(n_components=n).fit_transform(states)

        c_idx = cm.get_cmap(cmap)
        norm = colors.Normalize(vmin=np.min(rewards), vmax=np.max(rewards))

        for i in range(n):
            for j in range(n):
                x, y = states[:, i], states[:, j]
                ax = ax_mat[i, j]
                if i != j:
                    ax.scatter(x, y, c=rewards, cmap=cmap, s=5)
                    sns.kdeplot(x,
                                y,
                                cmap="Greys",
                                ax=ax,
                                shade=True,
                                shade_lowest=False,
                                alpha=0.2)
                    ax.set_xlim([np.min(x), np.max(x)])
                    ax.set_ylim([np.min(y), np.max(y)])
                else:
                    if len(np.unique(rewards)) < 10:
                        for r in np.unique(rewards):
                            sns.distplot(x[rewards == r],
                                         color=c_idx(norm(r)),
                                         ax=ax)
                    else:
                        sns.distplot(x, ax=ax)

                if i == 0:
                    ax.set_title("Dim {}".format(j), y=1.2)
                if i != j:
                    # Hide ticks
                    if i != 0 and i != n - 1:
                        ax.xaxis.set_visible(False)
                    if j != 0 and j != n - 1:
                        ax.yaxis.set_visible(False)

                    # Set up ticks only on one side for the "edge" subplots...
                    if j == 0:
                        ax.yaxis.set_ticks_position('left')
                    if j == n - 1:
                        ax.yaxis.set_ticks_position('right')
                    if i == 0:
                        ax.xaxis.set_ticks_position('top')
                    if i == n - 1:
                        ax.xaxis.set_ticks_position('bottom')

        plt.suptitle(title, fontsize=16)
        plt.show()
def dynamic_heatmap(df, columns, fontsize=20, annot=False, palette=None, figsize=(15, 10), squaresize=500):
    """Plots a heatmap that changes size values depending on correlation Adapted from:
    https://towardsdatascience.com/better-heatmaps-and-correlation-matrix-plots-in-python-41445d0f2bec"""

    plt.figure(figsize=figsize)
    corr = df[columns].corr()
    sns.set(style="dark")
    grid_bg_color = sns.axes_style()['axes.facecolor']

    # Generate a mask for the upper triangle
    mask = np.zeros_like(corr, dtype=np.bool)
    mask[np.triu_indices_from(mask)] = True

    corr = pd.melt(corr.reset_index(),
                   id_vars='index')  # Unpivot the dataframe, so we can get pair of arrays for x and y
    corr.columns = ['x', 'y', 'value']

    x = corr['x']
    y = corr['y']
    size = corr['value'].abs()

    # Set up the matplotlib figure
    f, ax = plt.subplots(figsize=figsize)
    ax.set_xticklabels(
        ax.get_xticklabels(),
        rotation=45,
        horizontalalignment='right');

    # Mapping from column names to integer coordinates
    x_labels = [v for v in sorted(x.unique())]
    y_labels = [v for v in sorted(y.unique())]
    x_to_num = {p[1]: p[0] for p in enumerate(x_labels)}
    y_to_num = {p[1]: p[0] for p in enumerate(y_labels)}

    size_scale = squaresize

    if palette:
        n_colors = len(palette)
    else:
        n_colors = 256  # Use 256 colors for the diverging color palette
        palette = sns.diverging_palette(20, 220, n=n_colors) # Create the palette
    color_min, color_max = [-1,
                            1]  # Range of values that will be mapped to the palette, i.e. min and max possible correlation
    color = corr["value"]

    def value_to_color(val):
        val_position = float((val - color_min)) / (
                    color_max - color_min)  # position of value in the input range, relative to the length of the input range
        ind = int(val_position * (n_colors - 1))  # target index in the color palette
        return palette[ind]

    plot_grid = plt.GridSpec(1, 15, hspace=0.2, wspace=0.1)  # Setup a 1x15 grid
    ax = plt.subplot(plot_grid[:, :-1])  # Use the leftmost 14 columns of the grid for the main plot

    ax.scatter(
        x=x.map(x_to_num),  # Use mapping for x
        y=y.map(y_to_num),  # Use mapping for y
        s=size * size_scale,  # Vector of square sizes, proportional to size parameter
        c=color.apply(value_to_color),  # Vector of square colors, mapped to color palette
        marker='s'  # Use square as scatterplot marker
    )

    # Show column labels on the axes
    ax.set_xticks([x_to_num[v] for v in x_labels])
    ax.set_xticklabels(x_labels, rotation=45, horizontalalignment='right')
    ax.set_yticks([y_to_num[v] for v in y_labels])
    ax.set_yticklabels(y_labels)
    #     ax.set_fontsize(font_scale)
    for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +
                 ax.get_xticklabels() + ax.get_yticklabels()):
        item.set_fontsize(fontsize)

    numbers = corr['value'].round(decimals=2)

    if annot:
        for i, txt in enumerate(numbers):
            annot_font_size = int(fontsize * size[i] * annot)
            ax.annotate(txt, (x.map(x_to_num)[i], y.map(x_to_num)[i]),
                        horizontalalignment="center", verticalalignment="center",
                        color=grid_bg_color, fontweight="black", fontsize=annot_font_size)

    ax.grid(False, 'major')
    ax.grid(True, 'minor')
    ax.set_xticks([t + 0.5 for t in ax.get_xticks()], minor=True)
    ax.set_yticks([t + 0.5 for t in ax.get_yticks()], minor=True)
    ax.set_xlim([-0.5, max([v for v in x_to_num.values()]) + 0.5])
    ax.set_ylim([-0.5, max([v for v in y_to_num.values()]) + 0.5])

    # Add color legend on the right side of the plot
    ax = plt.subplot(plot_grid[:, -1])  # Use the rightmost column of the plot

    col_x = [0] * len(palette)  # Fixed x coordinate for the bars
    bar_y = np.linspace(color_min, color_max, n_colors)  # y coordinates for each of the n_colors bars

    bar_height = bar_y[1] - bar_y[0]
    ax.barh(
        y=bar_y,
        width=[5] * len(palette),  # Make bars 5 units wide
        left=col_x,  # Make bars start at 0
        height=bar_height,
        color=palette,
        linewidth=0
    )
    ax.set_xlim(1, 2)  # Bars are going from 0 to 5, so lets crop the plot somewhere in the middle
    ax.grid(False)  # Hide grid
    ax.set_xticks([])  # Remove horizontal ticks
    ax.set_yticks(np.linspace(min(bar_y), max(bar_y), 3))  # Show vertical ticks for min, middle and max
    ax.yaxis.tick_right()  # Show vertical ticks on the right
    plt.show()
示例#57
0
    async def country(self, ctx, *countries):
        """Plots distribution of server members by countries. When no countries are specified, plots
         a bar graph of all members by country. When one or more countries are specified, plots a
         swarmplot of members by country and rating. Only members with registered handles and
         countries set on Codeforces are considered.
         """
        max_countries = 8
        if len(countries) > max_countries:
            raise GraphCogError(
                f'At most {max_countries} countries may be specified.')

        users = cf_common.user_db.get_cf_users_for_guild(ctx.guild.id)
        counter = collections.Counter(user.country for _, user in users
                                      if user.country)

        if not countries:
            # list because seaborn complains for tuple.
            countries, counts = map(list, zip(*counter.most_common()))
            plt.clf()
            fig = plt.figure(figsize=(15, 5))
            with sns.axes_style(rc={'xtick.bottom': True}):
                sns.barplot(x=countries, y=counts)

            # Show counts on top of bars.
            ax = plt.gca()
            for p in ax.patches:
                x = p.get_x() + p.get_width() / 2
                y = p.get_y() + p.get_height() + 0.5
                ax.text(x,
                        y,
                        int(p.get_height()),
                        horizontalalignment='center',
                        color='#30304f',
                        fontsize='x-small')

            plt.xticks(rotation=40, horizontalalignment='right')
            ax.tick_params(axis='x',
                           length=4,
                           color=ax.spines['bottom'].get_edgecolor())
            plt.xlabel('Country')
            plt.ylabel('Number of members')
            discord_file = gc.get_current_figure_as_file()
            plt.close(fig)
            embed = discord_common.cf_color_embed(
                title='Distribution of server members by country')
        else:
            countries = [country.title() for country in countries]
            data = [
                [user.country, user.rating] for _, user in users
                if user.rating and user.country and user.country in countries
            ]
            if not data:
                raise GraphCogError(
                    'No rated members from the specified countries are present.'
                )

            color_map = {
                rating: f'#{cf.rating2rank(rating).color_embed:06x}'
                for _, rating in data
            }
            df = pd.DataFrame(data, columns=['Country', 'Rating'])
            column_order = sorted(
                (country for country in countries if counter[country]),
                key=counter.get,
                reverse=True)
            plt.clf()
            if len(column_order) <= 5:
                sns.swarmplot(x='Country',
                              y='Rating',
                              hue='Rating',
                              data=df,
                              order=column_order,
                              palette=color_map)
            else:
                # Add ticks and rotate tick labels to avoid overlap.
                with sns.axes_style(rc={'xtick.bottom': True}):
                    sns.swarmplot(x='Country',
                                  y='Rating',
                                  hue='Rating',
                                  data=df,
                                  order=column_order,
                                  palette=color_map)
                plt.xticks(rotation=30, horizontalalignment='right')
                ax = plt.gca()
                ax.tick_params(axis='x',
                               color=ax.spines['bottom'].get_edgecolor())
            plt.legend().remove()
            plt.xlabel('Country')
            plt.ylabel('Rating')
            discord_file = gc.get_current_figure_as_file()
            embed = discord_common.cf_color_embed(
                title='Rating distribution of server members by '
                'country')

        discord_common.attach_image(embed, discord_file)
        discord_common.set_author_footer(embed, ctx.author)
        await ctx.send(embed=embed, file=discord_file)
示例#58
0
             roary.shape[1],
             histtype="stepfilled",
             alpha=.7)

    plt.xlabel('No. of genomes')
    plt.ylabel('No. of genes')

    sns.despine(left=True, bottom=True)
    plt.savefig('pangenome_frequency.%s' % options.format, dpi=300)
    plt.clf()

    # Sort the matrix according to tip labels in the tree
    roary_sorted = roary_sorted[[x.name for x in t.get_terminals()]]

    # Plot presence/absence matrix against the tree
    with sns.axes_style('whitegrid'):
        fig = plt.figure(figsize=(17, 10))

        ax1 = plt.subplot2grid((1, 40), (0, 10), colspan=30)
        a = ax1.matshow(
            roary_sorted.T,
            cmap=plt.cm.Blues,
            vmin=0,
            vmax=1,
            aspect='auto',
            interpolation='none',
        )
        ax1.set_yticks([])
        ax1.set_xticks([])
        ax1.axis('off')
def create_plots(df,
                 out_data,
                 out_plot='synth_sample_complexity.pdf',
                 colors=None,
                 hue_order=None,
                 show_fig=False):
    """Create figures for paper."""
    # Make sample complexity Fig 1
    fig, (ax, ax2) = plt.subplots(1,
                                  2,
                                  sharey=True,
                                  figsize=(9, 5),
                                  gridspec_kw={'width_ratios': [5, 1]})
    sns.set_style("white")
    sns.set_context("paper", font_scale=1)

    # Ax1
    g = sns.lineplot(
        data=df[np.logical_and(df.train_dataset != 'Baseline, N=200',
                               df.val_dataset == 'Same')],
        x='ds',
        y='average_precision',
        hue='model',
        # legend='brief',
        ax=ax,
        palette=colors,
        hue_order=hue_order,
        legend=False,
        markers=True,
        dashes=False)  # , palette=sns.color_palette("mako_r", 4))
    (g.set(ylim=(0.25, 1)))
    ax.legend(labels=hue_order, frameon=False)
    ax.set_xticks([1, 5, 10, 20])
    ax.set_xticklabels(['1 (5.0)', '5 (5.7)', '10 (6.0)', '20 (6.3)'])
    ax.set_yticks([0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.])
    ax.set_xlabel('Number of training images\n($log_{10}$ training samples)')
    ax.set_ylabel('Mean average precision')
    sns.despine()

    # Ax2
    new_df = df[df.train_dataset == 'Baseline, N=200']
    ext_df = df[df.train_dataset == 'Baseline, N=200']
    ext_df.train_dataset = 'Baseline, N=190'
    ext_df.ds = 190
    new_df.train_dataset = 'Baseline, N=210'
    new_df.ds = 210
    new_df = pd.concat((ext_df, new_df))
    sns.axes_style({'axes.spines.left': False})
    g2 = sns.lineplot(
        data=new_df,
        x='ds',
        y='average_precision',
        hue='model',
        legend=False,
        ax=ax2,
        palette=colors,
        hue_order=hue_order,
        markers=True,
        dashes=False)  # , palette=sns.color_palette("mako_r", 4))
    # (g2.set(ylim=(0.8, 1)))
    ax2.set_xticks([200])
    ax2.set_xticklabels(['200 (7.3)'])
    ax2.set_xlim([180, 220])
    ax2.set_xlabel('')
    g2.spines['left'].set_visible(False)
    # ax2.set_xlabel('Number of training examples')
    sns.despine()
    plt.tight_layout()
    plt.savefig(os.path.join(out_data, out_plot))
    if show_fig:
        plt.show()
    plt.close(fig)
示例#60
0
 def setup_figure(self):
     with sns.axes_style("white"):
         super(Visualizer, self).setup_figure()