def plot_decision_regions(X, y, classifier, resolution=0.02): # prepare marker and color map markers = ('s', 'x', 'o', '^', 'v') colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan') cmap = ListedColormap(colors[:len(np.unique(y))]) # plot decision regions x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1 x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1 # generate grid point xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution)) # translate features into array and predict Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T) # translate result to grid point Z = Z.reshape(xx1.shape) # plot contour line of grid point plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap) plt.xlim(xx1.min(), xx1.max()) plt.ylim(xx2.min(), xx2.max()) # plot sample by each class for idx, cl in enumerate(np.unique(y)): plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1], alpha=0.8, c=cmap(idx), marker=markers[idx], label=cl)
def plotPredictions(clf): xx, yy = np.meshgrid(np.arange(0, 250000, 10), np.arange(10, 70, 0.5)) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) plt.figure(figsize=(8, 6)) Z = Z.reshape(xx.shape) plt.contourf(xx, yy, Z, cmap=plt.cm.Paired, alpha=0.8) plt.scatter(X[:, 0], X[:, 1], c=y.astype(np.float)) plt.show()
def plot_predictions(clf, axes): x0s = np.linspace(axes[0], axes[1], 100) x1s = np.linspace(axes[2], axes[3], 100) x0, x1 = np.meshgrid(x0s, x1s) X = np.c_[x0.ravel(), x1.ravel()] y_pred = clf.predict(X).reshape(x0.shape) y_decision = clf.decision_function(X).reshape(x0.shape) plt.contourf(x0, x1, y_pred, cmap=plt.cm.brg, alpha=0.2) plt.contourf(x0, x1, y_decision, cmap=plt.cm.brg, alpha=0.1)
def plot_decision_boundary(model, X, y): # Set min and max values and give it some padding x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1 y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1 h = 0.01 # Generate a grid of points with distance h between them xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) # Predict the function value for the whole grid Z = model(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) # Plot the contour and training examples plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral) plt.ylabel('x2') plt.xlabel('x1') plt.scatter(X[0, :], X[1, :], c=y, cmap=plt.cm.Spectral) plt.show()
def get_contours(x,y,z,bounds): r""" points x and y with values z, with whole shape bounded by a matplotlib.path bounds """ grid_x, grid_y = np.mgrid[1.1*min(x):1.1*max(x):complex(0,10*len(x)j), 1.1*min(y):1.1*max(y):complex(0,10*len(y))] grid_z = griddata(zip(x,y), z, (grid_x, grid_y), method='cubic') grid_x = grid_x.flatten(); grid_y = grid_y.flatten(); grid_z = grid_z.flatten() new_grid_x = []; new_grid_y = []; new_grid_z = [] for i in xrange(len(grid_x)): if bounds.contains_point((grid_x[i], grid_y[i])): new_grid_x.append(grid_x[i]) new_grid_y.append(grid_y[i]) new_grid_z.append(grid_z[i]) return contourf(grid_x, grid_y, grid_z)
# ### Visualisation # In[15]: 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, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha=0.75, cmap=ListedColormap(('cyan', 'yellow', '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', 'green', 'yellow'))(i), label=j) plt.title('Logistic Regression (Training set)') plt.xlabel('PC1') plt.ylabel('PC2') plt.legend() plt.show()
print("x_test after scaling:\n", x_test) print("y:\n", y) print("y_train:\n", y_train) print("y_test:\n", y_test) X_set, y_set = x_train, y_train 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, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha=0.75, cmap=ListedColormap(('red', 'green'))) 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', 'green'))(i)) plt.show()
def plot_lib(x_nodes,l,b,topo_in_file,bouger_in_file,geoid_in_file,FA_in_file,heatflux_in_file,anomaly,c,l_nodes,b_nodes,mat,max_depth, label_size,marker_size,anomaly_x,anomaly_y,anomaly_amount,anomaly_type,anomaly_compo,anomaly_color): # # Making string list of the observables file input # #data_list=[];data_list.extend([topo_in_file,bouger_in_file,FA_in_file,geoid_in_file,heatflux_in_file]) # ## Figuring out what input files are given #name_len=[ len(data_list[k]) for k in range(len(data_list)) ]; #for i in range(len(name_len)): # if name_len[i] != 0 : # plot it # else # pass try: topo=np.loadtxt(topo_in_file)#f=np.loadtxt(self.digitized,comments=">") max_depth = -max_depth min_depth = max(topo[:,1]/1000) except Exception: max_depth = -400 min_depth = 3 # Initializing the figure # fig = plt.figure() #gs = gridspec.GridSpec(6, 1, width_ratios=[3, 1]) gs = gridspec.GridSpec(6, 1,height_ratios=[1,1,1,1,1,3]) # # ploting the bodies geometry # ax1 = plt.subplot(gs[5]) #fig.add_subplot(616) for i in range(len(l_nodes)): ax1.plot(l_nodes[i],b_nodes[i],color='black',lw=1,marker=None) poly = Polygon(list(zip(l_nodes[i],b_nodes[i])),facecolor=c[i],label=mat[i], lw=1) ax1.add_patch(poly) for i in range(len(anomaly_x)): ax1.plot(anomaly_x[i],anomaly_y[i],color="green",lw=1,marker='o',markersize=4) poly = Polygon(list(zip(anomaly_x[i],anomaly_y[i])),facecolor=anomaly_color[i],label="anomaly", lw=1) l_text=min(anomaly_x[i])+ (max(anomaly_x[i])-min(anomaly_x[i]))/2 b_text=min(anomaly_y[i])+ (max(anomaly_y[i])-min(anomaly_y[i]))/2 ax1.add_patch(poly) ax1.text(l_text, b_text, str(int(i+1))+" "+str(anomaly_type[i])+" Material" +str(anomaly_compo[i])+""+str(anomaly_amount[i]), fontsize=8,fontstyle='italic',color='black',bbox=dict(facecolor='white', alpha=0.9)) #ax1.plot(l[i][:],b[i][:],color='grey',linewidth=0.5) ax1.grid(True) ax1.tick_params(labelsize=10) plt.ylim((max_depth,min_depth)) plt.title('Profile Geometry') plt.xlabel('Distance ($km$)') plt.ylabel('Depth ($km$)') # # plotting the topography # ax2 = plt.subplot(gs[4])#fig.add_subplot(611) # topography data f_out=open("topo_out.dat","r") data_out=f_out.readlines() try: f_in=open(topo_in_file,"r") #f_in=open("test_top.dat","r")#f_in=open("test_top.dat","r") data_in=f_in.readlines() f_in.close() except Exception: data_in=data_out profile_out=[] profile_in=[] if anomaly==1: topo_in=[] topo_error=[] topo_out_coupled=[] topo_out_uncoupled=[] f_out.close() ## storing data into local variables for i in range(len(data_in)): try: data_temp=data_out[i].split() except IndexError: data_temp=[] pass try: profile_out.append(float(str(data_temp[0]))) topo_out_coupled.append(float(str(data_temp[1]))) topo_out_uncoupled.append(float(str(data_temp[2]))) except ValueError: data_temp=[] pass try: data_temp=data_in[i].split() except IndexError: data_temp=[] pass try: profile_in.append(float(str(data_temp[0]))) topo_in.append(float(str(data_temp[1]))) try: topo_error.append(float(str(data_temp[2]))) except: topo_error.append(0) except ValueError: data_temp=[] pass plt.hold(True) ax2.errorbar(profile_in,topo_in,yerr=topo_error,fmt='o-',markersize=marker_size,ecolor='b',label='Observed') ax2.plot(profile_out,topo_out_coupled,'k-',label='Coupled' ) ax2.plot(profile_out,topo_out_uncoupled, 'r-',label='Uncoupled') ''' ax2_=ax2.twinx() diff=[] diff=np.subtract(topo_out_uncoupled,topo_in) ax2_.plot(profile_out,diff,color='g',label='Diff') ax2_.set_ylabel('Diff', color='g') ax2_.tick_params('y', colors='g') ''' #ax2.plot(profile_in,topo_in, 'b-',label='Observed') ax2.grid(True) ax2.set_title('Elevation ') ax2.xaxis.set_ticklabels([]) ax2.tick_params(labelsize=10) #plt.xlabel('Distance (Km)') plt.ylabel('Elevation ($m$)') plt.legend( fancybox=True, framealpha=0.5,fontsize=8,loc='best') #ax2.legend(handles, ['input','Computed-coupled','Computed-uncoupled']) else: topo_in=[] topo_error=[] topo_out=[] f_out.close() ## storing data into local variables for i in range(len(data_in)): try: data_temp=data_out[i].split() except IndexError: pass try: profile_out.append(float(str(data_temp[0]))) topo_out.append(float(str(data_temp[1]))) except ValueError: passa try: data_temp=data_in[i].split() except IndexError: pass try: profile_in.append(float(str(data_temp[0]))) topo_in.append(float(str(data_temp[1]))) try: topo_error.append(float(str(data_temp[2]))) except: topo_error.append(0) except ValueError: pass #topo_misfit= (topo_in - topo_out)/len(topo_in) #print topo_misfit plt.hold(True) #ax2.plot(profile_in,topo_in, 'b-',label='Observed') ax2.errorbar(profile_in,topo_in,yerr=topo_error,fmt='o-',markersize=marker_size,ecolor='b',label='Observed') ax2.plot(profile_out,topo_out,'r-',label='Calculated') ''' ax2_=ax2.twinx() diff=[] diff=np.subtract(topo_out,topo_in) ax2_.plot(profile_out,diff,color='g',label='Diff') ax2_.set_ylabel('Diff', color='g') ax2_.tick_params('y', colors='g') ''' #ax2.fill(profile_in,topo_in+topo_error,zorder=10) ax2.grid(True) ax2.set_title('Elevation') ax2.xaxis.set_ticklabels([]) ax2.tick_params(labelsize=10) #plt.xlabel('Distance (Km)') plt.ylabel('Elevation ($m$)') plt.legend( fancybox=True, framealpha=0.5,fontsize=8,loc='best') # # bouguer data # f_out=open("bouguer_out.dat","r") data_out=f_out.readlines() try: f_in=open(bouger_in_file,"r") #f_in=open("test_bou.dat","r") data_in=f_in.readlines() f_in.close() except Exception: data_in=data_out profile_out=[] profile_in=[] boug_in=[] boug_out=[] boug_error=[] for i in range(len(data_in)): try: data_temp=data_out[i].split() except IndexError: pass try: profile_out.append(float(str(data_temp[0]))) boug_out.append(float(str(data_temp[1]))) except ValueError: pass try: data_temp=data_in[i].split() except IndexError: pass try: profile_in.append(float(str(data_temp[0]))) boug_in.append(float(str(data_temp[1]))) try: boug_error.append(float(str(data_temp[2]))) except: boug_error.append(0.0) except ValueError: pass ax3 = plt.subplot(gs[3])#fig.add_subplot(612) plt.hold(True) #ax3.plot(profile_in,boug_in, 'b-') ax3.errorbar(profile_in,boug_in,yerr=boug_error,fmt='o-',markersize=marker_size,ecolor='b',label='Observed') ax3.plot(profile_out,boug_out,'r-',label='Calculated') ''' ax3_=ax3.twinx() diff=[] diff=np.subtract(boug_out,boug_in[range(len(boug_out))]) ax3_.plot(profile_out,diff,color='g',label='Diff') ax3_.set_ylabel('Diff', color='g') ax3_.tick_params('y', colors='g') ''' ax3.grid(True) ax3.set_title('Bouguer') ax3.xaxis.set_ticklabels([]) ax3.tick_params(labelsize=10) #plt.xlabel('Distance (Km)') plt.legend( fancybox=True, framealpha=0.5,fontsize=8,loc='best') plt.ylabel('Bouguer ($mGal$)') f_out.close() # # geoid data # f_out=open("geoid_out.dat","r") data_out=f_out.readlines() try: f_in=open(geoid_in_file,"r")#f_in=open("test_geo.dat","r") data_in=f_in.readlines() f_in.close() except Exception: data_in=data_out profile_out=[] profile_in=[] geoid_in=[] geoid_out=[] geoid_error=[] for i in range(len(data_in)): try: data_temp=data_out[i].split() except IndexError: pass try: profile_out.append(float(str(data_temp[0]))) geoid_out.append(float(str(data_temp[1]))) except ValueError: pass try: data_temp=data_in[i].split() except IndexError: pass try: profile_in.append(float(str(data_temp[0]))) geoid_in.append(float(str(data_temp[1]))) try: geoid_error.append(float(str(data_temp[2]))) except IndexError: geoid_error.append(0.0) except ValueError: pass #geoid_in=np.loadtxt(geoid_in_file) ax4 = plt.subplot(gs[2])#fig.add_subplot(614) plt.hold(True) ax4.plot(profile_in,geoid_in, 'b-') ax4.errorbar(profile_in,geoid_in,yerr=geoid_error,fmt='o-',markersize=marker_size,ecolor='b',label='Observed') ''' ax4_=ax4.twinx() diff=[] diff=np.subtract(geoid_out,geoid_in[range(len(geoid_out))]) ax4_.plot(profile_out,diff,color='g',label='Diff') ax4_.set_ylabel('Diff', color='g') ax4_.tick_params('y', colors='g') ''' #test=[] #test=smoothListGaussian(geoid_in,degree=1) #ax4.plot(profile_in[0:len(test)],test,fmt='o-',markersize=marker_size,color='black',label='Observed--9') ''' try: ax4.errorbar(geoid_in[:,0],geoid_in[:,1],yerr=geoid_in[:,2],fmt='o-',markersize=marker_size,ecolor='b',label='8') plt.hold(True) except Exception: pass try: ax4.errorbar(geoid_in[:,0],geoid_in[:,3],yerr=geoid_in[:,4],fmt='o-',markersize=marker_size,ecolor='k',label='9') plt.hold(True) except Exception: pass try: ax4.errorbar(geoid_in[:,0],geoid_in[:,5],yerr=geoid_in[:,6],fmt='o-',markersize=marker_size,ecolor='m',label='10') plt.hold(True) except Exception: pass ''' plt.hold(True) ax4.plot(profile_out,geoid_out,'r-', label='Calculated') ax4.grid(True) ax4.set_title('Geoid') ax4.xaxis.set_ticklabels([]) ax4.tick_params(labelsize=10) plt.legend( fancybox=True, framealpha=0.5,fontsize=8,loc='best') #plt.xlabel('Distance (Km)') plt.ylabel('Geoid ($m$)') f_out.close() # # heat flux data # f_out=open("SHF_out.dat","r") data_out=f_out.readlines() f_out.close() try: f_in=open(heatflux_in_file,"r")#f_in=open("fluxout.dat","r") data_in=f_in.readlines() f_in.close() except Exception: data_in=data_out profile_out=[] profile_in=[] flux_in=[] flux_out=[] flux_error=[] for i in range(len(data_out)): try: data_temp=data_out[i].split() except IndexError: pass try: profile_out.append(float(str(data_temp[0]))) flux_out.append(float(str(data_temp[1]))) except ValueError: pass try: data_temp=data_in[i].split() except IndexError: pass for i in range(len(data_in)): try: data_temp=data_in[i].split() except IndexError: pass try: profile_in.append(float(str(data_temp[0]))) flux_in.append(float(str(data_temp[1]))) try: flux_error.append(float(str(data_temp[2]))) except IndexError: flux_error.append(0.0) except ValueError: pass try: data_temp=data_in[i].split() except IndexError: pass ax5 = plt.subplot(gs[0])#fig.add_subplot(615) plt.hold(True) ax5.errorbar(profile_in,flux_in,yerr=flux_error,fmt='o-',markersize=marker_size,ecolor='b',label='Observed') ax5.plot(profile_out,flux_out,'r-',label='Calculated') ax5.grid(True) ax5.set_title('Heat Flux') ax5.xaxis.set_ticklabels([]) ax5.tick_params(labelsize=10) #plt.xlabel('Distance (Km)') plt.legend( fancybox=True, framealpha=0.5,fontsize=8,loc='best') plt.ylabel('Heat-flux ($mW/m^2$)') #plt.tight_layout() #plt.tight_layout() # # FA data # f_out=open("FA_out.dat","r") data_out=f_out.readlines() f_out.close() try: f_in=open(FA_in_file,"r")#f_in=open("fluxout.dat","r") data_in=f_in.readlines() f_in.close() except Exception: data_in=data_out profile_out=[] profile_in=[] FA_in=[] FA_out=[] FA_error=[] for i in range(len(data_in)): try: data_temp=data_out[i].split() except IndexError: pass try: profile_out.append(float(str(data_temp[0]))) FA_out.append(float(str(data_temp[1]))) except ValueError: pass try: data_temp=data_in[i].split() except IndexError: pass try: profile_in.append(float(str(data_temp[0]))) FA_in.append(float(str(data_temp[1]))) try: FA_error.append(float(str(data_temp[2]))) except IndexError: FA_error.append(0.0) except ValueError: pass ax6 = plt.subplot(gs[1])#fig.add_subplot(613) plt.hold(True) #ax6.plot(profile_in,FA_in, 'b-') ax6.errorbar(profile_in,FA_in,yerr=FA_error,fmt='o-',markersize=marker_size,ecolor='b',label='Observed') ax6.plot(profile_out,FA_out,'r-',label='Calculated') ''' ax6_=ax6.twinx() diff=[] diff=np.subtract(FA_out,FA_in[range(len(FA_out))]) ax6_.plot(profile_out,diff,color='g',label='Diff') ax6_.set_ylabel('Diff', color='g') ax6_.tick_params('y', colors='g') ''' ax6.grid(True) ax6.set_title('Free-Air') ax6.xaxis.set_ticklabels([]) ax6.tick_params(labelsize=10) plt.legend( fancybox=True, framealpha=0.5,fontsize=8,loc='best') #plt.xlabel('Distance (Km)') plt.ylabel('FA (mGal)') #plt.tight_layout() multi = MultiCursor(fig.canvas,(ax1,ax2,ax3,ax4,ax5,ax6), color='r', lw=1) ##############33 temperature profile plotting gs_ = gridspec.GridSpec(4, 1) #fig_out = plt.figure() fig_out = plt.figure() #ax_temp = fig_out.add_subplot(411) ax_temp =plt.subplot(gs_[0]) #fig_out.add_subplot(411) f=open("tempout.dat","r") data_out=f.readlines() temp_x=[] temp_y=[] temp_z=[] for i in range(2,len(data_out)): data_temp=data_out[i].split() temp_x.append(float(str(data_temp[0]))) temp_y.append(float(str(data_temp[1]))) temp_z.append(float(str(data_temp[2]))) xlist=[] ylist = np.array(temp_y[0:96]) z =temp_z #np.array(temp_z) Z=[] temp=0 for i in range(0,x_nodes): tmp = [] xlist.append(temp_x[temp]) for j in range(0,96): tmp.append(z[temp]) temp=temp+1 Z.append(tmp) X,Y = np.meshgrid(ylist, xlist) levels = np.linspace(0, 50, 1600) for i in range(len(l)): ax_temp.plot(l[i][:],b[i][:],color='grey',linewidth=2) levels =[300,500,600,1000,1200,1300,1450,1550,1650] CS3 = plt.contourf(Y, X, Z, levels,extend='both',cmap=plt.cm.get_cmap('coolwarm',20)) CS3.cmap.set_under('white') CS3.cmap.set_over('black') #levels = np.arange(min(temp_z), max(temp_z)+100, 100) CS4 = plt.contour(Y, X, Z, levels,linewidths=0.2,linestyles='dashed',colors='black') plt.clabel(CS4,inline=5,inline_spacing=10,fontsize=10,fontstyles='arial',fontweight='bold',fmt='%1.0f',colors='black') plt.colorbar(CS3,label='$^oC$') plt.title('Temperature',fontsize=10, fontweight='bold') """ cp = plt.contourf(Y,X,Z) plt.colorbar(cp) #cpc=plt.contour(Y,X,Z,levels) # predefinrd number of contour CS = plt.contour(Y, X, Z, 30 ,linewidths=0.5,colors='grey') # automatice number of contours plt.clabel(CS,inline=1,inline_spacing=0,fontsize=12,fmt='%1.0f',colors='black') #plt.clabel(CS, inline=1, fontsize=10,color="black") # contour line labels """ #plt.title('Temperature profile') #plt.xlabel('Distance ($km$)') plt.tick_params(labelsize=10) plt.ylabel('Depth ($km$)') ##############33 density profile plotting f=open("dens_node2.dat","r") data_out=f.readlines() temp_x=[] temp_y=[] temp_z=[] for i in range(len(data_out)): data_temp=data_out[i].split() temp_x.append(float(str(data_temp[0]))) temp_y.append(float(str(data_temp[1]))) temp_z.append(float(str(data_temp[2]))) xlist=[] ylist = np.array(temp_y[0:95]) z =temp_z #np.array(temp_z) Z=[] temp=0 for i in range(0,x_nodes): tmp = [] xlist.append(temp_x[temp]) for j in range(0,95): tmp.append(z[temp]) temp=temp+1 Z.append(tmp) X,Y = np.meshgrid(ylist, xlist) levels = np.linspace(0, 50, 1600) #ax_dens = fig_out.add_subplot(412) ax_dens =plt.subplot(gs_[1]) for i in range(len(l)): ax_dens.plot(l[i][:],b[i][:],color='grey',linewidth=2) levels = np.arange(2800, 3800, 50) #levels = np.arange(3000, 3800, 20) CS3 = plt.contourf(Y, X, Z, levels,extend='both',cmap=plt.cm.get_cmap('rainbow',20),origin=origin) CS3.cmap.set_under('white') CS3.cmap.set_over('black') levels = np.arange(3000, 3800, 50) CS4 = plt.contour(Y, X, Z,levels,linewidths=0.2,linestyles='dashed',colors='grey') plt.clabel(CS4,inline=True,inline_spacing=2,fontsize=10,fontstyles='arial',fontweight='normal',fmt='%1.0f',colors='black') plt.colorbar(CS3,label='$kg/m^3$') plt.title('Density',fontsize=10, fontweight='bold') plt.tick_params(labelsize=10) """ cp = plt.contourf(Y,X,Z) plt.colorbar(cp)3 #cpc=plt.contour(Y,X,Z,levels) # predefinrd number of contour CS = plt.contour(Y, X, Z, 30 ,linewidths=0.5,colors='grey') # automatice number of contours plt.clabel(CS,inline=1,inline_spacing=0,fontsize=12,fmt='%1.0f',colors='black') #plt.clabel(CS, inline=1, fontsize=10,color="black") # contour line labels """ #plt.title('Density profile') #plt.xlabel('Distance ($km$)') plt.ylabel('Depth ($km$)') ##############33 Vp profile plotting #f=open("velatten.dat","r") f=open("velocities.dat","r") data_out=f.readlines() temp_x=[] temp_y=[] temp_z_vp=[] temp_z_vs=[] for i in range(len(data_out)): data_temp=data_out[i].split() temp_x.append(float(str(data_temp[0]))) temp_y.append(float(str(data_temp[1]))) temp_z_vp.append(float(str(data_temp[2]))) temp_z_vs.append(float(str(data_temp[3]))) xlist=[] ylist = np.array(temp_y[0:95]) z_vp =temp_z_vp #np.array(temp_z) z_vs =temp_z_vs Z_vp=[] Z_vs=[] temp=0 for i in range(0,x_nodes): tmp1 = [] tmp2 = [] xlist.append(temp_x[temp+1]) for j in range(0,95): tmp1.append(z_vp[temp]) tmp2.append(z_vs[temp]) temp=temp+1 Z_vp.append(tmp1) Z_vs.append(tmp2) X,Y = np.meshgrid(ylist, xlist) levels = np.linspace(0, 50, 1600) #ax_vp = fig_out.add_subplot(413) ax_vp =plt.subplot(gs_[2]) for i in range(len(l)): ax_vp.plot(l[i][:],b[i][:],color='grey',linewidth=2) levels = np.arange(7.2, 8.8, 0.01) CS3 = plt.contourf(Y, X, Z_vp, levels,extend='both',cmap=plt.cm.get_cmap('RdYlBu',20),origin=origin) #CS3 = plt.contourf(Y, X, Z_vp, levels,extend='both',cmap=cmap,origin=origin) CS3.cmap.set_under('white') CS3.cmap.set_over('black') levels = np.arange(7.7, 8.8, 0.05) CS4 = plt.contour(Y, X, Z_vp, levels,linewidths=0.2,linestyles='dashed',colors='black') plt.clabel(CS4,inline=5,inline_spacing=10,fontsize=10,fmt='%1.1f',colors='black') plt.colorbar(CS3,label='$km/s$') plt.tick_params(labelsize=10) plt.title('P wave velocity',fontsize=10, fontweight='bold') #plt.xlabel('Distance ($km$)') plt.ylabel('Depth ($km$)') #ax_vs = fig_out.add_subplot(414) ax_vs =plt.subplot(gs_[3]) for i in range(len(l)): ax_vs.plot(l[i][:],b[i][:],color='grey',linewidth=2) levels = np.arange(4.2, 4.8, 0.01) #CS3 = plt.contourf(Y, X, Z_vs, levels,extend='both') CS3 = plt.contourf(Y, X, Z_vs, levels,extend='both',cmap=plt.cm.get_cmap('RdYlBu',20),origin=origin) CS3.cmap.set_under('white') CS3.cmap.set_over('black') #levels = np.arange(4.1, 4.8, 0.05) levels = np.arange(4.3, 5.1, 0.05) CS4 = plt.contour(Y, X, Z_vs, levels,linewidths=0.2,linestyles='dashed',colors='black') plt.clabel(CS4,inline=5,inline_spacing=10,fontsize=10,fmt='%1.1f',colors='black') plt.colorbar(CS3,label='$km/s$') plt.title('S wave velocity',fontsize=10, fontweight='bold') plt.xlabel('Distance ($km$)') plt.ylabel('Depth ($km$)') plt.tick_params(labelsize=10) #plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0) #plt.tight_layout() savefig('Temp_Dens_velocities.png', dpi=300) ###########################3 ### calculating the misfit #boug_misfit= (bouger_in - bouguer_out)/len(bouger_in) #print boug_misfit #geoid_misfit=(geoid_in - geoid_out )/len(geoid_in) #print geoid_misfit ################## plt.show()
x1_min, x1_max = X_combined[:, 0].min() - 1, X_combined[:, 0].max() + 1 x2_min, x2_max = X_combined[:, 1].min() - 1, X_combined[:, 1].max() + 1 xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution)) xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution)) xx1 xx2 xx1.ravel() Z = tree.predict(np.array([xx1.ravel(), xx2.ravel()]).T) Z xx1.shape xx1 Z Z.shape Z.reshape(xx1.shape) plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap) import matplotlib.pyplot as plt import matplotlib.pyplot y_combined = np.vstack((y_train[:, np.newaxis], y_test[:, np.newaxis])) tree = DecisionTreeClassifier(criterion='entropy', max_depth=4, random_state=0).fit(X_train, y_train) test_idx = range(105, 150) resolution = 0.01 markers = ('s', 'x', 'o', '^', 'v') colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan') cmap = mpl.colors.ListedColormap(colors[:len(np.unique(y_combined))]) x1_min, x1_max = X_combined[:, 0].min() - 1, X_combined[:, 0].max() + 1 x2_min, x2_max = X_combined[:, 1].min() - 1, X_combined[:, 1].max() + 1 xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution))
fig1 = plb.figure() q = analyze.readGrid(sgrid=True) xx = q.x[:] yy = q.y[:] zz = q.z[:] #qq = np.meshgrid(xx, yy, zz, indexing='ij') #xc = qq[0] #yc = qq[1] #zc = qq[2] #x1 = xc[:,:,0] #y1 = yc[:,:,0] #z1 = zc[:,:,0] #z2 = np.pi/2 - y1 data = analyze.readData(ddens=True, binary=False) v = data.rhodust[0, :, :, 0] c = plb.contourf(zz / natconst.pc, xx / natconst.pc, (data.rhodust[0, :, :, 0]), 290) #plb.xlabel('r [au]') #plb.axis([-500000, 500000, -250000, 250000]) #plb.ylabel(r' [au]') #plb.xscale('log') #plb.yscale('log') cb = plb.colorbar(c) cb.set_label(r'$\log_{10}{\rho}$', rotation=270.) # View a 2-D slice of the 3-D array of the setup # #fig2 = plt.figure() #q = analyze.readGrid(sgrid = True) #v = analyze.readData(ddens=True, binary=False) #ax = fig2.add_subplot(111, projection='3d') #ax.plot_wireframe((y1), (x1), (v), rstride=1, cstride=1)
lr_b = 0 lr_w = 0 # Iterations for i in range(iteration): b_grad = 0.0 w_grad = 0.0 for n in range(len(x_data)): b_grad = b_grad - 2.0 * (y_data[n] - b - w * x_data[n]) * 1.0 w_grad = w_grad - 2.0 * (y_data[n] - b - w * x_data[n]) * x_data[n] lr_b = lr_b + b_grad**2 lr_w = lr_w + w_grad**2 # Update parameters b = b - lr / np.sqrt(lr_b) * b_grad w = w - lr / np.sqrt(lr_w) * w_grad # Store parameters for plotting b_history.append(b) w_history.append(w) #plot the figure plt.contourf(x, y, z, 50, alpha=0.5, cmap=plt.get_cmap('jet')) plt.plot([-188.4], [2.67], 'x', ms=12, markeredgewidth=3, color='orange') plt.plot(b_history, w_history, 'o-', ms=3, lw=1.5, color='black') plt.xlim(-200, -100) plt.ylim(-5, 5) plt.xlabel(r'$b$', fontsize=16) plt.ylabel(r'$w$', fontsize=16) plt.show()
def create_figure_surface(figid, aspect, xx, yy, cmin, cmax, levels, slices, v3d): ''' creates a plot of the surface of a tracer data Parameters ---------- figid : int id of figure aspect: float aspect ratio of figure xx : array scale of x axis yy : array scale of y axis cmin,cmax : array minimum and maxminm of the color range levels : array range of contourlines slices : array location of slices v3d : vector data in geometry format Returns ------- plot : of surface data ''' # prepare matplotlib import matplotlib matplotlib.rc("font",**{"family":"sans-serif"}) matplotlib.rc("text", usetex=True) #matplotlib.use("PDF") import matplotlib.pyplot as plt # basemap from mpl_toolkits.basemap import Basemap # numpy import numpy as np # data vv = v3d[0,:,:,0] # shift vv = np.roll(vv, 64, axis=1) # plot surface plt.figure(figid) # colormap cmap = plt.cm.bone_r # contour fill p1 = plt.contourf(xx, yy, vv, cmap=cmap, levels=levels, origin="lower")#, hold="on") plt.clim(cmin, cmax) # contour lines p2 = plt.contour(xx, yy, vv, levels=levels, linewidths = (1,), colors="k")#, hold="on") plt.clabel(p2, fmt = "%2.1f", colors = "k", fontsize = 14) #plt.colorbar(p2,shrink=0.8, extend='both') # slices #s1 = xx[np.mod(slices[0]+64, 128)] #s2 = xx[np.mod(slices[1]+64, 128)] #s3 = xx[np.mod(slices[2]+64, 128)] # print s1, s2, s3 #plt.vlines([s1, s2, s3], -90, 90, color='k', linestyles='--') # set aspect ratio of axes plt.gca().set_aspect(aspect) # basemap m = Basemap(projection="cyl") m.drawcoastlines(linewidth = 0.5) # xticks plt.xticks(range(-180, 181, 45), range(-180, 181, 45)) plt.xlim([-180, 180]) plt.xlabel("Longitude [degrees]", labelpad=8) # yticks plt.yticks(range(-90, 91, 30), range(-90, 91, 30)) plt.ylim([-90, 90]) plt.ylabel("Latitude [degrees]") # write to file plt.savefig("solution-surface", bbox_inches="tight") plt.show()
def Plot2DBoundary(DTrain, LTrain, DTest, LTest): # The dots are training samples (img not drawn), and the pics are testing samples (images drawn) # Play around with the K values. This is very controlled dataset so it should be able to get perfect classification on testing entries # Play with the K for isomap, play with the K for neighbors. fig = plt.figure() ax = fig.add_subplot(111) ax.set_title('Transformed Boundary, Image Space -> 2D') padding = 0.1 # Zoom out resolution = 1 # Don't get too detailed; smaller values (finer rez) will take longer to compute colors = ['blue', 'green', 'orange', 'red'] # ------ # Calculate the boundaries of the mesh grid. The mesh grid is # a standard grid (think graph paper), where each point will be # sent to the classifier (KNeighbors) to predict what class it # belongs to. This is why KNeighbors has to be trained against # 2D data, so we can produce this countour. Once we have the # label for each point on the grid, we can color it appropriately # and plot it. x_min, x_max = DTrain[:, 0].min(), DTrain[:, 0].max() y_min, y_max = DTrain[:, 1].min(), DTrain[:, 1].max() x_range = x_max - x_min y_range = y_max - y_min x_min -= x_range * padding y_min -= y_range * padding x_max += x_range * padding y_max += y_range * padding # Using the boundaries, actually make the 2D Grid Matrix: xx, yy = np.meshgrid(np.arange(x_min, x_max, resolution), np.arange(y_min, y_max, resolution)) # What class does the classifier say about each spot on the chart? # The values stored in the matrix are the predictions of the model # at said location: Z = model.predict(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) # Plot the mesh grid as a filled contour plot: plt.contourf(xx, yy, Z, cmap=plt.cm.terrain, z=-100) # ------ # When plotting the testing images, used to validate if the algorithm # is functioning correctly, size them as 5% of the overall chart size x_size = x_range * 0.05 y_size = y_range * 0.05 # First, plot the images in your TEST dataset img_num = 0 for index in LTest.index: # DTest is a regular NDArray, so you'll iterate over that 1 at a time. x0, y0 = DTest[img_num, 0] - x_size / 2., DTest[img_num, 1] - y_size / 2. x1, y1 = DTest[img_num, 0] + x_size / 2., DTest[img_num, 1] + y_size / 2. # DTest = our images isomap-transformed into 2D. But we still want # to plot the original image, so we look to the original, untouched # dataset (at index) to get the pixels: img = df.iloc[index, :].reshape(num_pixels, num_pixels) ax.imshow(img, aspect='auto', cmap=plt.cm.gray, interpolation='nearest', zorder=100000, extent=(x0, x1, y0, y1), alpha=0.8) img_num += 1 # Plot your TRAINING points as well... as points rather than as images for label in range(len(np.unique(LTrain))): indices = np.where(LTrain == label) ax.scatter(DTrain[indices, 0], DTrain[indices, 1], c=colors[label], alpha=0.8, marker='o') # Plot plt.show()
# Creating boundary on Gaussian NB import numpy as np import matplotlib as plt X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]) #collection of features Y = np.array([1, 1, 1, 2, 2, 2]) #class or label to which feature belongs to (responses) from sklearn.naive_bayes import GaussianNB clf = GaussianNB() #instance of Gaussian NB model clf.fit(X, Y) #training of model x = [-1, -2, -3, 1, 2, 3] y = [-1, -1, -2, 1, 1, 2] h = .02 #create a mesh to plot in x_min = X[:, 0].min() - 1 x_max = X[:, 0].max() + 1 y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) plt.contourf(xx, yy, Z, cmap=plt.cm.coolwarm, alpha=0.8) plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.coolwarm) plt.show()