def stem_hist(img, plotTitle): import matplotlib.pyplot as plt from matplotlib import cm imgarray = img.calc_hist() plt.figure() plt.stem(arange(img.grayLevel), imgarray) plt.title(plotTitle)
def plotstft(sxx, Fs=100): winlen = int(len(sxx[0])) # with plt.(): fig1 = plt.figure() ax = fig1.add_subplot(1,1,1) ctr = int(winlen / 2) faxis = np.multiply(Fs / 2, np.linspace(0, 1, ctr))*60 ratio = [] for dft in sxx: mag = abs(dft[0:ctr]) max_idx, max_val = max(enumerate(mag), key = lambda p: p[1]) ptotal = np.square(np.linalg.norm(mag,2)) pmax = np.square(np.absolute(max_val)) # print('max power: {}'.format(max_val)) frac = pmax/ptotal # print(frac) ratio.append(frac) ax.plot(faxis, mag, linewidth=3.0) ax.set_xlabel('Frequency (RPM)') ax.set_ylabel('|H(f)|') ax.set_title('User 4 STFT Spectrum') font = {'family' : 'sans-serif ', 'weight' : 'bold', 'size' : 30} rc('font', **font) fig1.savefig('STFTPlot.png') fig2 = plt.figure() plt.stem(np.linspace(1,len(ratio),num=len(ratio)),ratio, linewidth=3.0) plt.xlabel('Window (10s)', fontsize = 60) plt.ylabel('Symmetry in Pedaling', fontsize = 60) fig2.savefig('RatioPlot.png')
def show_spec_in_graph(graph, vertex, spec, pos, weight, file_name): dist = 1.0 - squareform(pdist(spec.T, 'cosine')) plt.figure() plt.stem(dist[vertex, :], markerfmt=' ') rim = graph.new_vertex_property('vector<double>') rim.set_2d_array(np.array([0, 0, 0, 1])) rim[graph.vertex(vertex)] = [0.8941176471, 0.1019607843, 0.1098039216, 1] rim_width = graph.new_vertex_property('float', vals=0.5) rim_width.a[vertex] = 2 shape = graph.new_vertex_property('int', vals=0) shape[graph.vertex(vertex)] = 2 size = graph.new_vertex_property('double', vals=10) size.a[vertex] = 15 correlation = graph.new_vertex_property('double', vals=2) correlation.a = dist[vertex, :] vorder = graph.new_vertex_property('int', vals=0) vorder.a[vertex] = 1 palette = sns.cubehelix_palette(256) cmap = colors.ListedColormap(palette) gt_draw.graph_draw(graph, pos=pos, vertex_color=rim, vorder=vorder, vertex_pen_width=rim_width, vertex_shape=shape, vertex_fill_color=correlation, vcmap=cmap, vertex_size=size, edge_color=[0, 0, 0, 0.7], edge_pen_width=weight, output=file_name + '.png', output_size=(1200, 1200)) plt.figure() utils.plot_colorbar(cmap, np.arange(0, 1.01, 0.2), file_name)
def impz(b, a=1): """Plot step and impulse response of an FIR filter. b : float Forward terms of the FIR filter. a : float Feedback terms of the FIR filter. (Default value = 1) From http://mpastell.com/2010/01/18/fir-with-scipy/ Returns ------- None """ l = len(b) impulse = np.repeat(0., l) impulse[0] = 1. x = np.arange(0, l) response = sp.lfilter(b, a, impulse) plt.subplot(211) plt.stem(x, response) plt.ylabel('Amplitude') plt.xlabel(r'n (samples)') plt.title(r'Impulse response') plt.subplot(212) step = sp.cumsum(response) plt.stem(x, step) plt.ylabel('Amplitude') plt.xlabel(r'n (samples)') plt.title(r'Step response') plt.subplots_adjust(hspace=0.5)
def stepplot(x, y, labels, plot_titles): """Generates Correlation Graph. With the x,y coordinates, labels, and plot titles established, the step-plots can be generated. Output is PDF file format""" plt.figure() #makes new image for each plot #plot x & y stemplot. format plot points plt.stem(x, y, linefmt='k--', markerfmt='ro', basefmt='k-') #set x-axis labels and set them vertical. size 10 font. plt.xticks(x, labels, rotation='vertical', fontsize = 10) #set titles for graph and axes plt.title(plot_titles[0]) plt.xlabel("Biomarkers") plt.ylabel("Correlation Values") # slightly move axis away from plot. prevents clipping the labels plt.margins(0.2) # Tweak spacing to prevent clipping of tick-labels plt.subplots_adjust(bottom=0.15) plt.tight_layout() #prevents labels from being clipped with PdfPages(plot_titles[0]+'.pdf') as pdf: #creates new file for each figure pdf.savefig()
def stemplotf(v, p): fig2=plt.figure() fig2.suptitle('Problem 2b: Data Set %s' % p) plt.stem(v) plt.xlabel('k') plt.ylabel('1/E[alpha_k]') fig2.savefig('Problem2b_data%s' % p)
def plotVibEpoch(self, epochTimes, signal=None, points=False): # indStart = int(epochTimes[0] * qu.s * self.entireVibrationSignal.sampling_rate + self.recordingStartIndex) # indEnd = int(epochTimes[1] * qu.s * self.entireVibrationSignal.sampling_rate + self.recordingStartIndex) # epochTVec = self.entireVibrationSignal.t_start + np.arange(indStart, indEnd) * self.entireVibrationSignal.sampling_period # plt.plot(epochTVec, self.entireVibrationSignal[indStart:indEnd], 'g' + extra) indStart = int(epochTimes[0] * qu.s * self.vibrationSignalDown.sampling_rate) indEnd = int(epochTimes[1] * qu.s * self.vibrationSignalDown.sampling_rate) epochTVec = self.vibrationSignalDown.t_start + np.arange(indStart, indEnd) * self.vibrationSignalDown.sampling_period stimEnds = (np.array(self.stimEndInds)) / self.downSamplingFactor stimStarts = (np.array(self.stimStartInds)) / self.downSamplingFactor stimEndsPresent = [x * self.vibrationSignalDown.sampling_period + self.vibrationSignalDown.t_start for x in stimEnds if indStart <= x <= indEnd] stimStartsPresent = [x * self.vibrationSignalDown.sampling_period + self.vibrationSignalDown.t_start for x in stimStarts if indStart <= x <= indEnd] extra = '' if points: extra = '*-' plt.plot(epochTVec, self.vibrationSignalDown[indStart:indEnd], 'g' + extra) plt.stem(stimStartsPresent, np.ones(np.shape(stimStartsPresent)), 'k') plt.stem(stimEndsPresent, np.ones(np.shape(stimEndsPresent)), 'm') if not signal is None: plt.plot(epochTVec, signal[indStart:indEnd], 'r' + extra) plt.plot(epochTVec, 2 * self.vibrationSignalDownStdDev * np.ones(epochTVec.shape), 'y')
def show_ae(autoencoder): encoder = autoencoder.Encoder() decoder = autoencoder.Decoder() encoded_imgs = encoder.predict(X_test) decoded_imgs = decoder.predict(encoded_imgs) n = 10 plt.figure(figsize=(20, 6)) for i in range(n): ax = plt.subplot(3, n, i + 1) plt.imshow(X_test[i].reshape(28, 28)) plt.gray() ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) ax = plt.subplot(3, n, i + 1 + n) plt.stem(encoded_imgs[i].reshape(-1)) plt.gray() ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) ax = plt.subplot(3, n, i + 1 + n + n) plt.imshow(decoded_imgs[i].reshape(28, 28)) plt.gray() ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) plt.show()
def plot_station_res(sta_res,ires,perr=False,scale=1): titles = ('Tangent Force','Normal Force','Tangent Moment','Normal moment','Inflow Angle','Angle of Attack','Reynolds number', 'Local vel.','Axial induction','Radial Induction','Effective Velocity','Lift Coeff','Drag Coeff','Loss Factor', 'CT','CQ','CP','dP','radius','azim','height','ind_vel_a','ind_vel_r') axis = get_station_res(sta_res,18) res = get_station_res(sta_res,ires) axis = np.array(axis) * scale #plt.figure() if perr is True: plt.subplot(211) plt.plot(axis,res,'-o') plt.subplot(212) err = get_station_res(sta_res,-1) plt.stem(axis, err, 'r-') else: plt.figure() plt.plot(axis,res,'-o') plt.grid() plt.title(titles[ires]) plt.show() return 0
def plotImpulseResponse(self, xmin=None, xmax=None, ymin_imp=None, ymax_imp=None, ymin_step=None, ymax_step=None): """Plot the frequency and phase response of the filter object. :param xmin: Minimum value for x-axis. :param xmax: Maximum value for x-axis. :param ymin_imp: Minimum value for y-axis for the impulse response plot. :param ymax_imp: Maximum value for y-axis for the impulse response plot. :param ymin_step: Minimum value for y-axis for the step response plot. :param ymax_step: Maximum value for y-axis for the step response plot. """ # def plotImpulseResponse(b,a=1): l = len(self.ir) impulse = np.repeat(0.0, l) impulse[0] = 1.0 x = np.arange(0, l) response = sp.signal.lfilter(self.ir, 1, impulse) mp.subplot(211) mp.stem(x, response) mp.ylabel("Amplitude") mp.xlabel(r"n (samples)") mp.title(r"Impulse response") mp.subplot(212) step = np.cumsum(response) mp.stem(x, step) mp.ylabel("Amplitude") mp.xlabel(r"n (samples)") mp.title(r"Step response") mp.subplots_adjust(hspace=0.5) mp.show()
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 run_OMP(plot=False, **options): """Recover one signal using OMP.""" n = options.pop('n', 128) k = options.pop('k', 5) m = options.pop('m', 20) dist = options.pop('dist', 'uniform') seed = options.pop('seed', None) return_locals = options.pop('return_locals', True) print ('Recovering signal wiht n=%(n)i, k=%(k)i and m=%(m)i using OMP' % locals()) if seed: np.random.seed(seed) x = get_sparse_x(n, k, dist=dist) if seed: np.random.seed(seed + 198) A = random_dict(m, n) y = np.dot(A, x) x_hat, residues, scores, Delta = omp(A, y, save_data=True) if plot: plt.figure() plt.stem(range(n), x, 'r-', 'ro', 'k:') plt.stem(range(n), x_hat, 'b:', 'bx', 'k:') plt.show() print 'error', norm(x - x_hat.reshape(n, 1)) if return_locals: return locals()
def moment_ss_shear_bending(L,Pin,ain): ''' Shear Bending plot of moment loads of a simply supported beam L = 4 # total length of beam Pin = [5] # point moment load ain = [2] # location of point load # or more multiple point moments L = 10 Pin = [3,-15] ain = [2,6] ''' import numpy as np import matplotlib.pyplot as plt x = np.arange(0,L,L*0.02) V = np.zeros(len(x)) M = np.zeros(len(x)) for a, P in zip(ain, Pin): V += -P/L M[x<=a] += -P*x[x<=a]/L M[x>a] += P*(1-x[x>a]/L) plt.figure() plt.title('Point Moment Loads') plt.subplot(2,1,1) plt.stem(x,V) plt.ylabel('V,shear') plt.subplot(2,1,2) plt.stem(x,M) plt.ylabel('M,moment')
def graph(b,a=1): #make a graph w,h = signal.freqz(b,a) h_dB = 20 * np.log10 (abs(h)) plt.figure() #plt.subplot(311) plt.plot(w/max(w),h_dB) plt.ylim(-150, 5) plt.ylabel('Magnitude (db)') plt.xlabel(r'Normalized Frequency (x$\pi$rad/sample)') plt.title(r'Frequency response') plt.show() plt.figure() l = len(b) impulse = np.repeat(0.,l); impulse[0] =1. x = arange(0,l) response = signal.lfilter(b,a,impulse) #plt.subplot(312) plt.stem(x, response) plt.ylabel('Amplitude') plt.xlabel(r'n (samples)') plt.title(r'Impulse response') plt.show() #plt.figure() #plt.subplot(313) #step = np.cumsum(response) #plt.stem(x, step) #plt.ylabel('Amplitude') #plt.xlabel(r'n (samples)') #plt.title(r'Step response') #plt.subplots_adjust(hspace=0.5) #plt.show() return 1
def viz_rank(Oi,k=None): if k is None: U, s, VT = np.linalg.svd(Oi) else: U, s, VT = thin_svd_randomized(Oi,k) plt.figure() plt.stem(np.arange(s.shape[0]),s)
def simple_plot(self, arr, filename, type='normal'): plt.figure() if type == 'normal': plt.plot(arr) elif type == 'stem': plt.stem(arr) plt.savefig('../images/{}.jpg'.format(filename)) plt.close()
def figure_binary_offset(title, axes, f_parent, signature, n, i): f = f_parent.add_subplot(*axes, title=title) plt.stem(n, i, linefmt='b-', markerfmt='b.', basefmt='b|') plt.axis([n[0], n[-1], signature.min, signature.max], figure=f) plt.xlabel('Time') plt.ylabel('Magnitude') return f
def plotHistogram(fg): nSubBands = fg.getNumberOfSubBands() histogram = [] for i in range(0,nSubBands): histogram.append(fg.getHistogram(i)) plt.stem(range(0,nSubBands), histogram) plt.ylabel('Number of FA in a given sub-band') plt.xlabel('sub-band') plt.draw()
def _make_channel_plots(self): plt.figure() channel = self._system.get_block(self._system.MULTI_PATH_CHANNEL) plt.stem(channel._impulse_response, basefmt='') plt.title(self._build_title("Odpowiedź impulsowa kanału")) plt.grid('on') length = len(channel._impulse_response) plt.xlim((-length / 20, length)) self._save_plt("channel_impulse")
def training(nfiltbank, orderLPC): nSpeaker = 8 nCentroid = 16 codebooks_mfcc = np.empty((nSpeaker,nfiltbank,nCentroid)) codebooks_lpc = np.empty((nSpeaker, orderLPC, nCentroid)) directory = os.getcwd() + '/train'; fname = str() for i in range(nSpeaker): fname = '/s' + str(i+1) + '.wav' print('Now speaker ', str(i+1), 'features are being trained' ) (fs,s) = read(directory + fname) mel_coeff = mfcc(s, fs, nfiltbank) lpc_coeff = lpc(s, fs, orderLPC) codebooks_mfcc[i,:,:] = lbg(mel_coeff, nCentroid) codebooks_lpc[i,:,:] = lbg(lpc_coeff, nCentroid) plt.figure(i) plt.title('Codebook for speaker ' + str(i+1) + ' with ' + str(nCentroid) + ' centroids') for j in range(nCentroid): plt.subplot(211) plt.stem(codebooks_mfcc[i,:,j]) plt.ylabel('MFCC') plt.subplot(212) markerline, stemlines, baseline = plt.stem(codebooks_lpc[i,:,j]) plt.setp(markerline,'markerfacecolor','r') plt.setp(baseline,'color', 'k') plt.ylabel('LPC') plt.axis(ymin = -1, ymax = 1) plt.xlabel('Number of features') plt.show() print('Training complete') #plotting 5th and 6th dimension MFCC features on a 2D plane #comment lines 54 to 71 if you don't want to see codebook codebooks = np.empty((2, nfiltbank, nCentroid)) mel_coeff = np.empty((2, nfiltbank, 68)) for i in range(2): fname = '/s' + str(i+2) + '.wav' (fs,s) = read(directory + fname) mel_coeff[i,:,:] = mfcc(s, fs, nfiltbank)[:,0:68] codebooks[i,:,:] = lbg(mel_coeff[i,:,:], nCentroid) plt.figure(nSpeaker + 1) s1 = plt.scatter(mel_coeff[0,6,:], mel_coeff[0,4,:],s = 100, color = 'r', marker = 'o') c1 = plt.scatter(codebooks[0,6,:], codebooks[0,4,:], s = 100, color = 'r', marker = '+') s2 = plt.scatter(mel_coeff[1,6,:], mel_coeff[1,4,:],s = 100, color = 'b', marker = 'o') c2 = plt.scatter(codebooks[1,6,:], codebooks[1,4,:], s = 100, color = 'b', marker = '+') plt.grid() plt.legend((s1, s2, c1, c2), ('Sp1','Sp2','Sp1 centroids', 'Sp2 centroids'), scatterpoints = 1, loc = 'upper left') plt.show() return (codebooks_mfcc, codebooks_lpc)
def GenerateFigure(_open, _close, _items): # GenerateFigure(Open, Close, items) #==================Ignore Figure==========# Percent = RisingPercent(items) Rise = map(sub, Close , Open) rise_index = [i for i,per in enumerate(Rise) if per>=0] fall_index = [i for i,per in enumerate(Rise) if per<0] step = 5 lookback = 55 id_start = idx[-1]-lookback if idx[-1]>lookback else idx[0] plt.subplot(3, 1, 1) # Draw K-fig rise_index = [i for i,per in enumerate(Rise) if per>=0] fall_index = [i for i,per in enumerate(Rise) if per<0] plt.vlines(rise_index, GetPart(rise_index,Low), GetPart(rise_index,High), edgecolor='red', linewidth=1, label='_nolegend_') plt.vlines(rise_index, GetPart(rise_index,Open), GetPart(rise_index,Close), edgecolor='red', linewidth=4, label='_nolegend_') plt.vlines(fall_index, GetPart(fall_index,Low), GetPart(fall_index,High), edgecolor='green', linewidth=1, label='_nolegend_') plt.vlines(fall_index, GetPart(fall_index,Open), GetPart(fall_index,Close), edgecolor='green', linewidth=4, label='_nolegend_') plt.title(stockname, fontproperties = FigureConf.Font) plt.grid(True, 'major', color='0.3', linestyle='solid', linewidth=0.2) ax = plt.gca() ax.autoscale(enable=True, axis='both', tight=True) ax.set_xticklabels( emp[0::step], rotation=75, fontsize='small') ax.set_xlim([id_start,idx[-1]]) ax.set_ylim(min(Close[id_start:]), max(Close[id_start:])) plt.subplot(3, 1, 2) plt.stem(idx, MACluster['VAR'], linefmt=VARclr, markerfmt=" ", basefmt=" ") plt.plot(idx,DDD, DDDclr, AMA, AMAclr ,DMA, DMAclr) plt.plot(zero_ndx[-3:], zero_pts[-3:], 'ro') plt.grid(True, 'major', color='0.3', linestyle='solid', linewidth=0.2) ax = plt.gca() ax.autoscale(enable=True, axis='both', tight=True) ax.set_xticklabels( emp[0::step], rotation=75, fontsize='small') ax.set_xlim([id_start,idx[-1]]) ax.set_ylim(min(DMA[id_start:] + AMA[id_start:] + DDD[id_start:]),\ max(DMA[id_start:] + AMA[id_start:]+ DDD[id_start:])) plt.subplot(3, 1, 3) plt.bar(rise_index, GetPart(rise_index,Vol),bottom=-20,color='r',edgecolor='r',align="center") plt.bar(fall_index, GetPart(fall_index,Vol),bottom=-20,color='g',edgecolor='g',align="center") plt.grid(True, 'major', color='0.3', linestyle='solid', linewidth=0.2) plt.xticks(np.arange(len(idx))[0::step], emp[0::step]) ax = plt.gca() ax.autoscale(enable=True, axis='both', tight=True) ax.set_xticklabels(datex[0::step], rotation=75, fontsize='small') ax.set_xlim([id_start,idx[-1]]) # # plt.show() try: plt.savefig('%s/%s/%s%s.png'%(baseFolder,RuleFolder,stockid+stockname,datex[zero_ndx[-1]]), dpi=100) except: plt.savefig('%s/%s/%s%s.png'%(baseFolder,RuleFolder,stockid+stockname[1:],datex[zero_ndx[-1]]), dpi=100) plt.clf()
def main(streaming): modes, evals = streaming_dmd() if streaming else standard_dmd() fdmd = np.abs(np.angle(evals)) / (2 * np.pi * dt) n_modes = len(fdmd) ydmd = np.zeros(n_modes) for i in range(n_modes): ydmd[i] = np.linalg.norm(modes[:, i] * np.abs(evals[i])) ydmd /= max(ydmd) plt.stem(fdmd, ydmd) plt.show()
def plot_file(json_file): try: with open(json_file, 'r') as events_file: data = json.load(events_file) events = {int(index): int(type_) for index, type_ in data['event_annotations'].items()} indexes, types = zip(*events.items()) plt.stem(indexes, types) plt.show() except Exception, e: print e
def plot_USR(response,name): p.figure() p.stem(range(len(response)),response) smin = min(response) smax = max(response) ds = smax - smin p.axis([-.5,len(response)+.5,smin - 0.1*ds,smax + 0.1*ds]) p.title('Response of channel %s' % name) p.xlabel('Sample number') p.ylabel('Voltage')
def graphify_stem(x, y, xlabel, ylabel, title, name, axis=None): plt.xlabel(xlabel) plt.ylabel(ylabel) plt.title(title) plt.stem(x, y) plt.grid = True plt.savefig(name+'stem.png') plt.show() if axis != None: plt.axis(axis)
def plot_srcfun(mdl): sel = mdl.runner.wave[:,0].argsort() [pl.axvline(x=X,ymin = .85,ymax=.95,color='r') for X in tar.atom_data.lines.wavelength] pl.stem(1e8*mdl.runner.wave[sel],mdl.runner.att_S_ul) pl.title("Source function") pl.gca().set_yscale('log') pl.gca().set_xscale('log') pl.ylim(0,1e-3) pl.xlabel("A") pl.show()
def plot_f(f, style="dots", color="b", ylabel="y", title="", xlim=50.): plt.xlabel("x") plt.ylabel(ylabel) plt.title(title) plt.xlim(-xlim, xlim) xs = np.arange(1000) - 500. if style == "dots": plt.plot(xs, f, color+".") elif style == "stem": plt.stem(xs, f, markerfmt=color+"o", linefmt=color+"--", basefmt="k-") plt.show()
def viz_rank2(y,i,k=None): Y = AR_striding(y,i-1).T l = Y.shape[0]//2 if k is None: _, s, _ = np.linalg.svd(np.cov(Y)[:l,l:]) else: _, s, _ = thin_svd_randomized(np.cov(Y)[:l,l:],k) plt.figure() plt.stem(np.arange(s.shape[0]),s)
def plot_overlap(): f = two_spikes() g = cone() plt.xlabel("x") plt.ylabel("y") plt.xlim(-50, 50) xs = np.arange(1000) - 500. plt.plot(xs-20., g, "b.") plt.plot(xs+20., 2*g, "b.") plt.stem(xs, f, markerfmt="ro", linefmt="r--", basefmt="k-") plt.show()
def plotTopics(s, minSupport=None): D = s.state["D_tr"] ks = np.zeros(D) for d in range(0, D): # necessary since topics may be selected several times! c_u = np.unique(s.state["c"][d, :]) sigPi_u = np.zeros(c_u.size) for i in range(0, c_u.size): # print('{}'.format(c_u[i] == s.c[d])) # print('{}'.format(s.sigPi[d])) sigPi_u[i] = np.sum(s.state["sigPi"][d, c_u[i] == s.state["c"][d, :]]) k_max = c_u[sigPi_u == np.max(sigPi_u)] # print('c={};'.format(s.c[d])) # print('sigPi={};'.format(s.sigPi[d])) print("sigPi_u = {};\tc_u={};\tk_max={}".format(sigPi_u, c_u, k_max)) # t_max=np.nonzero(s.sigPi[d]==np.max(s.sigPi[d]))[0][0] # print('d={}; D={}'.format(d,D)) # print('t_max={};'.format(np.nonzero(s.sigPi[d]==np.max(s.sigPi[d])))) # print('sigPi={}; sum={}'.format(s.sigPi[d],np.sum(s.sigPi[d]))) # print('c[{}]={};'.format(d,s.c[d])) # if t_max < s.c[d].size: # k_max = s.c[d][t_max] # else: # k_max = np.nan # this means that we arre not selecting one of the estimated models!! (the last element in sigPi is 1-sum(sigPi(0:end-1)) and represents the "other" models ks[d] = k_max[0] ks_unique = np.unique(ks) ks_unique = ks_unique[~np.isnan(ks_unique)] if minSupport is not None: Np = ks_unique.size # numer of subplots # print('D{0} Np{1}'.format(D,Np)) sup = np.zeros(ks_unique.size) for d in range(0, D): sup[np.nonzero(ks_unique == ks[d])[0]] += 1 # print('sup={0} sum(sup)={1}'.format(sup,np.sum(sup))) delete = np.zeros(ks_unique.size, dtype=np.bool) for i in range(0, Np): if sup[i] < minSupport: delete[i] = True ks_unique = ks_unique[~delete] Np = ks_unique.size # numer of subplots print("D{0} Np{1}".format(D, Np)) Nrow = np.ceil(np.sqrt(Np)) Ncol = np.ceil(np.sqrt(Np)) fig = plt.figure() for i in range(0, Np): plt.subplot(Ncol, Nrow, i + 1) x = np.linspace(0, s.state["beta"][int(ks_unique[i])].size - 1, s.state["beta"][int(ks_unique[i])].size) plt.stem(x, s.state["beta"][int(ks_unique[i])]) plt.ylim([0.0, 1.0]) plt.xlabel("topic " + str(ks_unique[i])) return fig
archivo = 'small.wav' muestreo, sonido = waves.read(archivo) print('frecuencia de muestreo: ', muestreo) print('dimensiones de matriz: ', np.shape(sonido)) print('datos de sonido: ') print(sonido) # Toda la señal inicia = 2000 termina = 3000 # Extraer el tiempo de muestreo dt = 1 / muestreo # Construir el intervalo de tiempo cada dt muestras t = np.arange(inicia * dt, termina * dt, dt) # Verificar la cantidad de muestras muestras = len(t) # Señal en dos canales, elegir uno canal = 0 fragmento = sonido[inicia:inicia + muestras, canal] # Gráfica analógica de sonido plt.plot(t, fragmento) plt.xlabel('t segundos') plt.ylabel('sonido(t)') plt.show() # Gráfica discreta de sonido n = np.arange(inicia, inicia + muestras, 1) plt.stem(n, fragmento) plt.xlabel('n') plt.ylabel('sonido[n]') plt.show()
import numpy as np import matplotlib.pyplot as plt M = 31 n = np.linspace(0, M - 1) whn = 0.5 - 0.5 * np.cos((2 * np.pi * n) / (M - 1)) plt.stem(n, whn) plt.show()
# Spacing in the frequency domain f0 = 1 / T # Signal creation sigFreq = 250 w = 2 * pi * sigFreq sig = np.sin(w * n) plt.figure() plt.plot(n, sig) # Implementaion with calculating f myself SIGf = np.fft.fftshift(np.fft.fft(sig)) / N f = np.arange(-fs / 2, fs / 2, f0) sig2 = np.fft.ifft(np.fft.fftshift(SIGf * N)) # Implementation with fftfreq # SIGf = np.fft.fft(sig)/N # f = np.fft.fftfreq(N,t0) # sig2 = np.fft.ifft(SIGf*N) # Correct quantization errors that will show up in phase SIGf[np.abs(SIGf) < .0000000001] = 0 plt.figure() plt.stem(f, np.abs(SIGf), use_line_collection=True) plt.figure() plt.stem(f, np.angle(SIGf), use_line_collection=True) plt.figure() plt.plot(n, np.real(sig2))
import scipy.io from matplotlib import pyplot as plt from scipy.io import wavfile import numpy as np F = 100 Fs = 250 m = np.arange(1, 400) x = np.random.rand(500) w = np.arange(-np.pi, np.pi, 0.01 * np.pi) l = len(x) y = [] for i in range(0, len(w)): s = 0 for n in range(0, l): s = s + x[n] * np.exp(-1 * 1j * w[i] * n) y.append(s) plt.subplot(211) plt.stem(w, np.abs(y)) plt.subplot(212) plt.stem(w, np.angle(y)) plt.show()
trials = int(1e5) X = np.random.geometric(p=0.166, size=trials) Pr_X = np.zeros((int(trials/2))) for i in range(int(trials/2)): Pr_X[i] = np.count_nonzero(X == (i*2 + 1)) Pr_X[i] = Pr_X[i]/trials Pr_A_win = np.sum(Pr_X) Pr_X_theo = [1/6, 22/216, 625/7776, 15625/279936] trials = [1, 3, 5, 7] print('Simulated Pr(On 1st trial die rolls a six by A) = ', Pr_X[0]) print('Mathematical Pr(On 1st trial die rolls a six by A) = ', 1/6) print('\n') print('Simulated Pr(On 3rd trial die rolls a six by A) = ', Pr_X[1]) print('Mathematical Pr(On 3rd trial die rolls a six by A) = ', 25/216) print('\n') print('Simulated Pr(On 5th trial die rolls a six by A) = ', Pr_X[2]) print('Mathematical Pr(On 5th trial die rolls a six by A) = ', 625/7776) print('\n') print('Simulated Pr(On 7th trial die rolls a six by A) = ', Pr_X[3]) print('Mathematical Pr(On 7th trial die rolls a six by A) = ', 15625/279936) print('\n') print('Simulated Pr(A = win) = ', Pr_A_win) print('Mathematical Pr(A = win) = ', 6/11) plt.stem(trials, Pr_X[0:4], linefmt='C1--', markerfmt='C1o', label='Sim') plt.stem(trials, Pr_X_theo, linefmt='C2--', markerfmt='C2.', label='Math') plt.legend() plt.xlabel('Trial #') plt.ylabel('Pr(A rolling six)') plt.title('Math Vs Sim Pr(A winning the game on odd $k^{th}$ trial)') plt.show()
#plot_heat_map('R_human', R_human[::-1] ) #plot_heat_map('R_machine', R_machine[::-1] ) #plot_heat_map('R_total', R[::-1] ) #cal eigen value eValue_h, eVector_h = eig(R_human) eValue_m, eVector_m = eig(R_machine) eValue_R, eVector_R = eig(R) print('R_human eValue: ', eValue_h[0:2]) print('R_human percentage of variance: ', np.sum(eValue_h[0:2]) / np.sum(eValue_h)) print('R_machine eValue: ', eValue_m[0:2]) print('R_machine percentage of variance: ', np.sum(eValue_m[0:2]) / np.sum(eValue_m)) fig = plt.figure() plt.stem(eValue_R, label='total', linefmt='tab:gray', markerfmt='ko') axes = plt.gca() axes.set_xlabel('index (k)') axes.set_ylabel('eigen-vlaues of R matrix') fig = plt.figure() plt.stem(eValue_h, label='total', linefmt='tab:gray', markerfmt='ko') axes = plt.gca() axes.set_xlabel('index (k)') axes.set_ylabel('eigen-vlaues of R-human matrix') fig = plt.figure() plt.stem(eValue_m, label='total', linefmt='tab:gray', markerfmt='ko') axes = plt.gca() axes.set_xlabel('index (k)') axes.set_ylabel('eigen-vlaues of R-machine matrix')
return amplitude, time def Squarer_System(x): # Function to apply filter on a array """ Applying Squarer System/Filter on an array """ n = x.shape[0] output = np.zeros(n) for i in range(n): output[i] = x[i] * x[i] return output S, time = Sin_Discrete(0, 50, 32) S_square = Squarer_System(S) plt.figure(figsize=(13, 8)) ax = plt.subplot(1, 2, 1) plt.stem(time, S, 'r') ax = plt.subplot(1, 2, 2) plt.stem(time, S_square, 'y') plt.show()
##################################################################### batch_size=64 model.load_weights("model/alpha_model_weights.hdf5") from get_spectrum_as_numpy import get_spectrum import shap spectrum = get_spectrum('example/example.mgf') background_spectra = np.zeros((1,3600,2)) e = shap.DeepExplainer(model, background_spectra) take_specific_spectrum=0 spectrum=spectrum[take_specific_spectrum,:,:] spectrum=np.expand_dims(spectrum,0) interpretation = np.squeeze(e.shap_values(spectrum)) spectrum = np.squeeze(spectrum) import matplotlib.pyplot as plt plt.title("Mirrorplot: demonstrating how SHAP values are used to interpret AHLF.") plt.stem(spectrum[:,0]/np.max(spectrum[:,0]),linefmt='C0-',markerfmt=' ',basefmt=' ',use_line_collection=True,label='acquired peak') plt.stem(- np.abs(interpretation[:,0])/np.max(np.abs(interpretation[:,0])),linefmt='C1-',markerfmt=' ',basefmt=' ',use_line_collection=True,label='abs. SHAP value') plt.xlabel('feature') plt.ylabel('Norm. abundance [a.u.]') plt.legend() plt.savefig('interpretation.png')
M = 1 t = 0 x0 = np.linspace(0, 400, 400) y0 = 0 surface = water.Surface(N=N, M=M, whitening=1) k = surface.k k0 = surface.k0 S = surface.spectrum(k) plt.figure(figsize=[8, 6]) plt.loglog(k0, surface.spectrum(k0), '-', color='black') plt.stem(surface.k_heights, surface.spectrum(surface.k_heights), use_line_collection=True, markerfmt=' ', linefmt='darkblue', label='Высоты', bottom=0) plt.stem(surface.k_slopes, surface.spectrum(surface.k_slopes), use_line_collection=True, markerfmt=' ', linefmt='r', label='Наклоны', bottom=0) plt.xlabel(r'$k, \text{ рад}\cdot\text{м}^{-1}$') plt.ylabel(r'S,~\text{a.u.}') plt.legend() # plt.savefig('/home/kannab/documents/water/poster/nodes.pdf')
# In[73]: # first our usual bookkeeping get_ipython().magic('pylab inline') import matplotlib import matplotlib.pyplot as plt import numpy as np # Typically, we will take a vector of data points, compute the DFT and plot the magnitude of the result. For instance, consider the DFT of a linear ramp: # In[74]: x = np.arange(0, 1.02, 0.02) - 0.5 X = np.fft.fft(x) plt.stem(abs(X)) # ## Positive and negative frequencies # # The coefficient number $k$ indicates the contribution (in amplitude and phase) of a sinusoidal component of frequency # # $$ # \omega_k = \frac{2\pi}{N}k # $$ # # Because of the rotational symmetry of complex exponentials, a positive frequency $\omega$ between $\pi$ and $2\pi$ is equivalent to a negative frequency of $\omega - 2\pi$; this means that half of the DFT coefficients correspond to negative frequencies and when we concentrate on the physical properties of the DFT it would probably make more sense to plot the coefficients centered around zero with positive frequencies on the right and negative frequencies on the left. # # The reason why this is not usuall done are many, including # # * convenience # * since we are manipulating finite-length signals, the convention dictates that we start at index zero
plt.ylabel('Mean Squared Error') plt.show() N_stem = max(y) * np.ones((np.shape(a)[0] + 1, )) MMMI_stem = 0.9 * max(y) * np.ones((len(SSLS_seg), )) MMI_stem = 0.8 * max(y) * np.ones((len(SSLS_seg_old), )) MI_stem = 0.7 * max(y) * np.ones((len(seg), )) plt.figure() plt.plot(y, alpha=0.8, lw=0.5, label='switching AR process') plt.stem(SSLS_seg, MMMI_stem, basefmt=" ", linefmt='b', markerfmt='+b', label='OSRLS (Linear Complexity)') plt.stem(SSLS_seg_old, MMI_stem, basefmt=" ", linefmt='r', markerfmt='1r', label='OSRLS') plt.stem(seg, MI_stem, basefmt=" ", linefmt='g', markerfmt='xg', label='segmented LS/RLS') plt.stem(NN[0:np.shape(a)[0] + 1],
print("[Received] Topic: " + msg.topic + ", Message: " + str(msg.payload) + "\n") tilt[num] = int(msg.payload) num += 1 def on_subscribe(mosq, obj, mid, granted_qos): print("Subscribed OK") def on_unsubscribe(mosq, obj, mid, granted_qos): print("Unsubscribed OK") # Set callbacks mqttc.on_message = on_message mqttc.on_connect = on_connect mqttc.on_subscribe = on_subscribe mqttc.on_unsubscribe = on_unsubscribe # Connect and subscribe print("Connecting to " + host + "/" + topic) mqttc.connect(host, port=1883, keepalive=60) mqttc.subscribe(topic, 0) # Publish messages from Python while num < 20: mqttc.loop() time.sleep(1) plt.stem(t, tilt) plt.xlabel('time') plt.ylabel('tilt') plt.title('# tilt plot') plt.show()
triangles. The `Triangle` class treats the development parameter as optional. This example instantiates a 'premium' triangle as a single vector. """ import chainladder as cl import pandas as pd import matplotlib.pyplot as plt # Raw premium data in pandas premium_df = pd.DataFrame({ 'AccYear': [item for item in range(1977, 1988)], 'premium': [3000000] * 11 }) # Create a premium 'triangle' with no development premium = cl.Triangle(premium_df, origin='AccYear', columns='premium') # Create some loss triangle loss = cl.load_sample('abc') ultimate = cl.Chainladder().fit(loss).ultimate_ loss_ratios = (ultimate / premium).to_frame() # Plot fig, ax = plt.subplots() plt.stem(loss_ratios.index.astype(str), loss_ratios.iloc[:, 0]) ax.grid(axis='y') for spine in ax.spines: ax.spines[spine].set_visible(False) plt.show()
e += 1 findBj(Tx, s, b, e) #to change the s and b values if i == 0 or i == 2: s += 1 elif i == 1: s -= 1 b += 1 #plotting the model print("Delay Value: ", delay) print("Impulse Response:", Hn) print(len(Hn), " piece of data") #plt.plot(delay, Hn) plt.xlabel("time(s)") plt.ylabel("Impulse Amplitude") plt.stem(delay, Hn, '-') plt.show() #convolution s1 = Hn s2 = Txx #print ('s1: ', s1) #print ('s2: ', s2) #s3 = np.flip(s2,0) #length = len(s1)+len(s2)-1 #s1_zeros = length - len(s1) #s3_zeros = length - len(s3) #temp_s1 = np.concatenate((np.zeros(s1_zeros),s1)) #temp_s2 = np.concatenate((s3, np.zeros(s3_zeros)))
x2 = list() for i in range(0, 21): x2.append(i) x1 = [ -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20 ] x = x1 + x2 # In[179]: ADFWN1 = autocorrelation(W)[1:21] ADFWN2 = autocorrelation(W)[0:21] ADFWN = ADFWN1 + ADFWN2 plt.stem(x, ADFWN, use_line_collection=True) plt.title('Autocorrelation formula for White noise', pad=20) plt.ylabel('Autocorrelation') plt.xlabel('Lag #') plt.show() # ### b. Plot both the generated WN in step 3 versus time and plot the histogram. # # In[180]: plt.plot(W) plt.title('White Noise through time', pad=40) plt.xlabel('Time') plt.ylabel('Generated White Noise') plt.show()
def plot(self, dB=False, phase=False, stem=False, frange=(0, 10000)): ''' Generate three subplots showing frequency-domain (both amplitude and phase) and time-domain representations of the given signal. If stem is True, stem plots will be used for both amplitude and phase If dB is True, the amplitude in the frequency domain plot will be shown with the log scale. If phase is True, the phase-shift plot will also be created. ''' plt.subplots_adjust(hspace=.4) if phase: num_plots = 3 else: num_plots = 2 # plot time-domain signal plt.subplot(num_plots, 1, 1) plt.cla() x, y = self.get_time_domain() plt.grid(True) plt.xlabel(u'Time (s)') plt.ylabel('Value') plt.plot(x, y, 'g') # plot frequency vs. amplitude x, a, p = self.get_freq_domain() start_index = int( float(frange[0]) / self.sampling_rate * len(self.freqs)) stop_index = int( float(frange[1]) / self.sampling_rate * len(self.freqs)) x = x[start_index:stop_index] a = a[start_index:stop_index] p = p[start_index:stop_index] plt.subplot(num_plots, 1, 2) plt.cla() plt.grid(True) plt.xlabel(u'Frequency (Hz)') if dB: a = 10. * np.log10(a + 1e-10) + 100 plt.ylabel(u'Amplitude (dB)') else: plt.ylabel(u'Amplitude') if stem: plt.stem(x, a, 'b') else: plt.plot(x, a, 'b') # plot frequency vs. phase-shift if phase: plt.subplot(num_plots, 1, 3) plt.cla() plt.grid(True) plt.xlabel(u'Frequency (Hz)') plt.ylabel(u'Phase (degree)') plt.ylim(-180, 180) if stem: plt.stem(x[start_index:stop_index], p[start_index:stop_index], 'r') else: plt.plot(x[start_index:stop_index], p[start_index:stop_index], 'r') plt.show()
def main(): # sine #sin = np.vectorize(sin_f) #series = sin(samples) # cos #cos = np.vectorize(cos_f) #series = cos(samples) # tan #tan = np.vectorize(tan_f) #series = tan(samples) # normal #series = np.random.normal(loc=6, scale=0.1, size=(N,1)) # binomial #series = np.random.binomial(n=10, p=0.7, size=(N,1)) # Poisson #series = np.random.poisson(lam=2, size=(N,1)) # Uniform #series = np.random.uniform(size=(N, 1)) # Logistic #series = np.random.logistic(loc=1, scale=2, size=(N, 1)) # Multi series = np.random.multinomial( n=6, pvals=[1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6, 1 / 6]) # Exponential #series = np.random.exponential(scale=2, size=(N, 1)) # Chi #series = np.random.chisquare(df=2, size=(N, 1)) # Rayleigh #series = np.random.rayleigh(scale=2, size=(N, 1)) # Pareto #series = np.random.pareto(a=2, size=(N, 1)) # Zipf #series = np.random.zipf(a=2, size=(N, 1)) g = visibility_graph(series) # Circular #pos = nx.circular_layout(g) # Bipartite #top = nx.bipartite.sets(g)[0] #pos = nx.bipartite_layout(g, top) # Kamada Kawai #pos = nx.kamada_kawai_layout(g) # Planar #pos = nx.planar_layout(g) # Random #pos = nx.random_layout(g) # Shell shells = [[0], list(np.arange(1, len(g), 1))] pos = nx.shell_layout(g, shells) # Spring #pos = nx.spring_layout(g) # Spectral #pos = nx.spectral_layout(g) # Spiral #pos = nx.spiral_layout(g) # Multipartite #pos = nx.multipartite_layout(g) print(g.nodes()) print(g.edges()) x = list(g.nodes()) y = series e = list(g.edges()) plt.stem(x, y) plt.figure(1) for edg in e: plt.plot(edg, [y[(edg[0])], y[(edg[1])]]) plt.show() plt.figure(2) nx.draw(g, pos) #nx.draw_networkx_labels(g,pos,font_size=7,font_family='sans-serif') #nx.draw_networkx_edge_labels(g,pos,q_list,label_pos=0.3) plt.show() plt.figure(3) plt.hist(y) plt.show()
# -*- coding: utf-8 -*- import numpy as np import matplotlib.pyplot as plt plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['axes.unicode_minus'] = False x = np.linspace(0, 8, 10) plt.subplot(111) A = 2 a = 0.6 y = A * a**x plt.grid(True) plt.title('实指数信号') plt.stem(x, y) plt.show()
if iterations % 1 == 0: print("iteration:", iterations, "train_loss: ", '%.2f' % loss1, "test_loss: ", '%.2f' % test_loss, "test_corr: ", '%.2f' % cor, end='\n') iterations += 1 # Results X1proj = sess.run(Fs_img,feed_dict={X1: train_X1 ,X2: train_X2}) plt.figure() x = np.linspace(0,90,90) markerline, stemlines, baseline = plt.stem(x,np.transpose(X1proj), '.-') X2proj = sess.run(Fs_snp,feed_dict={X1: train_X1 ,X2: train_X2}) print('image') plt.figure() x = np.linspace(0,3365,3365) markerline, stemlines, baseline = plt.stem(x,np.transpose(X2proj), '.-')
count = np.zeros(265) for j in range(0,x): for k in range(0,y): count[img[j,k]] = count[img[j,k]] + 1 return count img = cv.imread('image.png',cv.IMREAD_GRAYSCALE) cv.imshow("Image",img) k = cv.waitKey(100) cv.imwrite('greyscale.png',img) plt.figure(1) histogram = compute_histogram(img) plt.stem(histogram, markerfmt = ' ') plt.xlabel("Grayscale Values") plt.ylabel("No. Of Occurence") plt.title("Using compute_histogram()") plt.figure(2) plt.hist(img.ravel(),256,[0,256]) plt.xlabel("Grayscale Values") plt.ylabel("No. Of Occurence") plt.title("Using In-Built Commands") plt.show()
speed_out2.Update(s2[i]) #speed_out3.Update(s3[i]) i += 1 if ((speed_out0.Y() != s0).any()): print('Sensor-speedout: Fail in 1-1') raise AssertionError() p1 = 0 * speed_out1.timespace() + 1 p2 = 0 * speed_out2.timespace() + 1 plt.figure() plt.xlabel('t') plt.ylabel('speedout') plt.scatter(clock.timespace(), s1, c='r', s=0.5) plt.stem(speed_out1.timespace(), p1, '-', use_line_collection=True) plt.figure() plt.xlabel('t') plt.ylabel('speedout') plt.scatter(clock.timespace(), s2, c='r', s=0.5) plt.stem(speed_out2.timespace(), p2, '-', use_line_collection=True) """ plt.figure() plt.xlabel('t') plt.ylabel('speedout') plt.scatter(clock.timespace(), s3, c='r', s=0.5) plt.stem(clock.timespace(), speed_out3.Y(), '-', use_line_collection=True) """ plt.show()
import cmath import matplotlib.pyplot as plt import numpy as np def dft(f): F = [] for k in range(len(f)): s = complex(0) # s=0*j for n in range(len(f)): power = 2j * cmath.pi * n * k / len(f) s += f[n] * cmath.exp(-power) F.append(s) return F N = 8 print( "Let N=8 and f(n) where n = 0 ,.., N - 1 \nf(n) = 1 when n is even and f(n) = 0 when n is odd" ) f = [1 if n % 2 == 0 else 0 for n in range(N)] Dft = dft(f) print("DFT of", f, " is :", Dft) print("and F is real") absl = [np.absolute(i) for i in Dft] plt.suptitle("15.5.5") plt.title("DFT") plt.stem(absl) plt.show()
# calculate.. lkg = lk_gaussian(data, muHat, varHat) llkg = llk_gaussian(data, muHat, varHat) # generate output .. print("Gaussian likelihood: " + str(lkg)) print("Gaussian loglikelihood: " + str(llkg)) print("exp(loglikelihood): " + str(np.exp(llkg))) ############################################################################### ### Subtask 8. Visualisation ############################################################################### x = np.arange(0, max(data)) py = list(map(lambda d: lk_poisson([d], muHat), x)) gy = list(map(lambda d: lk_gaussian([d], muHat, varHat), x)) plt.plot(x, gy, label='Gaussian distribution', color='orange') plt.stem(x, py, label='Poisson distribution') plt.xlabel("samples") plt.xticks(np.arange(0, 12, step=1)) plt.ylabel("$pdf(x=x_i)$") plt.legend(loc='upper right') plt.show() ############################################################################### ### END ###############################################################################
array = np.zeros(com_list[1] + 1, dtype=int) array2 = np.zeros(com_list[1] + 1, dtype=int) counter = 4 for j in range(com_list[0], com_list[1] + 1): array[j] = com_list[counter] counter += 1 for k in range(com_list[2], com_list[3] + 1): array2[k] = com_list[counter] counter += 1 mean = sum(array) / len(array) sd = np.std(array) normalized_array = [(i - mean) / sd for i in array] mean2 = sum(array2) / len(array2) sd2 = np.std(array2) normalized_array2 = [(i - mean2) / sd2 for i in array2] convol = [ normalized_array[k] * normalized_array2[com_list[1] - k] for k in range(0, com_list[1] + 1) ] plt.title("Convolution of normalized") plt.stem(convol, '--')
def RESON_dyProg_mat(GCI_relAmp, GCI_N, F0mean, x, fs, trans_wgt, relAmp_wgt, plots=True): # Function to carry out dynamic programming method described in Ney (1989) # and used previously in the ESPS GCI detection algorithm. The method # considers target costs and transition costs which are accumulated in # order to select the `cheapest' path, considering previous context # USAGE: INPUT # GCI_relAmp - target cost matrix with N rows (GCI candidates) by M # columns (mean based signal derived intervals). # GCI_N - matrix containing N by M candidate GCI locations (in # samples) # F0_inter - F0 values updated every sample point # x - speech signal # fs - sampling frequency # trans_wgt - transition cost weight # # OUTPUT # GCI - estimated glottal closure instants (in samples) # ========================================================================= # === FUNCTION CODED BY JOHN KANE AT THE PHONETICS LAB TRINITY COLLEGE ==== # === DUBLIN. 25TH October 2011 =========================================== # ========================================================================= # ========================================================================= # === FUNCTION ADAPTED AND CODED IN PYTHON BY J. C. Vasquez-Correa # AT THE PATTERN RECOGNITION LAB, UNIVERSITY OF ERLANGEN-NUREMBERG ==== # === ERLANGEN, MAY, 2018 =========================================== # ========================================================================= ## Initial settings GCI_relAmp = np.asarray(GCI_relAmp) relAmp_wgt = np.asarray(relAmp_wgt) cost = GCI_relAmp * relAmp_wgt #print(cost.shape) GCI_N = np.asarray(GCI_N) ncands = GCI_N.shape[1] nframe = GCI_N.shape[0] #print(ncands, nframe, cost.shape) prev = np.zeros((nframe, ncands)) pulseLen = int(fs / F0mean) GCI_opt = np.zeros(nframe) for n in range(nframe): if n < 1: continue costm = np.zeros((ncands, ncands)) for c in range(ncands): #Transitions TO states in current frame start = int(GCI_N[n, c] - pulseLen / 2) stop = int(GCI_N[n, c] + pulseLen / 2) if stop > len(x): stop = len(x) pulse_cur = x[start:stop] for p in range(ncands): #Transitions FROM states in previous frame start = int(GCI_N[n - 1, p] - pulseLen / 2) stop = int(GCI_N[n - 1, p] + pulseLen / 2) if start < 1: start = 1 if stop > len(x): stop = len(x) pulse_prev = x[start:stop] if len(pulse_cur) == 0 or np.isnan(pulse_cur[0]) or np.isnan( pulse_prev[0]): costm[p, c] = 0 else: if len(pulse_cur) != len(pulse_prev): cor_cur = 0 else: cor_cur = pearsonr(pulse_cur, pulse_prev)[0] costm[p, c] = (1 - np.abs(cor_cur)) * trans_wgt costm = costm + np.tile(cost[n - 1, 0:ncands], (ncands, 1)) costm = np.asarray(costm) costi = np.min(costm, 0) previ = np.argmin(costm, 0) cost[n, 0:ncands] = cost[n, 0:ncands] + costi prev[n, 0:ncands] = previ best = np.zeros(n + 1) best[n] = np.argmin(cost[n, 0:ncands]) for i in range(n - 1, 1, -1): best[i - 1] = prev[i, int(best[i])] for n in range(nframe): #print(n,int(best[n])) GCI_opt[n] = GCI_N[n, int(best[n])] if plots: GCI_norm = np.zeros((nframe, ncands)) GCI_opt_norm = np.zeros((nframe, ncands)) for n in range(nframe): GCI_norm[n, :] = GCI_N[n, :] - GCI_N[n, 0] GCI_opt_norm[n] = GCI_opt[n] - GCI_N[n, 0] plt.subplot(211) plt.plot(x) plt.stem(GCI_N[:, 0], -0.1 * np.ones(len(GCI_N[:, 0])), 'r') plt.stem(GCI_opt, -0.1 * np.ones(len(GCI_opt)), 'k') plt.subplot(212) #plt.plot(GCI_opt, GCI_norm) plt.plot(GCI_opt, GCI_opt_norm, 'bo') plt.show() return GCI_opt
import numpy as np import matplotlib.pyplot as plt x = np.array([1, 2, 3, 4, 5]) #h1 is unit step function h1 = np.array([1, 1, 1, 1, 1]) y1 = np.convolve(x, h1) plt.xlabel('Time index') plt.ylabel('Amplitude') plt.stem(np.arange(len(x)), x, label='$x[n]$') plt.stem(np.arange(len(y1[0:5])), y1[0:5], label='$y_1[n]$', markerfmt='ro') #自動調整子圖間的間距 plt.tight_layout() plt.grid() plt.legend() plt.show()
for i in range(1, len(arr)): for k in range(0, size): arr[i] += arr[i - k] * filter[k] # def Medfilt (x, k): # k2 = (k - 1) // 2 # y = np.zeros((len (x), k)) # y[:,k2] = x # for i in range (k2): # j = k2 - i # y[j:,i] = x[:-j] # y[:j,i] = x[0] # y[:-j,-(i+1)] = x[j:] # y[-j:,-(i+1)] = x[-1] # return np.median (y, axis=1) arr = [1, 4, 6, 8, 0, 9, 4, 9, 9, 123] arr1 = [1, 20, 40, 60, 0, 40, 60, 80, 123] # Medfilt(arr,3) arr1 = medfilt(arr1, 3) print(arr) print(arr1) plt.subplot(2, 1, 1) plt.stem(arr) plt.subplot(2, 1, 2) plt.stem(arr1) plt.show()
x = new_x.copy() z = new_z.copy() this_pobj = 0.5 * linalg.norm(A.dot(x) - b)**2 + l * linalg.norm(x, 1) pobj.append((time.time() - time0, this_pobj)) times, pobj = map(np.array, zip(*pobj)) return x, pobj, times maxit = 1000 x_ista, pobj_ista, times_ista = ista(A, b, l, maxit) x_fista, pobj_fista, times_fista = fista(A, b, l, maxit) import matplotlib.pyplot as plt plt.close('all') plt.figure() plt.stem(x0, markerfmt='go') plt.stem(x_ista, markerfmt='bo') plt.stem(x_fista, markerfmt='ro') plt.figure() plt.plot(times_ista, pobj_ista, label='ista') plt.plot(times_fista, pobj_fista, label='fista') plt.xlabel('Time') plt.ylabel('Primal') plt.legend() plt.show()
p = 100 # Ambient dimension n = 100 # Number of samples # Generate a p-dimensional zero vector x_star = np.random.randn(p) # Normalize x_star = (1 / la.norm(x_star, 2)) * x_star # In[2]: # Plot xs = range(p) markerline, stemlines, baseline = plt.stem(xs, x_star, '-.') plt.setp(markerline, 'alpha', 0.3, 'ms', 6) plt.setp(markerline, 'markerfacecolor', 'b') plt.setp(baseline, 'color', 'r', 'linewidth', 1, 'alpha', 0.3) plt.rc('text', usetex=True) #plt.rc('font', family='serif') plt.xlabel('Index') plt.ylabel('Amplitude') plt.show() # <center> How would you solve this problem? </center> # <center>Closed form solution using matrix inverse</center> # # \begin{align}
lg.DI_set_acquisition_mode('Record') lg.DI_set_divider(500) #divider factor lg.DI_set_sample_bits(8) #format:among 8, 16, 32 lg.cSamples = 5000 lg.DI_set_samples(5000) # lg.DI_trigsrc('detectdigital') lg.DI_trig_position(lg.cSamples) lg.DI_trig_set(1, 'fsRise') #4.0 Excution pttn.PCtrig() lg.DI_start_acquisition() lg.DI_read_record() lg.CloseAll() pttn.CloseAll() # post processing data = np.zeros(len(lg.rgwSamples)) for idx in range(len(data)): data[idx] = lg.rgwSamples[idx] & 0x0F del lg, pttn plt.stem(data[0:32]) plt.show()