def execute_solver(IMAGE_FILE): sample4x4_crop = import_image(IMAGE_FILE) cluster_image = get_clustering_image(sample4x4_crop) cluster_groupings_dict = cluster_grouper(cluster_image).execute() final = pre_process_image(IMAGE_FILE) prediction_dict = clean_prediction_dict(get_predictions(final)) write_puzzle_file(cluster_groupings_dict,prediction_dict) try: solution = solve_puzzle('cv_puzzle.txt',False) except: return 'error' #get image of result fig = plt.figure(figsize=(2, 2), dpi=100,frameon=False) plt.axis('off') plt.imshow(sample4x4_crop, cmap=mpl.cm.Greys_r) for k,v in solution.items(): if v == None: return 'error' plt.annotate('{}'.format(v), xy=(k[0]*50+12,k[1]*50+40), fontsize=14) plt.tight_layout() plt.savefig('static/images/solution.jpg', bbox_inches='tight', dpi=100) #theres an issue with the saved layout, tight_layout #doesn't appear to work so I need to apply my own cropping again resize_final = import_image('static/images/solution.jpg',80) imsave('static/images/solution.jpg',resize_final) return 'good'
def showCumulOverlap(mode, modes, *args, **kwargs): """Show cumulative overlap using :func:`~matplotlib.pyplot.plot`. :type mode: :class:`.Mode`, :class:`.Vector` :arg modes: multiple modes :type modes: :class:`.ModeSet`, :class:`.ANM`, :class:`.GNM`, :class:`.PCA` """ import matplotlib.pyplot as plt if not isinstance(mode, (Mode, Vector)): raise TypeError('mode must be NMA, ModeSet, Mode or Vector, not {0}' .format(type(mode))) if not isinstance(modes, (NMA, ModeSet)): raise TypeError('modes must be NMA, ModeSet, or Mode, not {0}' .format(type(modes))) cumov = (calcOverlap(mode, modes) ** 2).cumsum() ** 0.5 if isinstance(modes, NMA): arange = np.arange(0.5, len(modes)+0.5) else: arange = modes.getIndices() + 0.5 show = plt.plot(arange, cumov, *args, **kwargs) plt.title('Cumulative overlap with {0}'.format(str(mode))) plt.xlabel('{0} mode index'.format(modes)) plt.ylabel('Cumulative overlap') plt.axis((arange[0]-0.5, arange[-1]+0.5, 0, 1)) if SETTINGS['auto_show']: showFigure() return show
def showCumulFractVars(modes, *args, **kwargs): """Show fraction of variances of *modes* using :func:`~matplotlib.pyplot. plot`. Note that mode indices are incremented by 1. See also :func:`.showFractVars` function.""" import matplotlib.pyplot as plt if not isinstance(modes, (Mode, NMA, ModeSet)): raise TypeError('modes must be a Mode, NMA, or ModeSet instance, ' 'not {0}'.format(type(modes))) if isinstance(modes, Mode): indices = modes.getIndices() + 0.5 modes = [modes] elif isinstance(modes, ModeSet): indices = modes.getIndices() + 0.5 else: indices = np.arange(len(modes)) + 0.5 fracts = calcFractVariance(modes).cumsum() show = plt.plot(indices, fracts, *args, **kwargs) axis = list(plt.axis()) axis[0] = 0.5 axis[2] = 0 axis[3] = 1 plt.axis(axis) plt.xlabel('Mode index') plt.ylabel('Fraction of variance') if SETTINGS['auto_show']: showFigure() return show
def test_prop(self): N = 800.0 V = linspace(5.0,51.0,50) rho = 1.2255 beta = 45.0 J = list() CT = list() CP = list() effy = list() for v in V: data = self.analyze_prop(beta,N,v,rho) J.append(data[2]) CT.append(data[3]) CP.append(data[4]) effy.append(data[5]) plt.figure(1) plt.grid(True) plt.hold(True) plt.plot(J,CT,'o-') plt.xlabel('J') plt.plot(J,CP,'ro-') plt.axis([0,2.5,0,0.15]) plt.figure(2) plt.plot(J,effy,'gs-') plt.hold(True) plt.grid(True) plt.axis([0,2.5,0,1.0]) plt.xlabel('advance ratio') plt.ylabel('efficiency') plt.show()
def showOverlapTable(modes_x, modes_y, **kwargs): """Show overlap table using :func:`~matplotlib.pyplot.pcolor`. *modes_x* and *modes_y* are sets of normal modes, and correspond to x and y axes of the plot. Note that mode indices are incremented by 1. List of modes is assumed to contain a set of contiguous modes from the same model. Default arguments for :func:`~matplotlib.pyplot.pcolor`: * ``cmap=plt.cm.jet`` * ``norm=plt.normalize(0, 1)``""" import matplotlib.pyplot as plt overlap = abs(calcOverlap(modes_y, modes_x)) if overlap.ndim == 0: overlap = np.array([[overlap]]) elif overlap.ndim == 1: overlap = overlap.reshape((modes_y.numModes(), modes_x.numModes())) cmap = kwargs.pop('cmap', plt.cm.jet) norm = kwargs.pop('norm', plt.normalize(0, 1)) show = (plt.pcolor(overlap, cmap=cmap, norm=norm, **kwargs), plt.colorbar()) x_range = np.arange(1, modes_x.numModes() + 1) plt.xticks(x_range-0.5, x_range) plt.xlabel(str(modes_x)) y_range = np.arange(1, modes_y.numModes() + 1) plt.yticks(y_range-0.5, y_range) plt.ylabel(str(modes_y)) plt.axis([0, modes_x.numModes(), 0, modes_y.numModes()]) if SETTINGS['auto_show']: showFigure() return show
def Test(self): test_Dir = "Result"; if not os.path.exists(test_Dir): os.makedirs(test_Dir); test_Label_List = [0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5]; test_Label_Pattern = np.zeros((16, 10)); test_Label_Pattern[np.arange(16), test_Label_List] = 1; feed_Dict = { self.noise_Placeholder: np.random.uniform(-1., 1., size=[16, self.noise_Size]), self.label_for_Fake_Placeholder: test_Label_Pattern, self.is_Training_Placeholder: False }; #Batch is constant in the test. global_Step, mnist_List = self.tf_Session.run(self.test_Tensor_List, feed_dict = feed_Dict); fig = plt.figure(figsize=(4, 4)) gs = gridspec.GridSpec(4, 4) gs.update(wspace=0.05, hspace=0.05) for index, mnist in enumerate(mnist_List): ax = plt.subplot(gs[index]) plt.axis('off') ax.set_xticklabels([]) ax.set_yticklabels([]) ax.set_aspect('equal') plt.imshow(mnist.reshape(28, 28), cmap='Greys_r') plt.savefig('%s/S%d.png' % (test_Dir, global_Step), bbox_inches='tight'); plt.close();
def do_plot(mode, content, wide): global style style.apply(mode, content, wide) data = np.load("data/prr_AsAu_%s%s.npz"%(content, wide)) AU, TAU = np.meshgrid(-data["Au_range_dB"], data["tau_range"]) Zu = data["PRR_U"] Zs = data["PRR_S"] assert TAU.shape == AU.shape == Zu.shape, "The inputs TAU, AU, PRR_U must have the same shape for plotting!" plt.clf() if mode in ("sync",): # Plot the inverse power ratio, sync signal is stronger for positive ratios CSf = plt.contourf(TAU, AU, Zs, levels=(0.0, 0.2, 0.4, 0.6, 0.8, 0.9, 1.0), colors=("1.0", "0.75", "0.5", "0.25", "0.15", "0.0"), origin="lower") CS2 = plt.contour(CSf, colors = ("r",)*5+("w",), linewidths=(0.75,)*5+(1.0,), origin="lower", hold="on") else: CSf = plt.contourf(TAU, AU, Zs, levels=(0.0, 0.2, 0.4, 0.6, 0.8, 0.9, 1.0), colors=("1.0", "0.75", "0.5", "0.25", "0.15", "0.0"), origin="lower") CS2f = plt.contour(CSf, levels=(0.0, 0.2, 0.4, 0.6, 0.8, 1.0), colors=4*("r",)+("w",), linewidths=(0.75,)*4+(1.0,), origin="lower", hold="on") #CS2f = plt.contour(TAU, -AU, Zu, levels=(0.9, 1.0), colors=("0.0",), linewidths=(1.0,), origin="lower", hold="on") if content in ("unif",): CSu = plt.contourf(TAU, AU, Zu, levels=(0.2, 1.0), hatches=("////",), colors=("0.75",), origin="lower") CS2 = plt.contour(CSu, levels=(0.2,), colors = ("r",), linewidths=(1.0,), origin="lower", hold="on") style.annotate(mode, content, wide) plt.axis([data["tau_range"][0], data["tau_range"][-1], -data["Au_range_dB"][-1], -data["Au_range_dB"][0]]) plt.ylabel(r"Signal power ratio ($\mathrm{SIR}$)", labelpad=2) plt.xlabel(r"Time offset $\tau$ ($/T$)", labelpad=2) plt.savefig("pdf/prrc2_%s_%s%s_z.pdf"%(mode, content, wide))
def plotTestData(tree): plt.figure() plt.axis([0,1,0,1]) plt.xlabel("X axis") plt.ylabel("Y axis") plt.title("Green: Class1, Red: Class2, Blue: Class3, Yellow: Class4") for value in class1: plt.plot(value[0],value[1],'go') plt.hold(True) for value in class2: plt.plot(value[0],value[1],'ro') plt.hold(True) for value in class3: plt.plot(value[0],value[1],'bo') plt.hold(True) for value in class4: plt.plot(value[0],value[1],'yo') plotRegion(tree) for value in classPlot1: plt.plot(value[0],value[1],'g.',ms=3.0) plt.hold(True) for value in classPlot2: plt.plot(value[0],value[1],'r.', ms=3.0) plt.hold(True) for value in classPlot3: plt.plot(value[0],value[1],'b.', ms=3.0) plt.hold(True) for value in classPlot4: plt.plot(value[0],value[1],'y.', ms=3.0) plt.grid(True) plt.show()
def vis_detections (im, class_name, dets, thresh=0.5): """Draw detected bounding boxes.""" inds = np.where(dets[:, -1] >= thresh)[0] if len(inds) == 0: return im = im[:, :, (2, 1, 0)] fig, ax = plt.subplots(figsize=(12, 12)) ax.imshow(im, aspect='equal') for i in inds: bbox = dets[i, :4] score = dets[i, -1] ax.add_patch( plt.Rectangle((bbox[0], bbox[1]), bbox[2] - bbox[0], bbox[3] - bbox[1], fill=False, edgecolor='red', linewidth=3.5) ) ax.text(bbox[0], bbox[1] - 2, '{:s} {:.3f}'.format(class_name, score), bbox=dict(facecolor='blue', alpha=0.5), fontsize=14, color='white') ax.set_title(('{} detections with ' 'p({} | box) >= {:.1f}').format(class_name, class_name, thresh), fontsize=14) plt.axis('off') plt.tight_layout() plt.draw()
def heatmap(vals, size=6, aspect=1): """ Plot a heatmap from matrix data """ plt.figure(figsize=(size, size)) plt.imshow(vals, cmap="gray", aspect=aspect, interpolation="none", vmin=0, vmax=1) plt.axis("off")
def zplane(self, title="", fontsize=18): """ Display filter in the complex plane Parameters ---------- """ rb = self.z ra = self.p t = np.arange(0, 2 * np.pi + 0.1, 0.1) plt.plot(np.cos(t), np.sin(t), "k") plt.plot(np.real(ra), np.imag(ra), "x", color="r") plt.plot(np.real(rb), np.imag(rb), "o", color="b") M1 = -10000 M2 = -10000 if len(ra) > 0: M1 = np.max([np.abs(np.real(ra)), np.abs(np.imag(ra))]) if len(rb) > 0: M2 = np.max([np.abs(np.real(rb)), np.abs(np.imag(rb))]) M = 1.6 * max(1.2, M1, M2) plt.axis([-M, M, -0.7 * M, 0.7 * M]) plt.title(title, fontsize=fontsize) plt.show()
def draw(self): cols, rows = self.size minx, maxx = self.xlimits miny, maxy = self.ylimits width, height = self.cell_dimensions x = map(lambda i: minx + width*i, range(cols+1)) y = map(lambda i: miny + height*i, range(rows+1)) f = plt.figure(figsize=self.figsize) hlines = np.column_stack(np.broadcast_arrays(x[0], y, x[-1], y)) vlines = np.column_stack(np.broadcast_arrays(x, y[0], x, y[-1])) lines = np.concatenate([hlines, vlines]).reshape(-1, 2, 2) line_collection = LineCollection(lines, color="black", linewidths=0.5) ax = plt.gca() ax.add_collection(line_collection) ax.set_xlim(x[0]-1, x[-1]+1) ax.set_ylim(y[0]-1, y[-1]+1) plt.gca().set_aspect('equal', adjustable='box') plt.axis('off') self.draw_obstacles(plt.gca()) return plt.gca()
def render(self, interval=50, **kwargs): import matplotlib.cm as cm import matplotlib.animation as animation import matplotlib.pyplot as plt p = self.plot_layout _axs = [] for i in range(self.image_list[0].shape[2]): plt.subplot(p[0], p[1], 1 + i) # Hide the x and y labels plt.axis('off') _ax = plt.imshow(self.image_list[0][:, :, i], cmap=cm.Greys_r, **kwargs) _axs.append(_ax) def init(): return _axs def animate(j): for k, _ax in enumerate(_axs): _ax.set_data(self.image_list[j][:, :, k]) return _axs self._ani = animation.FuncAnimation(self.figure, animate, init_func=init, frames=len(self.image_list), interval=interval, blit=True) return self
def visualize(u1, t1, u2, t2, U, omega): plt.figure(1) plt.plot(t1, u1, 'r--o') t_fine = np.linspace(0, t1[-1], 1001) # мелкая сетка для точного решения u_e = u_exact(t_fine, U, omega) plt.hold('on') plt.plot(t_fine, u_e, 'b-') plt.legend([u'приближенное', u'точное'], loc='upper left') plt.xlabel('$t$') plt.ylabel('$u$') tau = t1[1] - t1[0] plt.title('$\\tau = $ %g' % tau) umin = 1.2*u1.min(); umax = -umin plt.axis([t1[0], t1[-1], umin, umax]) plt.savefig('tmp1.png'); plt.savefig('tmp1.pdf') plt.figure(2) plt.plot(t2, u2, 'r--o') t_fine = np.linspace(0, t2[-1], 1001) # мелкая сетка для точного решения u_e = u_exact(t_fine, U, omega) plt.hold('on') plt.plot(t_fine, u_e, 'b-') plt.legend([u'приближенное', u'точное'], loc='upper left') plt.xlabel('$t$') plt.ylabel('$u$') tau = t2[1] - t2[0] plt.title('$\\tau = $ %g' % tau) umin = 1.2 * u2.min(); umax = -umin plt.axis([t2[0], t2[-1], umin, umax]) plt.savefig('tmp2.png'); plt.savefig('tmp2.pdf')
def influence_plot(X, y_true, y_pred, **kwargs): """Produces an influence plot. Parameters ---------- X : array Design matrix. y_true : array_like Observed labels, either 0 or 1. y_pred : array_like Predicted probabilities, floats on [0, 1]. Notes ----- .. plot:: pyplots/influence_plot.py """ r = pearson_residuals(y_true, y_pred) leverages = pregibon_leverages(X, y_pred) delta_X2 = case_deltas(r, leverages) dbetas = pregibon_dbetas(r, leverages) plt.scatter(y_pred, delta_X2, s=dbetas * 800, **kwargs) __, __, y1, y2 = plt.axis() plt.axis((0, 1, y1, y2)) plt.xlabel('Predicted Probability') plt.ylabel(r'$\Delta \chi^2$') plt.tight_layout()
def vis_square(data): data = (data - data.min()) / (data.max() - data.min()) n = int(np.ceil(np.sqrt(data.shape[0]))) padding = ((0, 0), (0, 0), (1, 1), (1, 1)) data = np.pad(data, padding, mode = 'constant', constant_values = 0) #data = data.squeeze() total_array = np.array([]) for i in range(data.shape[0]): row_array = np.array([]) for j in range(data.shape[1]): if j == 0: row_array = data[i, j, :, :] else: row_array = np.vstack((row_array, data[i, j, :, :])) if i == 0: total_array = row_array else: total_array = np.hstack((total_array, row_array)) print("shape of total_array: {}".format(total_array.shape)) #data = data.reshape((n, n) + data.shape[1:]) #data = data.reshape((n * data.shape[1], n * data.shape[3]) + data.shape[4:]) plt.imshow(total_array); plt.axis('off') plt.show()
def plot(i, pcanc, lr, pp, labelFlag, Y): if len(str(i)) == 1: fig = plt.figure(i) else: fig = plt.subplot(i) if pcanc == 0: plt.title( ' learning_rate: ' + str(lr) + ' perplexity: ' + str(pp)) print("Plotting tSNE") else: plt.title( 'PCA-n_components: ' + str(pcanc) + ' learning_rate: ' + str(lr) + ' perplexity: ' + str(pp)) print("Plotting PCA-tSNE") plt.scatter(Y[:, 0], Y[:, 1], c=colors) if labelFlag == 1: for label, cx, cy in zip(y, Y[:, 0], Y[:, 1]): plt.annotate( label.decode('utf-8'), xy = (cx, cy), xytext = (-10, 10), fontproperties=font, textcoords = 'offset points', ha = 'right', va = 'bottom', bbox = dict(boxstyle = 'round,pad=0.5', fc = 'yellow', alpha = 0.9)) #arrowprops = dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0')) ax.xaxis.set_major_formatter(NullFormatter()) ax.yaxis.set_major_formatter(NullFormatter()) plt.axis('tight') print("Done.")
def plot_unit_cell(self): r'''Plots the unit cell and atoms of the material. ''' import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D # @UnresolvedImport from itertools import product, combinations fig = plt.figure() ax = fig.gca(projection='3d') # draw unit cell for s, e in combinations(np.array(list(product([0, self.abc[0]], [0, self.abc[1]], [0, self.abc[2]]))), 2): if np.sum(np.abs(s - e)) in self.abc: ax.plot3D(*zip(s, e), color="b") # plot atoms x, y, z, m = [], [], [], [] for item in self.atoms: x.append(item.pos[0] * self.abc[0]) y.append(item.pos[1] * self.abc[1]) z.append(item.pos[2] * self.abc[2]) m.append(item.mass) ax.scatter(x, y, z, s=m) plt.axis('scaled') plt.axis('off') plt.show()
def word_cloud_fre_all(domain_dirs, merged_flag=False): ''' 通过所有domain的wordcloud对象绘制wordcloud图像并保存在相应domain下 :return: ''' for domain_name in listdir(domain_dirs): domain_dir = path.join(domain_dirs, domain_name) wordclouds = word_cloud_frequency(domain_dir, domain_name, merged_flag) if merged_flag: wordcloud_dir = path.join(domain_dir, domain_name + '_merged_wordcloud1/') else: wordcloud_dir = path.join(domain_dir, domain_name + '_wordcloud1/') if not path.exists(wordcloud_dir): makedirs(wordcloud_dir) for topic_id, wordcloud in enumerate(wordclouds): # dump(wordcloud, open(path.join(wordcloud_dir, 'topic' + str(topic_id)), 'wb')) plt.imshow(wordcloud) plt.axis("off") # plt.show() plt.savefig(path.join(wordcloud_dir, 'topic' + str(topic_id))) print(domain_name, ' complete!!!') break
def main(): G=nx.Graph() G.add_edge('a','b',weight=0.6) G.add_edge('a','c',weight=0.2) G.add_edge('c','d',weight=0.1) G.add_edge('c','e',weight=0.7) G.add_edge('c','f',weight=0.9) G.add_edge('a','d',weight=0.3) elarge=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] >0.5] esmall=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] <=0.5] pos=nx.spring_layout(G) # positions for all nodes # nodes nx.draw_networkx_nodes(G,pos,node_size=700) # edges nx.draw_networkx_edges(G,pos,edgelist=elarge,width=6) nx.draw_networkx_edges(G,pos,edgelist=esmall,width=6,alpha=0.5,edge_color='b',style='dashed') # labels nx.draw_networkx_labels(G,pos,font_size=20,font_family='sans-serif') plt.axis('off') #plt.savefig("weighted_graph.png") # save as png plt.show() # display return
def plotGenomicregions(GPcount, name): """ :param GPcount: is a list of tuples [(region, size),....()] :return: """ """ Now we produce some pie charts """ gr = ['tss', 'intergenic', 'intron', 'exon', 'upstream'] size = [0, 0, 0, 0, 0] for a, b in GPcount: if a == 'tss': size[0] = b if a == 'intergenic': size[1] = b if a == 'intron': size[2] = b if a == 'exon': size[3] = b if a == 'upstream': size[4] = b colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral', 'cyan'] explode = (0.1, 0, 0, 0, 0) # only "explode" the 2nd slice plt.pie(size, explode=explode, labels=gr, colors=colors, autopct='%1.1f%%', shadow=True, startangle=90) # Set aspect ratio to be equal so that pie is drawn as a circle. #plt.legend(['tss', 'intergenic', 'intron', 'exon', 'upstream'], loc='upper left') plt.axis('equal') plt.savefig('/ps/imt/e/20141009_AG_Bauer_peeyush_re_analysis/further_analysis/plots/' + name + '.svg') plt.clf()
def yplot(data, limits=[None,None], fname='', xval=[0.5], label='', loc='upper left', ext='png'): """Make transverse plots of data Usage: yplot(data, limits=[None,None], fname='', xval=[0.5], label='', loc='upper left', ext='ext') xval is a list of axial distances in units of nx If no filename is specified a plot is displayed The special filename 'M' turns "hold" on (for multiplots) File format is ext (default is png) """ nx, ny = data.shape[0], data.shape[1] y = np.array(range(ny)) + 0.5 for x in xval: ix = int(x*nx) plt.plot(y, data[ix,:], label=label+" : "+"x="+str(x)) if (fname == 'M'): plt.hold=True else: plt.axis([0,data.shape[1],limits[0],limits[1]]) plt.legend(loc=loc) plt.hold=False if len(fname) == 0: plt.show() else: plt.savefig(fname+'-y.'+ext, format=ext) plt.close()
def cplot(data, limits=[None,None], CM = 'jet', fname='', ext='png'): """Make a color contour plot of data Usage: cplot(data, limits=[None,None], fname='') If no filename is specified a plot is displayed File format is ext (default is png) """ SIZE = 12 DPI = 100 nx, ny = data.shape[0], data.shape[1] data = data.reshape(nx,ny) scale = SIZE/float(max(nx,ny)) plt.figure(figsize=(scale*nx, scale*ny+1.0)) plt.clf() c = plt.imshow(np.transpose(data), cmap=CM) plt.clim(limits) plt.axis([0,nx,0,ny]) #cbar = plt.colorbar(c, ticks=np.arange(0.831,0.835,0.001), aspect = 20, orientation='vertical', shrink=0.72, extend='neither', spacing='proportional') #cbar = plt.colorbar(c, aspect = 40, orientation='vertical', shrink=0.72, extend='neither', spacing='proportional') #cbar = plt.colorbar(c, orientation='horizontal', shrink=1.0) cbar = plt.colorbar(c, orientation='vertical', shrink=0.72, extend='neither', spacing='proportional') cbar.ax.tick_params(labelsize=21,size=10) #cbar.ax.yaxis.set_ticks_position('left') #c.cmap.set_under(color='black') if len(fname) == 0: plt.show() else: plt.savefig(fname+'.'+ ext, format=ext, dpi=DPI, bbox_inches='tight', pad_inches=0.1) plt.close()
def plot_residuals(turnstile_weather, predictions): ''' Using the same methods that we used to plot a histogram of entries per hour for our data, why don't you make a histogram of the residuals (that is, the difference between the original hourly entry data and the predicted values). Based on this residual histogram, do you have any insight into how our model performed? Reading a bit on this webpage might be useful: http://www.itl.nist.gov/div898/handbook/pri/section2/pri24.htm ''' plt.figure() residuals = (turnstile_weather['ENTRIESn_hourly'] - predictions) residuals_mean = np.mean(residuals) residuals_std = np.std(residuals) residuals.hist(color='blue', bins=100, alpha=0.5) the_axis = [-15000, 20000, 0, 40000] plt.axis(the_axis) plt.xlabel('Actual Hourly Entries - Predictions') plt.ylabel('Freq') plt.title('Linear Regression with Gradient Descent Residuals') return plt, residuals_mean, residuals_std
def plot_fun(self, x, y, x_min, x_max, y_min, y_max, style): fig = plt.figure() plt.axis([x_min, x_max, y_min, y_max]) ax = fig.add_subplot(1, 1, 1) ax.plot(x, y, 'g') ax.set_xscale('log') plt.savefig('plot.png')
def plothist(): n_groups = 3 means_men = (42.3113658071, 39.7803247373, 67.335243553) std_men = (1, 2, 3) fig, ax = plt.subplots() index = np.array([0.5,1.5,2.5]) bar_width = 0.4 opacity = 0.4 error_config = {'ecolor': '0'} rects1 = plt.bar(index, means_men, bar_width, alpha=opacity, color='b', error_kw=error_config) plt.xlabel('Approach') plt.ylabel('Accuracy') plt.axis((0,3.4,0,100)) plt.title('Evaluation') plt.xticks(index + bar_width/2, ('Bing Liu', 'AFINN', 'SentiWordNet')) plt.legend() plt.tight_layout() # plt.show() plt.savefig('foo.png')
def png(self, start_timestamp, end_timestamp): self.load(start_timestamp, end_timestamp) plt.figure(figsize=(10, 7.52)) plt.rc("axes", labelsize=12, titlesize=14) plt.rc("font", size=10) plt.rc("legend", fontsize=7) plt.rc("xtick", labelsize=8) plt.rc("ytick", labelsize=8) plt.axes([0.08, 0.08, 1 - 0.27, 1 - 0.15]) for plot in self.plots: plt.plot(self.timestamps, self.plots[plot], self.series_fmt(plot), label=self.series_label(plot)) plt.axis("tight") plt.gca().xaxis.set_major_formatter( matplotlib.ticker.FuncFormatter(lambda x, pos=None: time.strftime("%H:%M\n%b %d", time.localtime(x))) ) plt.gca().yaxis.set_major_formatter( matplotlib.ticker.FuncFormatter(lambda x, pos=None: locale.format("%.*f", (0, x), True)) ) plt.grid(True) plt.legend(loc=(1.003, 0)) plt.xlabel("Time/Date") plt.title( self.description() + "\n%s to %s" % ( time.strftime("%H:%M %d-%b-%Y", time.localtime(start_timestamp)), time.strftime("%H:%M %d-%b-%Y", time.localtime(end_timestamp)), ) ) output_buffer = StringIO.StringIO() plt.savefig(output_buffer, format="png") return output_buffer.getvalue()
def xplot(data, limits=[None,None], fname='', func='max', label='', loc='upper right', ext='png'): """Make an axial plot of a funtion of data Usage: xplot(data, limits=[None,None], fname='', loc='upper left', ext='png') Possible functions to plot are max, min, avg If no filename is specified a plot is displayed The special filename 'M' turns "hold" on (for multiplots) File format is ext (default is png) """ nx,ny = data.shape[0],data.shape[1] z = np.zeros([3,nx]) for x in range(nx): z[0,x] = data[x,:].min() z[1,x] = data[x,:].max() z[2,x] = data[x,:].sum()/float(ny) #plt.plot(z[0], label=label+' min') #plt.plot(z[1], label=label+' max') plt.plot(z[2], label=label+' avg') if (fname == 'M'): plt.hold=True else: plt.legend(loc=loc) plt.axis([0,data.shape[0]-1,limits[0],limits[1]]) plt.hold=False if len(fname) == 0: plt.show() else: plt.savefig(fname+'-x.'+ext, format=ext) plt.close()
def Figure_Cannon_with_AirResistance(): def Cannon(b= 150,ya=0.,va=35.,phi=np.pi/4,nu=0.): g = 9.8067 def ode_f(x,y): # y = [z,v,phi] return np.array([np.tan(y[2]), -(g*np.sin(y[2]) + nu*y[1]**2.)/(y[1]*np.cos(y[2])), -g/y[1]**2.]) a= 0. abstol,reltol= 1e-4,1e-4 dim, T = 3, np.linspace(a,b,801) example = ode(ode_f).set_integrator('dopri5',atol=abstol,rtol=reltol) example.set_initial_value(np.array([ya,va,phi]),a) Y = np.zeros((len(T),dim)) Y[0,:] = np.array([0.,.5,np.pi/4.]) for j in range(1,len(T)): Y[j,:] = example.integrate(T[j]) if Y[j,0]<(-1e-3): break return T, T[:j],Y[:j,0] T,X,Y = Cannon(nu = 0.,va = 45,phi=np.pi/3,b=200) T,X1,Y1 = Cannon(nu = 0.0003,va = 45,phi=np.pi/3,b=200) #plt.plot(T,np.zeros(T.shape),'-k',np.zeros(10),np.linspace(0,80,10),'-k') plt.plot(X1, Y1, '--r', linewidth=2.0) plt.plot(X1[-1], Y1[-1], 'or', markersize=6.) plt.plot(X, Y, '-k', linewidth=2.0) plt.plot(X[-1], Y[-1], 'ok', markersize=6.) plt.axis([0, 200, 0, 85]) plt.savefig("Cannon_with_AirResistance.pdf") plt.clf()
def main(): fname = iris.sample_data_path('ostia_monthly.nc') # load a single cube of surface temperature between +/- 5 latitude cube = iris.load_cube(fname, iris.Constraint('surface_temperature', latitude=lambda v: -5 < v < 5)) # Take the mean over latitude cube = cube.collapsed('latitude', iris.analysis.MEAN) # Now that we have our data in a nice way, lets create the plot # contour with 20 levels qplt.contourf(cube, 20) # Put a custom label on the y axis plt.ylabel('Time / years') # Stop matplotlib providing clever axes range padding plt.axis('tight') # As we are plotting annual variability, put years as the y ticks plt.gca().yaxis.set_major_locator(mdates.YearLocator()) # And format the ticks to just show the year plt.gca().yaxis.set_major_formatter(mdates.DateFormatter('%Y')) plt.show()
opts = {'maxiter' : 100} # Preferred value. w_init = np.zeros((X_i.shape[1],1)) for lambd in lambdas: args = (X_i, y, lambd) w_l = minimize(regressionObjVal, w_init, jac=True, args=args,method='CG', options=opts) w_l_1 = np.zeros((X_i.shape[1],1)) for j in range(len(w_l.x)): w_l_1[j] = w_l.x[j] rmses4[i] = testOLERegression(w_l_1,Xtest_i,ytest) i = i + 1 plt.plot(lambdas,rmses4) plt.plot(lambdas,rmses3) plt.xlabel('lambda') plt.title('Figure 1') plt.axis([0, .5, 4.5, 7]) plt.legend(('RMSE 4','RMSE 3')) plt.show() ######################################### Problem 5 ############################### pmax = 7 lambda_opt = lambdas[np.argmin(rmses3)] rmses5 = np.zeros((pmax,2)) for p in range(pmax): Xd = mapNonLinear(X[:,2],p) Xdtest = mapNonLinear(Xtest[:,2],p) w_d1 = learnRidgeRegression(Xd,y,0) rmses5[p,0] = testOLERegression(w_d1,Xdtest,ytest) w_d2 = learnRidgeRegression(Xd,y,lambda_opt) rmses5[p,1] = testOLERegression(w_d2,Xdtest,ytest) plt.plot(range(pmax), rmses5)
plt.axhline(5.5, color = 'blue', linestyle = '--', linewidth = 2, alpha = 0.6) plt.legend(fontsize = 'xx-large', loc = 'best') plt.title('Chain A', fontsize = 36) B = plt.subplot(212, sharex = A, sharey = A) plt.plot(Fen_B, label = 'Fenestration', color = 'blue', linewidth = 3) plt.plot(Zip_B, label = 'Zipper', color = 'green', linewidth = 3) plt.plot(Exp_B, label = 'Expansion', color = 'red', linewidth = 3) plt.setp(B.get_xticklabels(), fontsize = 18) plt.setp(B.get_yticklabels(), fontsize = 18) plt.xlabel("time (ns)", fontsize = '24') plt.ylabel("z ($\AA$)", fontsize = '24') plt.axhline(11.5, color = 'green', linewidth = 2, alpha = 0.6) plt.axhline(11.5, color = 'red', linestyle = '--', linewidth = 2, alpha = 0.6) plt.axhline(5.5, color = 'blue', linestyle = '--', linewidth = 2, alpha = 0.6) v = [0,100,3,18] plt.axis(v) plt.title('Chain B', fontsize = 36) plt.savefig("{}_FEZ_AB.png".format(args.o), format='png', dpi=300) plt.savefig("{}_FEZ_AB.svg".format(args.o), format='svg', dpi=300) plt.clf() plt.figure(figsize=(16,8)) FZ = plt.subplot(121) plt.scatter(Zip_A, Fen_A, label = 'Chain A', color = 'green') plt.scatter(Zip_B, Fen_B, label = 'Chain B', color = 'gray') plt.plot(Zip_A, Fen_A, label = 'Chain A', color = 'green', alpha = 0.5) plt.plot(Zip_B, Fen_B, label = 'Chain B', color = 'gray', alpha = 0.5) plt.scatter((ZAup[0] + ZBup[0])/2, (FAup[0] + FBup[0])/2, label = '4BW5 (Up)', color = 'black', marker = 'D', s = 40) plt.scatter((ZAdn[0] + ZBdn[0])/2, (FAdn[0] + FBdn[0])/2, label = '4XDJ (Down)', color = 'blue', marker = 'D', s = 40) plt.scatter(Zip_A[0], Fen_A[0], label = 'Chain A start', color = 'green', marker = '^', s = 40, edgecolor = 'black') plt.scatter(Zip_B[0], Fen_B[0], label = 'Chain B start', color = 'grey', marker = '^', s = 40, edgecolor = 'black')
lon_units = Dset.variables["lon"].units lon_max = Dset.variables["lon"].valid_max lon_min = Dset.variables["lon"].valid_min lat_scale = Dset.variables["lat"][:] lat_units = Dset.variables["lat"].units lat_max = Dset.variables["lat"].valid_max lat_min = Dset.variables["lat"].valid_min plt.figure() #____________________ # These lines create the basemap for the data. Mbase = bm.Basemap(projection = 'cyl', llcrnrlat = -24.0, llcrnrlon = -44.0, urcrnrlat = -21.0, urcrnrlon = -40.0, resolution='f') Mbase.drawparallels(np.array([-24, -23, -22, -21]), labels=[0,0,0,1]) Mbase.drawmeridians(np.array([-44, -43, -42, -41, -40]), labels = [0,0,0,1]) #Mbase.drawsmask(land_color='0.8', ocean_color='w', lsmask=None, lsmask_lons=None, lsmask_lats=None, lakes=True, resolution='l', grid=5) Mbase.drawcoastlines() Mbase.fillcontinents(color = 'gray') # blue can be changed to any color that you would like #____________________ mymap = plt.contour(lon_scale, lat_scale, sst[0,:,:], 6,levels=[17.,23.,24.,25.,26.,32.], colors = 'k') mymap2 = plt.contourf(lon_scale, lat_scale, sst[0,:,:], 6,levels=[17.,23.,24.,25.,26.,32.]) plt.colorbar(mymap2, orientation = 'horizontal') plt.plot(-41.78,-22.37,'*k', markersize=20) plt.axis([-44,-40,-24,-21]) plt.xlabel(lon_units) plt.ylabel(lat_units) plt.show()
# Set the working directory to be the current one os.chdir(os.path.dirname(os.path.abspath(__file__))) # Load grayscale images img_orig = cv2.imread('j.png', 0) # Settings kernel_sizes = [3, 5, 7] kernel_shapes = ['RECT', 'CROSS', 'ELLIPSE'] index = 1 for size in kernel_sizes: # Display original plt.subplot(3, 4, index); index += 1 plt.imshow(img_orig, 'gray') plt.title('Original') plt.axis('off') for shape in kernel_shapes: # Kernel kernel = cv2.getStructuringElement(getattr(cv2, 'MORPH_' + shape), (size, size)) # Dilation img_res = cv2.dilate(img_orig, kernel, iterations=1) # Display results plt.subplot(3, 4, index); index += 1 plt.imshow(img_res, 'gray') plt.title(shape + ' @ ' + str(size) + ' x ' + str(size)) plt.axis('off') plt.show()
# load the images -- the original, the original + contrast, # and the original + photoshop original = cv2.imread("images/jp_gates_original.png") contrast = cv2.imread("images/jp_gates_contrast.png") shopped = cv2.imread("images/jp_gates_photoshopped.png") # convert the images to grayscale original = cv2.cvtColor(original, cv2.COLOR_BGR2GRAY) contrast = cv2.cvtColor(contrast, cv2.COLOR_BGR2GRAY) shopped = cv2.cvtColor(shopped, cv2.COLOR_BGR2GRAY) # initialize the figure fig = plt.figure("Images") images = ("Original", original), ("Contrast", contrast), ("Photoshopped", shopped) # loop over the images for (i, (name, image)) in enumerate(images): # show the image ax = fig.add_subplot(1, 3, i + 1) ax.set_title(name) plt.imshow(image, cmap = plt.cm.gray) plt.axis("off") # show the figure plt.show() # compare the images compare_images(original, original, "Original vs. Original") compare_images(original, contrast, "Original vs. Contrast") compare_images(original, shopped, "Original vs. Photoshopped")
def plotvars(BB,Wi=None,short=False,Nob=False,bx=bx,mode="save",formatf=["pdf","svg","pgn"][0]): outputs={1:cpy(indict),2:cpy(indict),3:cpy(indict)} axs=(0,-2,-1) hol=[WAR,bs][BB] WV = wid if (Wi is None) else WAR[Wi] ding=0 BS= np.array(hol) if BB==1 else bs[bsvi] if BB==0: WS=np.array(hol) wu=np.unique(WS).shape[0] bu=np.unique(BS).shape[0] BD="{}Weight_{}".format(wu, "no-B_" if No_B else " {}B({})_".format(bu,bsvi)) if BB==0 else "{}Bias_{}W({})_".format(bu,wu,Wi if not(Wi is None) else "wid") if short:#subsample data for bb in hol:#bb are upscaled 5 times #print(bb) #print('B',bs[bsvi],'B') if BB==1: print('W',wid,'W') print('B',bb,'B') #print(wid.shape,bb.shape) d1=vecvari10(inputcols, WV,BB=0, B=bb,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v) d2=vecvari10(inputcols, WV,BB=1, B=bb,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v) d3=vecvari10(inputcols, WV,BB=0,BS=1, B=bb,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v)#-vecvari10(inputcols, wid,noB=0, B=bb,square=0,sqrt=0,verbose=0) p1=vecvari1(inputcols, WV, B=bb,BB=0,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) p2=vecvari1(inputcols, WV, B=bb,BB=1,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) p3=vecvari1(inputcols, WV, B=bb,BB=0,BS=1,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) elif BB==0: if Nob: bval=None else: bval=bs[bsvi] print('W',bb,'W') print('B',bval,'B') print(bb.shape,bs[9].shape) d1=vecvari10(inputcols, bb,BB=0, B=bval,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v) p1=vecvari1(inputcols, bb,BB=1, B=bval,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) d2=vecvari10(inputcols, bb,BB=0,BS=1, B=bval,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v) p2=vecvari1(inputcols, bb,BB=0, B=bval,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) d3=vecvari10(inputcols, bb,BB=1, B=bval,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v) p3=vecvari1(inputcols, bb,BB=0,BS=1, B=bval,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) for iou,out in enumerate([(d1,d2,d3),(p1,p2,p3),(d1-p1,d2-p2,d3-p3)]): if iou==0: ding+=1 iou+=1 #print(iou) #print(out.mean(axs).shape) out1=out[0] out2=out[1] out3=out[2]#out1-out2 [outputs[iou]['1mean'].append(oo) for oo in out1.mean(axs)] [outputs[iou]['1max'].append(oo) for oo in out1.max(axs)] [outputs[iou]['1min'].append(oo) for oo in out1.min(axs)] [outputs[iou]['2mean'].append(oo) for oo in out2.mean(axs)] [outputs[iou]['2max'].append(oo) for oo in out2.max(axs)] [outputs[iou]['2min'].append(oo) for oo in out2.min(axs)] [outputs[iou]['mean'].append(oo) for oo in out3.mean(axs)] [outputs[iou]['max'].append(oo) for oo in out3.max(axs)] [outputs[iou]['min'].append(oo) for oo in out3.min(axs)] else:#do each data point for kl in hol: for bb in kl: bb=np.broadcast_to(bb, kl.shape) #print(bb[:,0]) #print('B',bs[bsvi],'B') if BB==1: print('W',wid,'W') print('B',bb,'B') #print(wid.shape,bb.shape) d1=vecvari10(inputcols, wid,BB=0, B=bb,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v) d2=vecvari10(inputcols, wid,BB=1, B=bb,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v) d3=vecvari10(inputcols, wid,BB=0,BS=1, B=bb,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v)#-vecvari10(inputcols, wid,noB=0, B=bb,square=0,sqrt=0,verbose=0) p1=vecvari1(inputcols, wid, B=bb,BB=0,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) p2=vecvari1(inputcols, wid, B=bb,BB=1,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) p3=vecvari1(inputcols, wid, B=bb,BB=0,BS=1,sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) elif BB==0: if Nob: bval=None else: bval=bs[bsvi] print('W',bb,'W') print('B',bval,'B') print(bb.shape,bs[9].shape) print(bb.shape,bs[9].shape) d1=vecvari10(inputcols, bb,BB=0, B=bs[bsvi],sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v) p1=vecvari1(inputcols, bb,BB=1, B=bs[bsvi],sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) d2=vecvari10(inputcols, bb,BB=0,BS=1, B=bs[bsvi],sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v) p2=vecvari1(inputcols, bb,BB=0, B=bs[bsvi],sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) d3=vecvari10(inputcols, bb,BB=1, B=bs[bsvi],sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[0],v3=v3v) p3=vecvari1(inputcols, bb,BB=0,BS=1, B=bs[bsvi],sqrt=sqrtv,verbose=0,mulb=mulbv,mul2=mul2v,sizz=sizz[1],v3=v3v) for iou,out in enumerate([(d1,d2,d3),(p1,p2,p3),(d1-p1,d2-p2,d3-p3)]): if iou==0: ding+=1 iou+=1 #print(iou) #print(out.mean(axs).shape) out1=out[0] out2=out[1] out3=out[2]#out1-out2 outputs[iou]['1mean'].append(out1.mean()) outputs[iou]['1max'].append(out1.max()) outputs[iou]['1min'].append(out1.min()) outputs[iou]['2mean'].append(out2.mean()) outputs[iou]['2max'].append(out2.max()) outputs[iou]['2min'].append(out2.min()) outputs[iou]['mean'].append(out3.mean()) outputs[iou]['max'].append(out3.max()) outputs[iou]['min'].append(out3.min()) #bx=bxx#np.linspace(0, bxx[-1], num=outputs[1]['mean'].__len__(), dtype=np.float32) #print(ding,(np.array(outputs[1]['mean']),np.array(outputs[2]['mean']))) #print([outputs[d]['min'] for d in outputs ]) tree=1#tree plots instead of one ylog=[1,1,0]#set wich plot to have the y axes as a log coloros=["xkcd:racing green","xkcd:bright pink","xkcd:raw umber", "xkcd:bright orange", "xkcd:barney purple","xkcd:light green", "xkcd:piss yellow","xkcd:bright aqua","xkcd:fire engine red",] markers=['+--','*--','x-']#markers for each group of plot mks=[8,6,6]#size of the markers ALPH=0.58#alpha of the plot if tree: #tree plots fig, axs = plt.subplots(3, 1) #fig.set_xscale('log') plt.axis([0,np.amax(bs[-1]),min(outputs[3]['min']),max([max(outputs[d]['max']) for d in outputs ])]) f1=plt.subplot(311) f1y=outputs[1] plt.plot(bx,f1y['1mean'],markers[0],color=coloros[0],markersize=mks[0],alpha=ALPH,) plt.plot(bx,f1y['1max'],markers[0],color=coloros[1],markersize=mks[0],alpha=ALPH,) plt.plot(bx,f1y['1min'],markers[0],color=coloros[2],markersize=mks[0],alpha=ALPH,) plt.plot(bx,f1y['2mean'],markers[1],color=coloros[3],markersize=mks[1],alpha=ALPH,) plt.plot(bx,f1y['2max'],markers[1],color=coloros[4],markersize=mks[1],alpha=ALPH,) plt.plot(bx,f1y['2min'],markers[1],color=coloros[5],markersize=mks[1],alpha=ALPH,) plt.plot(bx,f1y['mean'],markers[2],color=coloros[6],markersize=mks[2],alpha=ALPH,) plt.plot(bx,f1y['max'],markers[2],color=coloros[7],markersize=mks[2],alpha=ALPH,) plt.plot(bx,f1y['min'],markers[2],color=coloros[8],markersize=mks[2],alpha=ALPH,) plt.setp(f1.set_xscale('log')) plt.setp(f1.set_title('{},vecvari10,V3:{},sizz:{},mulb:{},mul2v:{}'.format(BD,v3v,sizz,mulbv,mul2v))) if ylog[0]: plt.setp(f1.set_yscale('log')) f2=plt.subplot(312,sharex=f1)#,sharey=f1) f2y=outputs[2] plt.plot(bx,f2y['1mean'],markers[0],color=coloros[0],markersize=mks[0],alpha=ALPH,) plt.plot( bx,f2y['1max'],markers[0],color=coloros[1],markersize=mks[0],alpha=ALPH,) plt.plot( bx,f2y['1min'],markers[0],color=coloros[2],markersize=mks[0],alpha=ALPH,) plt.plot(bx,f2y['2mean'],markers[1],color=coloros[3],markersize=mks[1],alpha=ALPH,) plt.plot(bx,f2y['2max'],markers[1],color=coloros[4],markersize=mks[1],alpha=ALPH,) plt.plot( bx,f2y['2min'],markers[1],color=coloros[5],markersize=mks[1],alpha=ALPH,) plt.plot(bx,f2y['mean'],markers[2],color=coloros[6],markersize=mks[2],alpha=ALPH,) plt.plot(bx,f2y['max'],markers[2],color=coloros[7],markersize=mks[2],alpha=ALPH,) plt.plot(bx,f2y['min'],markers[2],color=coloros[8],markersize=mks[2],alpha=ALPH,) plt.setp(f2.set_xscale('log')) plt.setp(f2.set_title('{},vecvari1,V3:{},sizz:{},mulb:{},mul2v:{}'.format(BD,v3v,sizz,mulbv,mul2v))) if ylog[1]: plt.setp(f2.set_yscale('log')) f3=plt.subplot(313,sharex=f1)#,sharey=f1) f3y=outputs[3] plt.plot(bx,f3y['1mean'],markers[0],color=coloros[0],markersize=mks[0],alpha=ALPH,) plt.plot( bx,f3y['1max'],markers[0],color=coloros[1],markersize=mks[0],alpha=ALPH,) plt.plot( bx,f3y['1min'],markers[0],color=coloros[2],markersize=mks[0],alpha=ALPH,) plt.plot(bx,f3y['2mean'],markers[1],color=coloros[3],markersize=mks[1],alpha=ALPH,) plt.plot(bx,f3y['2max'],markers[1],color=coloros[4],markersize=mks[1],alpha=ALPH,) plt.plot( bx,f3y['2min'],markers[1],color=coloros[5],markersize=mks[1],alpha=ALPH,) plt.plot(bx,f3y['mean'],markers[2],color=coloros[6],markersize=mks[2],alpha=ALPH,) plt.plot(bx,f3y['max'],markers[2],color=coloros[7],markersize=mks[2],alpha=ALPH,) plt.plot(bx,f3y['min'],markers[2],color=coloros[8],markersize=mks[2],alpha=ALPH,) plt.setp(f3.set_xscale('log')) plt.setp(f3.set_title('{},vecvari10-vecvari1,V3:{},sizz:{},mulb:{},mul2v:{}'.format(BD,v3v,sizz,mulbv,mul2v))) if ylog[2]: plt.setp(f3.set_yscale('log')) else: #all in one plot fig=plt.figure(1, figsize=(10,10)) #plt.yscale('log') #plt.xscale('log') plt.axis([0,max(bx),min(outputs[3]['min']),max([max(outputs[d]['max']) for d in outputs ])]) #plt.Axes.set_yscale(ax,'log') #plt.Axes.set_xscale(ax,'log') fg=plt.plot(bx,outputs[1]['mean'],'gs-',bx,outputs[1]['max'],'bs-',bx,outputs[1]['min'],'rs-', bx,outputs[2]['mean'],'go-',bx,outputs[2]['max'],'bo-',bx,outputs[2]['min'],'ro-', bx,outputs[3]['mean'],'yH-',bx,outputs[3]['max'],'mH-',bx,outputs[3]['min'],'cH-',markersize=6) #print(fg) #plt.setp(fg,plt.yscale('log')) #plt.setp(fg,plt.xscale('log')) for I in range(3): I+=1 print(outputs[I]['mean'][0],outputs[I]['mean'][9*4],outputs[I]['mean'][-1]) print(outputs[I]['max'][0],outputs[I]['max'][9*4],outputs[I]['max'][-1]) print(outputs[I]['min'][0],outputs[I]['min'][9*4],outputs[I]['min'][-1]) #plt.ion() plt.tight_layout(pad=1, h_pad=0.35, w_pad=0.35,rect=(0,0.07,1,1)) plt.legend(['BB:0,BS:0, mean','BB:0,BS:0, max','BB:0,BS:0, min', 'BB:1,BS:0, mean','BB:1,BS:0, max','BB:1,BS:0, min', 'BB:0,BS:1, mean','BB:0,BS:1, max','BB:0,BS:1, min'],markerfirst=True, bbox_to_anchor=(0,0,1,0), loc=2, ncol=3, mode="expand", borderaxespad=0.5) #https://matplotlib.org/users/legend_guide.html if mode=="save": outf=".//varplots//{}siz{}_ml{}_ml2{}_v3{}_rt{}.{}".format(BD,sizz,mulbv,mul2v,v3v,sqrtv,formatf) print(outf) plt.savefig(outf,format=formatf) #exit() else: plt.show()
# Get the heading from the quaternion yaw = math.atan2(2.0*(x*y + w*z), w*w + x*x - y*y - z*z); gps_point = (gps_points[point[0]==gps_points[:,0]]).flatten() pos_x, pos_y, pos_z = gps_point[1:4] all_heading_points = np.vstack((all_heading_points, np.array([point[0], pos_x, pos_y, pos_z, yaw]))) if math.fabs(yaw - previous_yaw) < 1e-3: new_heading_points = np.vstack((new_heading_points, np.array([point[0], pos_x, pos_y, pos_z, yaw]))) else: old_heading_points = np.vstack((old_heading_points, np.array([point[0], pos_x, pos_y, pos_z, yaw]))) previous_yaw = yaw plt.figure() plt.axis('equal') # Plot all the GPS points and draw lines from one to the next x = all_heading_points[:,1] y = all_heading_points[:,2] plt.quiver(x[:-1], y[:-1], x[1:]-x[:-1], y[1:]-y[:-1], scale_units='xy', angles='xy', scale=1) # Transform angles from radians to degrees and plot the heading at the position of the GPS points x = old_heading_points[:,1] y = old_heading_points[:,2] angles = old_heading_points[:,4] * 180 / math.pi plt.quiver(x, y, 1, 0, scale_units='xy', angles=angles, scale=20, pivot='tail', color='r') x = new_heading_points[:,1] y = new_heading_points[:,2] angles = new_heading_points[:,4] * 180 / math.pi
def plotProbability(self,fig, ax): # These shold be settings contours = 12 bins=50 minX,maxX = self.axX[0],self.axX[1] minY,maxY = self.axY[0],self.axY[1] if minX == maxX: minX = min(self.data[self.geoX]) maxX = max(self.data[self.geoX]) minY = min(self.data[self.geoY]) maxY = max(self.data[self.geoY]) #fig, ax = plt.subplots() plt.axis([minX, maxX, minY, maxY]) if self.hasMatrix: xgrid, ygrid, zgrid = self.numpy else: xgrid, ygrid, zgrid = self.kde2D_scipy(kde,[minX,maxX,minY,maxY], bins) xgrid = np.linspace(minX, maxX, bins) ygrid = np.linspace(minY,maxY, bins) # Don't allow the axis to be on top of your data extent = [] if self.range != []: extent = [self.range[0], self.range[1],self.range[0],self.range[1]] plt.gca().set_aspect("equal") print(extent) ax.grid(True, which='major', axis='both', linestyle='-', color=(0.5, 0.5, 0.5), alpha=0.1) if self.centre: self.data[self.hue + '2'] = self.data[self.hue] ** 2 self.data = self.data.sort_values(by=self.hue + '2', ascending=True) self.vmax = max(self.data[self.hue].max(), -1 * self.data[self.hue].min()) self.vmin = self.vmax * -1 alpha=1 if self.title=='ghost': alpha = 0.4 #self.palette = 'seismic' if self.vmin == self.vmax: im = plt.pcolormesh(xgrid, ygrid, zgrid, shading='gouraud', cmap=self.palette,alpha=alpha) if self.range == []: cs = plt.contour(xgrid, ygrid, zgrid, contours, colors='0.7', linewidths=0.4,alpha=alpha) else: cs = plt.contour(xgrid, ygrid, zgrid, contours, colors='0.7', linewidths=0.4, alpha=alpha,extent=extent) else: im = plt.pcolormesh(xgrid, ygrid, zgrid, shading='gouraud', cmap=self.palette, vmin=self.vmin, vmax=self.vmax,alpha=alpha) if self.range == []: cs = plt.contour(xgrid, ygrid, zgrid, contours, colors='tab:purple', linewidths=0.05,alpha=alpha) else: cs = plt.contour(xgrid, ygrid, zgrid, contours, colors='tab:purple', linewidths=0.05, alpha=alpha,extent=extent) ax.set_axisbelow(True) cbar = fig.colorbar(im, ax=ax) cbar.remove() ax.set_xlabel(self.geoX) ax.set_ylabel(self.geoY) if self.hasMatrix: if self.title == '': title = 'Difference Image' else: title = self.title + '\nDifference Image' else: count = len(self.data.index) title = self.title if title == '': title += 'Count=' + str(count) else: title += '\nCount=' + str(count) plt.title(title) return ''
n_error_outliers = y_pred_outliers[y_pred_outliers == -1].size / len( y_pred_outliers) printVar("n_error_outliers", n_error_outliers) # plot the line, the points, and the nearest vectors to the plane Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) plt.title("Novelty Detection") plt.contourf(xx, yy, Z, levels=np.linspace(Z.min(), 0, 7), cmap=plt.cm.PuBu) a = plt.contour(xx, yy, Z, levels=[0], linewidths=2, colors='darkred') plt.contourf(xx, yy, Z, levels=[0, Z.max()], colors='palevioletred') s = 40 b1 = plt.scatter(X_train[:, 0], X_train[:, 1], c='white', s=s) b2 = plt.scatter(X_test[:, 0], X_test[:, 1], c='blueviolet', s=s) c = plt.scatter(X_outliers[:, 0], X_outliers[:, 1], c='gold', s=s) plt.axis('tight') plt.xlim((-5, 5)) plt.ylim((-5, 5)) plt.legend([a.collections[0], b1, b2, c], [ "learned frontier", "training observations", "new regular observations", "new abnormal observations" ], loc="upper left", prop=matplotlib.font_manager.FontProperties(size=11)) plt.xlabel("error train: %d/200 ; errors novel regular: %d/40 ; " "errors novel abnormal: %d/40" % (n_error_train, n_error_test, n_error_outliers)) plt.show()
def plotHexbin(self,fig, ax): # These shold be settings contours = 12 ax.grid(b=True, which='major', color='Gainsboro', linestyle='-',alpha=0.7,lw=0.7) #ax.set_axisbelow(True)can't set the lines below as the whole data is 1 image not scatters if self.operation == 'ABS': self.data[self.geoX] == abs(self.data[self.geoX]) x = self.data[self.geoX]#.ravel() y = self.data[self.geoY]#.ravel() extent = [] if self.range != []: extent = [self.range[0], self.range[1],self.range[0],self.range[1]] plt.gca().set_aspect("equal") if self.hue.lower() == 'count': if self.range == []: hb = plt.hexbin(x, y, bins=self.bins, cmap=self.palette,gridsize=self.gridsize) else: hb = plt.hexbin(x, y, bins=self.bins, cmap=self.palette, gridsize=self.gridsize,extent=extent) #cb = plt.colorbar() #cb.set_label('Count') else: z = self.data[self.hue] # .ravel() self.vmin = z.min() self.vmax = z.max() #ax = self.data.plot.hexbin(x=self.geoX,y=self.geoY,C=self.hue,gridsize=10,cmap=self.palette) if self.range == []: hb = plt.hexbin(x,y,C=z,bins=self.bins, cmap=self.palette,gridsize=self.gridsize,reduce_C_function=np.mean) #,vmin = self.vmin, vmax = self.vmax) else: hb = plt.hexbin(x, y, C=z, bins=self.bins, cmap=self.palette, gridsize=self.gridsize,reduce_C_function=np.mean, extent=extent) cb = plt.colorbar() cb.set_label('Average ' + self.hue) #cb.set_ticks(z.min(),z.max()) cb.set_ticks(np.linspace(hb.get_array().min(), hb.get_array().max(), 10)) lbls = np.linspace(round(z.min(),2), round(z.max(),2), 10) diff = z.max()-z.min() lblsrounded = [] for lbl in lbls: if diff < 5: lblsrounded.append(round(lbl,2)) elif diff < 10: lblsrounded.append(round(lbl, 1)) else: lblsrounded.append(int(round(lbl, 0))) #cb.set_ticklabels(np.linspace(round(z.min(),2), round(z.max(),2), 10)) cb.set_ticklabels(lblsrounded) #if self.range != []: # plt.xlim(xmin=self.range[0], xmax=self.range[1]) # plt.gca().set_aspect("equal") # ax.grid(b=True, which='major', color='Gainsboro', linestyle='-') # ax.set_axisbelow(True) plt.axis([x.min(), x.max(), y.min(), y.max()]) if self.range !=[]: bnds = np.array([self.range[0], self.range[1]]) ax.set_xlim(bnds) ax.set_ylim(bnds) #Labelling ax.set_xlabel(self.geoX) ax.set_ylabel(self.geoY) count = len(self.data.index) title = self.title if title == '': title += 'Count=' + str(count) else: title += '\nCount=' + str(count) plt.title(title) return ''
import sys import time filename=sys.argv[1] print('plot', filename) plt.ion() fig=plt.figure() while(True): ifile=open(filename) #for i,l in enumerate(ifile): l=ifile.readline() ifile.close() #title=l.split(',')[0]+' '+l.split(',')[1] data=l.split(',') try: data=np.array(data,dtype=np.float) except: pass print(data[:10]) fig.clf() plt.axis((0,4000,0,66000)) plt.title(time.strftime("%d %b %Y %H:%M:%S -0600",time.localtime())) plt.plot(data,'-') fig.canvas.draw() fig.canvas.flush_events() #plt.draw() #plt.show() time.sleep(3) #plt.close()
knn_graph = kneighbors_graph(X, 30, include_self=False) for connectivity in (None, knn_graph): for n_clusters in (30, 3): plt.figure(figsize=(10, 4)) for index, linkage in enumerate(('average', 'complete', 'ward', 'single')): plt.subplot(1, 4, index + 1) model = AgglomerativeClustering(linkage=linkage, connectivity=connectivity, n_clusters=n_clusters) t0 = time.time() model.fit(X) elapsed_time = time.time() - t0 plt.scatter(X[:, 0], X[:, 1], c=model.labels_, cmap=plt.cm.spectral) plt.title('linkage=%s\n(time %.2fs)' % (linkage, elapsed_time), fontdict=dict(verticalalignment='top')) plt.axis('equal') plt.axis('off') plt.subplots_adjust(bottom=0, top=.89, wspace=0, left=0, right=1) plt.suptitle('n_cluster=%i, connectivity=%r' % (n_clusters, connectivity is not None), size=17) plt.show()
def plot_mandel(mandel): plt.imshow(mandel) plt.axis('off') plt.show()
def main(options): fig = plt.figure(figsize=(14, 9), dpi=100) fig.canvas.mpl_connect('pick_event', onpick) xdata = 2 ydata = 1 typespec = { 't': ('Time', 0), 's': ('Speed', 1), 'd': ('Distance', 2), 'a': ('Acceleration', 3), 'i': ('Angle', 4), 'x': ('x-Position', 5), 'y': ('y-Position', 6), } shortFileNames = short_names(options.fcdfiles) if (len(options.ttype) == 2 and options.ttype[0] in typespec and options.ttype[1] in typespec): xLabel, xdata = typespec[options.ttype[0]] yLabel, ydata = typespec[options.ttype[1]] plt.xlabel(xLabel) plt.ylabel(yLabel) plt.title(','.join(shortFileNames ) if options.label is None else options.label) else: sys.exit("unsupported plot type '%s'" % options.ttype) routes = defaultdict(list) # vehID -> recorded edges # vehID -> (times, speeds, distances, accelerations, angles, xPositions, yPositions) data = defaultdict(lambda: ([], [], [], [], [], [], [])) for fileIndex, fcdfile in enumerate(options.fcdfiles): for timestep, vehicle in parse_fast_nested( fcdfile, 'timestep', ['time'], 'vehicle', ['id', 'x', 'y', 'angle', 'speed', 'lane']): vehID = vehicle.id if len(options.fcdfiles) > 1: suffix = shortFileNames[fileIndex] if len(suffix) > 0: vehID += "#" + suffix time = float(timestep.time) speed = float(vehicle.speed) prevTime = time prevSpeed = speed prevDist = 0 if vehID in data: prevTime = data[vehID][0][-1] prevSpeed = data[vehID][1][-1] prevDist = data[vehID][2][-1] data[vehID][0].append(time) data[vehID][1].append(speed) data[vehID][4].append(float(vehicle.angle)) data[vehID][5].append(float(vehicle.x)) data[vehID][6].append(float(vehicle.y)) if prevTime == time: data[vehID][3].append(0) else: data[vehID][3].append((speed - prevSpeed) / (time - prevTime)) if options.ballistic: avgSpeed = (speed + prevSpeed) / 2 else: avgSpeed = speed data[vehID][2].append(prevDist + (time - prevTime) * avgSpeed) edge = vehicle.lane[0:vehicle.lane.rfind('_')] if len(routes[vehID]) == 0 or routes[vehID][-1] != edge: routes[vehID].append(edge) def line_picker(line, mouseevent): if mouseevent.xdata is None: return False, dict() # minxy = None # mindist = 10000 for x, y in zip(line.get_xdata(), line.get_ydata()): dist = math.sqrt((x - mouseevent.xdata)**2 + (y - mouseevent.ydata)**2) if dist < options.pickDist: return True, dict(label=line.get_label()) # else: # if dist < mindist: # print(" ", x,y, dist, (x - mouseevent.xdata) ** 2, (y - mouseevent.ydata) ** 2) # mindist = dist # minxy = (x, y) # print(mouseevent.xdata, mouseevent.ydata, minxy, dist, # line.get_label()) return False, dict() minY = uMax maxY = uMin minX = uMax maxX = uMin for vehID, d in data.items(): if options.filterRoute is not None: skip = False route = routes[vehID] for required in options.filterRoute: if required not in route: skip = True break if skip: continue if options.invertDistanceAngle is not None: avgAngle = sum(d[4]) / len(d[4]) if abs(avgAngle - options.invertDistanceAngle) < 45: maxDist = d[2][-1] for i, v in enumerate(d[2]): d[2][i] = maxDist - v minY = min(minY, min(d[ydata])) maxY = max(maxY, max(d[ydata])) minX = min(minX, min(d[xdata])) maxX = max(maxX, max(d[xdata])) plt.plot(d[xdata], d[ydata], picker=line_picker, label=vehID) if options.invertYAxis: plt.axis([minX, maxX, maxY, minY]) if options.legend > 0: plt.legend() plt.savefig(options.output) if options.csv_output is not None: write_csv(data, options.csv_output) if options.show: plt.show()
def pie(): ylist = [ 2001, 2002, 1999, 2001, 2002, 2001, 2002, 2001, 2001, 2003, 2000, 2003, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2003, 2003, 2003, 2003, 2003 ] clist = [ 'kidnapping', 'murder', 'cyber_crime', 'robbery', 'accident', 'accident', 'accident', 'robbery', 'robbery', 'robbery', 'robbery', 'robbery', 'robbery', 'murder', 'kidnapping', 'kidnapping', 'kidnapping', 'kidnapping', 'kidnapping', 'kidnapping', 'kidnapping', 'kidnapping', 'kidnapping', 'kidnapping', 'cyber_crime', 'cyber_crime', ] nlist = [] colist = [] for i in range(len(ylist)): if ylist[i] == 2000: nlist.append(clist[i]) print nlist set1 = set(nlist) list2 = list(set1) lcrime = list2 for crime in list2: print crime, nlist.count(crime) colist.append(nlist.count(crime)) print colist #years = [2001,2002,2003,2004] '''murder = [4,5,2,3] kidnappingidnapping = [1,2,1,3] accident = [12,13,40,57] ''' slices = colist activities = list2 cols = ['y', 'r', 'g'] explode = (0.1, 0.1, 0.1) plt.pie(slices, explode=explode, labels=lcrime, colors=cols, autopct='%1.1f%%', shadow=True, startangle=140) plt.axis('equal') #plt.title('2000 crime Rate') plt.ylabel('2000 crime Rate') #plt.xlabel('X axis') plt.legend() plt.show()
def plot_graph(G, broken_graph, broken_partition, npartition, layer1, layer2, layer3, d1=1.5, d2=5., d3=0, d4=.8, nodesize=1000, withlabels=True, edgelist=[], layout=True, alpha=0.5): if layout: pos = nx.spring_layout(G) else: pos = nx.random_layout(G) top_set = set() bottom_set = set() middle_set = set() down = [] right = [] left = [] mlayer_part = {} for i in broken_partition: ii = i.split('_') if ii[1] not in mlayer_part: mlayer_part[ii[1]] = set([ii[2]]) else: mlayer_part[ii[1]].add(ii[2]) layers_m = Counter() for k, v in mlayer_part.items(): if len(v) == 1: layers_m[1] += 1 elif len(v) == 2: layers_m[2] += 1 elif len(v) == 3: layers_m[3] += 1 else: print k, v broken_pos = {} singles = 0 for i, v in broken_partition.items(): name = i.split('_') if name[-1] == 's': singles += 1 ndnd = random.choice(v) npos = pos[ndnd] if ndnd in layer1: broken_pos[i] = [d2 * (npos[0] - d1), d2 * (npos[1] + d1)] top_set.add(i) left.append(broken_pos[i]) elif ndnd in layer2: broken_pos[i] = [d2 * (npos[0] + d1), d2 * (npos[1] + d1)] bottom_set.add(i) right.append(broken_pos[i]) else: broken_pos[i] = [d2 * npos[0], d2 * (npos[1] - d1)] middle_set.add(i) down.append(broken_pos[i]) xleft = [i[0] for i in left] yleft = [i[1] for i in left] aleft = [min(xleft) - d1 / 2., max(yleft) + d1 / 2. + d3] bleft = [max(xleft) + d1 / 2., max(yleft) + d1 / 2. + 3 * d3] cleft = [max(xleft) + d1 / 2., min(yleft) - d1 / 2. - 3 * d3] dleft = [min(xleft) - d1 / 2., min(yleft) - d1 / 2. - d3] xright = [i[0] for i in right] yright = [i[1] for i in right] aright = [min(xright) - d1 / 2., max(yright) + d1 / 2. + d3] bright = [max(xright) + d1 / 2., max(yright) + d1 / 2. + 3 * d3] cright = [max(xright) + d1 / 2., min(yright) - d1 / 2. - 3 * d3] dright = [min(xright) - d1 / 2., min(yright) - d1 / 2. - d3] xdown = [i[0] for i in down] ydown = [i[1] for i in down] adown = [min(xdown) - d1 / 2., max(ydown) + d1 / 2. + d3] bdown = [max(xdown) + d1 / 2., max(ydown) + d1 / 2. + 3 * d3] cdown = [max(xdown) + d1 / 2., min(ydown) - d1 / 2. - 3 * d3] ddown = [min(xdown) - d1 / 2., min(ydown) - d1 / 2. - d3] fig = plt.figure(figsize=(20, 20)) ax = fig.add_subplot(111) ax.add_patch(Polygon([aleft, bleft, cleft, dleft], color='r', alpha=0.1)) plt.plot([aleft[0], bleft[0], cleft[0], dleft[0], aleft[0]], [aleft[1], bleft[1], cleft[1], dleft[1], aleft[1]], '-r') ax.add_patch( Polygon([aright, bright, cright, dright], color='b', alpha=0.1)) plt.plot([aright[0], bright[0], cright[0], dright[0], aright[0]], [aright[1], bright[1], cright[1], dright[1], aright[1]], '-b') ax.add_patch(Polygon([adown, bdown, cdown, ddown], color='g', alpha=0.1)) plt.plot([adown[0], bdown[0], cdown[0], ddown[0], adown[0]], [adown[1], bdown[1], cdown[1], ddown[1], adown[1]], '-g') nodeSize = [nodesize * len(broken_partition[i]) for i in list(top_set)] nodeColor = [broken_graph.node[i]['color'] for i in list(top_set)] nx.draw_networkx_nodes(broken_graph, broken_pos, nodelist=list(top_set), node_shape='s', node_color=nodeColor, alpha=1, node_size=nodeSize) nodeSize = [nodesize * len(broken_partition[i]) for i in list(middle_set)] nodeColor = [broken_graph.node[i]['color'] for i in list(middle_set)] nx.draw_networkx_nodes(broken_graph, broken_pos, nodelist=list(middle_set), node_shape='s', node_color=nodeColor, alpha=1, node_size=nodeSize) nodeSize = [nodesize * len(broken_partition[i]) for i in list(bottom_set)] nodeColor = [broken_graph.node[i]['color'] for i in list(bottom_set)] nx.draw_networkx_nodes(broken_graph, broken_pos, nodelist=list(bottom_set), node_shape='s', node_color=nodeColor, alpha=1, node_size=nodeSize) if withlabels: nx.draw_networkx_labels(G, pos) lay1_edges = [ ed for ed in G.edges() if ed[0] in layer1 and ed[1] in layer1 ] lay2_edges = [ ed for ed in G.edges() if ed[0] in layer2 and ed[1] in layer2 ] lay3_edges = [ ed for ed in G.edges() if ed[0] in layer3 and ed[1] in layer3 ] nx.draw_networkx_edges(broken_graph, broken_pos, alpha=0.3) #0.15 # orr=nx.attribute_assortativity_coefficient(broken_graph,'color') # for i,v in broken_partition.items(): # for nd in v: # atrr=G.node[nd] # G.add_node(nd,attr_dict=atrr,asso=i) # # print G.nodes(data=True) # rr=nx.attribute_assortativity_coefficient(G,'asso') rcom = nx.attribute_assortativity_coefficient(G, 'threeattributes') rlay = nx.attribute_assortativity_coefficient(G, 'layers_3') rr = nx.attribute_assortativity_coefficient(G, 'asso') # print 'Attribute assortativity coefficient wrt layer partition (old)= %f' %orr # title_s='%i communities (%i 3-layered, %i 2-layered, %i 1-layered)\nAssortativity_coef(%i_communities) = %.2f\nAssortativity_coef(3_layers) = %.2f\n Joint_Assortativity_coef(%i_communities, 3_layers) = %f' %(len(npartition),layers_m[3],layers_m[2],layers_m[1],len(npartition),rcom,rlay,len(npartition),rr) # print 'Attribute assortativity coefficient wrt layer partition (old) = %f' %orr # print 'Attribute assortativity coefficient wrt layer partition (old)= %f' %orr title_s = '%i Three vertex attributes (%i 3-layered, %i 2-layered, %i 1-layered)\nAssortativity_coef(%i_3Attributes) = %.2f\nAssortativity_coef(3_layers) = %.2f\n Joint_Assortativity_coef(%i_3Attributes, 3_layers) = %.2f ' % ( len(npartition), layers_m[3], layers_m[2], layers_m[1], len(npartition), rcom, rlay, len(npartition), rr) # title_s='%i Three vertex attributes (%i 3-layered, %i 2-layered, %i 1-layered)' %(len(npartition),layers_m[3],layers_m[2],layers_m[1]) plt.title(title_s, {'size': '20'}) plt.axis('off') plt.show()
#!/usr/bin/env python3 """ Plots x -> y1 and x -> y2 as line graphs in the same figure. """ import numpy as np import matplotlib.pyplot as plt x = np.arange(0, 21000, 1000) r = np.log(0.5) t1 = 5730 t2 = 1600 y1 = np.exp((r / t1) * x) y2 = np.exp((r / t2) * x) plt.plot(x, y1, 'r--', x, y2, 'g') plt.xlabel('Time (years)') plt.ylabel('Fraction Remaining') plt.title('Exponential Decay of Radioactive Elements') plt.axis([0, 20000, 0, 1]) plt.legend(['C-14', 'Ra-226']) plt.show()
for pairidx, pair in enumerate([[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]]): # We only take the two corresponding features feature_set = feature_data[:, pair] # Train clf = DecisionTreeClassifier().fit(feature_set, label_set) # Plot the decision boundary plt.subplot(2, 3, pairidx + 1) x_min, x_max = feature_set[:, 0].min() - 1, feature_set[:, 0].max() + 1 y_min, y_max = feature_set[:, 1].min() - 1, feature_set[:, 1].max() + 1 xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step), np.arange(y_min, y_max, plot_step)) plt.xlabel(feature_names[pair[0]]) plt.ylabel(feature_names[pair[1]]) plt.axis("tight") # Plot the training points for i, color in zip(range(n_classes), plot_colors): idx = np.where(label_set == i) plt.scatter(feature_set[idx, 0], feature_set[idx, 1], c=color, label=target_names[i], cmap=plt.cm.Paired) plt.axis("tight") plt.suptitle("Decision surface of a '{0}' using paired features".format("Decision Tree (DT)")) plt.legend() plt.show()
for i in xrange(0,10): sel = random.sample(xrange(60000),n) X = ocr['data'][sel,:] Y = ocr['labels'][sel,:] results = predictions(X,Y,test) error.append((sum(results!=correct_preds)+0.0)/(10000)) total_errors.append(error) error=[] # Plot results means = map(np.mean, total_errors) std_devs = map(np.std, total_errors) plt.errorbar(sizes, means, std_devs, linestyle='-', marker='o', linewidth=1.5) plt.axis([500,8500,0.05,0.12]) plt.ylabel('Error rate') plt.xlabel('Number of training points') plt.title('Error rate vs. Number of training points') plt.show() print "Mean error for the different sizes:", means print "Standard deviation for the different sizes:", std_devs # Parameter generating function using Laplace smoothing to estimate the parameters of each class def param_gen(X,Y): # X is data, Y is labels total= X.sum() num_lbls = np.unique(Y) params = []
# Plot the window and its frequency response: from scipy import signal from scipy.fftpack import fft, fftshift import matplotlib.pyplot as plt window = signal.hann(51) plt.plot(window) plt.title("Hann window") plt.ylabel("Amplitude") plt.xlabel("Sample") plt.figure() A = fft(window, 2048) / (len(window)/2.0) freq = np.linspace(-0.5, 0.5, len(A)) response = 20 * np.log10(np.abs(fftshift(A / abs(A).max()))) plt.plot(freq, response) plt.axis([-0.5, 0.5, -120, 0]) plt.title("Frequency response of the Hann window") plt.ylabel("Normalized magnitude [dB]") plt.xlabel("Normalized frequency [cycles per sample]")
def display_fraudulent_labels_linear( mypath, percent_thres, model_1, be_l, num_bins, max_histo_level, target_image_file_name, x, ): file_list = [] file_name_list = [] for filename in glob.glob(mypath + "*.*"): if filename in target_image_file_name: continue else: file_list.append(filename) similar_diff = 0.1 img_list = [] imgTarget = Image.open(target_image_file_name) for fn in file_list: # Load test beer label image test_img = Image.open(fn) # Normalize beer label image test_img = test_img.convert("RGB") test_img_resized = test_img.resize((224, 224)) test_img_array = np.array(test_img_resized) save_0 = test_img_array[:, :, 0] save_1 = test_img_array[:, :, 1] x[0] = test_img_array # Process normalized beer label through model to generate feature vectors x_out_2 = model_1.predict(x[0:1]) x_out_2_r = np.ravel(x_out_2[0]) # Generate histogram, and correlation product to determine if the label is fraudulent be_h, hist_h = np.histogram(x_out_2_r, bins=num_bins, range=[0.0, max_histo_level], density=True) cor02 = sum(np.abs(be_l[1:] - be_h[1:])) # Threshold the correlation product to determine fraudulence if cor02 < similar_diff * percent_thres: img_list.append(test_img_array) file_name_list.append(fn) # Plot the fraudulent beer labels num_figs = 5 num_blocks = int(len(img_list) / num_figs) index = 0 for block in range(num_blocks): (sub_plot1, sub_plot2) = plt.subplots(1, 5, figsize=(16, 16)) for image_index in range(5): sub_plot2[image_index].imshow(img_list[index]) sub_plot2[image_index].axis("off") index += 1 plt.show() left_over = len(img_list) % num_figs if left_over > 1: (sub_plot1, sub_plot2) = plt.subplots(1, left_over, figsize=(10, 10)) for image_index in range(left_over): sub_plot2[image_index].imshow(img_list[index]) sub_plot2[image_index].axis("off") index += 1 plt.show() elif left_over == 1: plt.subplots(1, 1, figsize=(10, 10)) plt.imshow(img_list[index]) plt.axis("off") plt.show() return file_name_list
def display(img): one_image = img.reshape(28, 28) plt.axis('off') plt.imshow(one_image, cmap=CM.binary)
def main(): args = parse_args() display = args.display use_dlibTracker = args.use_dlibTracker saver = args.saver total_time = 0.0 total_frames = 0 # for disp if display: colours = np.random.rand(32, 3) # used only for display plt.ion() fig = plt.figure() if not os.path.exists('output'): os.makedirs('output') out_file = 'output/townCentreOut.top' #init detector detector = GroundTruthDetections() #init tracker tracker = Sort(use_dlib= use_dlibTracker) #create instance of the SORT tracker if use_dlibTracker: print "Dlib Correlation tracker activated!" else: print "Kalman tracker activated!" with open(out_file, 'w') as f_out: frames = detector.get_total_frames() for frame in range(0, frames): #frame numbers begin at 0! # get detections detections = detector.get_detected_items(frame) total_frames +=1 fn = 'test/Pictures%d.jpg' % (frame + 1) # video frames are extracted to 'test/Pictures%d.jpg' with ffmpeg img = io.imread(fn) if (display): ax1 = fig.add_subplot(111, aspect='equal') ax1.imshow(img) if(use_dlibTracker): plt.title('Dlib Correlation Tracker') else: plt.title('Kalman Tracker') start_time = time.time() #update tracker trackers = tracker.update(detections,img) cycle_time = time.time() - start_time total_time += cycle_time print('frame: %d...took: %3fs'%(frame,cycle_time)) for d in trackers: f_out.write('%d,%d,%d,%d,x,x,x,x,%.3f,%.3f,%.3f,%.3f\n' % (d[4], frame, 1, 1, d[0], d[1], d[2], d[3])) if (display): d = d.astype(np.int32) ax1.add_patch(patches.Rectangle((d[0], d[1]), d[2] - d[0], d[3] - d[1], fill=False, lw=3, ec=colours[d[4] % 32, :])) ax1.set_adjustable('box-forced') #label ax1.annotate('id = %d' % (d[4]), xy=(d[0], d[1]), xytext=(d[0], d[1])) if detections != []:#detector is active in this frame ax1.annotate(" DETECTOR", xy=(5, 45), xytext=(5, 45)) if (display): plt.axis('off') fig.canvas.flush_events() plt.draw() fig.tight_layout() #save the frame with tracking boxes if(saver): fig.savefig("./frameOut/f%d.jpg"%(frame+1),dpi = 200) ax1.cla() print("Total Tracking took: %.3f for %d frames or %.1f FPS"%(total_time,total_frames,total_frames/total_time))
def display_fraudulent_labels_art( mypath, percent_thres, label_model, similar_diff, target_image_file_name, x_only, x, ): bin_group = 5 max_histo_level = 40 num_bins = 200 print(percent_thres * similar_diff) file_list = [] for filename in glob.glob(mypath + "*.*"): if filename in target_image_file_name: continue else: file_list.append(filename) file_name_list = [] img_list = [] for fn in file_list: # Load test beer label image test_label = Image.open(fn) # Normalize beer label image test_label = test_label.convert("RGB") test_label_resized = test_label.resize((224, 224)) test_label_array = np.array(test_label_resized) save_0 = test_label_array[:, :, 0] save_1 = test_label_array[:, :, 1] x[0] = test_label_array x[0] = test_label_array x[1] = test_label_array x_out_1 = label_model.predict(x[0:2]) x_out_1_r = np.ravel(x_out_1[0]) x_out_2_r = np.ravel(x_out_1[1]) print("file_name = " + str(fn)) # Generate histogram, and correlation product to determine if the label is fraudulent be_h, hist_h = np.histogram(x_out_2_r, bins=num_bins, range=[0.0, max_histo_level], density=True) diff = dist.chebyshev(x_out_2_r, x_only) print(diff) # Threshold the correlation product to determine fraudulence if diff < similar_diff * percent_thres: img_list.append(test_label_array) file_name_list.append(fn) # Plot the fraudulent beer labels num_figs = 5 num_blocks = int(len(img_list) / num_figs) index = 0 for block in range(num_blocks): (sub_plot1, sub_plot2) = plt.subplots(1, 5, figsize=(16, 16)) for image_index in range(5): sub_plot2[image_index].imshow(img_list[index]) sub_plot2[image_index].axis("off") index += 1 plt.show() left_over = len(img_list) % num_figs if left_over > 1: (sub_plot1, sub_plot2) = plt.subplots(1, left_over, figsize=(10, 10)) for image_index in range(left_over): sub_plot2[image_index].imshow(img_list[index]) sub_plot2[image_index].axis("off") index += 1 plt.show() elif left_over == 1: plt.subplots(1, 1, figsize=(10, 10)) plt.imshow(img_list[index]) plt.axis("off") plt.show() return file_name_list
import matplotlib.pyplot as mp import numpy as np mp.figure('pie',facecolor='lightgray') mp.axis('equal') # 设置x轴和Y轴等比 values = [23,25,29,28,65] spaces = [0.05,0.01,0.01,0.01,0.01] labels = ['php','c','c++','java','python'] colors = ['red','green','orangered','blue','yellow'] mp.pie(values,spaces,labels,colors,'%.1f%%') mp.legend() mp.show()
def draw_network(): with open(os.path.join(ABILITY_DIR, "output", "network_for_draw.csv")) as f: reader = list(csv.reader(f)) with open(os.path.join(ABILITY_DIR, "output", "network_helper.json")) as f: helper = json.load(f) header = reader[0] G = nx.Graph() labels = {} edge_colors = [] node_sizes = [] node_colors = [] for row in reader[1:]: # print(row[0]) G.add_node(row[0]) node_sizes.append(float(helper[row[0]]["size"])) node_colors.append(helper[row[0]]["color"]) labels[row[0]] = row[0] for row in reader[1:]: source = row[0] for index, r in enumerate(row[1:], 1): if r == "1": G.add_edge(source, header[index]) edge_colors.append(helper[header[index]]["color"]) pos = nx.spring_layout(G) # pos = nx.spring_layout(G, k=1, iterations=20) plt.figure(figsize=(24, 24)) ax = plt.gca() options = { "linewidths": 0, "alpha": 0.8, "node_size": node_sizes, "node_color": node_colors, } for idx, edge in enumerate(G.edges()): source, target = edge rad = 0.4 arrowprops = dict( linewidth=0.2, arrowstyle="-", color=helper[target]["color"], connectionstyle=f"arc3,rad={rad}", alpha=0.6, ) ax.annotate("", xy=pos[source], xytext=pos[target], arrowprops=arrowprops) nx.draw_networkx_nodes(G, pos, **options) # nx.draw_networkx_labels(G, pos, labels=labels, font_family="NanumGothic") # plt.text(x, y, node, fontsize=d[node] * 5, ha='center', va='center') plt.rc("font", family="NanumGothic") for node, (x, y) in pos.items(): plt.text( x, y, node, fontsize=float(helper[node]["font_size"]), ha="center", va="center", ) plt.axis("off") plt.savefig("network.svg", format="svg", dpi=400) plt.savefig("network.png", format="png", dpi=400)
#print(time_axis_data_app[0:60]) #print(time_axis_data_stack) #''' x = time_axis_data_app_array plt.xlabel("Time elapsed (s)") #y0 = latencies #y = y0.copy() + 2.5 y = app_latencies plt.ylabel("Latency (ms)") #lines = plt.step(x, y, label='Delay between sending data and receiving application data') lines = plt.plot(x, y, 'ro') plt.setp(lines, markersize=0.4) plt.setp(lines, markerfacecolor='r') plt.axis([0, 300, 0, 175]) #y -= 0.5 #plt.step(x, y, where='post', label='post') #y = ma.masked_where((y0 > -0.15) & (y0 < 0.15), y - 0.5) #plt.step(x, y, label='masked (preplt.legend() #plt.show() #plt.savefig('app_latency/%s.pdf' % sys.argv[1][:-4]) #plt.savefig('app-%s.png' % filename[-1]) plt.savefig('%s/app-%s.png' % ("/".join(str(s) for s in filename[:-1]), filename[-1])) #''' l = lines.pop(0)
def compare_plot(signal1, signal2, Fs, fft_size=512, norm=False, equal=False, title1=None, title2=None): import matplotlib.pyplot as plt td_amp = np.maximum(np.abs(signal1).max(), np.abs(signal2).max()) if norm: if equal: signal1 /= np.abs(signal1).max() signal2 /= np.abs(signal2).max() else: signal1 /= td_amp signal2 /= td_amp td_amp = 1. plt.subplot(2, 2, 1) plt.plot(np.arange(len(signal1)) / float(Fs), signal1) plt.axis('tight') plt.ylim(-td_amp, td_amp) if title1 is not None: plt.title(title1) plt.subplot(2, 2, 2) plt.plot(np.arange(len(signal2)) / float(Fs), signal2) plt.axis('tight') plt.ylim(-td_amp, td_amp) if title2 is not None: plt.title(title2) from .stft import stft, spectroplot from .windows import hann F1 = stft.stft(signal1, fft_size, fft_size / 2, win=windows.hann(fft_size)) F2 = stft.stft(signal2, fft_size, fft_size / 2, win=windows.hann(fft_size)) # try a fancy way to set the scale to avoid having the spectrum # dominated by a few outliers p_min = 1 p_max = 99.5 all_vals = np.concatenate((dB(F1 + eps), dB(F2 + eps))).flatten() vmin, vmax = np.percentile(all_vals, [p_min, p_max]) cmap = 'jet' interpolation = 'sinc' plt.subplot(2, 2, 3) stft.spectroplot(F1.T, fft_size, fft_size / 2, Fs, vmin=vmin, vmax=vmax, cmap=plt.get_cmap(cmap), interpolation=interpolation) plt.subplot(2, 2, 4) stft.spectroplot(F2.T, fft_size, fft_size / 2, Fs, vmin=vmin, vmax=vmax, cmap=plt.get_cmap(cmap), interpolation=interpolation)
def main(): #======================================================================= # part 1: datamation #======================================================================= # set barrier width a a = 0.16 # set ratio of E/U0 ratio = float(input('please input ratio of E/U0: ')) # example: # ratio = 0.6 # ratio = 1 # ratio = 1.4 # to avoid ratio being smaller than 0.01 or equal to 1 ratio = 0.01 if ratio < 0.01 else ratio if ratio != 1 else ratio + 1e-10 # set barrier constant k0 # k0 = cm.sqrt(2 * m * U0 / pow(h_, 2)) # it will affect the wavelength of probability wave k0 = 4 # define wave Energy E # E = ratio * U0 # set scale value.() # it will contral the wave length on display # while scale = 0.5e-8, there are no auto scale # if you don't want auto scale, just del denominator: cm.sqrt(ratio) # scale = 1 scale = 1 / cm.sqrt(ratio) # define wave vactor k # k1 = scale * cm.sqrt(2 * m * E / pow(h_, 2)) # k2 = scale * cm.sqrt(2 * m * (E - U0) / pow(h_, 2)) k1 = scale * k0 * cm.sqrt(ratio) # wave vector of part 1 and 3 k2 = scale * k0 * cm.sqrt(ratio - 1) # wave vector of part 2 # define intensity ratio of wave # A and A_ belong to wave of part 1 # B and B_ belong to wave of part 2 # C and C_ belong to wave of part 3 # De is just a common denominator value # we define A = 1 and others will be directly proportional to A A = 1.2 De = pow(k1 - k2, 2) * np.exp(1j * k2) - pow(k1 + k2, 2) * np.exp(-1j * k2) A_ = 2j * (pow(k1, 2) - pow(k2, 2)) * np.sin(k2) * A / De C = -4 * k1 * k2 * np.exp(-1j * k1) * A / De B = (A * k1 + A * k2 - A_ * k1 + A_ * k2) / (2 * k2) B_ = (A * k2 - A * k1 + A_ * k1 + A_ * k2)/ (2 * k2) # define three part x1 = np.linspace(-1, 0, 10e3) # x limit of part 1 x2 = np.linspace(0, a, 10e3) # x limit of part 2 x3 = np.linspace(a, a + 1, 10e3) # x limit of part 3 # define wave function y1_r = A * np.exp(1j * k1 * x1/a) # right wave function of part 1 y1_l = A_ * np.exp(-1j * k1 * x1/a) # left wave function of part 1 y2_r = B * np.exp(1j * k2 * x2/a) # right wave function of part 2 y2_l = B_ * np.exp(-1j * k2 * x2/a) # left wave function of part 2 y3_r = C * np.exp(1j * k1 * x3/a) # right wave function of part 3 y1 = y1_r + y1_l # wave function of part 1 y2 = y2_r + y2_l # wave function of part 2 y3 = y3_r # wave function of part 3 w1 = abs(y1)**2 w2 = abs(y2)**2 w3 = abs(y3)**2 # debug out # print('k1', k1, '\nk2', k2, '\nA', A, '\nA_', A_, '\nB', B, '\nB_', B_, '\nC', C, '\nDe', De) #======================================================================= # part 2: visualization #======================================================================= # set x, y half axis limit x_limit = 1 y_limit = 4 # create a new figure plt.figure(figsize=(10,45/8)) # set axis scope plt.axis([-x_limit, a + x_limit, -y_limit, y_limit]) # hide the axis plt.axis('off') # set hold on plt.hold(True) # set alpha of lines alpha = 1 color_com = (0,0.5,0, alpha) color_inc = (0,0,1,alpha) color_ref = (1,0,0,alpha) color_pro = (0,0,0.5,0.6) color_fil = (0,0,0.5,0.3) # draw wave in part 1 and get three plot handle for data updating later h10, = plt.plot(x1, np.real(y1), color=color_com, linestyle='-', label='composite wave', linewidth=2) h11, = plt.plot(x1, np.real(y1_r), color=color_inc, linestyle='--', label='incident wave', linewidth=2) h12, = plt.plot(x1, np.real(y1_l), color=color_ref, linestyle='--', label='reflected wave', linewidth=2) # draw imag wave of part 1 plt.plot(x1, np.imag(y1), color=color_com, linestyle=':', label='imag part', linewidth=2) # draw probability density line of part 1 plt.plot(x1, w1 - y_limit + 1, color=color_pro, label='probability density') # fill probability line of part 1 plt.fill_between(x1, np.zeros_like(x1)-y_limit+1, w1-y_limit+1, color=color_fil) # draw legend plt.legend(fontsize=14, frameon=True, fancybox=True, framealpha=0.3) # draw wave in part 2 and get three plot handle for data updating later h20, = plt.plot(x2, np.real(y2), color=color_com, linestyle='-', linewidth=2) h21, = plt.plot(x2, np.real(y2_r), color=color_inc, linestyle='--', linewidth=2) h22, = plt.plot(x2, np.real(y2_l), color=color_ref, linestyle='--', linewidth=2) # draw imag wave of part 1 plt.plot(x2, np.imag(y2), color=color_com, linestyle=':', linewidth=2) # draw probability density line of part 2 plt.plot(x2, w2 - y_limit + 1, color=color_pro) # fill probability line of part 2 plt.fill_between(x2, np.zeros_like(x2)-y_limit+1, w2-y_limit+1, color=color_fil) # draw wave in part 3 h30, = plt.plot(x3, np.real(y3), color=color_com, linestyle='-', linewidth=2) # draw imag wave of part 1 plt.plot(x3, np.imag(y3), color=color_com, linestyle=':', linewidth=2) # draw probability density line of part 3 plt.plot(x3, w3 - y_limit + 1, color=color_pro) # fill probability line of part 3 plt.fill_between(x3, np.zeros_like(x3)-y_limit+1, w3-y_limit+1, color=color_fil) # draw barrier line plt.plot([-1,0,0,a,a,a+1], [-3,-3,3,3,-3,-3], color=(0,0,0,alpha), linestyle='-', linewidth=2) # draw reference center line plt.plot([-1, a + 1], [0, 0], color=(0.5,0.5,0.5,alpha), linestyle='-.') # set hold off plt.hold(False) # draw text information ## define font dict creater function def font(family='serif', color='black', weight='normal', size='16'): return {'family': family, 'color': color, 'weight': weight, 'size': size} # draw title plt.title('Barrier Penetration And Tunneling', fontdict=font(size=20)) # draw barrier height value U0 plt.text(a, 3, '$U_0$', fontdict=font(size=20)) # draw value of k0 plt.text(-.9, 3, '$\itK_0=%d$' % k0, fontdict=font(size=20)) # draw value of E/U0 plt.text(-.6, 3, '$\itE/\itU_0=\it%.2f$' % ratio, fontdict=font(size=20)) # draw scale value text plt.text(-.7, -3.3, '$\itscale=%.2f$' % np.real(scale), fontdict=font()) # draw barrier left limit plt.text(-.02, -3.3, '$0$', fontdict=font()) # draw barrier right limit plt.text(a-.02, -3.3, '$a$', fontdict=font()) # draw x axis mark 'x' plt.text(a+.95, -2.95, '$x$', fontdict=font()) # draw water mark of author plt.text(a+.7, -3.4, '$author: ph$', fontdict=font(color='gray')) # show plot # plt.show() if len(sys.argv) > 1: if sys.argv[1] == '-d': # set gif save root dir gif_root = './gif' # check gif root dir if not os.path.isdir(gif_root): os.makedirs(gif_root) # set frame number N FN = 40 # pre storage allocation images = [] for i in range(FN): # add time factor Et = np.exp(-2j * np.pi * i / FN) # update the plot data h10.set_ydata(np.real(y1 * Et)) h11.set_ydata(np.real(y1_r * Et)) h12.set_ydata(np.real(y1_l * Et)) h20.set_ydata(np.real(y2 * Et)) h21.set_ydata(np.real(y2_r * Et)) h22.set_ydata(np.real(y2_l * Et)) h30.set_ydata(np.real(y3 * Et)) # create bytes buffer buf = BytesIO() # save plot date to buf plt.savefig(buf, format='png') # read buf as image date and append to images images.append(im.open(buf)) # set gif file save path gif_path = os.path.join(gif_root, 'slgc_%.2f.gif' % ratio) # create GIF dynamic plot from images im2gif.writeGif(filename=gif_path, images=images, duration=2 / FN) # print status message print('gif file created at path: %s.' % os.path.abspath(gif_path)) elif sys.argv[1]=='-s': png_root = './png' if not os.path.isdir(png_root): os.makedirs(png_root) png_path = os.path.join(png_root, 'slgc_%.2f.png' % ratio) plt.savefig(png_path, format='png') print('png file created at path: %s.' % os.path.abspath(png_path)) else: plt.show()
def drawDigit(position, image, title): plt.subplot(*position) plt.imshow(image.reshape(-1, 28), cmap='gray_r') plt.axis('off') plt.title(title)