def cepstral_analysis(self, aic_type='aic', Kmin_corrfactor=1.0, bayes_p=False, density_grid=None): """Perform the Cepstral Analysis on all blocks.""" if self.GUI: progbar = FloatProgress(min=0, max=100) progbar.description = "0 %" display(progbar) self.BLOCK_NFREQS = self.BLOCK_SIZE / 2 + 1 if self.MULTI_COMPONENT: print ' N_COMPONENTS = {:10d}'.format(self.N_COMPONENTS) self.ck_THEORY_var, self.psd_THEORY_mean = multicomp_cepstral_parameters( self.BLOCK_NFREQS, self.N_COMPONENTS) self.bayes_p = bayes_p if (self.N_BLOCKS == 1): raise NotImplemented('One block.') for L in range(self.N_BLOCKS): if self.MULTI_COMPONENT: self.block[L].compute_psd(DT=self.TSKIP, DT_FS=self.DT_FS, average_components=True) self.block[L].dct = ta.CosFilter(self.block[L].logpsd, \ ck_theory_var=self.ck_THEORY_var, psd_theory_mean=self.psd_THEORY_mean, aic_type=aic_type, Kmin_corrfactor=Kmin_corrfactor, normalization=self.BLOCK_SIZE) else: self.block[L].compute_psd(DT=self.TSKIP, DT_FS=self.DT_FS) self.block[L].dct = ta.CosFilter( self.block[L].logpsd, aic_type=aic_type, Kmin_corrfactor=Kmin_corrfactor, normalization=self.BLOCK_SIZE) # theory_var=None self.block[L].dct.scan_filter_tau() if self.bayes_p: self.block[L].dct.compute_p_aic(method='ba') if density_grid is not None: self.density_grid = density_grid self.block[L].dct.compute_logtau_density( method='ba', only_stats=False, density_grid=density_grid) else: self.block[L].dct.compute_logtau_density(method='ba', only_stats=True) if self.GUI: progbar.value = float(L + 1) / self.N_BLOCKS * 100. progbar.description = "%5.2f %%" % progbar.value if self.GUI: progbar.close() self.freqs = self.block[0].freqs return
def read_datalines(self, NSTEPS=0, start_step=-1, select_ckeys=None, max_vector_dim=None, even_NSTEPS=True): """Read NSTEPS steps of file, starting from start_step, and store only the selected ckeys. INPUT: NSTEPS -> number of steps to read (default: 0 -> reads all the file) start_step = -1 -> continue from current step (default) 0 -> go to start step N -> go to N-th step select_ckeys -> an array with the column keys you want to read (see all_ckeys for a list) max_vector_dim -> when reading vectors read only this number of components (None = read all components) even_NSTEPS -> round the number of steps to an even number (default: True) OUTPUT: data -> a dictionary with the selected-column steps """ if self._GUI: progbar = FloatProgress(min=0, max=100) display(progbar) start_time = time() if (NSTEPS == 0): NSTEPS = self.MAX_NSTEPS self._set_ckey(select_ckeys, max_vector_dim) # set the ckeys to read self._initialize_dic(NSTEPS) # allocate dictionary self.gotostep(start_step) # jump to the starting step # read NSTEPS of the file progbar_step = max(100000, int(0.005*NSTEPS)) for step in range(NSTEPS): line = self.file.readline() if len(line) == 0: # EOF print "Warning: reached EOF." break values = np.array(line.split()) for key, idx in self.ckey.iteritems(): # save the selected columns self.data[key][step,:] = np.array(map(float, values[idx])) if ( (step+1)%progbar_step == 0 ): if self._GUI: progbar.value = float(step+1)/NSTEPS*100.; progbar.description = "{:6.2f}%".format(progbar.value) else: print " step = {:9d} - {:6.2f}% completed".format(step+1, float(step+1)/NSTEPS*100.) if self._GUI: progbar.close() # check number of steps read, keep an even number of steps if (step + 1 < self.NSTEPS): if (step == 0): print "WARNING: no step read." return else: print "Warning: less steps read." self.NSTEPS = step + 1 if even_NSTEPS: if (NSTEPS%2 == 1): NSTEPS = NSTEPS - 1 for key, idx in self.ckey.iteritems(): # free memory not used self.data[key] = self.data[key][:NSTEPS,:] print " ( %d ) steps read." % (NSTEPS) self.NSTEPS = NSTEPS print "DONE. Elapsed time: ", time()-start_time, "seconds" return self.data
def evaluate (self, df, is_training, batch_size, sess, dropout_prob = 0.2): X = get_feature_X(df,maxlen) Y = pd.get_dummies(df.is_duplicate) sess = self.sess start_index = 0 final_loss = 0 final_acc = 0 current_total_trained =0 p_bar = FloatProgress() display(p_bar) start_time = time.time() while start_index < X[0].shape[0]: temp_x1 = X[0][start_index:start_index+batch_size] temp_x2 = X[1][start_index:start_index+batch_size] temp_seq_len1 = X[2][start_index:start_index+batch_size] temp_seq_len2 = X[3][start_index:start_index+batch_size] test_y = Y[start_index:start_index+batch_size] feed_dict = { self.min_mask1: get_init_min_mask_value(temp_seq_len1), self.min_mask2: get_init_min_mask_value(temp_seq_len2), self.seq_length1: temp_seq_len1, self.seq_length2: temp_seq_len2, self.input: temp_x1, self.input2: temp_x2, self.y: test_y } if is_training: feed_dict[self.prob] = 1 - dropout_prob current_total_trained += temp_x1.shape[0] if is_training: # the exact output you're looking for: _, c, ac = sess.run([self.optimizer, self.loss, self.acc], feed_dict=feed_dict) final_loss += c * temp_x1.shape[0] final_acc += ac * temp_x1.shape[0] #print("%s/%s training loss %s" % (start_index, X[0].shape[0], final_loss/current_total_trained)) # sys.stdout.write("\r%s/%s training loss %s" % (start_index, X[0].shape[0], c)) # sys.stdout.flush() duration = time.time() - start_time speed = duration/current_total_trained eta = (X[0].shape[0]-current_total_trained)*speed p_bar.value = current_total_trained/X[0].shape[0] p_bar.description = "%s/%s, eta %s sec"%(current_total_trained, X[0].shape[0], eta) else: c, ac, pred, real = sess.run([self.loss, self.acc, self.output, self.y], feed_dict=feed_dict) final_loss += c * temp_x1.shape[0] final_acc += ac * temp_x1.shape[0] # print('real:', real) # print('pred:', pred) print(sum(np.argmax(real, axis=1)==np.argmax(pred, axis=1))) start_index += batch_size final_loss = final_loss/X[0].shape[0] final_acc = final_acc/X[0].shape[0] return final_loss, final_acc
def iter_progress(it, n): f = FloatProgress(min=0, max=n) display(f) for x in it: yield x f.value += 1 f.description = f'{int(100*f.value/n)}%'
def read_timesteps(self, selection, start_step=-1, select_ckeys=None, fast_check=True): """ Read selected keys of file, within the provided range. Examples: read_timesteps(10, start_step=0, select_ckeys=['id,xu,yu,vu']) -->> Read first 10 timesteps, only the specified columns read_timesteps(10, select_ckeys=['id,xu,yu,vu']) -->> Read the next 10 timesteps, only the specified columns (DELTA_TIMESTEP is assumed) read_timesteps((10,30)) -->> Read from TIMESTEP 10 to 30 read_timesteps((10,30,2)) -->> Read every 2 steps from TIMESTEP 10 to 30 """ if self._GUI: progbar = FloatProgress(min=0, max=100) display(progbar) start_time = time() self._set_ckey(select_ckeys) # set the ckeys to read --> ckey self._set_timesteps(selection, start_step) # set the timesteps to read --> timestep self._initialize_dic() # allocate dictionary --> data # extract the steps from the file progbar_step = max(1000, int(0.005 * self.nsteps)) atomid_col = self.all_ckeys['id'][0] for istep, step in enumerate(self.timestep): self._gototimestep(step, fast_check) # jump to the desired step, self.data[istep]['TIMESTEP'] = step for nat in range(self.NATOMS): # read data (may be unsorted) line = self.file.readline() if len(line) == 0: # EOF raise EOFError('Warning: reached EOF.') values = np.array(line.split()) for key, idx in self.ckey.items(): # save the selected columns atomid = int(values[atomid_col]) - 1 # current atom index (in LAMMPS it starts from 1) if (key == 'element'): # this should be improved self.data[istep][key][atomid, :] = np.array(list(map(str, values[idx]))) else: self.data[istep][key][atomid, :] = np.array(list(map(float, values[idx]))) if ((istep + 1) % progbar_step == 0): if self._GUI: progbar.value = float(istep + 1) / self.nsteps * 100. progbar.description = '%g %%' % progbar.value else: log.write_log(' step = {:9d} - {:6.2f}% completed'.format(istep + 1, float(istep + 1) / self.nsteps * 100.)) if self._GUI: progbar.close() # check number of steps read, keep an even number of steps if (istep + 1 < self.nsteps): # (should never happen) if (istep == 0): log.write_log('WARNING: no step read.') return else: log.write_log('Warning: less steps read.') self.nsteps = istep + 1 if not self._quiet: log.write_log(' ( %d ) steps read.' % (self.nsteps)) log.write_log('DONE. Elapsed time: ', time() - start_time, 'seconds') self._compute_current_step = False # next time do not compute the current_step return self.data
def cepstral_analysis_kappa(self,other, aic_type='aic', Kmin_corrfactor=1.0, bayes_p=False, density_grid=None): #need also "other", a class with the charge current! """Perform the Cepstral Analysis on all blocks.""" if self.GUI: progbar = FloatProgress(min=0, max=100) progbar.description = "0 %" display(progbar) self.BLOCK_NFREQS = self.BLOCK_SIZE/2 + 1 if self.MULTI_COMPONENT: print ' N_COMPONENTS = {:10d}'.format(self.N_COMPONENTS) self.ck_THEORY_var, self.psd_THEORY_mean = tc.md.cepstral.multicomp_cepstral_parameters(self.BLOCK_NFREQS, self.N_COMPONENTS-1) #different number of degrees of freedom! self.bayes_p = bayes_p if (self.N_BLOCKS == 1): raise NotImplementedError('One block.') for L in range(self.N_BLOCKS): if self.MULTI_COMPONENT: self.block[L].compute_kappa(other=other.block[L],DT=self.TSKIP, DT_FS=self.DT_FS, average_components=True) #different method call! self.block[L].dct = tc.md.CosFilter(self.block[L].logpsd, \ ck_theory_var=self.ck_THEORY_var, psd_theory_mean=self.psd_THEORY_mean, aic_type=aic_type, Kmin_corrfactor=Kmin_corrfactor)#, normalization=self.BLOCK_SIZE) #removed (personal comunication with Loris) else: self.block[L].compute_kappa(other=other.block[L],DT=self.TSKIP, DT_FS=self.DT_FS) #different method call! self.block[L].dct = tc.md.CosFilter(self.block[L].logpsd, aic_type=aic_type, Kmin_corrfactor=Kmin_corrfactor)#, normalization=self.BLOCK_SIZE) # theory_var=None self.block[L].dct.scan_filter_tau() if self.bayes_p: self.block[L].dct.compute_p_aic(method='ba') if density_grid is not None: self.density_grid = density_grid self.block[L].dct.compute_logtau_density(method='ba', only_stats=False, density_grid=density_grid) else: self.block[L].dct.compute_logtau_density(method='ba', only_stats=True) if self.GUI: progbar.value = float(L+1)/self.N_BLOCKS*100.; progbar.description = "%5.2f %%" % progbar.value if self.GUI: progbar.close() self.freqs = self.block[0].freqs return
def labeled_progress(it, n, labels, fillvalue="...", final=""): "Iterator and set of labels. Reports progress with bar and label." detail = HTML(value='<i>initializing</i>', disabled=True) f = FloatProgress(min=0, max=n) display(HBox([f, detail])) for x, label in zip_longest(it, labels, fillvalue=fillvalue): detail.value = label yield x f.value += 1 f.description = f'{int(100*f.value/n)}%' detail.value = final
def gradients(self, df , batch_size, sess): X = get_feature_X(df,maxlen) Y = pd.get_dummies(df.is_duplicate) sess = self.sess start_index = 0 final_loss = 0 current_total_trained =0 p_bar = FloatProgress() display(p_bar) start_time = time.time() while start_index < X[0].shape[0]: temp_x1 = X[0][start_index:start_index+batch_size] temp_x2 = X[1][start_index:start_index+batch_size] temp_seq_len1 = X[2][start_index:start_index+batch_size] temp_seq_len2 = X[3][start_index:start_index+batch_size] test_y = Y[start_index:start_index+batch_size] feed_dict = { self.min_mask1: get_init_min_mask_value(temp_seq_len1), self.min_mask2: get_init_min_mask_value(temp_seq_len2), self.seq_length1: temp_seq_len1, self.seq_length2: temp_seq_len2, self.input: temp_x1, self.input2: temp_x2, self.y: test_y } current_total_trained += temp_x1.shape[0] var_grad = tf.gradients(self.loss, [self.output])[0] # the exact output you're looking for: g = sess.run([var_grad, self.concat_output], feed_dict=feed_dict) print("gradient %s" % (g)) # sys.stdout.write("\r%s/%s training loss %s" % (start_index, X[0].shape[0], c)) # sys.stdout.flush() duration = time.time() - start_time speed = duration/current_total_trained eta = (X[0].shape[0]-current_total_trained)*speed p_bar.value = current_total_trained/X[0].shape[0] p_bar.description = "%s/%s, eta %s sec"%(current_total_trained, X[0].shape[0], eta) start_index += batch_size break final_loss = final_loss/X[0].shape[0] return final_loss
def read_datalines(filedata, ckey, even_NSTEPS=True, GUI=False): if GUI: progbar = FloatProgress(min=0, max=100) display(progbar) NSTEPS = len(filedata) - 1 data = initialize_dic(NSTEPS, ckey) progbar_step = max(100000, int(0.005*NSTEPS)) for step, line in enumerate(filedata[1:]): if len(line) == 0: # EOF print "Warning: reached EOF." break values = np.array(line.split()) for key, idx in ckey.iteritems(): # save the selected columns data[key][step,:] = np.array(map(float, values[idx])) if ( (step+1)%progbar_step == 0 ): if GUI: progbar.value = float(step+1)/NSTEPS*100.; progbar.description = "{:6.2f}%".format(progbar.value) else: print " step = {:9d} - {:6.2f}% completed".format(step+1, float(step+1)/NSTEPS*100.) if GUI: progbar.close() # check number of steps read, keep an even number of steps if (step + 1 < NSTEPS): if (step == 0): print "WARNING: no step read." return else: print "Warning: less steps read." NSTEPS = step + 1 if even_NSTEPS: if (NSTEPS%2 == 1): NSTEPS = NSTEPS - 1 for key, idx in ckey.iteritems(): # free memory not used data[key] = data[key][:NSTEPS,:] print " ( %d ) steps read." % (NSTEPS) return data
def read_datalines(self, NSTEPS=0, start_step=-1, select_ckeys=None, max_vector_dim=None, even_NSTEPS=True): """ Read NSTEPS steps of file, starting from start_step, and store only the selected ckeys. INPUT: NSTEPS -> number of steps to read (default: 0 -> reads all the file) start_step = -1 -> continue from current step (default) 0 -> go to start step N -> go to N-th step select_ckeys -> an array with the column keys you want to read (see all_ckeys for a list) max_vector_dim -> when reading vectors read only this number of components (None = read all components) even_NSTEPS -> round the number of steps to an even number (default: True) OUTPUT: data -> a dictionary with the selected-column steps """ if self._GUI: progbar = FloatProgress(min=0, max=100) display(progbar) start_time = time() if (NSTEPS == 0): NSTEPS = self.MAX_NSTEPS self._set_ckey(select_ckeys, max_vector_dim) # set the ckeys to read self._initialize_dic(NSTEPS) # allocate dictionary self.gotostep(start_step) # jump to the starting step # read NSTEPS of the file progbar_step = max(100000, int(0.005 * NSTEPS)) for step in range(NSTEPS): line = self.file.readline() if (len(line) == 0): # EOF log.write_log('Warning: reached EOF.') break if self.endrun_keyword in line: # end-of-run keyword log.write_log(' endrun_keyword found.') step -= 1 break values = np.array(line.split()) if (values.size != self.NALLCKEYS): log.write_log( 'Warning: line with wrong number of columns found. Stopping here...' ) log.write_log(line) break for key, idx in self.ckey.items(): # save the selected columns self.data[key][step, :] = np.array( list(map(float, values[idx]))) if ((step + 1) % progbar_step == 0): if self._GUI: progbar.value = float(step + 1) / NSTEPS * 100. progbar.description = '{:6.2f}%'.format(progbar.value) else: log.write_log( ' step = {:9d} - {:6.2f}% completed'.format( step + 1, float(step + 1) / NSTEPS * 100.)) if self._GUI: progbar.close() # check number of steps read, keep an even number of steps if (step + 1 < NSTEPS): if (step == 0): log.write_log('WARNING: no step read.') return else: if (NSTEPS != self.MAX_NSTEPS): # if NSTEPS was specified log.write_log('Warning: less steps read.') NSTEPS = step + 1 # the correct number of read steps # even the number of steps if even_NSTEPS: if (NSTEPS % 2 == 1): NSTEPS = NSTEPS - 1 log.write_log( ' Retaining an even number of steps (even_NSTEPS=True).') for key, idx in self.ckey.items(): # free the memory not used self.data[key] = self.data[key][:NSTEPS, :] log.write_log(' ( %d ) steps read.' % (NSTEPS)) self.NSTEPS = NSTEPS log.write_log('DONE. Elapsed time: ', time() - start_time, 'seconds') return self.data
adam_params = {"lr": 0.1} #adam_params = {"lr": 0.005, "betas": (0.9, 0.999)} optimizer = pyro.optim.Adam(adam_params) #optimizer = pyro.optim.SGD(adam_params) svi = SVI(model, guide, optimizer, loss=Trace_ELBO()) # CHANGE: use a nice progress bar n_steps = 400 pro = FloatProgress(min=0, max=n_steps - 1) display(pro) for step in range(n_steps): svi.step(data) pro.value += 1 pro.description = str(step) # CHANGE: change only at the end np.save(file="qalpha0", arr=pyro.param("qalpha0").detach().numpy()) np.save(file="qalpha1", arr=pyro.param("qalpha1").detach().numpy()) plt.imshow(data_vis[:, 80:180]) # ADD: quick plot before exhaustive plot loaded = np.load("qalpha1.npy") plt.imshow(-loaded.reshape(-1, ntr), cmap="gray") plt.show() for i in range(nz): #plt.imshow(loaded[i].squeeze()) print(loaded[i].sum())
def benchmark(param, param_range=[0, 1, 0.1], learn=[], learn_i=[], test=[], test_i=[], learn_v="auto", test_v="auto", options={}, folder_learn="src/learning/", folder_test="src/tests/", neurons=(100), curve="interpolate"): """ Effectue un banc de tests avec des paramètres donnés en évaluant la précision du réseau de neurones artificiels. :param param: Nom du paramètre à changer (doit être le nom de la variable tel que défini dans la fonction compare) :type param: string (paramètre accepté par la fonction compare) :param param_range: Tableau tridimensionnel contenant la valeur de début, de fin et le pas :type param_range: number[start, end, step] :param learn: Liste de noms formattable des échantillons d'apprentissage :type learn: string[] :param test: Liste de noms formattable des échantillons de test :type test: string[] :param learn_i: Liste de range (de 1 à n) pour la génération des fichiers du paramètre learn :type learn_i: number[] :param test_i: Liste de range (de 1 à n) pour la génération des fichiers du paramètre test :type test_i: number[] :param learn_v: Liste des valeurs des échantillons d'apprentissage (déterminé selon le nom du fichier si non précisé) :type learn_v: string[] :param test_v: Liste des valeurs des échantillons de test (déterminé selon le nom du fichier si non précisé) :type test_v: string[] :param folder_learn: Dossier contenant les échantillons d'apprentissage :type folder_learn: string :param folder_test: Dossier contenant les échantillons de tests :type folder_test: string :param options: Options de comparaison (voir la documentation de compare, certains paramètres sont requis) :type options: object :param neurons: Nombre de couches et de neuronnes :type neurons: (number, ...) """ # Initialisation x = [] y = [] # Barre de progression progress = FloatProgress(min=param_range[0], max=param_range[1]+param_range[2], description="En attente...") display(progress) # Récupération des noms de fichiers pour réduire les temps de calculs #_learn = learning_files(learn, learn_i) #_test = learning_files(test, test_i) # Variation du paramètre for value in np.arange(param_range[0], param_range[1]+param_range[2], param_range[2]): # Calculs en cours progress.value = value progress.description = "{p} : {v}".format(p=param, v=value) options[param] = value x.append(value) y.append(learning( learn=learn, learn_i=learn_i, test=test, test_i=test_i, learn_v=learn_v, test_v=test_v, debug=False, benchmark_only=True, progress=[progress, param_range[2]], options=options, folder_learn=folder_learn, folder_test=folder_test, neurons=neurons )) # Mise à jour de la barre de progression progress.value = progress.max progress.description = "Terminé !" progress.bar_style = "success" # Nouvelle figure plt.figure(figsize=(8, 8), dpi= 80, facecolor="w", edgecolor="k") ax = plt.subplot(111) if (curve == "interpolate") and (len(x) >= 3): xi = np.linspace(x[0], x[-1], num=len(x)*10) ax.plot(xi, interp1d(x, y, kind="cubic")(xi)) else: ax.plot(x, y) ax.set_xlabel("Variation du paramètre {x}".format(x=param)) ax.set_xlim(param_range[0], param_range[1]) ax.set_ylabel("Précision") ax.set_ylim(0, 1) plt.show() return x, y
def worker(self): def cancel(b): self.sc.cancelJobGroup(self.job_info.group_id) def toggle(widget): def f(b): for w in widget.children: h = w.layout.height if h is None or h == "16px": w.layout.height = "0px" b.icon = "arrow-circle-down" else: w.layout.height = "16px" b.icon = "arrow-circle-right" return f style = {"description_width": "initial"} bars = {} labels = {} lastJob = None progressbars = VBox([]) cancel_button = Button(button_style="", tooltip="Cancel Spark Job", icon="window-close") cancel_button.add_class("db-button") cancel_button.on_click(cancel) toggle_button = Button(button_style="", tooltip="Toggle progress bar", icon="arrow-circle-right") toggle_button.add_class("db-button") toggle_button.on_click(toggle(progressbars)) indicator = HBox([toggle_button, progressbars]) while self.running == 1: time.sleep(0.2) jobs = [(jobid, self.tracker.getJobInfo(jobid)) for jobid in self.tracker.getJobIdsForGroup(self.job_info.group_id) if self.tracker.getJobInfo(jobid).status == "RUNNING"] for j, job in jobs: if bars.get(j, None) is None: if lastJob is not None: bars[lastJob].value = 100.0 bars[j] = FloatProgress( value=0.0, min=0.0, max=100.0, description="Job: %04d Stage: %04d" % (j, 0), bar_style="info", orientation="horizontal", style=style, ) bars[j].add_class("db-bar") labels[j] = Label( value="", description="Code:", disabled=False, layout=Layout(width="800px", height="100%", margin="0 0 0 5px"), ) labels[j].add_class("db-label") progressbar = HBox([bars[j], labels[j]]) progressbars.children = progressbars.children + ( progressbar, ) if not self.progressbar_showing: self.progressbar_showing = True display(indicator) lastJob = j stageIds = sorted(job.stageIds) for s in stageIds: stageInfo = self.tracker.getStageInfo(s) bars[j].description = "Job: %04d Stage: %04d" % (j, s) labels[j].value = "code: '%s' / stages: %s" % ( stageInfo.name, str(stageIds)[1:-1], ) if stageInfo.numActiveTasks > 0: progress = int(100 * stageInfo.numCompletedTasks / stageInfo.numTasks) bars[j].value = progress if lastJob is not None and self.running == 0: bars[lastJob].value = 100.0
def live_record2(filters, filters_fq, time_res, amp_res, fs, last, formants, drc_tl, drc_th, drc_r, duration, adc_res, predict): import pyaudio # Taille des blocs enregistrés chunk_size = 4096 # Barre de progression maxi = int(np.ceil(fs / chunk_size * duration)) progress = FloatProgress(min=0, max=maxi, description="Chargement") display(progress) # Initialisation plt.ion() f, ax = plt.subplots(2, 1, figsize=(24, 12), dpi= 80, facecolor="w", edgecolor="k") f.show() # Boucle principale try: while True: # Ouverture du flux p = pyaudio.PyAudio() stream = p.open(format=pyaudio.paInt16, channels=1, rate=fs, input=True, frames_per_buffer=chunk_size) # Enregistrement frames = [] progress.value = progress.min progress.description = "Enregistrement" progress.bar_style = "" for i in range(0, maxi): data = stream.read(chunk_size) frames.append(data) progress.value = i # Mise à jour de la barre de progression progress.value = progress.max progress.description = "Terminé !" progress.bar_style = "success" # Fermeture du flux stream.stop_stream() stream.close() p.terminate() # Enregistrement wf = wave.open("src/record.wav", "wb") wf.setnchannels(1) wf.setsampwidth(p.get_sample_size(pyaudio.paInt16)) wf.setframerate(fs) wf.writeframes(b''.join(frames)) wf.close() # Traitement ax[0].clear() ; ax[1].clear() _, _, rseqs = compute(file="src/record.wav", filters=filters, filters_fq=filters_fq, time_res=time_res, amp_res=amp_res, ax=ax, dbfs=False, drc_tl=drc_tl, drc_th=drc_th, drc_r=drc_r, adc_res=adc_res) # Prédiction if predict: f.suptitle(predict(rseqs, name=False, debug=False)[0], fontsize=30) # Pas très joli, mais évite le NonImplemented error ? try: plt.pause(3) except Exception: continue # Masque l'erreur en cas d'interruption du Kernel except KeyboardInterrupt: # Fermeture du flux stream.stop_stream() stream.close() p.terminate() clear_output() plt.close() print("Terminé !") return
#%% # *** MAIN ROUTINE ***/ # All units in m # Definitions file defs_fName = "Best fit mesh - Definitions file.csv" defs_data = npy.genfromtxt(defs_fName, dtype=None, delimiter=",", names=True) nFiles = defs_data.shape[0] # Initialise progress bar pBar = FloatProgress(min=0, max=nFiles) pBar.description = "Processing point cloud data" display(pBar) for f in arange(0, nFiles): # Update progress bar pBar.value += 1 # Read details from definitions file fName = defs_data["Filename"][f].decode('UTF-8') OD = defs_data["OD"][f] # outer diameter in m t = defs_data["t"][f] # wall thickness in m L = defs_data["L"][f] # segment length / spacing between ring flanges Le_x_target = defs_data["Le_x_target"][ f] # target length of elements in x direction Le_y_target = defs_data["Le_y_target"][