def plot_timeseries_comparison(masked, inf): fig = plt.figure(figsize=(16,4)) times = np.arange(len(masked))*inf.dt warnings.warn("Only plotting every 10th point of time series.") plt.plot(times[::10], masked.data[::10], 'k-', drawstyle='steps-post', label='Time series', zorder=1) inverted = invert_mask(masked) slices = np.ma.flatnotmasked_contiguous(inverted) if slices: for ii, badslice in enumerate(slices): if ii == 0: label='Radar indentified' else: label="_nolabel" tstart = inf.dt*(badslice.start) tstop = inf.dt*(badslice.stop-1) plt.axvspan(tstart, tstop, alpha=0.5, fc='r', ec='none', zorder=0, label=label) plt.figtext(0.02, 0.02, "Frac. of data masked: %.2f %%" % ((len(masked)-masked.count())/float(len(masked))*100), size='x-small') plt.figtext(0.02, 0.05, inf.basenm, size='x-small') plt.xlabel("Time (s)") plt.ylabel("Intensity") plt.xlim(0, times.max()+inf.dt) plt.subplots_adjust(bottom=0.15, left=0.075, right=0.98)
def snap1(vector): fig = plt.figure() plt.plot(vector) plt.axvspan(75, 125, facecolor='b', alpha=0.3) plt.xlabel('$x$') plt.ylabel('$Ez$') plt.show()
def plotRegion(start,end,area,bpScores,centers): if len(centers) < 6 or len(area) < 2000: return plt.clf() left=len(area)/2-1000 right=len(area)/2+1000 smooth=[] for i in range(len(area)): smooth.append(sum(area[max(0,i-10):i+10])/20.) print smooth print centers for center in centers: #plt.axvline(center[0]-start-74, color="gray") #plt.axvline(center[0]-start+74, color="gray") plt.axvspan(center[0]-73, center[0]+73, color='gray', alpha=0.3) plt.axvline(center[0], color="black") plt.plot(smooth) plt.plot(bpScores,"red") plt.title("Smoothed Read Start Count (chr21:"+str(start+left)+"-"+str(start+right)+")") plt.xlabel("Relative BP position") plt.ylabel("Count or Score") plt.xlim([left,right]) plt.ylim([0,10]) fig = matplotlib.pyplot.gcf() fig.set_size_inches(16,2) plt.savefig(sys.argv[3]+"_"+str(start)+"-"+str(end)+'.plot.pdf', dpi=100)
def plot_y_dist(y_train, y_test): """ Plotting the counts of inhibition scores :param y_train: Target values used for training :param y_test: Target values used for testing :return: None """ y_train = pd.read_csv('https://s3-us-west-2.amazonaws.com/pphilip-usp-inhibition/' 'data/y_train_postprocessing.csv') y_test = pd.read_csv('https://s3-us-west-2.amazonaws.com/pphilip-usp-inhibition/' 'data/y_test_postprocessing.csv') y_train.columns = ['ID', 'Activity_Score'] df_train = y_train.groupby('Activity_Score')['ID'].nunique().to_frame() df_train['score'] = df_train.index df_train.columns = ['score_counts', 'score'] df_train = df_train.reset_index(drop=True) y_test.columns = ['ID', 'Activity_Score'] df_test = y_test.groupby('Activity_Score')['ID'].nunique().to_frame() df_test['score'] = df_test.index df_test.columns = ['score_counts', 'score'] df_test = df_test.reset_index(drop=True) plt.plot(df_train['score'], df_train['score_counts']) plt.plot(df_test['score'], df_test['score_counts']) plt.title('Sample counts of unique inhibition scores') plt.xlabel('Inhibition score') plt.ylabel('Number of molecule samples') plt.axvspan(0, 40, facecolor='orange', alpha=0.2) plt.axvspan(40, 100, facecolor='violet', alpha=0.2) plt.savefig('./plots/score_counts.png', bbox_inches='tight')
def colorize_phases(STOP_TIME,durrationOfStep,ev_foot_const): for phase in range(int(1+STOP_TIME/durrationOfStep)): t0_phase = phase*durrationOfStep t1_phase = (phase+ev_foot_const)*durrationOfStep t2_phase = (phase+1)*durrationOfStep plt.axvspan(t0_phase, t1_phase, color='g', alpha=0.3, lw=2) #adaptative part (foot goal can change) plt.axvspan(t1_phase, t2_phase, color='r', alpha=0.3, lw=2) #non adaptative part
def plot_gen(ping, now, t, nans, host, interactive=False, size="1280x640"): ''' Generates ping vs time plot ''' if not interactive: import matplotlib matplotlib.use("Agg") # no need to load gui toolkit, can run headless import matplotlib.pyplot as plt size = [int(dim) for dim in size.split('x')] datestr = now[0].ctime().split() datestr = datestr[0] + " " + datestr[1] + " " + datestr[2] + " " + datestr[-1] plt.figure(figsize=(size[0]/80.,size[1]/80.)) # dpi is 80 plt.plot(now[~nans], ping[~nans], drawstyle='steps', marker='+') plt.title("Ping Results for {0}".format(host)) plt.ylabel("Latency [ms]") plt.xlabel("Time, {0} [GMT -{1} hrs]".format(datestr, time.timezone/3600)) plt.xticks(size=10) plt.yticks(size=10) plt.ylim(ping[~nans].min()-5, ping[~nans].max()+5) # plot packet losses start = [] finish = [] for i in range(len(nans)): if nans[i] == True: if i == 0: start.append(i) elif nans[i] != nans[i-1]: start.append(i) #if i != len(nans) and nans[i+1] != nans[i]: # finish.append(i) # add the red bars for bad pings for i in range(len(start)): plt.axvspan(now[start[i]], now[finish[i]+1], color='red') return plt
def Plot_Background(m_wavelengths,F_bgd,xs,ys): plt.scatter(m_wavelengths,F_bgd) plt.plot(xs,ys,'-',label='Integrated sky brightness') plt.title("Sky background as a function of wavelength") plt.xlabel("Wavelength / A"), plt.ylabel("log flux (ergs/s/cm2/A/arcsec2)") x_min,x_max = (m_wavelengths[0] - FWHM[0]), (m_wavelengths[-1] + FWHM[-1]) plt.xlim(x_min,x_max) plt.annotate # Shade in filters (optional) previous = 0 for i in range(0,len(band_colours)-1): if m_wavelengths[i]-FWHM[i] < previous: min,max = previous, m_wavelengths[i]+FWHM[i] else: min,max = m_wavelengths[i]-FWHM[i],m_wavelengths[i]+FWHM[i] plt.axvspan(min,max,facecolor=band_colours[i],alpha=0.35) previous = m_wavelengths[i]+FWHM[i] labels=['U','B','V','R','I','J','H','K'] for label, x, y in zip(labels, m_wavelengths,F_bgd): plt.annotate( label, xy = (x, y), xytext = (10, 12), textcoords = 'offset points', ha = 'right', va = 'bottom', bbox = dict(boxstyle = 'round,pad=0.5', fc = 'white', alpha = 0.5)) plt.show()
def plot_gen(ping, now, t, nans, host): ''' Generates ping vs time plot ''' datestr = now[0].ctime().split() datestr = datestr[0] + " " + datestr[1] + " " + datestr[2] + " " + datestr[-1] plt.figure(figsize=(25,8)) plt.plot(now[~nans], ping[~nans], drawstyle='steps') plt.title("Ping Results for {0}".format(host)) plt.ylabel("Latency [ms]") plt.xlabel("Time, {0} [GMT -{1} hrs]".format(datestr, time.timezone/3600)) plt.xticks(size=10) plt.yticks(size=10) plt.ylim(ping[~nans].min()-5, ping[~nans].max()+5) # plot packet losses start = [] finish = [] for i in range(len(nans)): if nans[i] == True: if i == 0: start.append(i) elif nans[i] != nans[i-1]: start.append(i) if i != len(nans) and nans[i+1] != nans[i]: finish.append(i) # add the red bars for bad pings for i in range(len(start)): plt.axvspan(now[start[i]], now[finish[i]+1], color='red') return
def calc_ola(window, M, R): window = scipy.signal.get_window(window, M, fftbins = True) f1, ax = plt.subplots(1) R0 = M - M%R #ax.axvline(R0,linewidth=3.0,color='black') plt.axvspan(R0, R0+M-1, facecolor='grey', alpha=0.5) #ax.axvline(R0+M-1,linewidth=3.0,color='black') ola = np.zeros(3*M) w_i = [] for shift in np.arange(0,2*M,R): win = np.zeros(3*M) win[shift:shift+M] += window w_i.append(win) if shift == R0: ax.plot(win, '-o', linewidth=2.5) else: ax.plot(win) ola += win ax.plot(ola, '-or') ola = ola[R0:R0+M] normCola = np.unique(np.round(ola,10)) print(normCola) if len(normCola)==1: return(True, normCola) else: return(False, ola)
def output_spectrum(wl, vec, interval=None): order = np.argsort(wl) p = plt.plot(wl[order], vec[order], color='red') ax = plt.gca() ax.set_xlabel('Wavelength') ax.set_ylabel('Magnitude') ax.grid(True) ax.spines['bottom'].set_color('white') ax.spines['top'].set_color('white') ax.spines['left'].set_color('white') ax.spines['right'].set_color('white') ax.xaxis.label.set_color('white') ax.yaxis.label.set_color('white') ax.tick_params(axis='x', colors='white') ax.tick_params(axis='y', colors='white') if interval is not None: plt.axvspan(interval[0], interval[1], facecolor='white', alpha=0.25) plt.savefig('spectrum_out.png',transparent=True) sys.stdout.write('%i'%len(wl)) for w in wl: sys.stdout.write(' %f' % w) for v in vec: sys.stdout.write(' %f' % v) sys.stdout.write('\n') os.system('convert -resize 100x100 spectrum_out.png thumb_out.png')
def profile_plot(self, bbox=None, start_freq=None, end_freq=None, start_time=None, end_time=None, t = None, ): """ generate plot of all of or bbox of spectrogram self ... Fingerprinter object """ spc = self.spectrum if bbox is None: bbox = Bbox(spc, start_freq, end_freq, start_time, end_time) freq_slice, time_slice = bbox.ix() x2 = spc.db_arr[freq_slice, time_slice] mn, mx = np.percentile(x2,[25,99.9]) Z = np.clip(x2,mn,mx) X,Y = np.meshgrid(spc.times[time_slice], spc.freqs[freq_slice],) # --build plot-- plt.clf() # spectrograph heatmap plt.pcolormesh(X,Y,Z, cmap='gist_heat_r', shading='gouraud') # place dots on detected harmonic peaks if hasattr(self, 'harmonic_intvl') and self.harmonic_intvl is not None: for i in self.harmonics: plt.plot(spc.times, self.harmonic_intvl*i, '.', color='g', alpha=.25) # shade areas of interest for start, stop in self.interest_areas: plt.axvspan(start, stop, facecolor='y', alpha=.5, edgecolor='k') if t is not None: plt.axvline(t, color='b') plt.grid(b=True, which='major',linestyle='-', alpha=.5) plt.xlim(bbox.start_time, bbox.end_time) plt.xlabel('Time (s)') plt.ylabel('Frequency (Hz)') return plt.gcf()
def plot_frag_arrays(conditions, transcript_arrays, outputdir, transcript_coords, transcripts_dict, paired): #Plot sererately per transcript for transcript in sorted(transcripts_dict): #Key is transcript, values are dict of positions and then fragments a = 1 for frag_pos in sorted(transcripts_dict[transcript]): c = 1 for sample in sorted(transcript_arrays[transcript]): length_of_transcript = len(transcript_arrays[transcript][sample]) base_label = np.array(xrange(length_of_transcript)) c += 1 #Count number of samples for legend size plt.plot(base_label, transcript_arrays[transcript][sample], label="{}".format(sample)) #Same as transcripts start_pos = int(frag_pos[1]) - int(transcript_coords[transcript][1]) end_pos = int(frag_pos[2]) - int(transcript_coords[transcript][1]) plt.axvspan(start_pos, end_pos, color='red', alpha=0.2) if paired: start_pos = int(frag_pos[3]) - int(transcript_coords[transcript][1]) end_pos = int(frag_pos[4]) - int(transcript_coords[transcript][1]) plt.axvspan(start_pos, end_pos, color='red', alpha=0.2) #Plot labels if c <= 4: #Control size of legend plt.legend(bbox_to_anchor=(1.05, 1), loc=1, borderaxespad=0., prop={'size':5}) else: plt.legend(bbox_to_anchor=(1.05, 1), loc=1, borderaxespad=0., prop={'size':7}) plt.ylabel('Read Count') plt.savefig(outputdir+'/plots/{}_{}.png'.format(transcript, a)) plt.close() a += 1
def plot_ks_analysis(lower_y, upper_y, pval, name): plt.figure(figsize=(5,10)) plt.subplot(311) ax = plt.gca() ax.set_axis_bgcolor('white') plt.title('smaller embryos, N={0}'.format(lower_y.shape[0])) for i,p in enumerate(pval): if p < 0.01: plt.axvspan(i, i+1, facecolor='0.5', alpha=0.5) elif p < 0.05: plt.axvspan(i, i+1, facecolor='0.5', alpha=0.2) plt.plot(np.exp(lower_y.T[:,:100])) plt.subplot(312) plt.title('bigger embryos, N={0}'.format(upper_y.shape[0])) plt.plot(np.exp(upper_y.T[:,:100])) plt.subplot(313) plt.plot(pval) plt.plot(np.ones(shape=len(pval))*0.05, "g--", label=r"5\% confidence") plt.plot(np.ones(shape=len(pval))*0.01, "r--", label=r"1\% confidence") plt.yscale('log') plt.ylabel('pvalue', fontsize=10) plt.xlabel('x/L') plt.suptitle(name) plt.savefig(ensure_dir(os.path.join(config.plots_path, "full_mutant", "ks_{0}.pdf".format(name)))) plt.clf()
def _periodogram_plot(title, column, data, trend, peaks): """display periodogram results using matplotlib""" periods, power = periodogram(data) plt.figure(1) plt.subplot(311) plt.title(title) plt.plot(data, label=column) if trend is not None: plt.plot(trend, linewidth=3, label="broad trend") plt.legend() plt.subplot(312) plt.title("detrended") plt.plot(data - trend) else: plt.legend() plt.subplot(312) plt.title("(no detrending specified)") plt.subplot(313) plt.title("periodogram") plt.stem(periods, power) for peak in peaks: period, score, pmin, pmax = peak plt.axvline(period, linestyle='dashed', linewidth=2) plt.axvspan(pmin, pmax, alpha=0.2, color='b') plt.annotate("{}".format(period), (period, score * 0.8)) plt.annotate("{}...{}".format(pmin, pmax), (pmin, score * 0.5)) plt.tight_layout() plt.show()
def PlotConcentrations(self, params, figure=None): concentrations = params['concentrations'] if figure is None: figure = plt.figure() plt.xscale('log', figure=figure) plt.ylabel('Compound KEGG ID', figure=figure) plt.xlabel('Concentration [M]', figure=figure) plt.yticks(range(self.Nc, 0, -1), self.cids, fontproperties=FontProperties(size=8)) plt.plot(concentrations.T, range(self.Nc, 0, -1), '*b', figure=figure) x_min = concentrations.min() / 10 x_max = concentrations.max() * 10 y_min = 0 y_max = self.Nc + 1 for c, cid in enumerate(self.cids): plt.text(concentrations[0, c] * 1.1, self.Nc - c, cid, \ figure=figure, fontsize=6, rotation=0) b_low, b_up = self.GetConcentrationBounds(cid) plt.plot([b_low, b_up], [self.Nc - c, self.Nc - c], '-k', linewidth=0.4) if self.c_range is not None: plt.axvspan(self.c_range[0], self.c_range[1], facecolor='r', alpha=0.3, figure=figure) plt.axis([x_min, x_max, y_min, y_max], figure=figure) return figure
def plot(rr_file, tag_file): """ Paint results of acquisition @param rr_file: Path to file that contains rr values @param tag_file: Path to file that contains tag values """ import matplotlib.pyplot as plt plt.switch_backend("WXAgg") colors = ['orange', 'green', 'lightblue', 'grey', 'brown', 'red', 'yellow', 'black', 'magenta', 'purple'] shuffle(colors) rr_values = parse_rr_file(rr_file) hr_values = map(lambda rr: 60 / (float(rr) / 1000), rr_values) tag_values = parse_tag_file(tag_file) x = [x / 1000 for x in cumsum(rr_values)] y = hr_values plt.plot(x, y) for tag in tag_values: c = colors.pop() plt.axvspan(tag[0], tag[0] + tag[2], facecolor=c, alpha=.8, label=tag[1]) plt.ylabel('Heart rate (bpm)') plt.xlabel('Time (s)') plt.title('Acquisition results') plt.ylim(ymin=min(min(y) - 10, 40), ymax=max(max(y) + 10, 150)) plt.legend() plt.show()
def _ref_single_cell_plot(self): seg = neo.PickleIO(self.cell_signal_path).read()[0] signal = seg.analogsignals[0] plt.figure() v_line, = plt.plot(signal.times, signal) for label, start, duration in zip(seg.epochs[0].labels, seg.epochs[0].times, seg.epochs[0].durations): if label == 'subthreshold': end = start + duration plt.axvspan(start, end, facecolor=self.subthresh_colour, alpha=0.05) plt.axvline(start, linestyle=':', color='gray', linewidth=0.5) plt.axvline(end, linestyle=':', color='gray', linewidth=0.5) fig = plt.gcf() fig.set_figheight(5) fig.set_figwidth(5) fig.suptitle('PyPe9 Simulation Output') plt.xlim((seg.analogsignals[0].t_start, seg.analogsignals[0].t_stop)) plt.xlabel('Time (ms)') plt.ylabel('Analog signals (mV)') plt.title("Analog Signals", fontsize=12) plt.legend(handles=[ v_line, mp.Patch(facecolor='white', edgecolor='grey', label='subVb regime', linewidth=0.5, linestyle=':'), mp.Patch(facecolor=self.subthresh_colour, edgecolor='grey', label='subthreshold regime', linewidth=0.5, linestyle=':')]) plt.savefig(self.ref_single_cell_path, dpi=100.0)
def draw_shannon_distrib(neut_h, obs_h, outfile=None, filetype=None, size=(15, 15)): ''' draws distribution of Shannon values for random neutral :argument neut_h: list of Shannon entropies corresponding to simulation under neutral model :argument obs_h: Shannon entropy of observed distribution of abundance :argument None outfile: path were image will be saved, if none, plot will be shown using matplotlib GUI :argument None filetype: pdf or png :argument (15,15) size: size in inches of the drawing ''' neut_h = np.array ([float (x) for x in neut_h]) obs_h = float (obs_h) pyplot.hist(neut_h, 40, color='green', histtype='bar', fill=True) pyplot.axvline(float(obs_h), 0, color='r', linestyle='dashed') pyplot.axvspan (float(obs_h) - neut_h.std(), float(obs_h) + neut_h.std(), facecolor='orange', alpha=0.3) pyplot.xlabel('Shannon entropy (H)') pyplot.ylabel('Number of observations over %s simulations' % (len (neut_h))) pyplot.title("Histogram of entropies from %s simulations compared to \nobserved entropy (red), deviation computed from simulation" % (len (neut_h))) fig = pyplot.gcf() dpi = fig.get_dpi() fig.set_size_inches (size) if outfile: fig.savefig(outfile, dpi=dpi+30, filetype=filetype) pyplot.close() else: pyplot.show()
def mousepress(self, event): if event.inaxes and event.button==1: self.eventpress = event if self.region_start is None: # Starting a new on-pulse region xx = int(event.xdata+0.5) self.region_start = xx self.region_start_line = plt.axvline(xx, c='k', ls='--') else: # Selected an on-pulse region if self.region_start > event.xdata: xlo = 0 xhi = int(event.xdata+0.5) self.regions.append(plt.axvspan(xlo, xhi, picker=True, facecolor='b', alpha=0.5)) xlo = int(self.region_start+0.5) xhi = self.nbin self.regions.append(plt.axvspan(xlo, xhi, picker=True, facecolor='b', alpha=0.5)) else: xlo = int(self.region_start+0.5) xhi = int(event.xdata+0.5) self.regions.append(plt.axvspan(xlo, xhi, picker=True, facecolor='b', alpha=0.5)) # Remove line self.region_start_line.remove() self.region_start = None self.region_start_line = None self.fig.canvas.draw()
def showdata(f, info): print(repr(info)) offA, offB = info offMin, offMax = min(info), max(info) offMax += 11*EODSamples*BytesPerSample offMin -= 10*EODSamples*BytesPerSample offMin = max(0, offMin) rlen = offMax - offMin posA = (offA-offMin) / BytesPerSample posB = (offB-offMin) / BytesPerSample f.seek(offMin) data = f.read(rlen) arr = np.frombuffer(data, dtype=np.float32) plt.figure(1,figsize=(24,14)) plt.clf() ax = None for ch in xrange(NumChannels): charr = arr[ch::NumChannels] if ch == 0: ax = plt.subplot(NumChannels, 1, 1) else: plt.subplot(NumChannels, 1, ch+1, sharex=ax) plt.plot(charr,'k') plt.axvspan(posA, posA + EODSamples, fc='r', ec='r', alpha=.5) plt.axvspan(posB, posB + EODSamples, fc='g', ec='g', alpha=.5) plt.axis([0, len(charr), -10, 10]) plt.ylabel('ch%d'%ch) plt.show()
def pointing_spectra(basename, savename, axlims): # Require axlims a priori """Plot four raw (but, averaged) spectra for single pnting""" left = np.load(basename + '_left0.npy') #leftn = np.load(basename + '_left_cal0.npy') right = np.load(basename + '_right0.npy') #rightn = np.load(basename + '_right_cal0.npy') fig = plt.figure(figsize=(4,3)) plt.axis(axlims) plt.plot(right, '-r', rasterized=True) #plt.plot(rightn, ':r', rasterized=True) plt.plot(left, '-b', rasterized=True) #plt.plot(leftn, ':b', rasterized=True) # Highlight where 1420 MHz is for each spectrum # Sent to 148.5, 151.5 MHz for left, right (range: 144-156 MHz) # Center channels: 3072, 5120 \pm 341 channels (covers 1 MHz) plt.axvspan(3072-341, 3072+341, facecolor='b', alpha=0.3) plt.axvspan(5120-341, 5120+341, facecolor='r', alpha=0.3) plt.legend(('$f_{\mathrm{LO}} = 1268.9$ MHz', #'$f_{\mathrm{LO}} = 1268.9$ MHz, noise', '$f_{\mathrm{LO}} = 1271.9$ MHz'))#, #'$f_{\mathrm{LO}} = 1271.9$ MHz, noise')) plt.xlabel('Channel number') plt.ylabel('Power (unknown units)') fig.set_tight_layout(True) # plt.tight_layout() plt.savefig(os.path.join('..','plots',savename+'.pdf'), dpi=400) plt.clf()
def plotSpectrum(template, conditions, outname): # Plot the template spectrum we are passed with frequency on the x-axis. # Initialise the plot. plt.clf() fig = plt.figure() ax = fig.add_subplot(111) # These are the colours we can use for the different lines. colours = [ "blue", "green", "red", "black", "yellow" ] # Go through the conditions (usually weather conditions) and plot a line for each. for i, c in enumerate(conditions): ax.plot(template[c]['centreFrequency'], template[c]['value'], colours[i], label=c) # Set the x-axis limits to be tight on the actual frequency range. plt.xlim(template[c]['centreFrequency'][0], template[c]['centreFrequency'][-1]) plt.xlabel("Frequency [MHz]") plt.ylabel("RMS noise level [mJy/beam]") # Ensure that the x- and y-axes don't have an offset value. ax.get_yaxis().get_major_formatter().set_useOffset(False) ax.get_xaxis().get_major_formatter().set_useOffset(False) # Put the legend with the condition names at the top of the plot outside the border. plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=len(c), mode="expand", borderaxespad=0.) # Highlight the regions that are flagged in the template. for i in xrange(0, len(template[conditions[0]]['flags'])): if (template[conditions[0]]['flags'][i] == True): x1 = template[conditions[0]]['centreFrequency'][i] - template[c]['channelWidth'] / 2.0 x2 = template[conditions[0]]['centreFrequency'][i] + template[c]['channelWidth'] / 2.0 plt.axvspan(x1, x2, alpha=0.2, edgecolor='none', facecolor='red') plt.savefig(outname)
def renderFullSignal(data, deltaT, labels, input_data, window_size, window_shift, ignore_list=[0], name="full.png"): fig = plt.figure() #Render the image huge fig.set_size_inches(300,25) plt.plot(data) #Generate a set of unique colors for each label colors = genColors(labels) #for color in colors.keys(): # print color, colors[color] #Flip through all the labels #The length of each box drawn is the length of the sample for index in range(len(labels)): label = labels[index] #Label 0 should be ignored, it is the "no other cluster" cluster if label not in ignore_list: color = colors[label] #Draw a box. X coords are in data units, y coords are in the range 0-1 #X start of the box is the size of the sample offset times the index of the sample xmin = index * window_shift #X end of the box is the start of the box plus the sample length xmax = xmin + window_size plt.axvspan(xmin, xmax, ymin=0.25, ymax=0.75, alpha=0.4, ec="none", fc=colors[label]) fig.savefig(name) plt.close()
def fig_nucleotide_gene(self): print '# Plotting gene in nucleotide resolution.' fig = plt.figure(figsize=(15, 10), dpi=80, facecolor='w', edgecolor='k') if len(self.experiments) > 1: print 'More than one experiment. Preprocess concat file to get only one experiment:' \ "cat your.concat | awk '$7 == \"experiment\" {print $0}' > experiment.concat" exit() else: e = self.experiments[0] fig_no, plot_no = 0, 0 for i_gene_id in self.genes_id_list: gene_name = self.id_to_names[i_gene_id] plot_no += 1 ax = fig.add_subplot(5, 1, plot_no) fig.tight_layout() plt.title(e) ax.set_ylabel("no. of reads") ax.set_xlabel('ID: '+i_gene_id+', Name: '+gene_name) try: self.data[gene_name][e] = self.data[gene_name][e][self.three_prime_flank:-self.three_prime_flank:] # plot only gene bar = ax.bar(self.data[gene_name][e]['position'], self.data[gene_name][e]['hits'], width=0.5) for i in self.genes[gene_name]['exons']: plt.axvspan(i[0], i[1], alpha=0.2, color='orange') plt.xticks(list(self.data[gene_name][e]['position']), list(self.data[gene_name][e]['nucleotides']), fontsize=8) except KeyError: plt.text(0.5,0.5,"NO READS") if plot_no == 5: fig_no += 1 plt.savefig(self.prefix+'nuc_gene'+'_l'+str(self.lookahead)+'_t'+str(self.hits_threshold)+'_'+'_fig_'+str(fig_no)+'.png') plt.clf() plot_no = 0 if plot_no > 0: plt.savefig(self.prefix+'nuc_gene'+'_l'+str(self.lookahead)+'_t'+str(self.hits_threshold)+'_'+'_fig_'+str(fig_no+1)+'.png') plt.clf() return True
def plot_trade_windows(self, dt_s, dt_e, f_width): ts_signal = self.getBollingerValue(dt_s, dt_e) dt_previous = '' s_color_previous = '' for i in range(len(ts_signal)): # get values for the current date dt = ts_signal.index[i] s = ts_signal[dt] s_color = 'r' if s >= f_width else 'g' if s <= -f_width else '' # update the figure: on change and in last day if s_color != s_color_previous \ or (i == len(ts_signal)-1): # if we are ending a trade opportunity window if s_color_previous != '': # shade the trade opportunity window plt.axvspan(dt_previous, dt, color=s_color_previous, alpha=0.25) # draw the end line plt.axvline(x=dt, color=s_color_previous, alpha=0.5) # if we are starting a new trade opportunity window if s_color != '': # draw the start line plt.axvline(x=dt, color=s_color, alpha=0.5) # save the last event s_color_previous = s_color dt_previous = dt
def day_e_plot(results, plot_date, save): import matplotlib.pyplot as plt fig = plt.figure() results['USAGE'].ix[plot_date].plot(linestyle='--', linewidth=5, color=darkgray) results['grid_demand_peak'].ix[plot_date].plot(marker='', linestyle='-', linewidth=2, color=redorange) results['grid_demand_offpeak'].ix[plot_date].plot(marker='', linestyle='-', linewidth=2, color=purple) results['grid_store'].ix[plot_date].plot(marker='', linestyle='-', linewidth=2, color=mint) results['storage_available'].ix[plot_date].plot(marker='', linestyle='-', linewidth=2, color=apple) results['storage_send'].ix[plot_date].plot(marker='', linestyle='-', linewidth=2, color=navy, grid='off') plt.axvspan(plot_date+' 10:00:00',plot_date+' 19:00:00', facecolor=lightgray, alpha=0.5) plt.legend(['Demand', 'Peak Grid for Demand', 'Off-Peak Grid for Demand', 'Grid to Battery', 'Storage Available', 'Storage to Demand'], labelspacing=.2, prop={'size':10}) plt.title('Demand-Side Storage Model, Hourly Energy State \n %s' %plot_date) plt.ylabel('Hourly Electricity State (kWh)', fontsize=14) if save == True: filename = 'Daily_Energy_State_'+plot_date+'.png' plt.savefig(filename) plt.show()
def day_purchase(results, plot_date, save): import matplotlib.pyplot as plt fig = plt.figure() results['USAGE'].ix[plot_date].plot(linestyle='--', linewidth=3, color='gray') #results['purchase_peak'].ix[plot_date].plot(marker='.', linestyle='', markersize=13, color='red') #results['purchase_offpeak'].ix[plot_date].plot(marker='.', linestyle='', markersize=13, color='orange', grid='off') results['purchase_peak'].ix[plot_date].plot(marker='', linestyle='-', linewidth=2, color='red') results['purchase_offpeak'].ix[plot_date].plot(marker='', linestyle='-', linewidth=2, color='orange', grid='off') plt.axvspan(plot_date+' 10:00:00',plot_date+' 19:00:00', facecolor=lightgray, alpha=0.5) plt.legend(['Demand','Purchased During Peak Hours', 'Purchased During Off-Peak Hours'], labelspacing=.2, prop={'size':10}) plt.ylabel('Electricity (kWh)', fontsize=14) plt.title('Demand-Side Storage Model, Hourly Electricity From Grid \n %s' %plot_date) if save == True: filename = 'Daily_Energy_Purchased_'+plot_date+'.png' plt.savefig(filename) plt.show()
def ScatterPlot(TransitionForces,ListOfSepAndFits,ExpectedContourLength, OutDir): """ Makes a scatter plot of the contour length and transition forces Args: TransitionForces: array, each element the transition region for curve i ListOfSepAndFits: array, each element the output of GetWLCFits ExpectedContourLength: how long we expect the construct to be OutDir: base directory, for saving stuff """ L0Arr = [] TxArr = [] for (SepNear,FitObj),TransitionFoces in zip(ListOfSepAndFits, TransitionForces): MedianTx = np.median(TransitionFoces) L0,Lp,_,_ = FitObj.Params() L0Arr.append(L0) TxArr.append(MedianTx) # go ahead an throw out ridiculous data from the WLC, where transition # normalize the contour length to L0 L0Arr = np.array(L0Arr)/ExpectedContourLength # convert to useful units L0Plot = np.array(L0Arr) TxPlot = np.array(TxArr) * 1e12 fig = pPlotUtil.figure(figsize=(12,12)) plt.subplot(2,2,1) plt.plot(L0Plot,TxPlot,'go',label="Data") alpha = 0.3 ColorForce = 'r' ColorLength = 'b' plt.axhspan(62,68,color=ColorForce,label=r"$F_{\rm tx}$ $\pm$ 5%", alpha=alpha) L0BoxMin = 0.9 L0BoxMax = 1.1 plt.axvspan(L0BoxMin,L0BoxMax,color=ColorLength, label=r"L$_{\rm 0}$ $\pm$ 10%",alpha=alpha) fudge = 1.05 # make the plot boundaries OK MaxX = max(L0BoxMax,max(L0Plot))*fudge MaxY = 90 plt.xlim([0,MaxX]) plt.ylim([0,MaxY]) pPlotUtil.lazyLabel("",r"F$_{\rm overstretch}$ (pN)", "DNA Characterization Histograms ",frameon=True) ## now make 1-D histograms of everything # subplot of histogram of transition force HistOpts = dict(alpha=alpha,linewidth=0) plt.subplot(2,2,2) TransitionForceBins = np.linspace(0,MaxY) plt.hist(TxPlot,bins=TransitionForceBins,orientation="horizontal", color=ColorForce,**HistOpts) pPlotUtil.lazyLabel("Count","","") plt.ylim([0,MaxY]) plt.subplot(2,2,3) ContourBins = np.linspace(0,MaxX) plt.hist(L0Plot,bins=ContourBins,color=ColorLength,**HistOpts) pPlotUtil.lazyLabel(r"$\frac{L_{\rm WLC}}{L_0}$","Count","") plt.xlim([0,MaxX]) pPlotUtil.savefig(fig,"{:s}Out/ScatterL0vsFTx.png".format(OutDir))
def plot(self, plot = None, ybound = None, fig = None, title = None): if fig == None: fig = plt.figure() if self.log == False: plt.plot(self.Follows[:,0], self.Follows[:,1], 'r-', label='read') plt.plot(self.Follows[:,0], self.Follows[:,2], 'b-', label='write') else: plt.semilogy(self.Follows[:,0], self.Follows[:,1], 'r-', label='read') plt.semilogy(self.Follows[:,0], self.Follows[:,2], 'b-', label='write') ax, = fig.get_axes() if title == None: plt.title(r'Distribution of "follows" observations') else: plt.title(title) if ybound != None: ax.set_ybound(upper = ybound) plt.axvspan(self.low, self.high, facecolor='g', alpha=0.5) plt.legend() plt.ylabel(r'$p_f(x)$') plt.xlabel('observation size (MB)') if plot == None: plt.show() else: plt.savefig(plot) return(fig)
def main(): tests = 100000 net_scores_1 = [trial(SCORES_1) for _ in range(tests)] net_scores_2 = [trial(SCORES_2) for _ in range(tests)] h1 = plt.hist(net_scores_1, 16, color='darkblue', alpha=0.4, label=r'$scoring_1$') h2 = plt.hist(net_scores_2, 16, color='red', alpha=0.7, label=r'$scoring_2$') actual_difference = 73.5 - 66.9 plt.axvline(actual_difference, lw=2, color='black', label=r'$Actual\ score\ difference$') plt.axvspan(significance_bound(h1, 0.05), significance_bound(h1, 0.95), color='skyblue', alpha=0.3, label=r'$2\sigma_1$') plt.axvspan(significance_bound(h2, 0.05), significance_bound(h2, 0.95), color='salmon', alpha=0.4, label=r'$2\sigma_2$') plt.legend() plt.show()
eventData = loader.get_session_events( cellInfo['ephysDirs'][cellInfo['laserIndex'][-1]]) spikeData = loader.get_session_spikes( cellInfo['ephysDirs'][cellInfo['laserIndex'][-1]], cellInfo['tetrode'], cluster=cellInfo['cluster']) eventOnsetTimes = loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps timeRange = [-0.1, 0.4] spikeTimesFromEventOnset, trialIndexForEachSpike, indexLimitsEachTrial = spikesanalysis.eventlocked_spiketimes( spikeTimestamps, eventOnsetTimes, timeRange) pRaster, hcond, zline = extraplots.raster_plot( spikeTimesFromEventOnset, indexLimitsEachTrial, timeRange) plt.setp(pRaster, ms=4) plt.xlabel('Time from laser onset (sec)') plt.axvspan(0, 0.1, alpha=0.2, color='blue') plt.subplot(gs[indCell, 1]) bandIndex = cellInfo['bandIndex'][0] eventData = loader.get_session_events(cellInfo['ephysDirs'][bandIndex]) spikeData = loader.get_session_spikes(cellInfo['ephysDirs'][bandIndex], cellInfo['tetrode'], cluster=cellInfo['cluster']) eventOnsetTimes = loader.get_event_onset_times(eventData) spikeTimestamps = spikeData.timestamps timeRange = [-0.2, 1.5] bandBData = loader.get_session_behavior( cellInfo['behavDirs'][bandIndex]) bandEachTrial = bandBData['currentBand'] ampEachTrial = bandBData['currentAmp'] numAmps = len(np.unique(ampEachTrial))
c[i:i + buffer_size] = signal[i:i + buffer_size] c = norm(c) * makeup_gain #draw plt.plot(range(len(signal)), signal, "black") plt.plot(range(len(signal)), c, "pink") plt.plot(range(len(compression)), compression * -1 + 1 - threshold, "red", dashes=[6, 2]) plt.plot(range(len(signal)), gr * -1 + 1, "blue") plt.axhline(y=threshold, color="green") for i in range(len(keyframes)): plt.axvline(x=keyframes[i], color="yellow") for v in segments(keyframes): plt.axvspan(v[0], v[1], facecolor='0.2', alpha=0.5) for v in segments(keyframes, False): plt.axvspan(v[0], v[1], facecolor='0.5', alpha=0.2) plt.show() #write file c *= 32767 c = np.int16(c) wavfile.write("file.wav", 44100, c)
def __init__(self, obsfilename, paramfilename, starnum, wvlcorr, galaxyname, slitmaskname, globular, lines, RA, Dec, obsspecial=None, plot=False, hires=None, smooth=None, specialparams=None): # Observed star self.obsfilename = obsfilename # File with observed spectra self.paramfilename = paramfilename # File with parameters of observed spectra self.starnum = starnum # Star number self.galaxyname = galaxyname # Name of galaxy self.slitmaskname = slitmaskname # Name of slitmask self.globular = globular # Parameter marking if globular cluster self.lines = lines # Parameter marking whether or not to use revised or original linelist # If observed spectrum comes from moogify file (default), open observed file and continuum normalize as usual if obsspecial is None: # Output filename if self.globular: self.outputname = '/raid/madlr/glob/' + galaxyname + '/' + slitmaskname else: self.outputname = '/raid/madlr/dsph/' + galaxyname + '/' + slitmaskname # Open observed spectrum self.specname, self.obswvl, self.obsflux, self.ivar, self.dlam, self.zrest = open_obs_file( self.obsfilename, retrievespec=self.starnum) # Get measured parameters from observed spectrum self.temp, self.logg, self.fe, self.alpha, self.fe_err = open_obs_file( self.paramfilename, self.starnum, specparams=True, objname=self.specname, inputcoords=[RA, Dec]) if specialparams is not None: self.temp = specialparams[0] self.logg = specialparams[1] self.fe = specialparams[2] self.alpha = specialparams[3] if plot: # Plot observed spectrum plt.figure() plt.plot(self.obswvl, self.obsflux, 'k-') plt.axvspan(4749, 4759, alpha=0.5, color='blue') plt.axvspan(4778, 4788, alpha=0.5, color='blue') plt.axvspan(4818, 4828, alpha=0.5, color='blue') plt.axvspan(5389, 5399, alpha=0.5, color='blue') plt.axvspan(5532, 5542, alpha=0.5, color='blue') plt.axvspan(6008, 6018, alpha=0.5, color='blue') plt.axvspan(6016, 6026, alpha=0.5, color='blue') plt.axvspan(4335, 4345, alpha=0.5, color='red') plt.axvspan(4856, 4866, alpha=0.5, color='red') plt.axvspan(6558, 6568, alpha=0.5, color='red') plt.savefig(self.outputname + '/' + self.specname + '_obs.png') plt.close() # Get synthetic spectrum, split both obs and synth spectra into red and blue parts synthfluxmask, obsfluxmask, obswvlmask, ivarmask, mask = mask_obs_for_division( self.obswvl, self.obsflux, self.ivar, temp=self.temp, logg=self.logg, fe=self.fe, alpha=self.alpha, dlam=self.dlam, lines=self.lines) if plot: # Plot spliced synthetic spectrum plt.figure() plt.plot(obswvlmask[0], synthfluxmask[0], 'b-') plt.plot(obswvlmask[1], synthfluxmask[1], 'r-') plt.savefig(self.outputname + '/' + self.specname + '_synth.png') plt.close() # Compute continuum-normalized observed spectrum self.obsflux_norm, self.ivar_norm = divide_spec( synthfluxmask, obsfluxmask, obswvlmask, ivarmask, mask, sigmaclip=True, specname=self.specname, outputname=self.outputname) if plot: # Plot continuum-normalized observed spectrum plt.figure() plt.plot(self.obswvl, self.obsflux_norm, 'k-') plt.axvspan(4749, 4759, alpha=0.5, color='blue') plt.axvspan(4778, 4788, alpha=0.5, color='blue') plt.axvspan(4818, 4828, alpha=0.5, color='blue') plt.axvspan(5389, 5399, alpha=0.5, color='blue') plt.axvspan(5532, 5542, alpha=0.5, color='blue') plt.axvspan(6008, 6018, alpha=0.5, color='blue') plt.axvspan(6016, 6026, alpha=0.5, color='blue') plt.axvspan(4335, 4345, alpha=0.5, color='red') plt.axvspan(4856, 4866, alpha=0.5, color='red') plt.axvspan(6558, 6568, alpha=0.5, color='red') plt.ylim((0, 5)) plt.savefig(self.outputname + '/' + self.specname + '_obsnormalized.png') plt.close() np.savetxt( self.outputname + '/' + self.specname + '_obsnormalized.txt', np.asarray((self.obswvl, self.obsflux_norm)).T) if wvlcorr: print('Doing wavelength correction...') try: # Compute standard deviation contdivstd = np.zeros(len(self.ivar_norm)) + np.inf contdivstd[self.ivar_norm > 0] = np.sqrt( np.reciprocal(self.ivar_norm[self.ivar_norm > 0])) # Wavelength correction self.obswvl = fit_wvl(self.obswvl, self.obsflux_norm, contdivstd, self.dlam, self.temp, self.logg, self.fe, self.alpha, self.specname, self.outputname + '/') print('Done with wavelength correction!') except Exception as e: print(repr(e)) print( 'Couldn\'t complete wavelength correction for some reason.' ) # Crop observed spectrum into regions around Mn lines self.obsflux_fit, self.obswvl_fit, self.ivar_fit, self.dlam_fit, self.skip = mask_obs_for_abundance( self.obswvl, self.obsflux_norm, self.ivar_norm, self.dlam, lines=self.lines) # Else, check if we need to open a hi-res file to get the spectrum elif hires is not None: # Output filename if self.globular: self.outputname = '/raid/madlr/glob/' + galaxyname + '/' + 'hires' else: self.outputname = '/raid/madlr/dsph/' + galaxyname + '/' + 'hires' # Open observed spectrum self.specname = hires self.obswvl, self.obsflux, self.dlam = open_obs_file( self.obsfilename, hires=True) # Get measured parameters from obsspecial keyword self.temp = obsspecial[0] self.logg = obsspecial[1] self.fe = obsspecial[2] self.alpha = obsspecial[3] self.fe_err = obsspecial[4] self.zrest = obsspecial[5] self.ivar = np.ones(len(self.obsflux)) # Correct for wavelength self.obswvl = self.obswvl / (1. + self.zrest) print('Redshift: ', self.zrest) # Get synthetic spectrum, split both obs and synth spectra into red and blue parts synthfluxmask, obsfluxmask, obswvlmask, ivarmask, mask = mask_obs_for_division( self.obswvl, self.obsflux, self.ivar, temp=self.temp, logg=self.logg, fe=self.fe, alpha=self.alpha, dlam=self.dlam, lines=self.lines, hires=True) # Compute continuum-normalized observed spectrum self.obsflux_norm, self.ivar_norm = divide_spec( synthfluxmask, obsfluxmask, obswvlmask, ivarmask, mask, specname=self.specname, outputname=self.outputname, hires=True) if smooth is not None: # Crop med-res wavelength range to match hi-res spectrum smooth = smooth[np.where((smooth > self.obswvl[0]) & (smooth < self.obswvl[-1]))] # Interpolate and smooth the synthetic spectrum onto the observed wavelength array self.dlam = np.ones(len(smooth)) * 0.7086 self.obsflux_norm = smooth_gauss_wrapper( self.obswvl, self.obsflux_norm, smooth, self.dlam) self.obswvl = smooth self.ivar_norm = np.ones(len(self.obswvl)) * 1.e4 if plot: # Plot continuum-normalized observed spectrum plt.figure() plt.plot(self.obswvl, self.obsflux_norm, 'k-') plt.savefig(self.outputname + '/' + self.specname + '_obsnormalized.png') plt.close() # Crop observed spectrum into regions around Mn lines self.obsflux_fit, self.obswvl_fit, self.ivar_fit, self.dlam_fit, self.skip = mask_obs_for_abundance( self.obswvl, self.obsflux_norm, self.ivar_norm, self.dlam, lines=self.lines, hires=True) # Else, take both spectrum and observed parameters from obsspecial keyword else: # Output filename self.outputname = '/raid/madlr/test/' + slitmaskname self.obsflux_fit = obsspecial[0] self.obswvl_fit = obsspecial[1] self.ivar_fit = obsspecial[2] self.dlam_fit = obsspecial[3] self.skip = obsspecial[4] self.temp = obsspecial[5] self.logg = obsspecial[6] self.fe = obsspecial[7] self.alpha = obsspecial[8] self.fe_err = obsspecial[9] self.specname = self.slitmaskname # Splice together Mn line regions of observed spectra print('Skip: ', self.skip) self.obsflux_final = np.hstack((self.obsflux_fit[self.skip])) self.obswvl_final = np.hstack((self.obswvl_fit[self.skip])) self.ivar_final = np.hstack((self.ivar_fit[self.skip]))
colors = ['#D9853B', '#d62728', '#2ca02c'] for j in raw_motion_data.iterkeys(): fish_id = j motion = raw_motion_data[fish_id][1] bouts, bout_indices = bout_detect(motion) all_bouts[fish_id] = bouts all_bout_indices[fish_id] = bout_indices # Plot the motion and highlight the detected bouts. # Try cycling through colours to see if there is patchy detection. if bout_detection_plot: plt.figure() plt.plot(motion) for ind, i in enumerate(bout_indices): color = colors[ind % len(colors)] plt.axvspan(i[0], i[-1], facecolor=color, alpha=0.5) plt.title("Bout detection for Fish %d" % (fish_id + 1)) plt.xlabel("Time (frames)") plt.ylabel("Raw Motion (a.u.)") # Extract bout parameters from a list of bouts. bout_number, bout_durations, interbout_intervals = bout_params( bouts, bout_indices) all_bout_numbers[fish_id] = bout_number all_bout_durations[fish_id] = bout_durations all_interbout_intervals[fish_id] = interbout_intervals #print bout_number # Plot 1 - Total Bout Number # Plot 2 - Bout Durations PER FISH # Plot 3 - Interbout Intervals PER FISH
def plotSaturation(title, variant, sample_names, data_values, types, verbose=False, hide=False, outputdir='./pictures/'): width = variant.end - variant.start array = variant.members rep = variant.signals original_seed = variant.seed parameters = len(variant.members) fig = plt.figure(figsize=(4, 1)) ax = fig.add_subplot(111) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.xaxis.set_ticks_position('bottom') ax.yaxis.set_ticks_position('left') title_font = { 'fontname': 'Arial', 'size': '15', 'color': 'black', 'weight': 'bold', 'verticalalignment': 'bottom' } # Bottom vertical alignment for more space axis_font = {'fontname': 'Arial', 'size': '15', 'weight': 'bold'} chromosome, start, end, cluster_number = title.split("_") xvalues = np.arange(array.shape[1]) * 10 # ax.set_prop_cycle(color=['grey']) # for i in range(parameters): # ax.plot(xvalues, array[i, :], linewidth=0.1, alpha=0.5) ax.set_prop_cycle(color=['red']) # ax.plot(xvalues, rep, linewidth=0.5, label='representative', alpha=0.5) ax.fill_between(xvalues, 0, rep, alpha=0.5, color='red') peaks = variant.units ####### # if original_seed != []: # ax.set_prop_cycle(color=['blue']) # ax.plot(xvalues, original_seed, linewidth=1, label='seed') # legend = ax.legend(loc='upper right', prop={'size': 2}) # # The frame is matplotlib.patches.Rectangle instance surrounding the legend. # frame = legend.get_frame() # frame.set_facecolor('0.90') # Set the fontsize # for label in legend.get_texts(): # label.set_fontsize(5) # # for label in legend.get_lines(): # label.set_linewidth(0.75) # the legend line width fig.set_tight_layout(True) variant_id = title.replace("_", ".")[3:] if hide: plt.axis('off') else: ax.set_title( chromosome + " " + start + "~" + end + " " + "variant " + str(int(cluster_number[-1]) + 1), **title_font) ax.set_xlabel("bp", **axis_font) ax.set_ylabel("Signal", **axis_font) for p in peaks: plt.axvspan(xmin=p.start - int(start) + width / 100.0, xmax=p.end - int(start) - width / 100.0, ymin=0, ymax=0.05, facecolor='blue', alpha=0.5, edgecolor='black') for type in types: fig.savefig(outputdir + type + '/' + variant_id + '.png', dpi=600, facecolor='w', edgecolor='w', orientation='portrait', bbox_inches='tight') plt.close('all') if verbose: best_sample_index = variant.best_representative_sample() for i in range(len(best_sample_index)): index = best_sample_index[i] sample_name = sample_names[index] output_name = variant_id + " " + sample_name cur_data = data_values[index] plotBestSample(sample_name, output_name, cur_data, xvalues, outputdir, hide) return peaks
plt.loglog(np.asarray(height), H_ions, label='H_ions') plt.loglog(np.asarray(height), He_ions, label='He_ions') plt.loglog(np.asarray(height), O2_ions, label='O2_ions') plt.loglog(np.asarray(height), O_ions, label='O_ions') plt.loglog(np.asarray(height), NO_ions, label='NO_ions') plt.loglog(np.asarray(height), N_ions, label='N_ions') plt.plot(np.asarray(height), neY, label=r'n$_e$ (Yabroff, 1961)', linestyle='--') #print(height,ne) perigeum = 450. apogeum = 720. plt.axvspan(perigeum, apogeum, color='y', alpha=0.5, lw=0) plt.xlabel(r"r (km)") plt.ylabel(r"plasma density (m$^{-3}$)") plt.legend(loc=1, prop={'size': 16}) #plt.title(fname) name = 'ionosphere_' + fname dir = '../IRI/' plt.savefig(dir + name + '.png') plt.show() #f = open('height.dat', 'w') #json.dump(height, f) #f.close()
theta1k10 = phievo[1500:2999,4] theta1k30 = phievo[3000:4499,4] theta1k50 = phievo[4500:5999,4] theta1k80 = phievo[6000:7499,4] theta1k100 = phievo[7500:8999,4] x_tick = [-20,-15,-10,-7.9,-5,0] plt.semilogy(x,deltk1,label=r"$kc/H_0 = 0.1$") plt.semilogy(x,deltk10,label=r"$kc/H_0 = 8.36$") plt.semilogy(x,deltk30,label=r"$kc/H_0 = 85.90$") plt.semilogy(x,deltk50,label=r"$kc/H_0 = 245.1$") plt.semilogy(x,deltk80,label=r"$kc/H_0 = 636.8$") plt.semilogy(x,deltk100,label=r"$kc/H_0 = 1000.0$") plt.text(-7.9, 10000, "Recombination", size=10) plt.axvspan(-7.397193821,-6.421947418, color='red', alpha=0.5) ax.set_xticks(x_tick) ax.set_xticklabels([-20,-15,-10,r"x$_{eq}$",-5,0]) plt.grid() plt.title("Dark Matter Perturbations") plt.xlabel(r'$x$',size=20) plt.ylabel(r"$\delta$",size=20) plt.legend(loc="best") plt.show() plt.plot(x,deltbk1,label=r"$kc/H_0 = 0.1$") plt.plot(x,deltbk10,label=r"$kc/H_0 = 8.36$") plt.plot(x,deltbk30,label=r"$kc/H_0 = 85.90$") plt.plot(x,deltbk50,label=r"$kc/H_0 = 245.1$") plt.plot(x,deltbk80,label=r"$kc/H_0 = 636.8$") plt.plot(x,deltbk100,label=r"$kc/H_0 = 1000.0$")
plt.text(27, ymax - 0.2, "30", color='black', va='top', alpha=0.5) plt.text(42, ymax - 0.2, "44", color='black', va='top', alpha=0.5) plt.text(64, ymax - 0.2, "70", color='black', va='top', alpha=0.5) plt.text(90, ymax - 0.2, "100", color='black', va='top', alpha=0.5) plt.text(135, ymax - 0.2, "143", color='black', va='top', alpha=0.5) plt.text(200, ymax - 0.2, "217", color='black', va='top', alpha=0.5) plt.text(330, ymax - 0.2, "353", color='black', va='top', alpha=0.5) plt.text(490, ymax - 0.2, "545", color='black', va='top', alpha=0.5) plt.text(770, ymax - 0.2, "857", color='black', va='top', alpha=0.5) #plt.text(1100,ymax-0-2,r"240$\mu$m",size=15,color='#CC0000', va='top') #plt.text(1800,ymax-0-2,r"140$\mu$m",size=15,color='#CC0000', va='top') #plt.text(2700,ymax-0-2,r"100$\mu$m",size=15,color='#CC0000', va='top') #plt.axvspan(band_range1[0],band_range1[1],color='red',hatch='+',alpha=0.3,label='DIRBE') #plt.axvspan(band_range2[0],band_range2[1],color='red',hatch='+',alpha=0.3) #plt.axvspan(band_range3[0],band_range3[1],color='red',hatch='+',alpha=0.3) plt.axvspan(band_range4[0], band_range4[1], color='C2', hatch='//', alpha=0.3) plt.axvspan(band_range5[0], band_range5[1], color='C2', hatch='//', alpha=0.3) plt.axvspan(band_range6[0], band_range6[1], color='C2', hatch='//', alpha=0.3) plt.axvspan(band_range7[0], band_range7[1], color='C2', hatch='//', alpha=0.3) plt.axvspan(band_range8[0], band_range8[1], color='C2', hatch='//', alpha=0.3) plt.axvspan(band_range9[0], band_range9[1], color='C2', hatch='//', alpha=0.3) plt.axvspan(band_range10[0], band_range10[1], color='C2', hatch='//', alpha=0.3) plt.axvspan(band_range11[0], band_range11[1], color='C2', hatch='//', alpha=0.3)
import matplotlib.pyplot as plt plt.axvspan(76, 76, facecolor='g', alpha=1) plt.annotate('This is awesome!', xy=(76, 0.75)) #xycoords='data' #textcoords='offset points') #arrowprops=dict(arrowstyle="->")) plt.show()
def _plot_comparison(self, start_idx, length=100, train=True): """Plot the predicted and true output-signals. Args: start_idx: Start-index for the time-series. length: Sequence-length to process and plot. train: Boolean whether to use training- or test-set. Returns: None """ # Initialize key variables datetimes = {} num_train = self.training_rows # End-index for the sequences. end_idx = start_idx + length # Variables for date formatting days = mdates.DayLocator() # Every day months = mdates.MonthLocator() # Every month months_format = mdates.DateFormatter('%b %Y') days_format = mdates.DateFormatter('%d') # Assign other variables dependent on the type of data we are plotting if train is True: # Use training-data. x_values = self._x_train_scaled[start_idx:end_idx] y_true = self._y_train[start_idx:end_idx] shim = 'Train' # Datetimes to use for training datetimes[shim] = self._data.datetime( )[:num_train][start_idx:end_idx] else: # Scale the data x_test_scaled = self._x_scaler.transform( self._data.vectors_test_all()) # Use test-data. x_values = x_test_scaled[start_idx:end_idx] y_true = self._yv_test[start_idx:end_idx] shim = 'Test' # Datetimes to use for testing datetimes[shim] = self._data.datetime( )[num_train:][start_idx:end_idx] # Input-signals for the model. x_values = np.expand_dims(x_values, axis=0) # Use the model to predict the output-signals. y_pred = self._model.predict(x_values) # The output of the model is between 0 and 1. # Do an inverse map to get it back to the scale # of the original data-set. y_pred_rescaled = self._y_scaler.inverse_transform(y_pred[0]) # For each output-signal. for signal in range(len(self._data.labels())): # Assign other variables dependent on the type of data plot if train is True: # Only get current values that are a part of the training data current = self._y_current[:num_train][start_idx:end_idx] # The number of datetimes for the 'actual' plot must match # that of current values datetimes['actual'] = self._data.datetime( )[:num_train][start_idx:end_idx] else: # Only get current values that are a part of the test data. current = self._y_current[num_train:][start_idx:] # The number of datetimes for the 'actual' plot must match # that of current values datetimes['actual'] = self._data.datetime( )[num_train:][start_idx:] # Create a filename filename = ( '/tmp/batch_{}_epochs_{}_training_{}_{}_{}_{}.png').format( self._data.batch_size(), self._data.epochs(), num_train, signal, int(time.time()), shim) # Get the output-signal predicted by the model. signal_pred = y_pred_rescaled[:, signal] # Get the true output-signal from the data-set. signal_true = y_true[:, signal] # Create a new chart (fig, axis) = plt.subplots(figsize=(15, 5)) # Plot and compare the two signals. axis.plot(datetimes[shim][:len(signal_true)], signal_true, label='Current +{}'.format(self._data.labels()[signal])) axis.plot(datetimes[shim][:len(signal_pred)], signal_pred, label='Prediction') axis.plot(datetimes['actual'], current, label='Current') # Set plot labels and titles axis.set_title('{1}ing Forecast ({0} Future Intervals)'.format( self._data.labels()[signal], shim)) axis.set_ylabel('Values') axis.legend(bbox_to_anchor=(1.04, 0.5), loc='center left', borderaxespad=0) # Add gridlines and ticks ax = plt.gca() ax.grid(True) # Add major gridlines ax.xaxis.grid(which='major', color='black', alpha=0.2) ax.yaxis.grid(which='major', color='black', alpha=0.2) # Add minor ticks (They must be turned on first) ax.minorticks_on() ax.xaxis.grid(which='minor', color='black', alpha=0.1) ax.yaxis.grid(which='minor', color='black', alpha=0.1) # Format the tick labels ax.xaxis.set_major_locator(months) ax.xaxis.set_major_formatter(months_format) ax.xaxis.set_minor_locator(days) # Remove tick marks ax.tick_params(axis='both', which='both', length=0) # Print day numbers on xaxis for Test data only if train is False: ax.xaxis.set_minor_formatter(days_format) plt.setp(ax.xaxis.get_minorticklabels(), rotation=90) # Rotates and right aligns the x labels, and moves the bottom of # the axes up to make room for them fig.autofmt_xdate() # Plot grey box for warmup-period if we are working with training # data and the start is within the warmup-period if (0 < start_idx < self._warmup_steps): if train is True: plt.axvspan(datetimes[shim][start_idx], datetimes[shim][self._warmup_steps], facecolor='black', alpha=0.15) # Show and save the image if self.display is True: fig.savefig(filename, bbox_inches='tight') plt.show() else: fig.savefig(filename, bbox_inches='tight') print('> Saving file: {}'.format(filename)) # Close figure plt.close(fig=fig)
def plot_neutrinos_by_year_ara(fluxes, energies, veff_additions, styles=None, years=[ 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 ], stations=[ "ARA 1", "ARA 1-3", "ARA 1-3", "ARA 1-3", "ARA 1-3", "ARA 1-3", "ARA 1-5" ], xlim=None, save_name=None, color_damping=0): plt.figure(figsize=(7, 6)) # plt.axhline(5, ls=':', c='k') # plt.grid(ls='--', c='dimgray', axis='y') detections = {} for flux in fluxes: detections[flux] = [0] for i, year in enumerate(years[1:]): nus = count_neutrinos( fluxes[flux], energies, veff_additions[i], stations=1, years=1) * 1e4 detections[flux].append(np.sum(nus)) uniq = [] for name in stations: if name not in uniq: uniq.append(name) i = 0 c = 0 while i < min(len(stations), len(years)): xmin = years[i] st = stations[i] j = i + 1 while j < len(stations) and stations[j] == st: j += 1 if j == len(stations): xmax = years[-1] else: xmax = years[j] cval = 1 - c / (len(uniq) + color_damping) plt.axvspan(xmin, xmax, color=(cval, cval, cval, 0.15)) plt.annotate(str(stations[i]), xy=(i / (len(years) - 1) + 0.1 / (len(years) - 1), 0.4), xycoords='axes fraction', color='k', rotation=90, verticalalignment='bottom', fontsize=12) i = j c += 1 for flux, counts in detections.items(): if styles is None: style = '.-' color = None ls = None else: style = styles[flux] color = style.rstrip('.-:&') style = style[len(color):] ls = None if style.endswith('&'): style = style[:-1] ls = (0, (5, 10)) line, = plt.plot(years, np.cumsum(counts), style, color=color, label=flux) if ls is not None: line.set_linestyle(ls) plt.xlabel("Year", fontsize=16) plt.ylabel("Expected Number of Neutrinos", fontsize=16) if xlim is None: plt.xlim(years[0], years[-1]) else: plt.xlim(*xlim) # plt.ylim(0, plt.ylim()[1]) plt.ylim(0, 10) plt.axvline(2019, c='k', ls='--') # ticks = plt.xticks()[0] # plt.xticks(ticks[ticks%0==0], [str(int(tick)) for tick in ticks[ticks%1==0]]) plt.xticks([2013, 2015, 2017, 2019, 2021, 2023]) plt.legend(loc=2, fontsize=12) ax1 = plt.gca() ax2 = ax1.twinx() ax2.set_ylim(ax1.get_ylim()) # ax2.set_yticklabels([]) for item in (ax1.get_xticklabels() + ax1.get_yticklabels() + ax2.get_yticklabels()): item.set_fontsize(14) plt.tight_layout() if save_name is not None: plt.savefig(save_name, dpi=300) plt.show()
y = [i] * len(x) if entry[0] == m_start and entry[1] == m_end: plt.plot(x, y, color=darkdarkgreen, linewidth=lw) mat_count += 1 elif entry[0] == s_start and entry[1] == s_end: plt.plot(x, y, color='darkred', linewidth=lw) else: plt.plot(x, y, color='black', linewidth=lw) #%% alpha = 0.25 ymin = 0 if m_start > s_start: plt.axvspan(0.5, s_start - 0.5, color='black', alpha=alpha, zorder=1, ymin=ymin) plt.axvspan(s_start - 0.5, s_end + 0.5, color='firebrick', alpha=alpha, zorder=1, ymin=ymin) plt.axvspan(s_end + 0.5, m_start - 0.5, color='gold', alpha=alpha, zorder=1, ymin=ymin) plt.axvspan(m_start - 0.5,
# In[11]: Df['P/Z'] # In[21]: Initial_gas_in_place = (0 - 2070.38439919) / -148.2874553 Initial_gas_in_place G = Initial_gas_in_place G # In[31]: plt.style.use('seaborn-whitegrid') plt.figure(figsize=(10, 7)) plt.plot(Df['Cumulative Gas Produced Gp(MMMSCF)'][1:700], Df['P/Z'][1:700]) plt.plot(Df['Cumulative Gas Produced Gp(MMMSCF)'][700:2071], Df['P/Z'][700:2071], ls='-.') plt.scatter(x, y, marker='o', color='green', label="Gas Produced Gp") plt.scatter(G, 5, label="Initial Gas in Place G") plt.xlim(0, 18) plt.ylim(1, 2200) plt.axvspan(0, 4, alpha=0.5, label='Production History', color='aquamarine') plt.xlabel("Cumulative Gas Production 'Gp' (MMMSCF)") plt.ylabel("P/Z") plt.title("Gas Material Balance") plt.legend(loc='upper right') plt.show() print("The Gas Initially in place is", G, "MMMSCF")
axPlot = plt.subplot(111) axPlot.set_xlim(-.001, 3) # add titles, labels, and legend plt.title('Velocity Error', fontdict=font) plt.xlabel('Time', fontdict=font) plt.ylabel('Velocity Error', fontdict=font) #plt.legend(loc=4, shadow=True) # annotate rise time (interval) plt.axhspan(set_point - error_band_delta, set_point + error_band_delta, facecolor='0.5', alpha=0.25) plt.axhline(y=set_point - error_band_delta, color='k', linestyle='--') plt.axvspan(0.0, rise_time, facecolor='0.5', alpha=0.25) #plt.axvline(x=rise_time, color='k',linestyle='--') #plt.annotate('rise time', xy=(rise_time-.5, set_point-eps)) # annotate peak_time #plt.axvline(x=peak_time, color='k',linestyle='--') #plt.annotate('peak time', xy=(peak_time+.1, set_point-2*eps)) # annotate overshoot #plt.axhline(y=overshoot, xmin=0, xmax=peak_time,color='k',linestyle='--') #plt.annotate('overshoot', xy=(peak_time, overshoot+eps)) # annotate settling time #plt.axvline(x=settling_time,color='k',linestyle='--') #plt.annotate('settling time', xy=(settling_time, set_point+eps))
EIGENVALUES = np.linalg.eigvalsh(K) if EIGENVALUES.min() <= 0: logging.warning('nonpositive eigenvalue of kernel spotted!') LOG_START = np.floor(np.log10(abs(EIGENVALUES).min())) - 2 LOG_END = np.ceil(np.log10(abs(EIGENVALUES).max())) + 4 REGULARIZATION_PARAMETERS = [0] + list(np.logspace(LOG_START, LOG_END, 100)) CV_ERROR = cv(reconstructor, DF.V, REGULARIZATION_PARAMETERS) idx = np.argmin(CV_ERROR) regularization_parameter = REGULARIZATION_PARAMETERS[idx] plt.figure() plt.title('CV') plt.xscale('symlog', linthreshx=10**LOG_START) plt.axvspan(abs(EIGENVALUES).min(), abs(EIGENVALUES).max(), color=cbf.YELLOW) for x in EIGENVALUES: if x > 0: plt.axvline(x, ls='--', color=cbf.SKY_BLUE) else: plt.axvline(-x, ls='-', color=cbf.VERMILION) plt.plot(REGULARIZATION_PARAMETERS, CV_ERROR, color=cbf.BLUE) plt.axvline(regularization_parameter, ls=':', color=cbf.BLACK) for rp in [0, regularization_parameter]: approximator = reconstructor(DF.V, regularization_parameter=rp) DIPOLES['W'] = approximator.dipole_moments() DIPOLES['WPX'] = DIPOLES.PX * DIPOLES.W DIPOLES['WPY'] = DIPOLES.PY * DIPOLES.W
t1 = np.arange(0.0, 9.0, 0.1) plt.figure(figsize=(16, 4)) sp = plt.subplot(1, 3, 1) plt.xlabel(u"KLOC, тыс. строк/компонент", fontsize=18) plt.ylabel(u"Трудоемкость, чел-мес", fontsize=18) plt.tick_params(axis='x', labelsize=14) plt.tick_params(axis='y', labelsize=14) plt.plot(t1, f1(t1), 'k') plt.ylim((0, y_lim)) plt.title(u"Минимальное", fontsize=18) plt.grid() plt.axvspan(x_begin, x_end, color='grey', alpha=0.3) plt.axhspan(f1(x_begin), f1(x_end), color='grey', alpha=0.3) plt.axhspan(391, 391, color='black', alpha=1) sp1 = plt.subplot(1, 3, 2) plt.xlabel(u"KLOC, тыс. строк/компонент", fontsize=18) plt.ylabel(u"Трудоемкость, чел-мес", fontsize=18) plt.tick_params(axis='x', labelsize=14) plt.tick_params(axis='y', labelsize=14) plt.plot(t1, f2(t1), 'k') plt.ylim((0, y_lim)) plt.title(u"Усредненное", fontsize=18) plt.axvspan(x_begin, x_end, color='grey', alpha=0.3) plt.axhspan(f2(x_begin), f2(x_end), color='grey', alpha=0.3)
def plot_effects(self, sub=None, bottom=0, top=None): # plots variance ratio (variance first group/variance second group) and Cohen's d ((mean first group - mean second group)/pooled standard deviation) across epochs if not sub: sub = range(self.masks) assert len( sub ) == 2, "Number of groups must be 2, got %.0f. Specify sub parameter." % len( sub) if not top: top = self.epochs assert [type(x) for x in [bottom, top] ] == [int, int], 'bottom and top must be of type int, got %s' % str( [type(x) for x in [bottom, top]]) vr = self.get_vr(sub=sub, bottom=bottom, top=top) d = self.get_d(sub=sub, bottom=bottom, top=top) fig = plt.figure() plt.suptitle(self.name, fontsize=30) ax1 = fig.add_subplot(111) line1 = ax1.plot(range(bottom, top), vr, color='black', linestyle='solid', label='Variance ratio') ax1.set_xlabel('Epoch', fontsize=28) ax1.set_ylabel('Variance ratio', fontsize=28) ax2 = ax1.twinx() line2 = ax2.plot(range(bottom, top), d, color='black', linestyle='dotted', label='Cohen\'s d') ax2.set_ylabel('Cohen\'s d', fontsize=28) fig = plt.gca() fig.tick_params(axis='x', which='major', width=1, length=7, labelsize=24) lns = line1 + line2 labs = [l.get_label() for l in lns] plt.legend(lns, labs, loc=4, prop={'size': 28}) leg = fig.get_legend() llines = leg.get_lines() plt.setp(llines, linewidth=2.0) for bin in self.get_conditional_bins(sub=sub, bottom=bottom, top=top): plt.axvspan(bin[0], bin[1], alpha=0.3, facecolor='gray', edgecolor='none') if len(sub) == 2: for bin in self.get_conditional_bins(sub=sub[::-1], bottom=bottom, top=top): plt.axvspan(bin[0], bin[1], alpha=0.3, facecolor='red', edgecolor='none')
time = np.linspace(0,0.5, 50) pts = np.zeros(50, dtype=np.float64) pts[10:40] = 0.5 pts[40:] = 1 spline_interpolation_(pts) plt.plot(time, pts*100) plt.xticks([0.1, 0.4], [r'$t_{HS}$', r'$t_{TO}$']) plt.axvline(0.1, ls=':', color='black') plt.axvline(0.4, ls=':', color='black') plt.title('Percentage of force applied on one foot') plt.xlabel('Time [s]') plt.ylabel('Distribution of force on one foot [%]') plt.axvspan(0.1, 0.4, facecolor='gray', alpha=0.2) plt.text(0.05, 15, 'Swinging\nfoot', horizontalalignment='center') plt.text(0.25, 15, 'Double stance\nphase', horizontalalignment='center') plt.text(0.45, 15, 'Stance\nfoot', horizontalalignment='center') x = np.linspace(0,1.2,100) y = 0.5 * (np.tanh(-np.pi*(2*(x-0.15)-0.85)/0.85)+1) plt.figure() plt.plot(x, y) plt.xticks([0.15, 1], [r'$u_{th}$', '1']) plt.axvline(0.15, ls=':', color='black') plt.axvline(1, ls=':', color='black') plt.title('Smoothing function') plt.xlabel('Input ratio') plt.ylabel('Smoothed ratio')
def plot_line_chart(self, sub=None, bottom=0, top=None, yaxis=[None, None], is_subplot=False): """ plot mean error over epochs for each mask, show variance as error bars Args: sub: list of integers, specifies a subsample of the masks Returns: None """ if not sub: sub = range(self.masks) if not top: top = self.epochs assert [type(x) for x in [bottom, top] ] == [int, int], 'bottom and top must be of type int, got %s' % str( [type(x) for x in [bottom, top]]) if not is_subplot: plt.figure() plt.xlabel('Epoch', fontsize=28, labelpad=15) plt.ylabel('Mean squared error', fontsize=28, labelpad=15) plt.suptitle(self.name, fontsize=30) for i in sub: mean = self.mean[i, :] var = self.std[i, :] plt.plot(range(bottom, top), mean[bottom:top], color=self.colors[i], label=self.labels[i], linewidth=5.0) plt.fill_between(range(bottom, top), mean[bottom:top] - var[bottom:top], mean[bottom:top] + var[bottom:top], alpha=0.2, facecolor=self.colors[i]) plt.axis([bottom, top, yaxis[0], yaxis[1]]) fig = plt.gca() fig.tick_params(axis='both', which='major', width=1, length=7, labelsize=24) plt.legend(prop={'size': 28}) leg = fig.get_legend() llines = leg.get_lines() plt.setp(llines, linewidth=5.0) for bin in self.get_conditional_bins(sub=sub, bottom=bottom, top=top): plt.axvspan(bin[0], bin[1], alpha=0.2, facecolor='grey', edgecolor='none')
def plot_d(self, sub=None, bottom=0, top=None, add_lines=None, add_lables=[None], linestyles=['solid'], long_title=False): if not sub: sub = range(self.masks) assert len( sub ) == 2, "Number of groups must be 2, got %.0f. Specify sub parameter." % len( sub) if not top: top = self.epochs assert [type(x) for x in [bottom, top] ] == [int, int], 'bottom and top must be of type int, got %s' % str( [type(x) for x in [bottom, top]]) d = self.get_d(sub=sub, bottom=bottom, top=top) plt.figure() plt.xlabel('Epoch', fontsize=28, labelpad=15) plt.ylabel('Cohen\'s d', fontsize=28, labelpad=15) if long_title: plt.suptitle("%s\n%s vs. %s" % (self.name, self.labels[sub[0]], self.labels[sub[1]]), fontsize=30) else: plt.suptitle(self.name, fontsize=30) plt.subplots_adjust(top=0.9) plt.plot(range(bottom, top), d, c='black', linewidth=2.0, label=add_lables[0], linestyle=linestyles[0]) fig = plt.gca() if add_lines: for idx, line in enumerate(add_lines): plt.plot(range(bottom, top), line, c='black', linewidth=2.0, label=add_lables[idx + 1], linestyle=linestyles[idx + 1]) plt.legend(prop={'size': 28}) leg = fig.get_legend() llines = leg.get_lines() plt.setp(llines, linewidth=2.0) fig.tick_params(axis='both', which='major', width=1, length=7, labelsize=24) for bin in self.get_conditional_bins(sub=sub): plt.axvspan(bin[0], bin[1], alpha=0.3, facecolor='gray', edgecolor='none') if len(sub) == 2: for bin in self.get_conditional_bins(sub=sub[::-1], bottom=bottom, top=top): plt.axvspan(bin[0], bin[1], alpha=0.3, facecolor='red', edgecolor='none')
test_y = test_y.reshape((len(test_y), 1)) inv_y = concatenate((test_y, test_X[:, -(len(series.columns) - 2):]), axis=1) inv_y = scaler.inverse_transform(inv_y) inv_y = inv_y[:, 0] pyplot.clf() pyplot.plot(inv_y, label='actual') pyplot.plot(inv_yhat, label='predicted') pyplot.xlabel('Test Samples', color='#1C2833') pyplot.ylabel('Values', color='#1C2833') pyplot.title('Actual vs Predicted Values (' + str(originalTestSamples) + ' Test Samples):' + currentFeatureName) pyplot.legend() pyplot.axvspan(originalTestSamples, len(test_y), alpha=0.5, color='yellow') pyplot.savefig(outfolder + "Out\\ActualVsPredictedValues.png", bbox_inches='tight', dpi=100) pyplot.show() inv_yhat_df = pd.DataFrame(inv_yhat) inv_y_df = pd.DataFrame(inv_y) # print out all actual vs predicted values (inclusive of horizon steps into future) inv_yhat_df.to_excel(outfolder + r'Out\\Predicted.xlsx', index=False) inv_y_df.to_excel(outfolder + r'Out\\Actual.xlsx', index=False) rmse = sqrt(mean_squared_error(inv_y, inv_yhat)) writeAccuracyFile = open(outfolder + "Out\\TESTRMSE.txt", "w")
import numpy as np import matplotlib.pyplot as ploty from scipy.signal import medfilt import matplotlib.lines as mlines import matplotlib.patches as mpatches #plot entire signal x and night time ploty.figure(10) ploty.plot(range(0, len(x_axis)), x_axis, 'b-') ploty.ylabel('g') ploty.xlabel('samples') #ploty.axis([0,len(x_axis),-6,6]) ploty.title('neki' + ' x axis') ploty.xticks(range(0, len(x_axis), 10), [str(x) + " h" for x in range(0, 10)]) ploty.axvspan(first_night_begin_index, first_night_end_index, facecolor='b', alpha=0.5) ploty.axvspan(second_night_begin_index, second_night_end_index, facecolor='b', alpha=0.5) blue_shade = mpatches.Patch(color='blue', alpha=0.5, label='night (21.00:7.00)') ploty.legend(handles=[blue_shade]) red_mark = mlines.Line2D([], [], color='red', linewidth=1, linestyle='-', label='no wear') ploty.legend(handles=[red_mark])
def test_axvspan(): ax = plt.subplot(projection="polar") span = plt.axvspan(0, np.pi / 4) assert span.get_path()._interpolation_steps > 1
def main(): first_second, last_second = start_end_second() intervals = [ ] #used to separate packet loss between congested and uncongested periods raw_ts_far = [] raw_ts_near = [] path = '' x_label = 'UTC Time' y_label = 'RTT 15-min \nminimums (ms)' yaxislow = 15 yaxishigh = 45 in_files = str(sys.argv[1]) number_files = in_files.count(' ') + 1 packet_high = 40 packet_low = -0.1 msize = 12 alfa = 1 #first_second = 0 # last_second = 1494201600 + int(5.75* 86400) #end time x axis if (number_files == 0): sys.stderr.write('No files were provided\n') elif (number_files > 5): sys.stderr.write( 'more than 5 files provided. Will plot first 2. files provided:') sys.stderr.write(str(sys.argv[1])) number_files = 5 #Read all filenames provided for j in range(number_files): #print "j = " + str(j) plotx = [] ploty = [] #Get information about file from inputs filename = in_files.split(' ')[j] #series labels if j == 0: s_label = 'Far RTT' month = filename.split('/')[-1].split('.')[2] monitor = filename.split('/')[-1].split('.')[0] #create output directory output_dir = "/project/comcast-ping/kabir-plots/loss_data/supplemental_data/ddc/ndt" #dir_creation = "mkdir -p " + output_dir #raw_plot_data = output_dir + '/' + in_files.split(' ')[0].split('/')[-1] + '.txt' #os.system(dir_creation) #raw = open (raw_plot_data, 'w+') #sys.stderr.write('opened ' + + ' for writing \n') elif j == 1: s_label = 'congestion periods' elif j == 2: s_label = 'Near RTT' elif j == 3: s_label = 'Download Throughput' else: s_label = 'Upload Throughput' #file_path = path + monitor + '/' + month + '/' file_path = '' filename = file_path + in_files.split(' ')[j] if j == 1 or j == 3 or j == 4: f = open(filename, 'rb') #import file g = open(filename, 'rb') #import fi if j == 0 or j == 2: #The time series files command = "gunzip -f " + filename os.system(command) f = open(filename, 'rb') #import file1 g = open(filename, 'rb') #import fi data = g.readlines() ploty, plotx = filter_minimums(data, first_second, last_second) #print plotx[0] #print plotx[-1] #print "y values" #print ploty[0] #print ploty[-1] command = "gzip -f " + filename os.system(command) elif j > 2: plotx = [] ploty = [] sys.stderr.write('reading time series file %s\n' % filename) if j == 0: #space-separated file reader = csv.reader(f, delimiter=' ') #read file into variable reader fig = plt.figure(1, figsize=(12, 8)) else: reader = csv.reader(f, delimiter=' ') #Read values from file for row in reader: if float(row[0]) < first_second: continue if float(row[0]) > last_second: break secs = mdate.epoch2num(float(row[0])) if j == 1: secs2 = mdate.epoch2num(float(row[1])) #plt.axvline(x=secs, color='g') #plt.axvline(x=secs2, color='r') plt.axvspan(secs, secs2, facecolor='gray', alpha=0.5) intervals.append([int(row[0]), int(row[1]) ]) #append intervals to compute loss elif j == 2: #near ts secs3 = mdate.epoch2num(float(row[0])) y = float(row[1]) #plotx.append(secs3) #ploty.append(y) elif j == 3: #far loss secs3 = mdate.epoch2num(float(row[0])) y = float(row[1]) raw_ts_far.append(int(row[0])) plotx.append(secs3) ploty.append(y) elif j == 4: #near loss secs3 = mdate.epoch2num(float(row[0])) y = float(row[2]) #upload throughput raw_ts_near.append(int(row[0])) plotx.append(secs3) ploty.append(y) if j == 0: fig = plt.figure(1, figsize=(9, 6)) ax = fig.add_subplot(211) title = in_files.split(' ')[0].split("/")[-1] #ax.set_title(title) s_color = 'b-' #bigger marker for levelshift ax.plot_date(plotx, ploty, s_color, alpha = alfa, \ marker = ".", markersize = msize, label = s_label, lw = 0) ax.set_xlabel(x_label) ax.set_ylabel(y_label) ax.set_ylim([yaxislow, yaxishigh]) ax.autoscale_view() #artificial limit below ax.set_xlim([ datetime.date(year, first_month, first_day), datetime.datetime(year, second_month, first_day + 4, 6) ]) date_fmt = '%m-%d-%y' # Use a DateFormatter to set the data to the correct format date_formatter = mdate.DateFormatter(date_fmt) ax.xaxis.set_major_formatter(date_formatter) if j == 2: s_color = 'r-' ax.plot_date(plotx, ploty, s_color, alpha = alfa, \ marker = ".", markersize = msize, label = s_label, lw=0) ax.set_xlim([ datetime.date(year, first_month, first_day), datetime.datetime(year, second_month, first_day + 4, 6) ]) ax.legend(fontsize=14, framealpha=0.8) if j == 3: ax = fig.add_subplot(212) s_color = 'k-' ax.plot_date(plotx, ploty, s_color, alpha = alfa, \ marker = ".", markersize = msize, label = s_label, lw=0) ax.set_xlabel(x_label) ax.set_ylabel("Throughput \n (Mbps)") yaxishigh = packet_high yaxislow = packet_low ax.set_ylim([yaxislow, yaxishigh]) ax.autoscale_view() # Choose your xtick format string date_fmt = '%H:%M' #date_fmt = '%m-%d-%y' # Use a DateFormatter to set the data to the correct format date_formatter = mdate.DateFormatter(date_fmt) ax.xaxis.set_major_formatter(date_formatter) ax.set_xlim([ datetime.date(year, first_month, first_day), datetime.datetime(year, second_month, first_day + 4, 6) ]) for k in range(len(intervals)): secs = mdate.epoch2num(float(intervals[k][0])) secs2 = mdate.epoch2num(float(intervals[k][1])) #plt.axvline(x=secs, color='g') #plt.axvline(x=secs2, color='r') plt.axvspan(secs, secs2, facecolor='gray', alpha=0.5) ''' string = 'far' plt.axvline(x=mdate.epoch2num(intervals[k][0]), color='g') plt.axvline(x=mdate.epoch2num(intervals[k][1]), color='r') this_period_lost = 0 this_period_sent = 0 this_period_loss = 0 next_period_lost = 0 next_period_sent = 0 next_period_loss = 0 next_interval = [] for l in range(len(raw_ts_far)): if is_in_window(raw_ts_far[l], intervals[k][0], intervals[k][1]): this_period_lost = this_period_lost + ploty[l][0] this_period_sent = this_period_sent + ploty[l][1] if k < (len(intervals)-1): #all but last congestion interval if is_in_window(raw_ts_far[l], intervals[k][1], intervals[k+1][0]): next_period_lost = next_period_lost + ploty[l][0] next_period_sent = next_period_sent + ploty[l][1] string = string + ',' + convert_to_ht(intervals[k][0])#save interv begin/end string = string + ',' + convert_to_ht(intervals[k][1]) string = string + ',' + str(this_period_lost) string = string + ',' + str(this_period_sent) if this_period_sent > 0 and this_period_lost > 0: this_period_loss = 100*float(this_period_lost) / float(this_period_sent) this_central_interval = central_limit(this_period_lost, this_period_sent) this_interval = proportion_confint(this_period_lost, this_period_sent) else: this_period_loss = 0.0 this_central_interval = [0.0, 0.0] this_interval = [0.0, 0.0] string = string + ',' + str(round(this_period_loss,3)) upper = 100 * this_interval[1] + this_period_loss lower = -100. * this_interval[0] + this_period_loss #print this_interval string = string + ',' + str(round(upper,3)) string = string + ',' + str(round(lower,3)) #save central limit intervals for forensics string = string + ',' + \ str(round( 100*(this_central_interval[1]) + this_period_loss ,3)) string = string + ',' + \ str(round(( -100.*this_central_interval[0] + this_period_loss ),3)) this_x = mdate.epoch2num(float(intervals[k][0]+ 0.5*(intervals[k][1]-intervals[k][0]))) raw.write(string + '\n') if k < (len(intervals)-1): #Save next interval info string = 'far' string = string + ',' + convert_to_ht(intervals[k][1]) string = string + ',' + convert_to_ht(intervals[k+1][0]) string = string + ',' + str(next_period_lost) string = string + ',' + str(next_period_sent) if next_period_sent > 0 and next_period_lost > 0: next_period_loss = 100*float(next_period_lost) \ / float(next_period_sent) next_central = central_limit(next_period_lost, next_period_sent) next_interval = proportion_confint(next_period_lost, next_period_sent) else: next_period_loss = 0.0 next_central = [0.0, 0.0] next_interval = [0.0, 0.0] string = string + ',' + str(round(next_period_loss,3)) upper_n = 100 * next_interval[1] + next_period_loss lower_n = -100. * next_interval[0] + next_period_loss string = string + ',' + str(round(upper_n,3)) string = string + ',' + str(round(lower_n,3)) upper_n_central = 100 * next_central[1] + next_period_loss lower_n_central = -100. * next_central[0] + next_period_loss string = string + ',' + str(round(upper_n_central,3)) string = string + ',' + str(round(lower_n_central,3)) raw.write(string + '\n') #print this_interval next_x = mdate.epoch2num(float(intervals[k][1]+ 0.5*(intervals[k+1][0] - intervals[k][1]))) if k == 0: ax.plot_date(this_x, this_period_loss, \ color = s_color, alpha = 1, \ marker = "^", markersize = msize, label = s_label) label_s = 'far conf. interval' ax.plot_date([this_x,this_x], [lower, upper], \ color = s_color, alpha = 1, \ marker = "+", markersize = msize, label = label_s) else: ax.plot_date(this_x, this_period_loss, \ color = s_color, alpha = 1, \ marker = "^", markersize = msize) ax.plot_date([this_x,this_x], [lower, upper], \ color = s_color, alpha = 1, \ marker = "+", markersize = msize) if k < len(intervals)-1: ax.plot_date([next_x,next_x], [lower_n, upper_n], \ color = s_color, alpha = 1, \ marker = "+", markersize = msize) ax.plot_date(next_x, next_period_loss, \ color = s_color, alpha = 1, \ marker = "^", markersize = msize) #plot triangle and bars at 1/3 of distance between beginning and end of interval ax.set_xlim([datetime.date(year, month_p, first_day), datetime.date(year, month_p, last_day)]) ''' if j == 4: s_color = 'g' #ax.plot_date(plotx, ploty, color = s_color, alpha = alfa, \ # marker = ".", markersize = msize, label = s_label) ''' for k in range(len(intervals)): this_period_lost = 0 this_period_sent = 0 this_period_loss = 0 next_period_lost = 0 next_period_sent = 0 next_period_loss = 0 next_interval = [] for l in range(len(raw_ts_near)): if is_in_window(raw_ts_near[l], intervals[k][0], intervals[k][1]): this_period_lost = this_period_lost + ploty[l][0] this_period_sent = this_period_sent + ploty[l][1] if k < (len(intervals)-1): if is_in_window(raw_ts_near[l], intervals[k][1], intervals[k+1][0]): next_period_lost = next_period_lost + ploty[l][0] next_period_sent = next_period_sent + ploty[l][1] string = 'near' if this_period_sent > 0 and this_period_lost > 0: this_period_loss = 100*float(this_period_lost) / float(this_period_sent) this_central_interval = central_limit(this_period_lost, this_period_sent) this_interval = proportion_confint(this_period_lost, this_period_sent) else: this_period_loss = 0.0 this_central_interval = [0.0, 0.0] this_interval = [0.0, 0.0] upper = 100 * (this_interval[1]) + this_period_loss lower = (-100. * this_interval[0]) + this_period_loss string = string + ',' + convert_to_ht(intervals[k][0])#save interv begin/end string = string + ',' + convert_to_ht(intervals[k][1]) string = string + ',' + str(this_period_lost) string = string + ',' + str(this_period_sent) string = string + ',' + str(round(this_period_loss,3)) string = string + ',' + str(round(upper,3)) string = string + ',' + str(round(lower,3)) string = string + ',' + \ str(round( 100*(this_central_interval[1] + this_period_loss) ,3)) string = string + ',' + \ str(round((-100.*this_central_interval[0] + this_period_loss),3)) raw.write(string + '\n') #print this_interval this_x = mdate.epoch2num(float(intervals[k][0]+ 0.5*(intervals[k][1]-intervals[k][0]))) if k < (len(intervals)-1): string = 'near' if next_period_sent > 0 and next_period_lost > 0: next_period_loss = 100*float(next_period_lost) / float(next_period_sent) next_interval = proportion_confint(next_period_lost, next_period_sent) next_central_interval = central_limit(next_period_lost, next_period_sent) else: next_period_loss = 0.0 next_central_interval = [0.0, 0.0] next_interval = [0.0, 0.0] upper_n = 100 * next_interval[1] + next_period_loss lower_n = -100. * next_interval[0] + next_period_loss upper_central_n = 100 * next_central_interval[1] + next_period_loss lower_central_n = -100. * next_central_interval[0] + next_period_loss string = string + ',' + convert_to_ht(intervals[k][1])#save interv begin/end string = string + ',' + convert_to_ht(intervals[k+1][0]) string = string + ',' + str(next_period_lost) string = string + ',' + str(next_period_sent) string = string + ',' + str(round(next_period_loss,3)) string = string + ',' + str(round(upper_n,3)) string = string + ',' + str(round(lower_n,3)) string = string + ',' + str(round(upper_central_n,3)) string = string + ',' + str(round(lower_central_n,3)) raw.write(string + '\n') #print this_interval next_x = mdate.epoch2num(float(intervals[k][1]+ 0.5*(intervals[k+1][0] - intervals[k][1]))) if k == 0: ax.plot_date(this_x, this_period_loss, \ color = s_color, alpha = 1, \ marker = "^", markersize = msize, label = s_label) label_s = 'near conf. interval' ax.plot_date([this_x,this_x], [lower, upper], \ color = s_color, alpha = 1, \ marker = "+", markersize = msize, label = label_s) else: ax.plot_date(this_x, this_period_loss, \ color = s_color, alpha = 1, \ marker = "^", markersize = msize) ax.plot_date([this_x,this_x], [lower, upper], \ color = s_color, alpha = 1, \ marker = "+", markersize = msize) if k < (len(intervals)-1): ax.plot_date([next_x,next_x], [lower_n, upper_n], \ color = s_color, alpha = 1, \ marker = "+", markersize = msize) ax.plot_date(next_x, next_period_loss, \ color = s_color, alpha = 1, \ marker = "^", markersize = msize) ''' #plot triangle and bars at 1/3 of distance between beginning and end of interval #ARTIFICIAL LIMIT BELOW ax.set_xlim([ datetime.date(year, first_month, first_day), datetime.datetime(year, second_month, first_day + 4, 6) ]) plt.axhline(y=0, color='gray') ax.legend(fontsize=14, framealpha=0.8) fig.autofmt_xdate() fig.tight_layout() output_dir = "/project/comcast-ping/kabir-plots/loss_data/supplemental_data/ddc/ndt" #+ monitor + '/' + month dir_creation = "mkdir -p " + output_dir os.system(dir_creation) output = output_dir + '/' + filename + '.pdf' sys.stderr.write("saving " + output) fig.savefig(output, transparent=True)
# Let's plot the histogram as well as some standard values such as mean # upper, and lower value and the one-sigma range. plt.figure() # Note that we have to use ``.ravel()`` here to avoid matplotlib interpreting each # row in the array as a different dataset to histogram. plt.hist(aia_smap.data.ravel(), bins=bins, label='Histogram', histtype='step') plt.xlabel('Intensity') plt.axvline(aia_smap.min(), label='Data min={:.2f}'.format(aia_smap.min()), color='black') plt.axvline(aia_smap.max(), label='Data max={:.2f}'.format(aia_smap.max()), color='black') plt.axvline(aia_smap.data.mean(), label='mean={:.2f}'.format(aia_smap.data.mean()), color='green') one_sigma = np.array([aia_smap.data.mean() - aia_smap.data.std(), aia_smap.data.mean() + aia_smap.data.std()]) plt.axvspan(one_sigma[0], one_sigma[1], alpha=0.3, color='green', label='mean +/- std = [{:.2f}, {:.2f}]'.format( one_sigma[0], one_sigma[1])) plt.axvline(one_sigma[0], color='green') plt.axvline(one_sigma[1], color='red') plt.yscale('log') plt.legend(loc=9) ############################################################################### # Finally let's overplot the one-sigma contours. plt.figure() aia_smap.plot() levels = one_sigma / aia_smap.max() * u.percent * 100 aia_smap.draw_contours(levels=levels, colors=['blue']) plt.show()
plt.grid(True) ax.set_ylim([0, 1]) plt.plot(history.history["val_loss"], label="val_loss", linewidth=2.0) plt.plot(history.history["loss"], label="loss", linewidth=2.0) plt.plot(history.history["val_acc"], label="val_acc", linewidth=2.0) plt.plot(history.history["acc"], label="acc", linewidth=2.0) plt.legend(bbox_to_anchor=(1.0, 1), loc=2, borderaxespad=0.) plt.text( 0, 0.5, "acc: %.2f loss: %.2f\nval_acc: %.2f val_loss: %.2f" % (history.history["acc"][-1], history.history["loss"][-1], history.history["val_acc"][-1], history.history["val_loss"][-1]), fontsize=20) plt.text(0, 0.1, "at_%s: %.2f (epoch-%d)" % (idk, va, index[0]), fontsize=20) plt.axvspan(index[0], index[0], color='red', alpha=1) plt.savefig("training.png") # In[ ]: md.load_weights("../working/weights-improvement-top.hdf5") # In[ ]: rst = (md.predict(data_cleaner[1])) rta = [] for t in rst: rta.append(int(round(t[0]))) test_dat = pd.read_csv("../input/test.csv") a = pd.Series(test_dat["PassengerId"], name='PassengerId') b = pd.Series(rta, name='Survived')
facecolor(fc):mpl颜色规则 linestyle(ls):[‘solid’ | ‘dashed’, ‘dashdot’, ‘dotted’ | (offset, on-off-dash-seq) | '-' | '--' | '-.' | ':' | 'None' | ' ' | ''] linewidth(lw):float or None for default ''' #例 import numpy as np import matplotlib.pyplot as plt t = np.arange(-1, 2, .01) s = np.sin(2 * np.pi * t) plt.plot(t, s) l = plt.axhline(linewidth=8, color='#d62728') #在y=0处画一条粗红横线,它跨越了xrange l = plt.axhline(y=1) #在y=1处画一条默认的水平线,横跨xrange l = plt.axvline(x=1) #在x=1处画一条默认的垂直线,横跨yrange #在x = 0处画一条粗蓝色的垂直线,它跨越了yrange的上象限 l = plt.axvline(x=0, ymin=0.75, linewidth=8, color='#1f77b4') #在y =0.5上画一个默认的hline。它跨越了axes中间的一半 l = plt.axhline(y=.5, xmin=0.25, xmax=0.75) p = plt.axhspan(0.25, 0.75, facecolor='0.5', alpha=0.5) p = plt.axvspan(1.25, 1.55, facecolor='#2ca02c', alpha=0.5) plt.axis([-1, 2, -1, 2]) plt.show()
def savehist(data, snname, Zs, nsample, i, path, nmeas, measnames, verbose=False, fs=24): global BINMODE #global NOPLOT name = '%s_n%d_%s_%d' % ((snname, nsample, Zs, i + 1)) outdir = os.path.join(path, 'hist') outfile = os.path.join(outdir, name + ".pdf") if not NOPLOT: fig = plt.figure(figsize=(11, 8)) plt.clf() ####kill outliers, infinities, and bad distributions### data = data[np.isfinite(data)] n = data.shape[0] kde = None if not n > 0: if verbose: print "data must be an actual distribution (n>0 elements!, %s)" % Zs return "-1,-1,_1", [], kde if data.shape[0] <= 0 or np.sum(data) <= 0: print '{0:15} {1:20} {2:>13d} {3:>7d} {4:>7d} '.format( snname, Zs, -1, -1, -1) return "-1, -1, -1", [], kde try: ###find C.I.### median, pc16, pc84 = np.percentile(data, [50, 16, 84]) std = np.std(data) left = pc16 right = pc84 maxleft = median - std * 5 maxright = median + std * 5 if "%2f" % maxright == "%2f" % maxleft: maxleft = median - 1 maxright = median + 1 if round(right, 6) == round(left, 6) and round(left, 6) == round( median, 6): print '{0:15} {1:20} {2:>13.3f} -{3:>7.3f} +{4:>7.3f} (no distribution)'.format( snname, Zs, median, 0, 0) return "%f\t %f\t %f" % (round(median, 3), round( median - left, 3), round(right - median, 3)), data, kde #"-1,-1,-1",[] ###print out the confidence interval### print '{0:15} {1:20} {2:>13.3f} -{3:>7.3f} +{4:>7.3f}'.format( snname, Zs, round(median, 3), round(median - left, 3), round(right - median, 3)) alpha = 1.0 ######histogram###### if BINMODE == 'kd': ##if sklearn is available use it to get Kernel Density try: from sklearn.neighbors import KernelDensity except ImportError: print '''sklearn is not available, thus we cannot compute kernel density. switching to bayesian blocks''' BINMODE = 'bb' if BINMODE == 'kd': ##bw is chosen according to Silverman 1986 bw = 1.06 * std * n**(-0.2) numbin, bm = getbinsize(data.shape[0], data) distrib = np.histogram(data, bins=int(numbin), density=True) ###make hist### counts, bins = distrib[0], distrib[1] widths = np.diff(bins) countsnorm = counts / np.max(counts) if bw > 0: kde = KernelDensity(kernel='gaussian', bandwidth=bw).fit(data[:, np.newaxis]) kdebins = np.linspace(maxleft, maxright, 1000)[:, np.newaxis] log_dens = kde.score_samples(kdebins) dens = np.exp(log_dens) norm = countsnorm.sum() * (bins[1] - bins[0]) / dens.sum() / ( kdebins[1] - kdebins[0]) if not NOPLOT: plt.fill(kdebins[:, 0], dens * norm, fc='#7570b3', alpha=0.8) alpha = 0.5 ###find appropriate bin size### else: if BINMODE == 'bb': ##if astroML is available use it to get Bayesian blocks bm = 0 try: from astroML.plotting import hist as amlhist if BINMODE == 'bb': distrib = amlhist(data, bins='blocks', normed=True) if not NOPLOT: plt.clf() except ImportError: print "bayesian blocks for histogram requires astroML to be installed" print "defaulting to Knuth's rule " ##otherwise numbin, bm = getbinsize(data.shape[0], data) distrib = np.histogram(data, bins=int(numbin), density=True) else: numbin, bm = getbinsize(data.shape[0], data) distrib = np.histogram(data, numbin, density=True) ###make hist### counts, bins = distrib[0], distrib[1] widths = np.diff(bins) countsnorm = counts / np.max(counts) ###plot hist### if NOPLOT: return "%f\t %f\t %f" % (round(median, 3), round( median - left, 3), round(right - median, 3)), data, kde plt.bar(bins[:-1], countsnorm, widths, color=['gray'], alpha=alpha) plt.minorticks_on() plt.gca().xaxis.set_major_formatter(FormatStrFormatter('%.2f')) plt.xlim(maxleft, maxright) #the following lines assure the x tick label is #within the length of the x axis xticks = plt.xticks()[0] dx = xticks[-1] - xticks[-2] xticks = xticks[(xticks < maxright) * (xticks > maxleft)] if (maxright - xticks[-1]) < 0.25 * dx: maxright = maxright + 0.25 * dx maxleft = maxleft - 0.25 * dx plt.xlim(maxleft, maxright) plt.xticks(xticks, ['%.2f' % s for s in xticks]) plt.ylim(0, 1.15) plt.yticks(np.arange(0.2, 1.3, 0.2), ["%.1f" % x for x in np.arange(0.2, 1.1, 0.2)]) plt.axvspan(left, right, color='DarkOrange', alpha=0.4) plt.axvline(x=median, linewidth=2, color='white', ls='--') #labels and legends st = '%s ' % (snname) plt.annotate(st, xy=(0.13, 0.6), xycoords='axes fraction', size=fs, fontweight='bold') st = '%s ' % (Zs.replace('_', ' ')) plt.annotate(st, xy=(0.61, 0.93), xycoords='axes fraction', fontsize=fs, fontweight='bold') st = 'measurement %d of %d\n %s\nmedian: %.3f\n16th Percentile: %.3f\n84th Percentile: %.3f' % ( i + 1, nmeas, measnames[i], round(median, 3), round( left, 3), round(right, 3)) plt.annotate(st, xy=(0.61, 0.65), xycoords='axes fraction', fontsize=fs) effectiven = len(data[~np.isnan(data)]) if effectiven: st = 'MC sample size %d (%d)\nhistogram rule: %s' % ( effectiven, nsample, binning[BINMODE]) if bm: if effectiven < nsample: st = 'MC sample size %d (%d)\nhistogram rule: %s' % ( effectiven, nsample, binning[bm]) else: st = 'MC sample size %d\nhistogram rule: %s' % (nsample, binning[bm]) plt.annotate(st, xy=(0.61, 0.55), xycoords='axes fraction', fontsize=fs - 5) if "E(B-V)" in Zs: plt.xlabel('E(B-V) [mag]') outfile = outfile.replace('(', '').replace(')', '') elif "logR23" in Zs: plt.xlabel('logR23') else: plt.xlabel('12+log(O/H)') plt.ylabel('relative counts') plt.savefig(outfile, format='pdf') plt.close(fig) return "%f\t %f\t %f" % (round(median, 3), round( median - left, 3), round(right - median, 3)), data, kde except (OverflowError, AttributeError, ValueError): if VERBOSE: print data print name, 'had infinities (or something in plotting went wrong)' return "-1, -1,-1", [], None
#plt.hist(hist) #Plot values on histogram #plt.scatter(x,y) #Plot points on scatter graph fig = plt.figure(figsize=(25, 10)) #Create 25 x 10 figure ax = fig.add_subplot(111) # ax.bar(x, y) #Create a bar graph in the subplot ax.bar(y, x, color='red') #Append an additional bar graph in the subplot ax2 = ax.twinx() #Create a twin axes sharing the xaxis ax2.plot(hist, color='green') #Plot aditional data ax.set_xlabel('Test X-axis') #Set the x-axis label ax.set_ylabel('Test Y-axis') #Set the y-axis label ax.set_xticks([1, 3, 5, 7, 9, 11]) #Sets the x-axis tick marks ax.set_yticks([1, 3, 5, 7, 9, 11]) #Sets the y-axis tick marks ax.set_xticklabels(['a', 'b', 'c', 'd', 'e', 'f']) #For the x-axis ticks, set a label ax.set_yticklabels(['g', 'h', 'i', 'j', 'k', 'l']) #For the y-axis ticks, set a label ax.legend(loc="Upper right", fontsize=18) plt.title("Test graph") #Add title to the graph plt.axvspan(2, 10, 0.4, 0.5) #Add demarkation regions to the graph plt.axvline(1, 0, 1) #Adds demarkation line to the graph plt.gca().invert_xaxis() #Flip graph on x-axis plt.savefig("result.png") #Save the picture to a file plt.show() #Display plot
def show_test_statistics( bi_corr_array, mean_correlations, # shutdown if sparse eigenvalues, # shutdown if sparse selector, test_bi_corr_array, test_mean_corr, # shutdown if sparse eigenvalue, # shutdown fi sparse re_samples, sparse=False): """ A general function that performs demonstration of an example of random samples of the same size as our sample and of our sample and conducts the statistical tests on wherther any of nodes or functional groups in our sample are non-random :param bi_corr_array: [[current, informativity, confusion_potential], ...] - characteristics of the random samples :param mean_correlations: [[cluster size, average internode connection], ...] - characteristics of clustering random samples with the same parameters :param eigenvalues: eigenvalues associated to the interconnection matrix of random samples :param selector: range on which we would like to visually zoom and plot a histogram :param test_bi_corr_array: [[current, informativity, confusion_potential], ...] - characteristics of the true sample. If none, nothing happens :param test_mean_corr: [[cluster size, average internode connection], ...] - characteristics of clustering the true sample :param eigenvalue: eigenvalues associated to the interconnection matrix of the true sample :param re_samples: how many random samples we analyzed for the default model :param sparse: True if we are showing test statistics of a sparse kernel run :return: """ fig = plt.figure() fig.set_size_inches(30, 20) plt.subplot(331) plt.title('current through nodes') bins = np.linspace(bi_corr_array[0, :].min(), bi_corr_array[0, :].max(), 100) if test_bi_corr_array is not None: bins = np.linspace( min(bi_corr_array[0, :].min(), test_bi_corr_array[0, :].min()), max(bi_corr_array[0, :].max(), test_bi_corr_array[0, :].max()), 100) plt.hist(bi_corr_array[0, :], bins=bins, histtype='step', log=True, color='b') if test_bi_corr_array is not None: plt.hist(test_bi_corr_array[0, :], bins=bins, histtype='step', log=True, color='r') plt.subplot(332) plt.title('test current vs degree') plt.scatter(bi_corr_array[1, :], bi_corr_array[0, :]) if test_bi_corr_array is not None: plt.scatter(test_bi_corr_array[1, :], test_bi_corr_array[0, :], color='r', alpha=0.5) plt.axvspan(selector[0], selector[1], facecolor='0.5', alpha=0.3) plt.subplot(333) plt.title('Currently empty') plt.subplot(334) plt.title('Gaussian KDE current_info') estimator_function = kde_compute(bi_corr_array[(1, 0), :], 50, re_samples) current_info_rel = None if test_bi_corr_array is not None: current_info_rel = estimator_function(test_bi_corr_array[(1, 0), :]) plt.subplot(335) plt.title('Node degree distribution') bins = np.linspace(bi_corr_array[1, :].min(), bi_corr_array[1, :].max(), 100) if test_bi_corr_array is not None: bins = np.linspace( min(bi_corr_array[1, :].min(), test_bi_corr_array[1, :].min()), max(bi_corr_array[1, :].max(), test_bi_corr_array[1, :].max()), 100) plt.hist(bi_corr_array[1, :], bins=100, histtype='step', log=True, color='b') if test_bi_corr_array is not None: plt.hist(test_bi_corr_array[1, :], bins=100, histtype='step', log=True, color='r') plt.subplot(336) plt.title('Density of current in the highlighted area') if test_bi_corr_array is not None: bins = np.linspace( min( local_indexed_select(bi_corr_array, 1, selector)[0, :].min(), local_indexed_select(test_bi_corr_array, 1, selector)[0, :].min()), max( local_indexed_select(bi_corr_array, 1, selector)[0, :].max(), local_indexed_select(test_bi_corr_array, 1, selector)[0, :].max()), 100) plt.hist(local_indexed_select(bi_corr_array, 1, selector)[0, :], bins=bins, histtype='step', log=True, color='b') if test_bi_corr_array is not None: plt.hist(local_indexed_select(test_bi_corr_array, 1, selector)[0, :], bins=100, histtype='step', log=True, color='r') # this property is better off viewed as a scatterplot of true points and # default points cluster_props = None plt.subplot(337) plt.title('Clustering correlation') if not sparse: # plt.scatter(mean_correlations[0, :], mean_correlations[1, :], color = 'b') estimator_function = kde_compute(mean_correlations[(0, 1), :], 50, re_samples) cluster_props = None if test_mean_corr is not None: plt.scatter(test_mean_corr[0, :], test_mean_corr[1, :], color='k', alpha=0.8) cluster_props = estimator_function(test_mean_corr[(0, 1), :]) plt.subplot(338) plt.title('Eigvals_hist') if not sparse: bins = np.linspace(eigenvalues.min(), eigenvalues.max(), 100) if test_bi_corr_array is not None: bins = np.linspace(min(eigenvalues.min(), eigenvalue.min()), max(eigenvalues.max(), eigenvalue.max()), 100) plt.hist(eigenvalues, bins=bins, histtype='step', color='b') if eigenvalue is not None: plt.hist(eigenvalue.tolist() * 3, bins=bins, histtype='step', color='r') plt.subplot(339) plt.title('Currently empty') # plt.show() plt.savefig(Outputs.interactome_network_stats) # pull the groups corresponding to non-random associations. return current_info_rel, cluster_props