def show_plot(points): plt.figure() fig, ax = plt.subplots() loc = ticker.MultipleLocator(base=0.2) # put ticks at regular intervals ax.yaxis.set_major_locator(loc) plt.plot(points)
import numpy as np import matplotlib.pyplot as plt import matplotlib.ticker as ticker # Question 2. (c) Plot data = np.loadtxt('s_price_1yr.dat') s = data[:, 0] t = data[:, 1] tick_spacing = 0.1 fig, ax = plt.subplots(1, 1) ax.plot(t, s) ax.xaxis.set_major_locator(ticker.MultipleLocator(tick_spacing)) plt.xlabel("Time (years)") plt.ylabel("Stock Price") plt.title("Daily Share Price for One Year") plt.xlim(min(t), max(t)) plt.ylim(min(s) - 5, max(s) + 5) plt.show() # Question 2. (d) Plot data_1yr = np.loadtxt('portfolio_value_1yr.dat') data_2yr = np.loadtxt('portfolio_value_2yr.dat') data_5yr = np.loadtxt('portfolio_value_5yr.dat') data_20yr = np.loadtxt('portfolio_value_20yr.dat') print(data_1yr)
def jacobian_aspcap(self, jacobian=None, dr=14): """ NAME: cal_jacobian PURPOSE: calculate jacobian INPUT: OUTPUT: HISTORY: 2017-Nov-20 Henry Leung """ import pylab as plt import numpy as np import seaborn as sns import matplotlib.ticker as ticker from astroNN.apogee.chips import wavelength_solution, chips_split from urllib.request import urlopen from urllib.error import HTTPError import pandas as pd if jacobian is None: raise ValueError('Please provide jacobian to plot') if len(jacobian.shape) == 3: jacobian = np.mean(jacobian, axis=-1) elif len(jacobian.shape) == 2: pass else: raise ValueError('Unknown jacobian shape!!') # Some plotting variables for asthetics plt.rcParams['axes.facecolor'] = 'white' sns.set_style("ticks") plt.rcParams['axes.grid'] = False plt.rcParams['grid.color'] = 'gray' plt.rcParams['grid.alpha'] = '0.4' path = os.path.join(self.fullfilepath, 'jacobian') if not os.path.exists(path): os.makedirs(path) fullname = self.targetname lambda_blue, lambda_green, lambda_red = wavelength_solution(dr=dr) for j in range(self._labels_shape): fig = plt.figure(figsize=(45, 30), dpi=150) scale = np.max(np.abs((jacobian[j, :]))) scale_2 = np.min((jacobian[j, :])) blue, green, red = chips_split(jacobian[j, :], dr=dr) blue, green, red = blue[0], green[0], red[0] ax1 = fig.add_subplot(311) fig.suptitle(f'{fullname[j]}', fontsize=50) ax1.set_ylabel(r'$\partial$' + fullname[j] + '/' + r'$\partial\lambda$', fontsize=40) ax1.set_ylim(scale_2, scale) ax1.plot(lambda_blue, blue, linewidth=0.9, label='astroNN') ax2 = fig.add_subplot(312) ax2.set_ylabel(r'$\partial$' + fullname[j] + '/' + r'$\partial\lambda$', fontsize=40) ax2.set_ylim(scale_2, scale) ax2.plot(lambda_green, green, linewidth=0.9, label='astroNN') ax3 = fig.add_subplot(313) ax3.set_ylim(scale_2, scale) ax3.set_ylabel(r'$\partial$' + fullname[j] + '/' + r'$\partial\lambda$', fontsize=40) ax3.plot(lambda_red, red, linewidth=0.9, label='astroNN') ax3.set_xlabel(r'Wavelength $\lambda$ (Angstrom)', fontsize=40) ax1.axhline(0, ls='--', c='k', lw=2) ax2.axhline(0, ls='--', c='k', lw=2) ax3.axhline(0, ls='--', c='k', lw=2) try: if dr == 14: url = f"https://svn.sdss.org/public/repo/apogee/idlwrap/trunk/lib/l31c/" \ f"{aspcap_windows_url_correction(self.targetname[j])}.mask" df = np.array( pd.read_csv(urlopen(url), header=None, sep='\t')) else: raise ValueError('Only support DR14') aspcap_windows = df * scale aspcap_windows = aspcap_windows.T # Fix the shape to the one I expect aspcap_blue, aspcap_green, aspcap_red = chips_split( aspcap_windows, dr=dr) print( f'Found {aspcap_windows_url_correction(self.targetname[j])} ASPCAP window at: {url}' ) ax1.plot(lambda_blue, aspcap_blue[0], linewidth=0.9, label='ASPCAP windows') ax2.plot(lambda_green, aspcap_green[0], linewidth=0.9, label='ASPCAP windows') ax3.plot(lambda_red, aspcap_red[0], linewidth=0.9, label='ASPCAP windows') except HTTPError: print( f'No ASPCAP window data for {aspcap_windows_url_correction(self.targetname[j])}' ) tick_spacing = 50 ax1.xaxis.set_major_locator(ticker.MultipleLocator(tick_spacing)) ax2.xaxis.set_major_locator( ticker.MultipleLocator(tick_spacing / 1.5)) ax3.xaxis.set_major_locator( ticker.MultipleLocator(tick_spacing / 1.7)) ax1.minorticks_on() ax2.minorticks_on() ax3.minorticks_on() ax1.tick_params(labelsize=30, width=2, length=20, which='major') ax1.tick_params(width=2, length=10, which='minor') ax2.tick_params(labelsize=30, width=2, length=20, which='major') ax2.tick_params(width=2, length=10, which='minor') ax3.tick_params(labelsize=30, width=2, length=20, which='major') ax3.tick_params(width=2, length=10, which='minor') ax1.legend(loc='best', fontsize=40) plt.tight_layout() plt.subplots_adjust(left=0.05) plt.savefig(path + f'/{self.targetname[j]}_jacobian.png') plt.close('all') plt.clf()
def plot_conn_mat(conn_matrix, labels, out_path_fig, cmap, binarized=False, dpi_resolution=300): """ Plot a connectivity matrix. Parameters ---------- conn_matrix : array NxN matrix. labels : list List of string labels corresponding to ROI nodes. out_path_fig : str File path to save the connectivity matrix image as a .png figure. """ import warnings warnings.filterwarnings("ignore") import matplotlib import mplcyberpunk matplotlib.use('Agg') from matplotlib import pyplot as plt plt.style.use("cyberpunk") from matplotlib import pyplot as plt from nilearn.plotting import plot_matrix from pynets.core import thresholding import matplotlib.ticker as mticker conn_matrix = thresholding.standardize(conn_matrix) conn_matrix_bin = thresholding.binarize(conn_matrix) conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin)) try: plot_matrix( conn_matrix_plt, figure=(10, 10), labels=labels, vmax=np.percentile(conn_matrix_plt[conn_matrix_plt > 0], 95), vmin=0, reorder="average", auto_fit=True, grid=False, colorbar=True, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") if len(labels) > 500: tick_interval = 5 elif len(labels) > 100: tick_interval = 4 elif len(labels) > 50: tick_interval = 2 else: tick_interval = 1 plt.axes().yaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) plt.axes().xaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) for param in ['figure.facecolor', 'axes.facecolor', 'savefig.facecolor']: plt.rcParams[param] = '#000000' plt.savefig(out_path_fig, dpi=dpi_resolution) plt.close() return
bbox_to_anchor=(0.0, 1.05, 1.0, 0.2), mode="expand", ncol=5) box = ax.get_position() ax.set_position([box.x0, box.y0, box.width, box.height * 0.8]) # Start and end of time-step real_start_t = (mintic_step - tic_step) / CPU_CLOCK ax.plot([real_start_t, real_start_t], [0, nthread + nrow + 1], "k--", linewidth=1) ax.plot([end_t, end_t], [0, nthread + nrow + 1], "k--", linewidth=1) ax.set_xlabel("Wall clock time [ms]", labelpad=0.0) if expand == 1: ax.set_ylabel("Thread ID", labelpad=0) else: ax.set_ylabel("Thread ID * " + str(expand), labelpad=0) ax.set_yticks(pl.array(list(range(nthread))), True) loc = plticker.MultipleLocator(base=expand) ax.yaxis.set_major_locator(loc) ax.grid(True, which="major", axis="y", linestyle="-") pl.show() pl.savefig(outpng) print("Graphics done, output written to", outpng) sys.exit(0)
ax1.plot(x1, y1, 'r-', x2, y2, 'r-', x3, y3, 'b.', markersize=10) # , alpha=0.7) ax1.set_xlabel('log2(ratio)', fontsize=20) ax1.set_ylabel('-log10(p-value)', fontsize=20) if "label" in self.df.columns: cond = self.df["s_val"] >= s_value_cutoff for index_, row in self.df[cond].iterrows(): label = row["label"] x_coord = row["ratio"] y_coord = row["p_val"] if x_coord < 0: ax1.plot(x_coord,y_coord,'r.',markersize=10) ax1.annotate(label,xy=(x_coord, y_coord),xycoords='data',xytext=(5,5), textcoords='offset points',arrowprops=dict(arrowstyle="-"),fontsize=12,color='r') else: ax1.plot(x_coord,y_coord,'g.',markersize=10) ax1.annotate(label, xy=(x_coord, y_coord), xycoords='data', xytext=(5, 5), textcoords='offset points', arrowprops=dict(arrowstyle="-"), fontsize=12,color="g") #ax1.annotate(label, xy=(x_coord, y_coord), xycoords='data', xytext=(5, 5), #textcoords='offset points', arrowprops=dict(arrowstyle="-"), fontsize=12) return fig, ax1 volc = Volcano(x["log(FC)"], x["log(P)"], x["Symbol"], s_curve_x_axis_overplot=2, s_curve_y_axis_overplot=.5) fig, axs = volc.get_fig() axs.xaxis.set_major_locator(ticker.MultipleLocator(1.0))
plt.plot(lucro_hof_all[melhor][0].index, lucro_hof_all[melhor][0].iloc[:,3]) plt.plot(lucro_hof_all[melhor][0].index, lucro_hof_all[melhor][0].iloc[:,4]) # Shrink current axis by 20% box = ax.get_position() ax.set_position([box.x0, box.y0 + box.height * 0.1, box.width, box.height * 0.9]) # Put a legend to the right of the current axis ax.legend(["Trading Balance (BTC)", "Holding Balance (BTC)"], loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=5) #plt.title("Saldo Ao Longo do Tempo - %s" %melhor) plt.xlabel("Date") plt.ylabel("Balance (BTC)") loc = plticker.MultipleLocator(base=3.5) # this locator puts ticks at regular intervals ax.xaxis.set_major_locator(loc) ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d/%y')) plt.show() figura.savefig("D:/Dropbox/Nebuloso/Artigo/Artigo/Imagens/saldoxtempo.eps") #mudar para eps # valor no tempo melhor resultado melhor_saldo = np.argmax(tabela_saldo_final_hof.loc[:,"Relação Saldo Final Algoritmo/Saldo Final Manter (%)"]) figura = plt.figure() ax = plt.subplot(111) plt.plot(lucro_hof_all[melhor_saldo][0].index, lucro_hof_all[melhor_saldo][0].iloc[:,3])
sum_upper_asymptomatic_testing_list = [x * 100 for x in upper_asymptomatic_testing_list] sum_mean_symptomatic_testing_list = [x * 100 for x in mean_symptomatic_testing_list] sum_upper_symptomatic_testing_list = [x * 100 for x in upper_symptomatic_testing_list] x = list(range(len(sum_mean_asymptomatic_testing_list))) plt.bar(x, sum_mean_asymptomatic_testing_list, label='ASY Testing', tick_label = xlabel, hatch = patterns[2]) plt.bar(x, sum_mean_symptomatic_testing_list, bottom= sum_mean_asymptomatic_testing_list, label='SY Testing', hatch = patterns[1]) plt.legend(loc=4) y_upper_error = [ x-y for x,y in zip(sum_upper_asymptomatic_testing_list, sum_mean_asymptomatic_testing_list)] ax.errorbar(x, sum_mean_asymptomatic_testing_list, yerr = y_upper_error, color = "k", capsize=13, fmt=".", ms = 0.0001, elinewidth=5, capthick = 2) # plt.gca().xaxis.set_major_locator(mticker.MultipleLocator(10)) plt.gca().yaxis.set_major_locator(mticker.MultipleLocator(50)) plt.xlabel(r'Population $\bf{N}$', fontsize=35) plt.ylabel("Average POMDP action", fontsize=35) plt.tight_layout() plt.savefig("./Plots/Asymptomatic_Testing_Number.png", dpi = 400) plt.close(fig)
zmean=np.append(zmean,np.median(x11[xx[0]])) xx=np.where((idsurvey1!=15) & (idsurvey1!=1) & (idsurvey1!=4)) n, bins, patches = ax[2].hist(x11[xx[0]], bins=15,range=[-3,3], histtype='step', alpha=0.75,color='black',linewidth=2) zmean=np.append(zmean,np.median(x11[xx[0]])) xx=np.where((idsurvey1!=15) & (idsurvey1!=1) & (idsurvey1!=4)&(z1>0.5)) n, bins, patches = ax[2].hist(x11[xx[0]], bins=15,range=[-.3,.3], histtype='step', alpha=0.75,color='purple',linewidth=2) zmean=np.append(zmean,np.median(x11[xx[0]])) str2=['black','green','blue','red','purple'] proxy = [plt.Rectangle((0,0),.02,.02,fc = str2[pc]) for pc in range(0,5)] ax[2].legend(proxy, ["Low-z "+fformx(zmean[3]).strip(), "SDSS "+fformx(zmean[1]).strip(),"PS1 "+fformx(zmean[0]).strip(), "SNLS "+fformx(zmean[2]).strip(), "HST "+fformx(zmean[4]).strip()],loc='upper left',prop={'size':8},frameon=False,fontsize=8,ncol=2) #plt.text(2.1,45,"x1",fontdict={'fontsize':20}) ax[2].set_xlabel(r'$x_1$',labelpad=-1) ax[2].set_ylabel('\# of SNeIa') ax[2].set_ylim(0.0,100) ax[2].set_xlim(-3.0,3.0) ax[0].yaxis.set_major_locator(ticker.MultipleLocator(20)) ax[1].yaxis.set_major_locator(ticker.MultipleLocator(20)) ax[2].yaxis.set_major_locator(ticker.MultipleLocator(20)) plt.show() plt.savefig('csz_hist.png') asdf
def plotTrajPose(xyzrxryrzT, xyzrxryrzVT, xyzrxryrzAT, vTcPT, aTcpT, t): fig1 = plt.figure().gca() try: fig1.plot(t, xyzrxryrzT[:, 0], color='r', label='X') fig1.plot(t, xyzrxryrzT[:, 1], color='g', label='Y') fig1.plot(t, xyzrxryrzT[:, 2], color='b', label='Z') except: return 1 fig1.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig1.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title("Pose XYZ") plt.ylabel('XYZ in mm') plt.xlabel('Zeit in s') plt.legend() fig2 = plt.figure().gca() try: fig2.plot(t, xyzrxryrzT[:, 3], color='c', label='rx') fig2.plot(t, xyzrxryrzT[:, 4], color='magenta', label='ry') fig2.plot(t, xyzrxryrzT[:, 5], color='orange', label='rz') except: return 2 fig2.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig2.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title("Pose rxryrz") plt.ylabel('rxryrz in Rad') plt.xlabel('Zeit in s') plt.legend() fig3 = plt.figure().gca() try: fig3.plot(t, vTcPT[:], color='r', label='vTCP') except: return 3 fig3.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig3.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title("TCP Geschwindigkeit") plt.ylabel('Geschwindigkeit in mm/s') plt.xlabel('Zeit in s') plt.legend() fig4 = plt.figure().gca() try: fig4.plot(t, aTcpT[:], color='r', label='aTCP') except: return 4 fig4.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig4.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title("TCP Beschleunigung") plt.ylabel('Beschleunigung in mm/ s**2') plt.xlabel('Zeit in s') plt.legend() fig5 = plt.figure().gca() try: fig5.plot(t, xyzrxryrzVT[:, 0], color='r', label='dX') fig5.plot(t, xyzrxryrzVT[:, 1], color='g', label='dY') fig5.plot(t, xyzrxryrzVT[:, 2], color='b', label='dZ') except: return 5 fig5.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig5.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title("Pose Geschwindigkeit XYZ") plt.ylabel('XYZ in mm/s') plt.xlabel('Zeit in s') plt.legend() fig6 = plt.figure().gca() try: fig6.plot(t, xyzrxryrzAT[:, 0], color='r', label='ddX') fig6.plot(t, xyzrxryrzAT[:, 1], color='g', label='ddY') fig6.plot(t, xyzrxryrzAT[:, 2], color='b', label='ddZ') except: return 6 fig6.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig6.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title("Pose Beschleunigung XYZ") plt.ylabel('XYZ in mm/s**2') plt.xlabel('Zeit in s') plt.legend() return 0
def plotCSVTcp(filenameCSV): filename = os.path.splitext(filenameCSV)[0] with open(('csv/' + filenameCSV)) as csvfile: r = csv_reader.CSVReader(csvfile) fig1 = plt.figure().gca() try: fig1.plot(r.timestamp, r.target_q_0, color='r', label='q0') fig1.plot(r.timestamp, r.target_q_1, color='g', label='q1') fig1.plot(r.timestamp, r.target_q_2, color='b', label='q2') fig1.plot(r.timestamp, r.target_q_3, color='c', label='q3') fig1.plot(r.timestamp, r.target_q_4, color='magenta', label='q4') fig1.plot(r.timestamp, r.target_q_5, color='orange', label='q5') except: print("Singular target_q_0-5") #return 1 fig1.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig1.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title(filenameCSV + " - Gelenkwinkel") plt.ylabel('Gelenkwinkel in Rad') plt.xlabel('Zeit in s') plt.legend() plt.savefig('png/' + filename + '_q.png', dpi=300) fig12 = plt.figure().gca() try: fig12.plot(r.timestamp, r.target_qd_0, color='r', label='qd0') fig12.plot(r.timestamp, r.target_qd_1, color='g', label='qd1') fig12.plot(r.timestamp, r.target_qd_2, color='b', label='qd2') fig12.plot(r.timestamp, r.target_qd_3, color='c', label='qd3') fig12.plot(r.timestamp, r.target_qd_4, color='magenta', label='qd4') fig12.plot(r.timestamp, r.target_qd_5, color='orange', label='qd5') except: print("Singular target_qd_0-5") #return 12 fig12.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig12.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title(filenameCSV + " - Winkelgeschwindigkeit") plt.ylabel('Winkelgeschwindigkeit in Rad/s') plt.xlabel('Zeit in s') plt.legend() plt.savefig('png/' + filename + '_qd.png', dpi=300) fig2 = plt.figure().gca() try: fig2.plot(r.timestamp, r.target_TCP_pose_0, color='r', label='X') fig2.plot(r.timestamp, r.target_TCP_pose_1, color='g', label='Y') fig2.plot(r.timestamp, r.target_TCP_pose_2, color='b', label='Z') except: print("Singular target_TCP_pose_0-2") # return 2 fig2.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig2.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title(filenameCSV + " - Pose XYZ") plt.ylabel('XYZ in m') plt.xlabel('Zeit in s') plt.legend() plt.savefig('png/' + filename + '_Pose_XYZ.png', dpi=300) fig3 = plt.figure().gca() try: fig3.plot(r.timestamp, r.target_TCP_pose_3, color='c', label='rx') fig3.plot(r.timestamp, r.target_TCP_pose_4, color='magenta', label='ry') fig3.plot(r.timestamp, r.target_TCP_pose_5, color='orange', label='rz') except: print("Singular target_TCP_pose_3-5") #return 3 fig3.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig3.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title(filenameCSV + " - Pose rxryrz") plt.ylabel('rxryrz in Rad') plt.xlabel('Zeit in s') plt.legend() plt.savefig('png/' + filename + '_Pose_rxryrz.png', dpi=300) fig4 = plt.figure().gca() try: fig4.plot(r.timestamp, r.target_TCP_speed_0, color='r', label='dX') fig4.plot(r.timestamp, r.target_TCP_speed_1, color='g', label='dY') fig4.plot(r.timestamp, r.target_TCP_speed_2, color='b', label='dZ') except: print("Singular target_TCP_speed_0-2") #return 4 fig4.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig4.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title(filenameCSV + " - Pose Geschwindigkeit XYZ") plt.ylabel('dXYZ in m/s') plt.xlabel('Zeit in s') plt.legend() plt.savefig('png/' + filename + '_Pose_Geschwindigkeit_XYZ.png', dpi=300) fig5 = plt.figure().gca() try: fig5.plot(r.timestamp, r.target_TCP_speed_3, color='c', label='drx') fig5.plot(r.timestamp, r.target_TCP_speed_4, color='magenta', label='dry') fig5.plot(r.timestamp, r.target_TCP_speed_5, color='orange', label='drz') except: print("Singular target_TCP_speed_3-5") #return 5 fig5.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig5.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title(filenameCSV + " - Pose Geschwindigkeit rxryrz") plt.ylabel('drxryrz in Rad/s') plt.xlabel('Zeit in s') plt.legend() plt.savefig('png/' + filename + '_Pose_Geschwindigkeit_rxryrz.png', dpi=300) #target_TCP_acc_X fig6 = plt.figure().gca() try: fig6.plot(r.timestamp, r.target_TCP_acc_0, color='r', label='ddX') fig6.plot(r.timestamp, r.target_TCP_acc_1, color='g', label='ddY') fig6.plot(r.timestamp, r.target_TCP_acc_2, color='b', label='ddZ') except: print("Singular target_TCP_acc_X") #return 6 fig6.xaxis.set_major_locator(ticker.MultipleLocator(0.50)) fig6.xaxis.set_minor_locator(ticker.MultipleLocator(0.25)) plt.grid(True) plt.title(filenameCSV + " - Pose Beschleunigung XYZ") plt.ylabel('ddXYZ in m/s**2') plt.xlabel('Zeit in s') plt.legend() plt.savefig('png/' + filename + '_Pose_Beschleunigung_XYZ.png', dpi=300) return 0
def plot_energy_landscape(x, y, values, log_legend=False, title=None, legend_title=None, legend_min=0, legend_max=None): # Clearing the canvas, so we always draw on the empty canvas. Just in case. plt.clf() x, y = preprocess(x, y) fig, ax = plt.subplots() XX, YY = np.meshgrid(x, y) z = values.reshape(len(x) - 1, len(y) - 1).T # ax.grid(True, which='minor', axis='both', linestyle='-', color='k') # ax.set_xticks(x, minor=True) # ax.set_yticks(y, minor=True) ## This is for having ticks in the plot as multiples of pi ax.xaxis.set_major_formatter( tck.FuncFormatter(lambda val, pos: '{:.2f}$\pi$'.format(val / np.pi) if val != 0 else '0')) ax.xaxis.set_major_locator(tck.MultipleLocator(base=np.pi / 4)) ax.yaxis.set_major_formatter( tck.FuncFormatter(lambda val, pos: '{:.2f}$\pi$'.format(val / np.pi) if val != 0 else '0')) ax.yaxis.set_major_locator(tck.MultipleLocator(base=np.pi / 4)) if log_legend: mesh_plot = ax.pcolormesh(XX, YY, z, cmap='RdBu', vmax=legend_max, norm=LogNorm()) else: mesh_plot = ax.pcolormesh(XX, YY, z, cmap='RdBu', vmin=legend_min, vmax=legend_max) ax.set_xlabel("beta") ax.set_ylabel("gamma") if title is None: title = "QAOA energy landscape" ax.set_title(title) # set the limits of the plot to the limits of the data ax.axis([x.min(), x.max(), y.min(), y.max()]) if log_legend: cbar_formatter = tck.LogFormatter(10, labelOnlyBase=False) cbar = fig.colorbar(mesh_plot, ax=ax, format=cbar_formatter) else: cbar = fig.colorbar(mesh_plot, ax=ax) if legend_title is None: legend_title = "energy" cbar.set_label(legend_title) plt.savefig(title) return ax
xs = np.linspace(0, 2 * np.pi, 100) xs_deg = np.linspace(0, 360, 100) times = lambda max_t : np.linspace(0, max_t, 10 * max_t) def exp(r, x): return np.exp(r * x) rate = 0.05 grow = lambda x : exp(rate, x) # Plotting fontsize = 20 linewidth = 3 ticks = ticker.MultipleLocator(base = 60) def make_plot(mode, t_max = 0): ts = times(t_max + 1) for time in ts: """ sin wave with frequency 'mode' """ ys = [np.sin(mode * x - np.pi * time / 10) * grow(time) for x in xs] figure, ax = plot.subplots(figsize = (10, 3)) plot.plot(xs_deg, ys, 'b', linewidth = linewidth + 1) # Limit plot.xlim(0, 360) plot.ylim(-8, 8)
import chaosmagpy as cp import matplotlib.pyplot as plt import matplotlib.ticker as ticker import numpy as np model = cp.CHAOS.from_mat('CHAOS-6-x9.mat') # load the mat-file of CHAOS-6-x9 nmax = 20 time = cp.data_utils.mjd2000(2018, 1, 1) degrees = np.arange(1, nmax + 1, dtype=int) fig, ax = plt.subplots(1, 1, figsize=(12, 7)) for deriv, label in enumerate(['nT', 'nT/yr', 'nT/yr$^2$']): # get spatial power spectrum from time-dependent internal field in CHAOS spec = model.model_tdep.power_spectrum(time, nmax=nmax, deriv=deriv) ax.semilogy(degrees, spec, label=label) ax.legend() ax.grid(which='both') ax.yaxis.set_major_locator(ticker.LogLocator(base=10.0, numticks=15)) ax.xaxis.set_major_locator(ticker.MultipleLocator(1)) ax.set_title("Spatial power spectra at Earth's surface", fontsize=14) ax.set_xlabel('Spherical harmonic degree') plt.tight_layout() plt.show()
data_file.close() if GR_Connected == True: fig, ax = pl.subplots(2, 2) pl.suptitle("Sensor " + sensor_name + " at " + temperature + " for " + annealing + "\n") ax[0, 0].plot(bias_voltage, avg_current, "ro") ax[0, 0].ticklabel_format( style='sci', axis='y', scilimits=(0, 0)) #scientific notation on the y-axis ax[0, 0].set_xlabel("Bias Voltage (V)") #x label ax[0, 0].set_ylabel("Average Current (A)") #y label ax[0, 0].xaxis.set_major_locator( ticker.MultipleLocator(100)) #major ticks ax[0, 0].xaxis.set_minor_locator(ticker.MultipleLocator(50)) #minor ticks # ax1.xaxis.set_major_locator(ticker.MultipleLocator(100))#major ticks # ax1.xaxis.set_minor_locator(ticker.MultipleLocator(50))#minor ticks ax[0, 1].plot(bias_voltage, C_freq1, "ro") ax[0, 1].plot(bias_voltage, C_freq2, "bo") ax[0, 1].ticklabel_format( style='sci', axis='y', scilimits=(0, 0)) #scientific notation on the y-axis ax[0, 1].set_xlabel("Bias Voltage (V)") #x label ax[0, 1].set_ylabel("Capacitance (F)") #y label ax[0, 1].xaxis.set_major_locator( ticker.MultipleLocator(100)) #major ticks
# size and fixed aspect ratio ax.set_aspect('equal') ax.set_xlim(minx - ROOMBA_WIDTH, maxx + ROOMBA_WIDTH) ax.set_ylim(miny - ROOMBA_WIDTH, maxy + ROOMBA_WIDTH) # set background colors fig.patch.set_facecolor('#065da2') ax.set_facecolor('#065da2') # setup grid ax.grid(which="both", linestyle="dotted", linewidth=1, alpha=.5, zorder=5) # spacing 0.5m ax.xaxis.set_major_locator(ticker.MultipleLocator(500)) ax.yaxis.set_major_locator(ticker.MultipleLocator(500)) # all off ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.spines['left'].set_visible(False) plt.tick_params(top=False, bottom=False, left=False, right=False, labelleft=False, labelbottom=False)
def massfractionvtime2(datafile1, datafile2, end, num_plots=1, min_mf=.00000001, time_spacing=.2, h_ratio=[3, 1], zz_wanted='None', zz_wanted2='None', aa_wanted='None', nuc_names_wanted='None'): ''' Inputs: datafile = a ts file datafile2 = a second ts file to be plotted simultaneously end = k value at end of desired time num_plots = number of plots to be shown simultaneously, default to 1 min_mf = cutoff point below which mass fraction does not appear on the graph, default to .00000001 time_spacing = desired interval between x-axis ticks, default to .2 h_ratio = height ratio (if plotting multiple plots), default to 3:1 zz_wanted = list of atomic numbers of desired isotopes (if multiple isotopes of the same element are desired, their zz values must be added multiple times) zz_wanted2 = zz_wanted for the second datafile aa_wanted = list of atomic masses of desired isotopes (used in conjunction with zz_wanted) nuc_names_wanted = list of desired species names, formatted as '$^{aa}$Symbol' (best option when plotting specific isotopes) Outputs: plot of mass fraction vs time ''' import numpy as np import matplotlib.pyplot as plt from matplotlib import colors import matplotlib.ticker as plticker import matplotlib.gridspec as gridspec import find_file_type as fft import read_ts_file as rtf import random #Create plot space plt.figure(1) #Read ts file, use variables. zz, aa, xmf, time, temperature, density, timestep, edot, flx_end, flx = rtf.read_ts_file( datafile1) element = rtf.build_element_symbol() nuc_name = rtf.build_isotope_symbol(zz, aa) #Create plot. ax1 = plt.subplot(1, 1, 1) #Set parameter based on data. num_species_total = np.shape(xmf)[1] #Assign each species a random color. colors_array = [] for counter in np.arange(1, num_species_total + 1): item1 = np.random.rand(counter)[0] item2 = np.random.rand(counter)[0] item3 = np.random.rand(counter)[0] colors_array.append(item1) colors_array.append(item2) colors_array.append(item3) colors_array = np.asarray(colors_array) colors_array = colors_array.reshape((num_species_total, 3)) colors = [] for counter in np.arange(1, num_species_total + 1): item1 = np.random.rand(counter)[0] item2 = np.random.rand(counter)[0] item3 = np.random.rand(counter)[0] colors.append(item1) colors.append(item2) colors.append(item3) colors = np.asarray(colors) colors = colors.reshape((num_species_total, 3)) #Plot mf, add a legend. for counter in np.arange(0, num_species_total): if zz_wanted != 'None': if zz[counter] in zz_wanted and aa_wanted == 'None': #Plot all isotopes of an element. if zz[counter] == 1 and aa[ counter] == 1: #Explicitly plots protons and hydrogen. plt.plot(time, xmf[:, counter], color='r', label=nuc_name[counter]) elif zz[counter] == 1 and aa[counter] == 2: plt.plot(time, xmf[:, counter], color='b', label=nuc_name[counter]) else: plt.plot(time, xmf[:, counter], color=colors_array[counter], label=nuc_name[counter]) box = ax1.get_position() ax1.set_position( [box.x0, box.y0, box.width * 0.995, box.height]) ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=10) elif zz[counter] in zz_wanted and aa[ counter] in aa_wanted: #Plot by atomic number and mass number. plt.plot(time, xmf[:, counter], color=colors_array[counter], label=nuc_name[counter]) box = ax1.get_position() ax1.set_position( [box.x0, box.y0, box.width * 0.995, box.height]) ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=10) zz_wanted.remove(zz[counter]) elif zz_wanted == 'None' and nuc_names_wanted == 'None': #Plot all species above specified threshold. if np.amax(xmf[:, counter]) >= min_mf: plt.plot(time, xmf[:, counter], color=colors_array[counter]) elif nuc_names_wanted != 'None': #Listed nuclear names switches plotting mechanism. break if nuc_names_wanted != 'None': #Sort through list to find mass fraction of named species, and plot. for counter in np.arange(0, len(nuc_names_wanted)): species_number = nuc_name.index(nuc_names_wanted[counter]) species_number = int(species_number) plt.plot(time, xmf[:, species_number], color=colors_array[species_number], label=nuc_name[species_number]) box = ax1.get_position() ax1.set_position([box.x0, box.y0, box.width * 0.995, box.height]) ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=10) #Start of datafile2. #Read second ts file, use variables. zz, aa, xmf, time, temperature, density, timestep, edot, flx_end, flx = rtf.read_ts_file( datafile2) element = rtf.build_element_symbol() nuc_name = rtf.build_isotope_symbol(zz, aa) #Set parameter based on data size. num_species_total = np.shape(xmf)[1] #Repeat plotting process above, using dashed lines and second set of provided information. for counter in np.arange(0, num_species_total): if zz_wanted2 != 'None': if zz[counter] in zz_wanted2 and aa_wanted == 'None': if zz[counter] == 1 and aa[counter] == 1: plt.plot(time, xmf[:, counter], color='r', label=nuc_name[counter], linestyle='--') elif zz[counter] == 1 and aa[counter] == 2: plt.plot(time, xmf[:, counter], color='b', label=nuc_name[counter], linestyle='--') else: plt.plot(time, xmf[:, counter], color=colors_array[counter], label=nuc_name[counter], linestyle='--') elif zz[counter] in zz_wanted2 and aa[counter] in aa_wanted: plt.plot(time, xmf[:, counter], color=colors_array[counter], label=nuc_name[counter], linestyle='--') zz_wanted2.remove(zz[counter]) aa_wanted.remove(aa[counter]) elif zz_wanted2 == 'None' and nuc_names_wanted == 'None': if np.amax(xmf[:, counter]) >= min_mf: plt.plot(time, xmf[:, counter], color=colors_array[counter], linestyle='--') elif nuc_names_wanted != 'None': break if nuc_names_wanted != 'None': for counter in np.arange(0, len(nuc_names_wanted)): species_number = nuc_name.index(nuc_names_wanted[counter]) plt.plot(time, xmf[:, species_number], color=colors_array[species_number], label=nuc_name[species_number], linestyle='--') #Format and label axes plt.yscale('log') plt.ylim(min_mf, 1.5) plt.ylabel("Mass Fraction") plt.xscale('linear') plt.xlim(time[0], time[end]) plt.xlabel("Time (s)") #Add x ticks at specified intervals x_labels = [] tick = time[0] while tick <= time[end]: tick = float("{0:.1f}".format(tick)) x_labels.append(tick) tick += time_spacing loc = plticker.MultipleLocator(base=time_spacing) ax1.xaxis.set_major_locator(loc) plt.xticks(x_labels, x_labels) #Remove superfluous ticks, show grid line instead plt.tick_params(axis='both', which='both', bottom='on', top='on', labelbottom='on', left='off', right='off', labelleft='on') plt.grid(True) plt.title("%s (solid) and %s (dashed)" % (datafile1, datafile2)) #Show graph plt.show()
def renderFrameBlocks(self): self.axFrameBlocks1.clear() self.axFrameBlocks2.clear() # after a clear() annSelection object is gone. reset variable self.annSelection = None padding = 0.0 duration = 0.0 cnt = len(self.jointFrames) if (cnt > 0): duration = self.jointFrames[cnt - 1]['timeS'][0] maxTime = (duration / 1000.0) def format_func(value, tick_number): return r"${:.2f}$".format(value) self.axSliderTime.set_xlim((0, maxTime)) self.axSliderTime.tick_params(axis='x', labelsize=8) self.axSliderTime.get_xaxis().set_major_locator( ticker.AutoLocator()) self.axSliderTime.get_xaxis().set_minor_locator( ticker.AutoMinorLocator()) # show minor ticks every 5 frames and major ticks every 10 frames on the top of frame block 1 onetick = (maxTime) / float(cnt) self.axFrameBlocks1.set_xlim((0, maxTime)) self.axFrameBlocks1.xaxis.tick_top() self.axFrameBlocks1.xaxis.set_minor_locator( ticker.MultipleLocator(onetick * 5)) self.axFrameBlocks1.xaxis.set_major_locator( ticker.MultipleLocator(onetick * 10)) self.axFrameBlocks1.set_xticklabels([]) self.axFrameBlocks1.get_yaxis().set_visible(False) self.axFrameBlocks2.set_xlim((0, maxTime)) self.axFrameBlocks2.get_xaxis().set_visible(False) self.axFrameBlocks2.get_yaxis().set_visible(False) # render individual kinect joint frame blocks xx = self.axFrameBlocks1.get_xlim() yy = self.axFrameBlocks1.get_ylim() cx = (xx[1] - xx[0]) cy = (yy[1] - yy[0]) padding = cx * 0.01 cnt = len(self.jointFrames) if (cnt > 0): padding = (cx / cnt) * 0.3 for i in range(0, cnt): start = (self.jointFrames[i]['timeS'][0] / 1000.0) - (padding / 2.0) x_width = padding isFilled = self.jointFrames[i]['filled'][0] c = 'r' if (isFilled) else 'b' p = patches.Rectangle((start, yy[0]), x_width, cy, alpha=0.50, color=c) self.axFrameBlocks1.add_patch(p) self.axFrameBlocks1.text((maxTime), (cy / 2.0), ' Original', horizontalalignment='left', verticalalignment='center', color='black') # render individual laban frame blocks xx = self.axFrameBlocks2.get_xlim() yy = self.axFrameBlocks2.get_ylim() cx = (xx[1] - xx[0]) cy = (yy[1] - yy[0]) cnt = len(self.timeS) if (cnt > 0): for i in range(0, cnt): start = (self.timeS[i] / 1000.0) - (padding / 2.0) x_width = padding p = patches.Rectangle((start, yy[0]), x_width, cy, alpha=0.50, color='g') self.axFrameBlocks2.add_patch(p) self.axFrameBlocks2.text((maxTime), (cy / 2.0), ' Labanotation', horizontalalignment='left', verticalalignment='center', color='black') self.fig.canvas.draw_idle()
data = np.loadtxt("points.txt") p = int(input("Введите степень полинома: ")) n = len(data) x = np.arange(data[0][0] - 2, data[n - 1][0] + 2, 0.1) y = polinom(p, n, x, *data) xmin = data[0][0] - 2 xmax = data[n - 1][0] + 2 ymin = data[0][1] - 15 ymax = data[n - 1][1] + 10 fig, ax = plt.subplots() ax.axis([xmin, xmax, ymin, ymax]) ax.xaxis.set_major_locator(ticker.MultipleLocator(10)) ax.xaxis.set_minor_locator(ticker.MultipleLocator(5)) ax.yaxis.set_major_locator(ticker.MultipleLocator(5)) ax.yaxis.set_minor_locator(ticker.MultipleLocator(1)) ax.scatter(data[:, 0], data[:, 1], c='deeppink') ax.plot(x, y, color='r', linewidth=3) ax.grid(which='major', color='k') ax.minorticks_on() ax.grid(which='minor', color='gray', linestyle=':') fig.set_figwidth(8) fig.set_figheight(5)
def data_summary_vis(scrna_fname, dlp_fname, ifmpif_fname, wgs_fname, storage_filename, plot_file_name): scrna_file = import_scrna_from_github(scrna_fname) dlp_file = import_dlp_from_github(dlp_fname) if_file = import_ifmpif_from_github(ifmpif_fname) wgs_file = import_wgs_from_github(wgs_fname) # import elab pull and filter for storage aliquots from patients included in study storage_aliquots = pd.read_excel(storage_filename) filtered_aliquots = storage_aliquots.loc[ (storage_aliquots['Excluded'] == "No") & (storage_aliquots['Downstream Submission'] == "Storage Only")] pt_id_aliquots = filtered_aliquots["Patient ID"].drop_duplicates() patients = pt_id_aliquots.tolist() all_data_files = pd.concat([scrna_file, dlp_file, if_file, wgs_file], axis=0, sort=True) all_data_files = all_data_files[["Platform", "Patient ID"]] data_dict = {} for i in all_data_files["Platform"].tolist(): data_dict[i] = all_data_files[all_data_files["Platform"] == i]["Patient ID"].tolist() platforms = [] matrix = [] #identify matrix size (x and y length) for key, value in sorted(data_dict.items()): platforms.append(key) for patient in value: if patient not in patients: patients.append(patient) patients.sort() #create matrix from key value pairs currentPlatform = 0 for key, value in sorted(data_dict.items()): matrix.append([]) # initialize each matrix row to 0 matrix[currentPlatform] = [0] * len(patients) for patient in value: patientIndex = patients.index(patient) matrix[currentPlatform][patientIndex] = 1 currentPlatform += 1 patients = [patient.lstrip("SPECTRUM-") for patient in patients] print(patients) # plot matrix fig = plt.figure() ax = fig.add_subplot(111) ax.matshow(matrix, cmap=plt.cm.Blues) plt.title('SPECTRUM Data Summary', weight='bold', fontsize=8) plt.xlabel('Patients wtih scs Stored', fontsize=4, weight='bold') plt.ylabel('Platforms', rotation='vertical', fontsize=4, weight='bold') ax.set_xticklabels([''] + patients, rotation='vertical', fontsize=3, ha="center") ax.set_yticklabels([''] + platforms, fontsize=3) ax.xaxis.set_major_locator(ticker.MultipleLocator(1)) ax.yaxis.set_major_locator(ticker.MultipleLocator(1)) plt.gca().xaxis.tick_bottom() ax.set_xticks(np.arange(-.5, len(patients)), minor=True) ax.set_yticks(np.arange(-.5, len(platforms)), minor=True) ax.grid(which="minor", linewidth=0.5, alpha=0.5) plt.tight_layout() plt.savefig(fname=plot_file_name, dpi=300)
errs_aper[j] = np.std((cat['mag_input'] - cat['mag_aper'])[inds]) errs_err_aper[j] = calc_std_err((cat['mag_input'] - cat['mag_aper'])[inds]) # second plot pyplot.subplot(2, 1, 2) m = ns > 3 pyplot.errorbar(hist.locations[m], errs[m], errs_err[m], fmt='o', color='black') pyplot.errorbar(hist.locations[m], errs_aper[m], errs_err_aper[m], fmt='o', color='black', mfc='white') pyplot.axis([xmin, xmax, 0, 0.75]) pyplot.ylabel('$\sigma$Mag') axis = pyplot.axis() pyplot.gca().xaxis.set_major_locator(ticker.MultipleLocator(2)) pyplot.xlabel('Mag In') # plot estimated limit due to sky noise mags = np.linspace(xmin, xmax, 1000) fluxes = 10**(-0.4 * (mags - zpt)) errs = -2.5 * np.log10((fluxes - sky) / fluxes) #pyplot.plot( mags, errs, 'k-' ) pyplot.gcf().set_size_inches((6, 4)) pyplot.savefig('ps/irac_sims_cut.eps')
action_val = dqn.eval_net.forward(current_state) #前向传播 action = torch.max(action_val, 1)[1].data.numpy()[0] # 选出最大值 next_state, reward, done, _, _ = environ.run(current_state, action) print('current_state: {}, action: {}, next_state: {}'.format((current_state == POS_VALUE).nonzero()[0, 2:4], actions[action], (next_state == POS_VALUE).nonzero()[0, 2:4])) if done: break current_state = copy.deepcopy(next_state) dqn = DQN() # 定义 DQN 系统 start = time.clock() train_net() # 训练网络 test_net() # 测试网络 elapsed = (time.clock() - start) print("Time used:", elapsed) fig = plt.figure(figsize = (10, 10)) plt.plot(episode_list, step_list) plt.ylabel("step") plt.xlabel("episode") plt.title("DQN") plt.ylim(0, 6000) plt.xlim(0, 1000) ax = plt.gca() ax.xaxis.set_major_locator(tk.MultipleLocator(100)) ax.yaxis.set_major_locator(tk.MultipleLocator(500)) plt.show()
def plot_community_conn_mat(conn_matrix, labels, out_path_fig_comm, community_aff, cmap, dpi_resolution=300): """ Plot a community-parcellated connectivity matrix. Parameters ---------- conn_matrix : array NxN matrix. labels : list List of string labels corresponding to ROI nodes. out_path_fig_comm : str File path to save the community-parcellated connectivity matrix image as a .png figure. community_aff : array Community-affiliation vector. """ import warnings warnings.filterwarnings("ignore") import matplotlib import mplcyberpunk from matplotlib import pyplot as plt matplotlib.use("agg") plt.style.use("cyberpunk") import matplotlib.patches as patches import matplotlib.ticker as mticker from nilearn.plotting import plot_matrix from pynets.core import thresholding plt.style.use("cyberpunk") conn_matrix_bin = thresholding.binarize(conn_matrix) conn_matrix = thresholding.standardize(conn_matrix) conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin)) sorting_array = sorted(range(len(community_aff)), key=lambda k: community_aff[k]) sorted_conn_matrix = conn_matrix[sorting_array, :] sorted_conn_matrix = sorted_conn_matrix[:, sorting_array] rois_num = sorted_conn_matrix.shape[0] if rois_num < 100: try: plot_matrix( conn_matrix_plt, figure=(10, 10), labels=labels, vmax=np.percentile(conn_matrix_plt[conn_matrix_plt > 0], 95), vmin=0, reorder=False, auto_fit=True, grid=False, colorbar=False, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") else: try: plot_matrix( conn_matrix_plt, figure=(10, 10), vmax=np.abs(np.max(conn_matrix_plt)), vmin=0, auto_fit=True, grid=False, colorbar=False, cmap=cmap, ) except RuntimeWarning: print("Connectivity matrix too sparse for plotting...") ax = plt.gca() total_size = 0 for community in np.unique(community_aff): size = sum(sorted(community_aff) == community) ax.add_patch( patches.Rectangle( (total_size, total_size), size, size, fill=False, edgecolor="white", alpha=None, linewidth=1, )) total_size += size if len(labels) > 500: tick_interval = 5 elif len(labels) > 100: tick_interval = 4 elif len(labels) > 50: tick_interval = 2 else: tick_interval = 1 plt.axes().yaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) plt.axes().xaxis.set_major_locator(mticker.MultipleLocator(tick_interval)) for param in ['figure.facecolor', 'axes.facecolor', 'savefig.facecolor']: plt.rcParams[param] = '#000000' plt.savefig(out_path_fig_comm, dpi=dpi_resolution) plt.close() return
def set_y_major(base): loc = plticker.MultipleLocator( base=base) # this locator puts ticks at regular intervals plt.gca().yaxis.set_major_locator(loc)
for label, shape in zip(np.unique(labels), ['o', 's', '*', 'x', 'D']) } fig, axs = plt.subplots(ncols=2, sharex=True, sharey=True) #display pcs on left axs[0].scatter(X[:, 0], X[:, 1], c=X[:, 2], cmap=plt.cm.seismic, alpha=0.8, clip_on=False) artist.adjust_spines(axs[0]) axs[0].set_xlabel(artist.format('PC 1')) axs[0].set_ylabel(artist.format('PC 2')) axs[0].set_aspect('equal') loc = plticker.MultipleLocator(base=1.0) axs[0].xaxis.set_major_locator(loc) axs[0].yaxis.set_major_locator(loc) #--Print out effects in each cluster d = { cluster: [effect for i, effect in enumerate(effects) if labels[i] == cluster] for cluster in np.unique(labels) } for i in xrange(X.shape[0]): axs[1].scatter(X[i, 0], X[i, 1], marker=shapes[labels[i]], c=colors[labels[i]],
from textblob import TextBlob import matplotlib.pyplot as plt import matplotlib.ticker as plticker import time start = time.time() print(plt.style.available) plt.style.use("seaborn-talk" ) # _classic_test, fivethirtyeight, classic, bmh, seaborn-talk loc = plticker.MultipleLocator(base=.3) polarity = [] subjectivity = [] lines = [] polarityEqualsZero = 0 with open("./GambinoSong.txt") as f: for line in f.read().split("\n"): if line != "" and line not in lines: sentiment = TextBlob(line) if sentiment.sentiment.polarity != 0: polarity.append(sentiment.sentiment.polarity) else: polarityEqualsZero += 1 polarity.append(sentiment.sentiment.polarity) subjectivity.append(sentiment.subjectivity) lines.append(line)
def setup(ax): ax.spines['right'].set_color('none') ax.spines['left'].set_color('none') ax.yaxis.set_major_locator(ticker.NullLocator()) ax.spines['top'].set_color('none') ax.xaxis.set_ticks_position('bottom') ax.tick_params(which='major', width=1.00) ax.tick_params(which='major', length=5) ax.tick_params(which='minor', width=0.75) ax.tick_params(which='minor', length=2.5) ax.set_xlim(0, 5) ax.set_ylim(0, 1) ax.patch.set_alpha(0.0) labels = [2, 3, 4, 5, 8, 9, 10, 11, 12, 15, 16] seconds = [i.seconds for i in time_list] f = plt.figure() ax = plt.subplot(1, 1, 1) setup(ax) ax.bar(labels, seconds) ax.yaxis.set_major_formatter(formatter) # this locates y-ticks at the hours ax.yaxis.set_major_locator(ticker.MultipleLocator(base=3600)) # this ensures each bar has a 'date' label ax.xaxis.set_major_locator(ticker.MultipleLocator(base=1)) plt.show()
# adding sub plot using subplot2grid fig1 = plt.figure() bx3 = plt.subplot2grid((6, 1), (4, 0), rowspan=2, colspan=1) bx1 = plt.subplot2grid((6, 1), (0, 0), rowspan=2, colspan=1, sharex=bx3, sharey=bx3) bx2 = plt.subplot2grid((6, 1), (2, 0), rowspan=2, colspan=1, sharex=bx3, sharey=bx3) bx3.xaxis.set_major_locator(mticker.MultipleLocator(1)) ## Y axis ticks are not constant, it's [0,5] or [2.5, 5, 7.5], changing this here bx3.yaxis.set_major_locator(mticker.MultipleLocator(1)) bx3TwinX = bx3.twinx( ) ##creates a new copy of x axis with an y axis to the other side #with different range(default 0->1 may be) and ticks bx3TwinX.axes.set_ylim(0, 9) ## I need to set the y axis range explicitly bx3TwinX.yaxis.set_major_locator(mticker.MultipleLocator(1)) ## one way of changing tick size bx1.tick_params(axis='y', labelsize=8, color='m') bx2.tick_params(axis='y', labelsize=8, color='m') bx3.tick_params(axis='y', labelsize=8, color='m') bx3TwinX.tick_params(axis='y', labelsize=8, color='g') bx1.plot(x1, y1)
def plot_rt(result, ax, state_name, fig): ax.set_title(f"{state_name}") # Colors ABOVE = [1, 0, 0] MIDDLE = [1, 1, 1] BELOW = [0, 0, 0] cmap = ListedColormap(np.r_[np.linspace(BELOW, MIDDLE, 25), np.linspace(MIDDLE, ABOVE, 25)]) def color_mapped(y): return np.clip(y, .5, 1.5) - .5 index = result['ML'].index.get_level_values('date') values = result['ML'].values # Plot dots and line ax.plot(index, values, c='k', zorder=1, alpha=.25) ax.scatter(index, values, s=40, lw=.5, c=cmap(color_mapped(values)), edgecolors='k', zorder=2) # Aesthetically, extrapolate credible interval by 1 day either side lowfn = interp1d(date2num(index), result['Low'].values, bounds_error=False, fill_value='extrapolate') highfn = interp1d(date2num(index), result['High'].values, bounds_error=False, fill_value='extrapolate') extended = pd.date_range(start=pd.Timestamp('2020-03-01'), end=index[-1] + pd.Timedelta(days=1)) ax.fill_between(extended, lowfn(date2num(extended)), highfn(date2num(extended)), color='k', alpha=.1, lw=0, zorder=3) ax.axhline(1.0, c='k', lw=1, label='$R_t=1.0$', alpha=.25) # Formatting ax.xaxis.set_major_locator(mdates.MonthLocator()) ax.xaxis.set_major_formatter(mdates.DateFormatter('%b')) ax.xaxis.set_minor_locator(mdates.DayLocator()) ax.yaxis.set_major_locator(ticker.MultipleLocator(1)) ax.yaxis.set_major_formatter(ticker.StrMethodFormatter("{x:.1f}")) ax.yaxis.tick_right() ax.spines['left'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.spines['right'].set_visible(False) ax.margins(0) ax.grid(which='major', axis='y', c='k', alpha=.1, zorder=-2) ax.margins(0) ax.set_ylim(0.0, 3.5) ax.set_xlim( pd.Timestamp('2020-03-01'), result.index.get_level_values('date')[-1] + pd.Timedelta(days=1)) fig.set_facecolor('w')
def plot(self, *args, **kwargs): ps = self.env.ps myc = self._get_class_config() iter_list = self.config['iter_list'] l, b, r, t = myc['bbox_rect'] drange = [[20, 160], [-.5, 1.2]] gammaF_all = np.empty(0) gridness_all = np.empty(0) # Separate noise sigmas for ns_idx, noise_sigma in enumerate(ps.noise_sigmas): if ns_idx == 0: mi_title = 'Gamma frequency vs. gridness score' else: mi_title = None gammaFData = aggr.GammaAggregateData('freq', ps.bumpGamma[ns_idx], iter_list, normalizeTicks=False, collapseTrials=True) gridnessData = aggr.GridnessScore(ps.grids[ns_idx], iter_list, normalizeTicks=False, collapseTrials=True) gammaFData, _, _ = gammaFData.getData() gridnessData, _, _ = gridnessData.getData() gammaF_all = np.hstack((gammaF_all, gammaFData.flatten())) gridness_all = np.hstack((gridness_all, gridnessData.flatten())) # Gamma frequency vs. gridness score fig = self._get_final_fig(myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) self.plotDistribution(gammaFData, gridnessData, ax, noise_sigma=noise_sigma, range=drange, xlabel='Gridness score', ylabel='', yticks=False, title_size=self.myc['title_size']) ax.axis('tight') ax.xaxis.set_major_locator(ti.MultipleLocator(0.5)) if 'strip_axis' in self.myc and self.myc['strip_axis']: ax.axis('off') fname = self.config[ 'output_dir'] + "/gammaFreq_gridness_probability_{0}.pdf" fig.savefig(fname.format(int(noise_sigma)), dpi=300, transparent=True) plt.close(fig) self.mutual_information(gridnessData, gammaFData, noise_sigma=noise_sigma, title=mi_title) # All together fig = self._get_final_fig(myc['fig_size']) ax = fig.add_axes(Bbox.from_extents(l, b, r, t)) self.plotDistribution(gammaF_all, gridness_all, ax, xlabel='Gridness score', ylabel='Oscillation frequency (Hz)', range=drange, title_size=self.myc['title_size']) ax.axis('tight') ax.xaxis.set_major_locator(ti.MultipleLocator(0.5)) if 'strip_axis' in self.myc and self.myc['strip_axis']: ax.axis('off') fname = self.config[ 'output_dir'] + "/gammaFreq_gridness_probability_all.pdf" fig.savefig(fname, dpi=300, transparent=True) plt.close(fig) self.mutual_information(gammaF_all, gridness_all)