def animate_plotting(subdir_path,): average_filename = 'averaged_out.txt' if os.path.exists( os.path.join(subdir_path,average_filename) ): print(subdir_path+average_filename+' already exists please use hotPlot.py') #import existing data for average at the end # data_out = numpy.genfromtxt(os.path.join(subdir_path,average_filename)) # averaged_data = numpy.array(data_out[:,1]) # angles = data_out[:,0] #os.remove( os.path.join(subdir_path,average_filename)) else: files = os.listdir(subdir_path) #files = [d for d in os.listdir(subdir_path) if os.path.isdir(os.path.join(subdir_path, d))] onlyfiles_path = [os.path.join(subdir_path,f) for f in files if os.path.isfile(os.path.join(subdir_path,f))] onlyfiles_path = natsort.natsorted(onlyfiles_path) averaged_data = [] angles = [] for f in onlyfiles_path: data = numpy.genfromtxt(f,delimiter = ',') #data = pandas.read_csv(f) averaged_data.append(numpy.mean(data)) angle = os.path.basename(f).split('_')[0] angles.append(float(angle)) fig = plt.plot(angles, averaged_data,'o') plt.yscale('log') plt.xscale('log') plt.legend(loc='upper right') plt.title(base_path) plt.grid(True) plt.xlabel(r'$\theta$ $[deg.]}$') #plt.xlabel(r'$\mathrm{xlabel\;with\;\LaTeX\;font}$') plt.ylabel(r'I($\theta$) $[a.u.]$')
def genCurve(dataSet, tree): x = [] # stores the x axis of the graph trainList = [] # the list of accuracies derived from training data valList = [] # the list of accuracies derived from validation data i = 0 while i < 1: i = i+0.1 a = 0 b = 0 for trial in range(3): newData = sortData(dataSet, i) # MAKE THIS tree = getTree(newData) # NEED TO GET THIS FUNCTION WHEN TREEGEN WORKS a = a + model_validation.validateTree(tree, newData) b = b + model_validation.validateTree(tree, newData) a = float(a)/3 b = float(b)/3 trainList.append(a) valList.append(b) x.append(i) plt.plot(x, trainList) plt.plot(x, valList) plt.xlabel('percent training used') plt.ylabel('percent accuracy') plt.title('learning curve') plt.show()
def plotDataFrame(self, variables): try: import matplotlib.pyplot as plt except ImportError: print "Unable to import matplotlib" plt.plot(self.df[variables[0]], self.df[variables[1]]) plt.xlabel(r"{}".format(variables[0])) plt.ylabel(r"$P$") plt.minorticks_on() plt.show()
def plot2D(x,y,x_ex,y_ex,ylabl): #static variable counter plot2D.fig_num += 1 plt.subplot(2,2,plot2D.fig_num) plt.xlabel('$x$ (cm)') plt.ylabel(ylabl) plt.plot(x,y,"b+-",label="Lagrangian") plt.plot(x_ex,y_ex,"r--",label="Exact") plt.savefig("var_"+str(plot2D.fig_num)+".pdf")
def generate_plot(array, vmin, vmax, figNumber=1): plt.figure(figNumber) plt.subplot(2,3,i) print i plt.imshow(array, vmin = vmin, vmax= vmax, interpolation = None) plt.xlabel('Sample') plt.ylabel('Line') plt.title(row[0]) cb = plt.colorbar(orientation='hor', spacing='prop',ticks = [vmin,vmax],format = '%.2f') cb.set_label('Reflectance / cos({0:.2f})'.format(incAnglerad*180.0/math.pi)) plt.grid(True)
def plot_f_score(self, disag_filename): plt.figure() from nilmtk.metrics import f1_score disag = DataSet(disag_filename) disag_elec = disag.buildings[building].elec f1 = f1_score(disag_elec, test_elec) f1.index = disag_elec.get_labels(f1.index) f1.plot(kind='barh') plt.ylabel('appliance'); plt.xlabel('f-score'); plt.title(type(self.model).__name__);
def plot(self, output): plt.figure(figsize=output.fsize, dpi=output.dpi) for ii in range(0, len(self.v)): imsize = [self.t[0], self.t[-1], self.x[ii][-1], self.x[ii][0]] lim = amax(absolute(self.v[ii])) / output.scale_sat plt.imshow(self.v[ii], extent=imsize, vmin=-lim, vmax=lim, cmap=cm.gray, origin='upper', aspect='auto') plt.title("%s-Velocity for Trace #%i" % (self.comp.upper(), ii)) plt.xlabel('Time (s)') plt.ylabel('Offset (km)') #plt.colorbar() plt.savefig("Trace_%i_v%s.pdf" % (ii, self.comp)) plt.clf()
def plot2D(x,y,ylabl,x_ex=None,y_ex=None): #static variable counter plot2D.fig_num += 1 plt.subplot(2,2,plot2D.fig_num) plt.xlabel('$x$ (cm)') plt.ylabel(ylabl) plt.plot(x,y,"b+-",label="Numerical") if (x_ex != None): plt.plot(x_ex,y_ex,"r-x",label="Exact") plt.savefig("var_"+str(plot2D.fig_num)+".pdf")
def plot_confusion_matrix(cm, labels, title='Confusion matrix', cmap=plt.cm.Blues, save=False): plt.figure() plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() tick_marks = np.arange(len(labels)) plt.xticks(tick_marks, labels, rotation=45) plt.yticks(tick_marks, labels) plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') plt.show() if save: plt.savefig(save)
def print_scatter_data(): import matplotlib.pylab as plt filename = Par.dirname + ('/Scatter.dat') fitnesses = [] self_reliences = [] life_times = [] self_reliences_dead = [] for Agent in Par.Agents: if Agent.dead != True: fitnesses.append(Agent.fitness) Needs = Agent.needs Production = Agent.production selfReli = [0.0]*Par.num_resources for i in range(Par.num_resources): selfReli[i] = Production[i]*Needs[i] self_reliences.append(abs(sum(selfReli))) else: life_time = Agent.t_death - Agent.t_discovery life_times.append(life_time) Needs = Agent.needs Production = Agent.production selfReli = [0.0]*Par.num_resources for i in range(Par.num_resources): selfReli[i] = Production[i]*Needs[i] self_reliences_dead.append(abs(sum(selfReli))) file =open(filename, 'w') for i in range(len(fitnesses)): s= str(fitnesses[i]) +' '+ str(self_reliences[i]) file.write(s) file.write('\n') file.close() plt.scatter(self_reliences, fitnesses) plt.ylabel('Fitness') plt.xlabel('self_reliences') plt.savefig('FitnessVSR.png') plt.close() plt.scatter(self_reliences_dead, life_times) plt.ylabel('LifeTimes') plt.xlabel('self_reliences') plt.savefig('LifeTimeVSR.png') plt.close()
def plot_data(): import matplotlib.pylab as plt t, suffering = np.loadtxt('suffering.dat', unpack= True, usecols = (0,1)) t, fitness = np.loadtxt('fitness.dat', unpack = True, usecols = (0,1)) plt.plot(t, suffering) plt.xlabel('t') plt.ylabel('suffering') plt.savefig('suffering.png') plt.close() plt.plot(t, fitness) plt.xlabel('t') plt.ylabel('fitness') plt.savefig('fitness.png') plt.close()
def blca(datafile,numprocs): #run c++ blocking routine, saves txt data file with blocking data os.system("make --silent") os.system("mpirun -n %i blocking.out 100 3000 2 %i %s"%(nprocs,numprocs,datafile))#VMC #os.system("mpirun -n %i blocking.out 5000 100 20000 %i %s"%(nprocs,numprocs,datafile))#DMC #read txt file and save plot data = np.genfromtxt(fname=datafile+'.txt') fig=plt.figure() plt.plot(data[:,0],data[:,2],'k+') plt.xlabel(r'$\tau_{trial}$', size=20) plt.ylabel(r'$\epsilon$', size=20) plt.xlim(np.min(data[:,0]),np.max(data[:,0])) plt.ylim(np.min(data[:,2]),np.max(data[:,2])) fig.savefig(datafile+'.eps',format='eps') #open plot if -p in argv if plot_res: os.system('evince %s%s '%(datafile+'.eps','&')) print("plot saved : %s"%(datafile+'.eps'))
def __save(self,n,plot,sfile): p.figure(figsize=sfile) p.xlabel(plot.xlabel) p.ylabel(plot.ylabel) p.xscale(plot.xscale) p.yscale(plot.yscale) p.grid() for curve in plot.curves: if curve[1] == None: p.plot(curve[0],curve[2], label=curve[3]) else: p.plot(curve[0], curve[1], curve[2], label=curve[3]) p.rc('legend', fontsize='small') p.legend(shadow=0, loc='best') p.axes().set_aspect(plot.aspect) if not plot.dir: plot.dir = './plots/' if not plot.name: plot.name = self.__global_name+'_%0*i'%(2,n) if not os.path.isdir(plot.dir): os.mkdir(plot.dir) if plot.pgf: p.savefig(plot.dir+plot.name+'.pgf') else: p.savefig(plot.dir+plot.name+'.pdf', bbox_inches='tight') p.close()
def plot_sinad_sfdr (label, data_x, data_y, chans=[0,1,2,3], titles=['SFDR','SINAD']): """ x x values of data (same for all chans) y array with shape (2, chans, data) """ n=len(chans) n2=len(titles) pos=np.arange(n2*n)+1 for t in range(n2): pos_val=pos[t::n2] for chan in chans: plt.subplot(n,n2,pos_val[chan]) plt.plot(data_x,data_y[t][chan],label=label) if t==0: plt.ylabel('Chan %i' %chan) if chan==0: plt.title(titles[t])
def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues, filename='viz\\confusion_matrix.png'): plt.figure() plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45) plt.yticks(tick_marks, classes) if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] thresh = cm.max() / 2. for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])): plt.text(j, i, cm[i, j], horizontalalignment="center", color="white" if cm[i, j] > thresh else "black") plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') plt.savefig(filename)
def display(self, data, candidates, fname, display): finallist=[] for c in candidates: finallist.append(c[0]) #print finallist part1 = finallist[:len(finallist)/2] part2 = finallist[len(finallist)/2:] meandiff=int(np.sqrt(np.power(np.mean(part2),2)-np.power(np.mean(part1),2))) rangeA = max(part1)-min(part1) rangeB = max(part2)-min(part2) span = int((rangeA+rangeB)/2) dspan = int(meandiff/span) theta = float(meandiff/(rangeA+rangeB)) oneortwo="" if dspan >3 and meandiff > 20 or meandiff>36: oneortwo = "Two distributions \n\n MD: %d \n Span: %d \n Dspan: %d \n theta: %d" % (meandiff, span, dspan, theta) else: oneortwo = "One distribution \n\n MD: %d \n Span: %d \n Dspan: %d \n theta: %d" % (meandiff, span, dspan, theta) cans = np.array(candidates) plt.plot(cans[:,0],cans[:,1],'ro') plt.axhline(max(cans[:,1])/4, color='r') plt.axhline(max(cans[:,1]/2), color='r') plt.axhline(int(max(cans[:,1]))*0.75, color='r') red_patch = mpatches.Patch(color='red', label='75%, 50% and 25% \nof maximum frequency') plt.legend(handles=[red_patch]) plt.ylabel('Frequency of occurence') plt.xlabel('separate items') plt.title('Frequency distribution estimation graph: %s' %(fname)) plt.text(max(data)*1.1, max(cans[:,1])*0.62, oneortwo, fontsize = 11, color = 'r') plt.hist(data,range(int(min(data)),int(max(data)),1)) ofile = fname[0:-3]+"png" print ("Writing outfile: %s") % (ofile) plt.savefig(ofile, bbox_inches='tight') if display == True: plt.show() return;
def plot(self, model, output): Z = linspace(0, model.number[2] * model.spacing[2], model.number[2]) + model.spacing[2] imsize = [model.origin[0], model.size[0] + model.origin[0], model.origin[1], model.size[1] + model.origin[1]] fig = plt.figure(figsize=(output.hres / output.sres, output.hres / (output.sres * output.hratio)), dpi=output.sres) vimg = plt.imshow(transpose(self.v[:, :, 0]), extent=imsize, vmin=round(amin(self.v), 1) - 0.05, vmax=round(amax(self.v) + 0.05, 1), cmap=cm.jet) vtitle = plt.title('') plt.xlabel('X') plt.ylabel('Y') plt.colorbar() def animate(ii): vimg.set_array(transpose(self.v[:, :, ii])) vtitle.set_text("%s Plot (Z = %1.2fkm)" % (self.name, Z[ii])) return vimg, vtitle try: ani = animation.FuncAnimation(fig, animate, frames=len(Z), interval=20, blit=False, repeat=False) ani.save("./%s.mp4" % self.type, fps=30, codec='libx264', bitrate=1800) except IndexError: print 'To render movies, make sure that ffmpeg is installed!'
def plot(self, output): # Create adaptive scale scale_len = 100 scale_fix = 250 nframes = self.v.shape[2] scale = zeros((nframes, 1)) win = ones((scale_len, 1)) for ii in range(0, nframes): scale[ii] = amax(absolute(self.v[:, :, ii])) scale = convolve(squeeze(scale), squeeze(win), mode='same') / output.scale_sat if (self.writestep == 0): scale[:scale_fix] = scale[scale_fix] # Initialize figure comp = {'x': ['Y', 'Z'], 'y': ['X', 'Z'], 'z': ['X', 'Y']} fig = plt.figure(figsize=(output.hres / output.sres, output.hres / (output.sres * output.hratio)), dpi=output.sres) imsize = [self.x[0], self.x[-1], self.y[-1], self.y[0]] vimg = plt.imshow(transpose(self.v[:, :, 0]), extent=imsize, vmin=-scale[0], vmax=scale[0], cmap=cm.RdBu) vtitle = plt.title('') plt.xlabel(comp[self.dir][0]) plt.ylabel(comp[self.dir][1]) plt.colorbar() def animate(ii): vimg.set_array(transpose(self.v[:, :, ii])) vimg.set_clim(-scale[ii], scale[ii]) vtitle.set_text("%s for %s=%s km (t=%1.2e s)" % (self.type, self.dir, self.loc, self.t[ii])) return vimg, vtitle try: ani = animation.FuncAnimation(fig, animate, frames=self.v.shape[2], interval=20, blit=False, repeat=False) if (self.writestep == 0): ani.save("./%s_%s_%s.mp4" % (self.dir, self.loc, self.type), fps=30, codec='libx264', bitrate=1800) else: ani.save("./%s_%s_%s_%i.mp4" % (self.dir, self.loc, self.type, self.writestep), fps=30, codec='libx264', bitrate=1800) except IndexError: print 'To render movies, make sure that ffmpeg is installed!' self.writestep += 1
def execute(): plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['axes.unicode_minus'] = False x = random.normal(5, .5, 1000) y = random.normal(3, 1, 1000) a = x*cos(pi/4) + y*sin(pi/4) b = -x*sin(pi/4) + y*cos(pi/4) plt.plot(a, b, '.') plt.xlabel('x') plt.ylabel('y') plt.title('原数据集') data = zeros((1000, 2)) data[:, 0] = a data[:, 1] = b x, y, evals, evecs = pca(data, 1) print(y) plt.figure() plt.plot(y[:, 0], y[:, 1], '.') plt.xlabel('x') plt.ylabel('y') plt.title('重新构造数据') plt.show()
def plotdatatree(treeID, scale1, mass1): plot_title="Mass Accretion History Tree " + str(treeID) #Can code the number in with treemax x_axis="scale time" y_axis="total mass" figure_name=os.path.expanduser('~/figureTree' + str(treeID)) #Choose which type of plot you would like: Commented out. plt.plot(scale1, mass1, linestyle="-", marker="o") #plt.scatter(scale1, mass1, label="first tree") plt.title(plot_title) plt.xlabel(x_axis) plt.ylabel(y_axis) #plt.yscale("log") plt.savefig(figure_name) #In order to Plot only a single tree on a plot must clear lists before loop. #Comment out to over plot curves. plt.clf() clearmass = [] clearscale = [] return clearmass, clearscale
if os.path.isfile('results/' + filename): f = h5py.File('results/' + filename, 'r') else: f = h5py.File('results/' + assembly + '-errors.h5', 'r') for j, x in enumerate(x_axis): value_keys = f[test][sorted_keys[j]].keys() for key in value_keys: if 'Kinf_Error' in key: kinf_list.append(f[test][sorted_keys[j]][key][...]*10**5) plt.plot(x_axis,kinf_list, colors[i] + 'o-', ms = 10, lw = 2) f.close() plt.axis([max(x_axis), 0, 0, 400]) plt.title('Error in K-Infinity') plt.xlabel('Track Spacing [cm]') plt.ylabel('K-Infinity Error [pcm]') plt.grid() plt.legend(legend) plt.show() fig.savefig('K-Infinity-Error-TS.png') fig = plt.figure() for i, assembly in enumerate(assembly_list): mean_list = [] filename = assembly + '-trackspacing-errors.h5' if os.path.isfile('results/' + filename): f = h5py.File('results/' + filename, 'r') else: f = h5py.File('results/' + assembly + '-errors.h5', 'r') for j, x in enumerate(x_axis): value_keys = f[test][sorted_keys[j]].keys()
@author: DELL """ import pandas as pd import numpy as np import seaborn as sns import matplotlib as plt import matplotlib.pyplot as plt data = pd.read_csv("E:\\assignment\\ass 13 ml starter\\train_HK6lq50.csv") data.head() count_classes = pd.value_counts(data['is_pass'], sort=True) count_classes.plot(kind='bar', rot=0) plt.title("Transaction Class Distribution") plt.xlabel("Class") plt.ylabel("Frequency") from sklearn.utils import resample data_majority = data[data.is_pass == 1] data_minority = data[data.is_pass == 0] data_majority.count() data_minority_upsampled = resample( data_minority, replace=True, # sample with replacement n_samples=50867, # to match majority class random_state=123) data_upsampled = pd.concat([data_majority, data_minority_upsampled]) data_upsampled.is_pass.value_counts() data_upsampled.head() data_upsampled.info() data_upsampled.drop(['id', 'program_id', 'trainee_id'], axis=1, inplace=True) data_upsampled['is_handicapped'].unique()
v = pickle.load(pickle_file) print t print v initialize(v, s, t, dt, n) calculate(v, s, t, dt, n) store(v, t, n) #plot plt.figure(1) plt.subplot(211) plt.plot(t, v,"g-", linewidth=2.0) plt.scatter(t, v) plt.title('The Velocity of a Free Falling Object') plt.xlabel('Time($t$)', fontsize=14) plt.ylabel('Velocity($m/s$)', fontsize=14) plt.text(3,-60,r'$g = 9.8 m/s^2$', fontsize=16) plt.grid(True) plt.subplot(212) plt.plot(t, s,"g-", linewidth=2.0) plt.scatter(t, s) plt.title('The Displacement of a Free Falling Object') plt.xlabel('Time($t$)', fontsize=14) plt.ylabel('Displacement($m$)', fontsize=14) plt.text(3,-300,r'$g = 9.8 m/s^2$', fontsize=16) plt.grid(True) plt.show() plt.savefig("ex1.jpg") read()
#coding:utf-8 import numpy as np import pandas as pd import matplotlib as plt #65ans:matplotlib.pyplot import string dfxy = pd.read_csv( 'xyfilm.csv', delimiter=';', names=['fn', 'date', 'bor'], ) dfxypt = dfxy[['date', 'bor']] dfpxy = dfxypt.sort_values(by='date', ascending=1) #66ans: 'date'#67ans:ascending=1 dfpxy['bor'] = dfpxy['bor'] / 10.0 #69ans:['bor'] #69ans:/10.0 dfpxy.index = dfpxy['date'] del dfpxy['date'] plt.title("BOR") #70ans:title plt.xlabel('day') plt.ylabel('Box Office Return') #71ans:Box Office Return dfpxy['bor'].plot(style='rD--') #72ans:rD-- plt.show()
""" adc_cal.clear_ogp() adc_cal.clear_inl() freqarray=[50,800,30] sfdr,sinad=adc_cal.do_sfdr_sinad_cw_sweep(chans=[2,3], freqarray=freqarray) sinad_values,freqs= dic2arr(sinad) sfdr_values,f = dic2arr(sfdr) """ No corrections """ plt.subplot(221) plt.plot(freqs,sinad_values[0],'-*', label='No corrections') plt.title('SINAD') plt.ylabel('Chan 2') plt.subplot(223) plt.plot(freqs,sinad_values[1],'-*', label='No corrections') plt.ylabel('Chan 3') plt.subplot(222) plt.plot(freqs,sfdr_values[0],'-*', label='No corrections') plt.title('SFDR') plt.subplot(224) plt.plot(freqs,sfdr_values[1],'-*', label='No corrections') """ OGP corrections """ adc_cal.do_ogp_cw_sweep(chans=[2,3]) ogp2 = adc_cal.get_ogp_chan(2)
import matplotlib as plt # X-axis sorted for making the graph clean from crazy lines all over and just a single line print(plt.style.available) plt.style.use("dark_background") forest_fires = forest_fires.sort(["rain"]) plt.plot(forest_fires["rain"], forest_fires["area"]) # Set the x axis label plt.xlabel("Amount of Rain") # Set the y axis label plt.ylabel("Area") # Set the title plt.title("Rain quantity vs fire area") plt.show()
std_order = orders.groupby('month').price.std().reset_index() print std_order #create a set of axes ax = plt.subplot() #create a variable with the average prices bar_heights = avg_order['price'] #create a variable with the standard deviation bar_errors = std_order['price'] #Create a bar chart with the following attributes: bar_heights as the bar value, bar_errors as error bars, capsize of 5, the months as x-label, a y-label and a descriptive title plt.bar(range(len(bar_heights)), bar_heights, yerr=bar_errors, capsize=5) ax.set_xticks(range(len(avg_order))) #ax.set_xticklabels(avg_order.month) ax.set_xticklabels(["April", "May", "June", "July", "August", "September"]) plt.ylabel('price') plt.title("Average amount spent on order for each month") plt.show() """How much has each customer on FoodWheel spent over the past six months? What can this tell us about the average FoodWheel customer?""" #Calculate the sum of price spent by each customer customer_amount = orders.groupby('customer_id').price.sum().reset_index() #print customer_amount.head() #create a histogram of this data with the following attributes: range from 0 to 200, 40 bins, "Total spent" as x-axis, "Number of customers" as y-axis and an appropriate title plt.hist(customer_amount.price.values, range=(0, 200), bins=40) plt.xlabel('Total Spent') plt.ylabel('Number of Customers') plt.title('Customer purchases over the past six months') plt.show()
nesterovs_momentum=True, power_t=0.5, random_state=None, shuffle=False, solver='lbfgs', tol=0.0001, validation_fraction=0.1, verbose=False, warm_start=False) mlp.fit(x_train, y_train.ravel()) predict_test = mlp.predict(x_test) predict_train = mlp.predict(x_train) from sklearn.metrics import r2_score, mean_squared_log_error, mean_squared_error score = r2_score(y_test, predict_test) print("R2 Score Test=", score) #print("MLG SCORE " , mean_squared_log_error(y_test, predict_test)) #print("Difference in value" , y_test - predict_test) print("MSE Train", mean_squared_error(y_train, predict_train)) print("MSE Test", mean_squared_error(y_test, predict_test)) plt.scatter(x_train, y_train, color='red') plt.plot(x_train, predict_train, color='blue') plt.plot(x_test, predict_test, color='blue') plt.plot(x_test, y_test, color='red') plt.title('Model Fit') plt.xlabel('Days') plt.ylabel('confirmed Adjusted') plt.show()
"""Module.2:GraphingUtility(ver:0.001a) Nov 1, 2014 @ 6:25PM-date of modified version upon save Reads a file containing stock data in the correct format (LIST FORMAT CONVENTION HERE) and writes the data to an--- array""" #Parent-Project: SSGG #Nov 1, 2014 @ 6:25PM-date started ##Dev Notes: -Notes on current development and planned features # ##CODE (followed by two blank lines) import matplotlib as plt plt.plot([1,2,3,4]) plt.ylabel('some numbers') plt.show()
linestyle=':', linewidth=4) colors = cycle(['aqua', 'darkorange', 'cornflowerblue']) for i, color in zip(range(2), colors): plt.plot(fpr[i], tpr[i], color=color, lw=2, label='ROC curve of class {0} (area = {1:0.2f})' ''.format(i, roc_auc[i])) plt.plot([0, 1], [0, 1], 'k--', lw=2) plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Some extension of Receiver operating characteristic to multi-class') plt.legend(loc="lower right") plt.show() #%% prediction2 = model.predict_classes(data3) from sklearn.metrics import classification_report, confusion_matrix print('Confusion Matrix') print(confusion_matrix(labels2, prediction2)) print('Classification Report') target_names = ['Benign', 'Malignant'] print(classification_report(labels2, prediction2, target_names=target_names))
if __name__ == '__main__': ''' ==================== Part 1: Basic Function ==================== ''' print(id_matrix()) # warmUpExercise ''' ==================== Part 2: Plotting ========================== ''' # Read the data file data = np.loadtxt('ex1data1.txt', delimiter=',') # Store the strings as float arrays x = np.array(data[:, 0], ndmin=2).reshape(len(data), 1) y = np.array(data[:, 1], ndmin=2).reshape(len(data), 1) m = len(data) # Plot the data plt.plot(x, y, 'rx') plt.ylabel('Profit in $10,000\'s') plt.xlabel('Population of City in 10,000s') plt.axis([0, 25, -5, 25]) plt.show() ''' ==================== Part 3: Cost and Gradient descent ========= ''' # Add x-sub-0 (vector of 1's) X = np.concatenate((np.ones((m, 1)), x), axis=1) # Test thetas thetas = np.zeros((2, 1)) cost = compute_cost(X, y, thetas) print('Cost using thetas(2, 1): ', cost) # Test different thetas thetas = np.array([[-1.0], [2.0]]) cost = compute_cost(X, y, thetas)
# In[30]: n = 50 P = np.dot(Z, V[:, :n]) R = np.dot(P, V[:, :n].T) RX = R + mu # In[31]: fig = plt.figure() plt.plot(range(n), P.max(axis=0), label="max") plt.plot(range(n), P.min(axis=0), label="min") plt.plot(range(n), P.mean(axis=0), label="mean") plt.plot(range(n), P.std(axis=0), label="std") plt.ylabel("Value of Principle Component") plt.xlabel("Index of Principle Component") plt.legend() fig.set_size_inches(8, 8) fName = os.path.join(pDir, 'describe_PC_n{}_{}.png'.format(n, rev)) savefig(fName, bbox_inches='tight') plt.show() # In[32]: print P.max() print P.min() print P.shape # Display scatter plot of a list of letters.
print(TPRi) print(cnf_matrixi) print(k) print(cnf_matrixi.iloc[0,0]/ (sum(cnf_matrixi.iloc[:,0]))) #%% Plot the accuracy metrics versus number of eigenvectors import matplotlib.pyplot as plt plt.plot(neigvec, TPRi, 'b-', label='TPR') plt.plot(neigvec, TNRi, 'g-', label='TNR') plt.plot(neigvec, PPVi, 'r-', label='PPV') plt.plot(neigvec, NPVi, 'y-', label='NPV') plt.plot(neigvec, Acci, 'k-', label='Accuracy') plt.xlabel('Number of eigenvectors') plt.ylabel('Metrics of Accuracy') plt.legend() loc= 'lower right' #%% BIG GAP FOR Applying the classifier to the post treatment samples! # Here we are doing it to just the 107 Aziz sample (one of the very late post treatment samples). # We will combine this with the other sample, and we should also do the 30 hour time point. #%% Project the post treatment cells into eigenspace dfpost107=dfpost[dfpost['sample'].str.contains("Aziz")]
mode='min') history = model.fit_generator(generator=tr_gen, steps_per_epoch=count, nb_epoch=5, validation_data=tr_gen1, validation_steps=count1, max_queue_size=2, callbacks=[m_check]) #model.fit(np.array(data_train),np.array(label_train), batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_data=(np.array(data_test),np.array(label_test))) score = model.evaluate(np.array(data_test), np.array(label_test), verbose=0) print('Score: ', score) score = model.evaluate(np.array(data_holdout), np.array(label_holdout), verbose=0) print('Score holdout: ', score) plt.plot(history.history[fmeasure]) plt.title('Model Fmeasure-score') plt.ylabel('Fmeasure') plt.xlabel('Epoch') plt.legend(['train', 'validation'], loc='upper-left') plt.show() plt.plot(history.history['loss']) plt.title('Model Loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['train', 'validation'], loc='upper-left') plt.show()
lable_name = "Seodaemun" Y_train = train[lable_name] Y_test = test[lable_name] print(X_train.shape) print(X_test.shape) lm = LinearRegression(fit_intercept=True, normalize=True, n_jobs=4) lm.fit(X_train, Y_train) accuracy = lm.score(X_test, Y_test) coefs = pd.DataFrame(zip(X_train.columns,lm.coef_), columns = ['features', 'coefficients']) coefs.reindex(coefs.coefficients.abs().sort_values(ascending=False).index) print ("Linear Regression test file accuracy:"+str(accuracy)) print(coefs) Y_pred = lm.predict(X_test) plt.scatter(Y_test,Y_pred) plt.xlabel('Dust Index: $Y_i$') plt.ylabel("Predicted dust Index: $\hat{Y}_i$") plt.title("Dust vs Predicted dust Index: $Y_i$ vs $\hat{Y}_i$") # print error print(Y_test - Y_pred) mse = sklearn.metrics.mean_squared_error(Y_test, Y_pred) print(mse) plt.show()
# TODO """ TASK 2: Plot metrics against frame number """ # TODO: Define frame_number! # TODO: We can vary noise parameter and plot several noisy results in # same graph, labeling them by noise param. frame_number = 1 # Plot F-score plt.plot(fscore_original, '-o', frame_number, label='Original') plt.plot(fscore_noisy, '-o', frame_number, label='Noisy') plt.legend() plt.xlabel('Frame Number') plt.ylabel('F-score') plt.title('F-score in time') plt.savefig(os.path.join(FIGURES_DIR, 'fscore.png')) # Plot IoU plt.plot(iou_original, '-o', frame_number, label='Original') plt.plot(iou_noisy, '-o', frame_number, label='Noisy') plt.legend() plt.xlabel('Frame Number') plt.ylabel('IoU') plt.title('IoU in time') plt.savefig(os.path.join(FIGURES_DIR, 'iou.png')) # Plot Mapk : plt.plot(map_original, '-o', frame_number, label='Original') plt.plot(map_noisy, '-o', frame_number, label='Noisy')
# -*- coding: utf-8 -*- """ Created on Mon Jan 23 11:07:06 2017 @author: Paige """ import matplotlib as plt import numpy as np x = np.linspace(-10, 10, 400) cos = np.cos(x) sin = np.sin(x) plt.plot(x, cos, "r", label="cos(x)") # r for red line plt.plot(x, sin, "b--", label="sin(x)") # b-- for blue dashed line # colors include red(r), green(g), yellow(y), blue(b), cyan(c), # magenta(m), black(k), white(w) # line styles include solid line("-"), dashed line("--"), # solid line("-"), square("s"), dots("o"), smaller dots(".") plt.xlim(-10, 10) plt.legend() plt.xlabel("x") plt.title("Trigonometric Functions") plt.ylabel("cos(x) or sin(x)") # plt.savefig("1-23-2017.png") plt.show()
plt.contourf(X1, X2, svmclassifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha=0.75, cmap=ListedColormap(('red', 'blue'))) plt.xlim(X1.min(), X1.max()) plt.ylim(X2.min(), X2.max()) for i, j in enumerate(np.unique(Y_set)): plt.scatter(X_set[Y_set == j, 0], X_set[Y_set == j, 1], c=ListedColormap(('red', 'blue'))(i), label=j) plt.title('SVM (Training set)') plt.xlabel('Age') plt.ylabel('Estimated Salaries') plt.legend() plt.show() # Visualising the Test set results from matplotlib.colors import ListedColormap X_set, Y_set = X_test, Y_test X1, X2 = np.meshgrid( np.arange(start=X_set[:, 0].min() - 1, stop=X_set[:, 0].max() + 1, step=0.01), np.arange(start=X_set[:, 1].min() - 1, stop=X_set[:, 1].max() + 1, step=0.01)) plt.contourf(X1, X2,
cos += ((-1)**i)*x**(2*i)/math.factorial(2*i) return cos x0 = time.clock() for i in range(1, 100): x = tcos(1, i) x = time.clock() y = numpy.cos(1) y = time.clock() print 'tcos :' + str(x - x0) + ' numpy: ' + str(y - x) x0 = y t = numpy.arange(0.0, 1.1, 0.01) plt.plot(t, tcos(2*pi*t, 10)) plt.plot(t, tcos(2*pi*t, 9)) plt.plot(t, numpy.cos(t*2*pi)) plt.xlabel('x') plt.ylabel('y') plt.grid(True) plt.show() print '\nExercise 1.3.2:\n' print ' As you can see in the plot, the 10th order gives a good approximation of the cos-function.' print '\nExercise 1.3.3:\n' print ' My method does not determine any significant difference betwwen the two implementations.' print ' I would expect a better performance of the numpy implementation.'
def final_decision_plot(df, z_s=10, z_b=10, show=False, block=False, trafoD_bins=True, bin_number=15): """Plots histogram decision score output of classifier""" nJets = df['nJ'].tolist()[1] if trafoD_bins == True: bins, arg2, arg3 = trafoD_with_error(df) print(len(bins)) else: bins = np.linspace(-1, 1, bin_number + 1) # Initialise plot stuff plt.ion() plt.close("all") fig = plt.figure(figsize=(8.5, 7)) plot_range = (-1, 1) plot_data = [] plot_weights = [] plot_colors = [] plt.rc('font', weight='bold') plt.rc('xtick.major', size=5, pad=7) plt.rc('xtick', labelsize=10) plt.rcParams["font.weight"] = "bold" plt.rcParams["axes.labelweight"] = "bold" plt.rcParams["mathtext.default"] = "regular" df = setBinCategory(df, bins) bins = np.linspace(-1, 1, len(bins)) decision_value_list = df['bin_scaled'].tolist() post_fit_weight_list = df['post_fit_weight'].tolist() sample_list = df['sample'].tolist() # Get list of hists. for t in class_names_grouped[::-1]: class_names = class_names_map[t] class_decision_vals = [] plot_weight_vals = [] for c in class_names: for x in range(0, len(decision_value_list)): if sample_list[x] == c: class_decision_vals.append(decision_value_list[x]) plot_weight_vals.append(post_fit_weight_list[x]) plot_data.append(class_decision_vals) plot_weights.append(plot_weight_vals) plot_colors.append(colour_map[t]) # Plot. if nJets == 2: multiplier = 20 elif nJets == 3: multiplier = 100 plt.plot([], [], color='#FF0000', label=r'VH $\rightarrow$ Vbb x ' + str(multiplier)) plt.hist(plot_data, bins=bins, weights=plot_weights, range=plot_range, rwidth=1, color=plot_colors, label=legend_names[::-1], stacked=True, edgecolor='none') df_sig = df.loc[df['Class'] == 1] plt.hist(df_sig['bin_scaled'].tolist(), bins=bins, weights=(df_sig['post_fit_weight'] * multiplier).tolist(), range=plot_range, rwidth=1, histtype='step', linewidth=2, color='#FF0000', edgecolor='#FF0000') x1, x2, y1, y2 = plt.axis() plt.yscale('log', nonposy='clip') plt.axis((x1, x2, y1, y2 * 1.2)) axes = plt.gca() axes.set_ylim([5, 135000]) axes.set_xlim([-1, 1]) x = [-1, -0.8, -0.6, -0.4, -0.2, 0, 0.2, 0.4, 0.6, 0.8, 1] plt.xticks(x, x, fontweight='normal', fontsize=20) y = [r"10", r"10$^{2}$", r"10$^{3}$", r"10$^{4}$", r"10$^{5}$"] yi = [10, 100, 1000, 10000, 100000] plt.yticks(yi, y, fontweight='normal', fontsize=20) axes.yaxis.set_ticks_position('both') axes.yaxis.set_tick_params(which='major', direction='in', length=10, width=1) axes.yaxis.set_tick_params(which='minor', direction='in', length=5, width=1) axes.xaxis.set_ticks_position('both') axes.xaxis.set_tick_params(which='major', direction='in', length=10, width=1) axes.xaxis.set_tick_params(which='minor', direction='in', length=5, width=1) axes.xaxis.set_minor_locator(AutoMinorLocator(4)) handles, labels = axes.get_legend_handles_labels() #Weird hack thing to get legend entries in correct order handles = handles[::-1] handles = handles + handles handles = handles[1:12] plt.legend(loc='upper right', ncol=1, prop={'size': 12}, frameon=False, handles=handles) plt.ylabel("Events", fontsize=20, fontweight='normal') axes.yaxis.set_label_coords(-0.07, 0.93) plt.xlabel(r"BDT$_{VH}$ output", fontsize=20, fontweight='normal') axes.xaxis.set_label_coords(0.89, -0.07) an1 = axes.annotate("ATLAS Internal", xy=(0.05, 0.91), xycoords=axes.transAxes, fontstyle='italic', fontsize=16) offset_from = OffsetFrom(an1, (0, -1.4)) an2 = axes.annotate(r'$\sqrt{s}$' + " = 13 TeV , 36.1 fb$^{-1}$", xy=(0.05, 0.91), xycoords=axes.transAxes, textcoords=offset_from, fontweight='normal', fontsize=12) offset_from = OffsetFrom(an2, (0, -1.4)) an3 = axes.annotate("1 lepton, " + str(nJets) + " jets, 2 b-tags", xy=(0.05, 0.91), xycoords=axes.transAxes, textcoords=offset_from, fontstyle='italic', fontsize=12) offset_from = OffsetFrom(an3, (0, -1.6)) an4 = axes.annotate("p$^V_T \geq$ 150 GeV", xy=(0.05, 0.91), xycoords=axes.transAxes, textcoords=offset_from, fontstyle='italic', fontsize=12) plt.show(block=block) return fig, axes
eye_sample, eye_line = row[1:3] nose_sample, nose_line = row[3:5] print eye_sample, eye_line, nose_sample, nose_line print "opening",bg_file[0] cube = gdal.Open(bg_file[0], GA_ReadOnly ) xOff = int(eye_sample) - size/2 -1 yOff = int(eye_line) - size/2 -1 array = cube.ReadAsArray(xOff, yOff, size, size) array = array / math.cos(incAnglerad) means.append(array.mean()) if i == 1 and vmin == None: vmin = array.min() vmax = array.max() print vmin,vmax generate_plot(array, vmin, vmax) xOff = int(nose_sample) - size/2 -1 yOff = int(nose_line) - size/2 -1 array = cube.ReadAsArray(xOff, yOff, size, size) array = array/math.cos(incAnglerad) means2.append(array.mean()) generate_plot(array, vmin,vmax, 3) plt.figure(2) plt.plot(times,means,'bo') plt.xlabel('L_s [deg]') plt.ylabel('Reflectance / cos(i) for {0}x{0} pixels'.format(size)) plt.title('mean(BG) vs L_s, eye-crater') plt.plot(times,means2,'ro') plt.show()
def process(path): msev = [] maev = [] rsqv = [] rmsev = [] acyv = [] df = pd.read_csv(path, encoding="latin-1") x1 = np.array(df['Lyrics'].values.astype('U')) y1 = np.array(df['MoodValue']) print(x1) print(y1) print(x1) print(y1) X_train, X_test, y_train, y_test = train_test_split(x1, y1, test_size=0.20) count_vectorizer = CountVectorizer(stop_words='english') count_train = count_vectorizer.fit_transform( X_train ) # Learn the vocabulary dictionary and return term-document matrix. count_test = count_vectorizer.transform(X_test) tfidf_vectorizer = TfidfVectorizer( stop_words='english', max_df=0.7 ) # This removes words which appear in more than 70% of the articles tfidf_train = tfidf_vectorizer.fit_transform(X_train) tfidf_test = tfidf_vectorizer.transform(X_test) model2 = DecisionTreeClassifier() model2.fit(count_train, y_train) y_pred = model2.predict(count_test) print("predicted") print(y_pred) print("test") print(y_test) result2 = open("results/resultCOUNTDT.csv", "w") result2.write("ID,Predicted Value" + "\n") for j in range(len(y_pred)): result2.write(str(j + 1) + "," + str(y_pred[j]) + "\n") result2.close() mse = mean_squared_error(y_test, y_pred) mae = mean_absolute_error(y_test, y_pred) r2 = abs(r2_score(y_test, y_pred)) print("---------------------------------------------------------") print("MSE VALUE FOR DecisionTree COUNT IS %f " % mse) print("MAE VALUE FOR DecisionTree COUNT IS %f " % mae) print("R-SQUARED VALUE FOR DecisionTree COUNT IS %f " % r2) rms = np.sqrt(mean_squared_error(y_test, y_pred)) print("RMSE VALUE FOR DecisionTree COUNT IS %f " % rms) ac = accuracy_score(y_test, y_pred) print("ACCURACY VALUE DecisionTree COUNT IS %f" % ac) print("---------------------------------------------------------") msev.append(mse) maev.append(mae) rsqv.append(r2) rmsev.append(rms) acyv.append(ac * 100) result2 = open('results/COUNTDTMetrics.csv', 'w') result2.write("Parameter,Value" + "\n") result2.write("MSE" + "," + str(mse) + "\n") result2.write("MAE" + "," + str(mae) + "\n") result2.write("R-SQUARED" + "," + str(r2) + "\n") result2.write("RMSE" + "," + str(rms) + "\n") result2.write("ACCURACY" + "," + str(ac) + "\n") result2.close() df = pd.read_csv('results/COUNTDTMetrics.csv') acc = df["Value"] alc = df["Parameter"] colors = ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#8c564b"] explode = (0.1, 0, 0, 0, 0) fig = plt.figure() plt.bar(alc, acc, color=colors) plt.xlabel('Parameter') plt.ylabel('Value') plt.title(' COUNT DecisionTree Metrics Value') fig.savefig('results/COUNTDTMetricsValue.png') plt.pause(5) plt.show(block=False) plt.close() model2 = DecisionTreeClassifier() model2.fit(tfidf_train, y_train) y_pred = model2.predict(tfidf_test) print("predicted") print(y_pred) print("test") print(y_test) result2 = open("results/resultTFIDFDT.csv", "w") result2.write("ID,Predicted Value" + "\n") for j in range(len(y_pred)): result2.write(str(j + 1) + "," + str(y_pred[j]) + "\n") result2.close() mse = mean_squared_error(y_test, y_pred) mae = mean_absolute_error(y_test, y_pred) r2 = abs(r2_score(y_test, y_pred)) print("---------------------------------------------------------") print("MSE VALUE FOR DecisionTree TFIDF IS %f " % mse) print("MAE VALUE FOR DecisionTree TFIDF IS %f " % mae) print("R-SQUARED VALUE FOR DecisionTree TFIDF IS %f " % r2) rms = np.sqrt(mean_squared_error(y_test, y_pred)) print("RMSE VALUE FOR DecisionTree TFIDF IS %f " % rms) ac = accuracy_score(y_test, y_pred) print("ACCURACY VALUE DecisionTree TFIDF IS %f" % ac) print("---------------------------------------------------------") msev.append(mse) maev.append(mae) rsqv.append(r2) rmsev.append(rms) acyv.append(ac * 100) result2 = open('results/TFIDFDTMetrics.csv', 'w') result2.write("Parameter,Value" + "\n") result2.write("MSE" + "," + str(mse) + "\n") result2.write("MAE" + "," + str(mae) + "\n") result2.write("R-SQUARED" + "," + str(r2) + "\n") result2.write("RMSE" + "," + str(rms) + "\n") result2.write("ACCURACY" + "," + str(ac) + "\n") result2.close() df = pd.read_csv('results/TFIDFDTMetrics.csv') acc = df["Value"] alc = df["Parameter"] colors = ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#8c564b"] explode = (0.1, 0, 0, 0, 0) fig = plt.figure() plt.bar(alc, acc, color=colors) plt.xlabel('Parameter') plt.ylabel('Value') plt.title(' TFIDF DecisionTree Metrics Value') fig.savefig('results/TFIDFCOUNTDTMetricsValue.png') plt.pause(5) plt.show(block=False) plt.close() al = ['COUNT', 'TFIDF'] result2 = open('results/DTMSE.csv', 'w') result2.write("Vectorization,MSE" + "\n") for i in range(0, len(msev)): result2.write(al[i] + "," + str(msev[i]) + "\n") result2.close() colors = ["#1f77b4", "#ff7f0e", "#2ca02c"] explode = (0.1, 0, 0, 0, 0) #Barplot for the dependent variable fig = plt.figure(0) df = pd.read_csv('results/DTMSE.csv') acc = df["MSE"] alc = df["Vectorization"] plt.bar(alc, acc, color=colors) plt.xlabel('Vectorization') plt.ylabel('MSE') plt.title("DecisionTree MSE Value") fig.savefig('results/DTMSE.png') plt.pause(5) plt.show(block=False) plt.close() result2 = open('results/DTMAE.csv', 'w') result2.write("Vectorization,MAE" + "\n") for i in range(0, len(maev)): result2.write(al[i] + "," + str(maev[i]) + "\n") result2.close() fig = plt.figure(0) df = pd.read_csv('results/DTMAE.csv') acc = df["MAE"] alc = df["Vectorization"] plt.bar(alc, acc, color=colors) plt.xlabel('Vectorization') plt.ylabel('MAE') plt.title('DecisionTree MAE Value') fig.savefig('results/DTMAE.png') plt.pause(5) plt.show(block=False) plt.close() result2 = open('results/DTR-SQUARED.csv', 'w') result2.write("Vectorization,R-SQUARED" + "\n") for i in range(0, len(rsqv)): result2.write(al[i] + "," + str(rsqv[i]) + "\n") result2.close() fig = plt.figure(0) df = pd.read_csv('results/DTR-SQUARED.csv') acc = df["R-SQUARED"] alc = df["Vectorization"] plt.bar(alc, acc, color=colors) plt.xlabel('Vectorization') plt.ylabel('R-SQUARED') plt.title('DecisionTree R-SQUARED Value') fig.savefig('results/DTR-SQUARED.png') plt.pause(5) plt.show(block=False) plt.close() result2 = open('results/DTRMSE.csv', 'w') result2.write("Vectorization,RMSE" + "\n") for i in range(0, len(rmsev)): result2.write(al[i] + "," + str(rmsev[i]) + "\n") result2.close() fig = plt.figure(0) df = pd.read_csv('results/DTRMSE.csv') acc = df["RMSE"] alc = df["Vectorization"] plt.bar(alc, acc, color=colors) plt.xlabel('Vectorization') plt.ylabel('RMSE') plt.title('DecisionTree RMSE Value') fig.savefig('results/DTRMSE.png') plt.pause(5) plt.show(block=False) plt.close() result2 = open('results/DTAccuracy.csv', 'w') result2.write("Vectorization,Accuracy" + "\n") for i in range(0, len(acyv)): result2.write(al[i] + "," + str(acyv[i]) + "\n") result2.close() fig = plt.figure(0) df = pd.read_csv('results/DTAccuracy.csv') acc = df["Accuracy"] alc = df["Vectorization"] plt.bar(alc, acc, color=colors) plt.xlabel('Vectorization') plt.ylabel('Accuracy') plt.title('DecisionTree Accuracy Value') fig.savefig('results/DTAccuracy.png') plt.pause(5) plt.show(block=False) plt.close()
Y = list(data_subset[to_plot]) Y_err = [0] * len(Y) # Y_err = list(data_subset[to_plot + '_std']) # plt.errorbar(T[:], Y[:], yerr = Y_err, markersize = 5, marker = 'o', label = type) plt.plot(T[3:], Y[3:], markersize = 5, lw = 3, marker = 'o', label = type[4:-8] + ' spins') # if i == 0: # plt.plot(T[:], Y[:], markersize = 5, lw = 3, marker = 'o', label = '1D') # elif i == 1 : # plt.plot(T[1:], Y[1:], markersize = 5, lw = 3, marker = 'o', label = '1.5D') # elif i == 2 : # plt.plot(T[1:], Y[1:], markersize = 5, lw = 3, marker = 'o', label = '2D') # else: # plot(T[7:], Y[7:], markersize = 5, lw = 3, marker = 'o', label = '2.5D') plt.xlabel('$T$', fontsize = 20) plt.ylabel('$E$', fontsize = 20, rotation = 'horizontal', labelpad = 25) #plt.axvline(x = 2.2, lw = 5, color = 'k', alpha = 0.2) plt.subplots_adjust(left = 0.15, right = 0.92, top = 0.92, bottom = 0.15) plt.tick_params(axis = 'both', which = 'major', labelsize = 20) plt.xlim(left = 0, right = 5) plt.ylim(bottom = -2.1, top = 0) legend = plt.legend(fontsize = 18, loc = 2) show()
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, num_epochs=500, minibatch_size=64, print_cost=True): """ Implements a three-layer ConvNet in Tensorflow: CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED Arguments: X_train -- training set, of shape (None, 64, 64, 3) Y_train -- test set, of shape (None, n_y = 6) X_test -- training set, of shape (None, 64, 64, 3) Y_test -- test set, of shape (None, n_y = 6) learning_rate -- learning rate of the optimization num_epochs -- number of epochs of the optimization loop minibatch_size -- size of a minibatch print_cost -- True to print the cost every 100 epochs Returns: train_accuracy -- real number, accuracy on the train set (X_train) test_accuracy -- real number, testing accuracy on the test set (X_test) parameters -- parameters learnt by the model. They can then be used to predict. """ ops.reset_default_graph( ) # to be able to rerun the model without overwriting tf variables tf.set_random_seed(1) # to keep results consistent (tensorflow seed) seed = 3 # to keep results consistent (numpy seed) (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] # To keep track of the cost # Create Placeholders of the correct shape # START CODE HERE ### (1 line) X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) ### END CODE HERE ### # Initialize parameters # START CODE HERE ### (1 line) parameters = initialize_parameters() ### END CODE HERE ### # Forward propagation: Build the forward propagation in the tensorflow graph # START CODE HERE ### (1 line) Z3 = forward_propagation(X, parameters) ### END CODE HERE ### # Cost function: Add cost function to tensorflow graph # START CODE HERE ### (1 line) cost = compute_cost(Z3, Y) ### END CODE HERE ### # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost. # START CODE HERE ### (1 line) optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) ### END CODE HERE ### # Initialize all the variables globally init = tf.global_variables_initializer() # Start the session to compute the tensorflow graph with tf.Session() as sess: # Run the initialization sess.run(init) # Do the training loop for epoch in range(num_epochs): minibatch_cost = 0. num_minibatches = int( m / minibatch_size ) # number of minibatches of size minibatch_size in the train set seed = seed + 1 minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed) for minibatch in minibatches: # Select a minibatch (minibatch_X, minibatch_Y) = minibatch # IMPORTANT: The line that runs the graph on a minibatch. # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y). # START CODE HERE ### (1 line) _, cost_ = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) ### END CODE HERE ### minibatch_cost += cost_ / num_minibatches # Print the cost every epoch if print_cost == True and epoch % 5 == 0: print("Cost after epoch %i: %f" % (epoch, minibatch_cost)) if print_cost == True and epoch % 1 == 0: costs.append(minibatch_cost) # plot the cost plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterations (per tens)') plt.title("Learning rate =" + str(learning_rate)) plt.show() # Calculate the correct predictions predict_op = tf.argmax(Z3, 1) true_op = tf.argmax(Y, 1) correct_prediction = tf.equal(predict_op, true_op) # Calculate accuracy on the test set accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print(accuracy) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuracy = accuracy.eval({X: X_test, Y: Y_test}) print("Train Accuracy:", train_accuracy) print("Test Accuracy:", test_accuracy) return train_accuracy, test_accuracy, parameters
options_data.loc[option]['PRICE'], sigma_est=2., #Estimate for implied volatility it=100) options_data['IMP_VOL'].loc[option] = imp_vol futures_data['MATURITY'] #Select column with name MATURITY options_data.loc[46170] #Select Data row for index 46170 options_data.loc[46710]['STRIKE'] #Select only value in column STRIKE plot_data = options_data[options_data['IMP_VOL'] > 0] maturities = sorted(set(options_data['MATURITY'])) maturities #Reiterate over all maturities and plot import matplotlib as plt #%matplotlib inline plt.figure(figsize=(8,6)) for maturity in maturities: data = plot_data[options_data.MATURITY == maturity] #Select data for this maturity plt.plot(data['STRIKE'], data['IMP_VOL'], label=maturity.date(), lw=1.5) plt.plot(datadata['STRIKE'], data['IMP_VOL'], 'r.') plt.grid(True) plt.xlabel('strike') plt.ylabel('implied volatility of volatility') plt.legend() plt.show()
linabundpost.to_csv("linabundpost.csv") filename = "linabundpost.csv" #%%Map the lineages in dchange to the cells in the anndata object # each cell now is labeled by the amount its lineage changes post treatment adata.obs['linabundchange']= adata.obs['lineage'].map(dchange) # Set the threshold for calling cells sensitive or resistant, pulling from only # the lineages with greatest increase (R) or decrease (S) in abundance S_threshold = 0.05 R_threshold = 0 # Plot the change in lineage abundance distribution plt.figure() plt.hist(adata.obs.loc[adata.obs.timepoint == 't=0 wks','linabundchange'], bins = 100) plt.plot([R_threshold,R_threshold], [0,900], c='r', alpha = 1) plt.plot([-S_threshold, -S_threshold],[0,900], c='g', alpha = 1) plt.xlabel(' Change in lineage abundance') plt.ylabel('Number of cells in the lineage') plt.title('Distribution of lineage abundance change') #plt.legend(loc=1, prop={'size': 15}) plt.ylim(0, 900) plt.xlim(-0.5, 0.5) plt.grid(b=None) #%% Make the sensitive and resistant labels within your anndata object classLabel = np.array(['res', 'sens', 'unknown', 'res_est', 'sens_est']) adata.obs.loc[adata.obs.timepoint=='t=0 wks','classLabel'] = 'unknown' adata.obs.loc[adata.obs.timepoint=='t=7 wks','classLabel'] = 'unknown' adata.obs.loc[adata.obs.timepoint=='t=10 wks','classLabel'] = 'unknown' adata.obs.loc[(adata.obs.linabundchange>R_threshold)&(adata.obs.timepoint=='t=0 wks'), 'classLabel'] = 'res' adata.obs.loc[(adata.obs.linabundchange<-S_threshold)&(adata.obs.timepoint=='t=0 wks'), 'classLabel'] = 'sens'
import numpy as np import matplotlib as plt import sys path = sys.argv a = np.loadtxt('result/') plt.plot() plt.xlabel('长度') plt.ylabel('Translation Error') plt.show()
kind='linear') window_size, poly_order = 101, 2 yy_sg = savgol_filter(itp(xx), window_size, poly_order) plt.plot(wavelengths[1:-1], 100.0 * (QE[index_chip, 1:-1, this_area_y, this_area_x]), 'o--', color=colors[color_tmp], label='Chip: ' + str(sensor_name_list[index_chip]) + ', X: ' + str(frame_x_divisions[this_area_x]) + ', Y: ' + str(frame_y_divisions[this_area_y])) color_tmp = color_tmp + 1 plt.plot(xx, 100.0 * yy_sg, 'k', label='Fit for chip: ' + str(sensor_name_list[index_chip]) + ', X: ' + str(frame_x_divisions[this_area_x]) + ', Y: ' + str(frame_y_divisions[this_area_y])) lgd = plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.) plt.xlabel('Wavelength [nm] ') plt.ylabel('Quantum Efficiency [%] ') plt.savefig(figure_dir + "qe_wl.pdf", format='pdf', bbox_extra_artists=(lgd, ), bbox_inches='tight') plt.savefig(figure_dir + "qe_wl.png", format='png', bbox_extra_artists=(lgd, ), bbox_inches='tight', dpi=1000)
def pos_plot(iPartType, box_size): 'Function plots position plots of particles for three projections' #... Time #time = isnap*0.05 #...Tag for Saving tag_list = ['Gas', 'DM', '?', '', 'Stars', ''] tag_type = tag_list[iPartType] #...Load File #f = h5py.File(base + '/snapshot_' + str(isnap).zfill(3) +'.hdf5') f = h5py.File(base + '/snapshot_555.0.hdf5') #...Load Stellar Data xyz = np.array(f['PartType' + str(iPartType) + '/Coordinates']) ############################################## PLOT ######################################################## #...Set up figure box: fig = plt.figure(figsize=[20, 6]) ######################### Plot xy ax = fig.add_subplot(1, 3, 1) plt.scatter(xyz[:, 0], xyz[:, 1], marker='.') plt.axis('equal') plt.xlim(box_size) plt.ylim(box_size) plt.xlabel('x') plt.ylabel('y') plt.title('xy') #ax.text(-lim+1, lim+1, str(time)+'Gyr', fontsize=15) ######################### Plot xz ax = fig.add_subplot(1, 3, 2) plt.scatter(xyz[:, 0], xyz[:, 2], marker='.') plt.axis('equal') plt.xlim(box_size) plt.ylim(box_size) plt.xlabel('x') plt.ylabel('z') plt.title('xz') #ax.text(-lim+1, lim+1, str(time)+'Gyr', fontsize=15) ######################### Plot yz ax = fig.add_subplot(1, 3, 3) plt.scatter(xyz[:, 1], xyz[:, 2], marker='.') plt.axis('equal') plt.xlim(box_size) plt.ylim(box_size) plt.xlabel('y') plt.ylabel('z') plt.title('yz') #ax.text(-lim+1, lim+1, str(time)+'Gyr', fontsize=15) ################################################# SAVING ######################################################## save_fig_file = '/data8/data/mercadf1/scratch/Plots/' + tag_type + '_pos_run_ELVIS_RomeoJuliet_snap_555_0.png' #save_fig_file = '/data25/rouge/gonzaa11/francisco/outputs/runmed'+str(irun)+'/Plots/pos_plots/'+tag_type+'_pos_run'+str(irun)+'_snap'+str(isnap)+'.png' #...Report saving: print "Saving : " print str(save_fig_file) #...Save Figure: plt.savefig(save_fig_file)
axes_label_font_size = 12 linewidth = 2 contour_font = 10 fig = plt.figure(figsize=(6, 5)) ax_ray = fig.add_subplot(111) dist = [20, 60, 85, 95] dist = [8, 27, 48, 67, 89, 99] dist = [10, 25, 30, 35, 40] # 15,20,25,30,35,40,45,50,55,60] for i in range(len(dist)): s = str(str(dist[i]) + "_SURF96.inp") data = np.loadtxt(s, usecols=(5, 6, 7)) ax_ray.plot(data[:, 0], data[:, 1], label=str(dist[i] * 10) + "km") ax_ray.grid(True, linestyle='--', color='black', linewidth=0.15) plt.xticks(fontsize=axes_label_font_size) plt.yticks(fontsize=axes_label_font_size) plt.xlabel('Time period ($s$)', fontsize=axes_label_font_size, fontweight='bold') plt.ylabel('Phase velocity ($km/s$)', fontsize=axes_label_font_size, fontweight='bold') plt.legend(fancybox=True, shadow=True, framealpha=0.5, loc='lower right', fontsize=legend_font_size) plt.savefig('Rayleigh_Phase_dispersion.jpg', dpi=400) plt.show()