async def oneloop(dut): """perf oneloop test""" t = TicToc() tb = settings() await reset(dut) clkobj = Clock(dut.clk, tb.period, 'us') cocotb.fork(clkobj.start()) t.tic() k = 0 for cycle in range(tb.dinArate * tb.npoints): await (RisingEdge(dut.clk)) if (cycle % tb.dinArate) == 0: k = k + 1 dut.dinA <= 1 if (k % 100 == 0): dut._log.info("Sim progress...{} %".format( int(100 * float(k) / tb.npoints))) else: dut.dinA <= 0 if (cycle % tb.dinBrate) == 0: dut.dinB <= 1 else: dut.dinB <= 0 t.toc() print(t.elapsed)
def main(individuals_number): global individuals individuals = individuals_number print_variable_info() t = TicToc() t.tic() # Initialize a population population = initialize() population = [ (calculate_fitness(i), i) for i in population ] # Calculates the fitness of each individual, and stores it in pairs ordered in the form (5 , [1,2,1,1,1,4,1,8,9,4,1]) initial_population = sorted(population, key=lambda x: x[0]) # Evolves the population for i in range(generations): print("→→", i) population = selection_and_reproduction(population) print("←←") # Print the results print_results(initial_population, population) t.toc()
def run_tsp(difficulty, file_name): t = TicToc() all_cities = my_utils.generate_cities_dict(difficulty) cities_map = cities_visualitation.CitiesMap(all_cities) tsp = TravelingSalesmanProblem(all_cities, (0, ), ()) t.tic() best_known_solution_value = 0.0 if difficulty == 'big': best_known_solution_value = params.big_best_known_solution elif difficulty == 'medium': best_known_solution_value = params.medium_best_known_solution elif difficulty == 'small': best_known_solution_value = params.small_best_known_solution tsp_result, msg = search.astar_search(tsp, best_known_solution_value, display=True) print(msg) t.toc() cities_list = cities_visualitation.get_normalized_cities_identification( tsp_result.state) cities_list_evaluation = (-1) * tsp.value(tsp_result.state) cities_map.show_map(list(tsp_result.state)) cities_map.save_plot(file_name) my_utils.save_results(file_name, cities_list_evaluation, cities_list, msg)
def main(): t = TicToc() t.tic() with open("/home/ubuntu/sbmd/station", "rb") as f: fileobj = pickle.load(f) statit = fileobj[2][int(sys.argv[1])] statit = np.flip(statit) credfile = "/home/ubuntu/sbmd/dwh.cfg" config = configparser.ConfigParser() config.read(credfile) s3k = config['AWS']['KEY'] s3ks = config['AWS']['SECRET'] pool = mp.Pool(mp.cpu_count()) [pool.apply(load_trains_all, args=(co, s3k, s3ks)) for co in statit] ind = sys.argv[1] logging.info(f"Gathered conn data succesfully with index {ind}") t.toc()
def main(): #Create the Matrix to be tri-diagonalized #n = 12 #Size of input matrix (nxn) #A = SymmMat(n) #Input matrix. (Hermitian) #Hamiltonian of tV Model for L = 4, N = 2, ell=2 A = -1.0 * np.array( ((0, 1, 0, 1, 0, 0), (1, 0, 1, 0, 1, 1), (0, 1, 0, 1, 0, 0), (1, 0, 1, 0, 1, 1), (0, 1, 0, 1, 0, 0), (0, 1, 0, 1, 0, 0))) #A = -1.0*np.array(((0,0,1,0), # (0,0,1,0), # (1,1,0,1), # (0,0,1,0))) #Change print format to decimal instead of scientific notation np.set_printoptions(formatter={'float_kind': '{:f}'.format}) #Transform the matrix A to tridiagonal form via Lanczos T = LanczosTri(A) #Find Eigenvalues for Real, Symmetric, Tridiagonal Matrix via QR Iteration t2 = TicToc() t2.tic() lam = IPI(T, maxiter=50000) t2.toc() print("Eigs(T): ", lam) #Get eigenpairs of untransformed hermitian matrix A and time the process using blackbox function t1 = TicToc() t1.tic() e_gs_A, gs_A = eigsh(A, k=1, which='SA', maxiter=1000) #e_gs_A = NSI(A,maxiter=1000) t1.toc() print("Eigs(A): ", e_gs_A[0])
def derotate_image_forloop(startNum,stopNum,dateString): for f in range(startNum,stopNum+1): # loop over filenames print('----------------------------------------') print('Derotating image '+str("{:0>5d}".format(f))+'...') t = TicToc() # create instance of timer t.tic() # start timer # retrieve image image, header = fits.getdata(calibrated_trapezium_data_stem+ 'step02_dewarped/'+ 'lm_'+dateString+'_'+ str("{:0>5d}".format(f))+ '.fits', 0, header=True) # find PA from header pa = header['LBT_PARA'] # derotate image_derot = rot(image, -pa, [1024,1024], order=3, pivot=False) # axis coord here is just a dummy # save fits.writeto(calibrated_trapezium_data_stem+ 'step03_derotate/'+ 'lm_'+dateString+'_'+ str("{:0>5d}".format(f))+ '.fits', image_derot, header, overwrite=False) t.toc() print('------------------------------')
def main(individuals_number, crossover, mutation): global individuals individuals = individuals_number global crossover_type crossover_type = crossover global mutation_type_random mutation_type_random = mutation print_variable_info() t = TicToc() t.tic() # Initialize a population population = initialize() population = [(fitnes(i), i) for i in population] # Calculates the fitness of each individual, and stores it in pairs ordered in the form (5 , [1,2,1,1,1,4,1,8,9,4,1]) initial_population = sorted(population, reverse=True) # Evolves the population for i in range(generations): population = selection_and_reproduction(population) population = mutate(population) # Print the results print_results(initial_population, population) t.toc()
def accuracyCalculator(dataSetLoader, crrNeuralNet): ''' Calculate and return accuracy on the given data set using current trained Neural Net Args: dataSetLoader: given data set loader crrNeuralNet: given current trained neural net. Returns: accuracyForCurrentNet: current accuracy on the given data set by trained net at current epoch ''' numOfCorrectPrediction = 0 numOfTotalDataPoints = 0 timerObj = TicToc() timerObj.tic() with torch.no_grad(): for crrData in dataSetLoader: crrInputData, crrLabels = crrData predictedOutputs = crrNeuralNet.feedForward(crrInputData) _, predictedLabels = torch.max(predictedOutputs.data, 1) numOfTotalDataPoints += crrLabels.size(0) numOfCorrectPrediction += ( predictedLabels == crrLabels).sum().item() accuracyForCurrentNet = numOfCorrectPrediction / numOfTotalDataPoints print('Accuracy of the network on the images(train or test): %d %%' % (100 * numOfCorrectPrediction / numOfTotalDataPoints)) timerObj.toc() return accuracyForCurrentNet
def print_time_operation_took(function): """ Print the time it took to complete a given function :param function: the function to run """ t = TicToc() function() t.toc()
async def ocr_translate(request): tic_toc = TicToc() # Read the image from the web request tic_toc.tic() image_bytes = await request.read() image = imread(image_bytes, pilmode="RGB") tic_toc.toc("Read image in") results = await get_ocr_results(ctx.ocr, image, ctx.max_height) return web.json_response({"results": results})
def _find_matches_in_database(db_value_finder, potential_values): matches = [] tic_toc = TicToc() tic_toc.tic() print(f'Find potential candiates "{potential_values}" in database {db_value_finder.database}') try: matching_db_values = db_value_finder.find_similar_values_in_database(potential_values) matches = list(map(lambda v: v[0], matching_db_values)) except Exception as e: print(f"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Error executing a query by the database finder. Error: {e}") tic_toc.toc() return matches
def derotate_image_forloop(dateString): # obtain the list of files which have been dewarped, and need to de-rotated # according to the PA in the FITS headers asterism_frames_directory_retrieve = str( config["data_dirs"]["DIR_ASTERISM_DEWARP"]) asterism_frames_pre_derot_names = list( glob.glob(os.path.join(asterism_frames_directory_retrieve, "*.fits"))) for f in range( 0, len(asterism_frames_pre_derot_names)): # loop over filenames print('----------------------------------------') t = TicToc() # create instance of timer t.tic() # start timer # retrieve image image, header = fits.getdata(asterism_frames_pre_derot_names[f], 0, header=True) #print(header) try: # find PA from header pa = np.float(header['LBT_PARA']) # derotate image_derot = rot(im=image, angle=-pa, axis=[1024, 1024], order=3, pivot=False) # axis coord here is just a dummy #print(angle) print('Derotating image ' + str(os.path.basename(asterism_frames_pre_derot_names[f])) + '...') # save fits.writeto(str(config["data_dirs"]["DIR_ASTERISM_DEROT"] + \ "derotated_" + \ os.path.basename(asterism_frames_pre_derot_names[f])), image_derot, header, overwrite=True) t.toc() print('----------------------------------------') except: print("Frame " + str(os.path.basename(asterism_frames_pre_derot_names[f])) + \ " has no parallactic angle. Maybe header keyword being sought is wrong?")
def train_epoch(self, epoch, X_iter, verbose=0): t = TicToc() start = t.tic() epoch_loss = 0.0 num_batches = 5 for idx, inputs in enumerate(X_iter): inputs = inputs['input'] batch_size = inputs.shape[0] # Convert to tensors and move to device inputs = torch.tensor(inputs).to(self.device) # Train batch and get batch loss batch_loss = self.train_batch(inputs) # Update epoch loss given als batch loss epoch_loss += batch_loss if verbose != 0: print( '[{}] Epoch: {} #batches {}/{}, loss: {:.8f}, learning rates: {:.6f}/{:.6f}' .format(datetime.timedelta(seconds=int(t.toc() - start)), epoch + 1, idx + 1, num_batches, (batch_loss / ((idx + 1) * batch_size)), self.encoder_lr, self.decoder_lr), end='\r') return epoch_loss
def integrateFittedPeakIntensity(self, spaDict=""): inTimer = TicToc() inTimer.tic() if spaDict == "": spaDict = self.SPAResultRawDict for frameID, frameDict in spaDict.items(): numberOfSpot = frameDict["numberOfSpot"] totalIntensity = 0 for spotID in range(int(numberOfSpot)): spotDict = frameDict[str(spotID)] Am = spotDict["Am"] xCenter = spotDict["xCenter"] yCenter = spotDict["yCenter"] sigma_x = spotDict["sigma_x"] sigma_y = spotDict["sigma_y"] theta = spotDict["theta"] xUpperLimit = xCenter + self.halfCropRange xLowerLimit = xCenter - self.halfCropRange yUpperLimit = yCenter + self.halfCropRange yLowerLimit = yCenter - self.halfCropRange spotDict["integratedIntensity"], spotDict["integratedIntensityError"] = dblquad( lambda x, y: fitFunc.gauss2D(x, y, Am, xCenter, yCenter, sigma_x, sigma_y, theta), yLowerLimit, yUpperLimit, lambda x: xLowerLimit, lambda x: xUpperLimit) totalIntensity += spotDict["integratedIntensity"] frameDict["totalIntensity"] = totalIntensity if int(frameID) % 50 == 0: print("Integrating Frame ID:", frameID, end=', ') inTimer.toc() for frameID, frameDict in spaDict.items(): numberOfSpot = frameDict["numberOfSpot"] for spotID in range(int(numberOfSpot)): spotDict = frameDict[str(spotID)] spotDict["integratedIntensityRatio"] = spotDict["integratedIntensity"] / frameDict["totalIntensity"] self.SPAResultRawDict = spaDict return self.SPAResultRawDict
def components( nodes ): #randomize graph and calculate connected components given number of nodes G = Graph.Erdos_Renyi(nodes, p=0.3) t = TicToc() #create an adjacency matrix. #An = (sparse(1:nodes,assig,np.ones(1,nodes),nodes,nodes)) tables = G.components(mode=WEAK) largest = max(tables) t.tic() adj = G.get_adjacency() t.toc() return (tables, largest, adj, t.tocvalue())
def value_iteration(self, rewards, error=1): # Initialize the value function t_complete_func = TicToc() t_complete_func.tic() values = np.zeros([self.n_states]) states_range_value = range(0, self.n_states) print "states range value is ", states_range_value self.rewards = rewards # estimate values while True: # Temporary copy to check find the difference between new value function calculated & current value function # to ensure improvement in value self.values_tmp = values.copy() t_value = TicToc() t_value.tic() for q, s in self.map(self.calc_value_for_state, states_range_value): values[s] = q # print "\nvalues is ", values[s] ''' for s in range(self.n_states): values[s] = max( [sum([P_a[s, a, s1] * (rewards[s] + self.gamma * values_tmp[s1]) for s1 in range(self.n_states)]) for a in range(self.n_actions)]) ''' t_value.toc('Value function section took') # print "values ", values[s] if max([ abs(values[s] - self.values_tmp[s]) for s in range(self.n_states) ]) < error: break # generate deterministic policy policy = np.zeros([self.n_states]) for s in range(self.n_states): policy[s] = np.argmax([ sum([ self.P_a[s, a, s1] * (self.rewards[s] + self.gamma * values[s1]) for s1 in range(self.n_states) ]) for a in range(self.n_actions) ]) t_complete_func.toc('Complete function section took') return values, policy
def derotate_image_northern_target(fileNum, ignoreExisting=True): # this takes single images (intended for multiprocessing) print('----------------------------------------') t = TicToc() # create instance of timer t.tic() # start timer if ignoreExisting: # if the file already exists, skip it if os.path.exists(dirTreeStem + depositPiece + fileNameStem + str("{:0>5d}".format(fileNum)) + '.fits'): print('Not derotating frame ' + str(fileNum) + '!') return else: if os.path.exists(dirTreeStem + retrievalPiece + fileNameStem + str("{:0>5d}".format(fileNum)) + '.fits'): print('Derotating image ' + str("{:0>5d}".format(fileNum)) + '...') # retrieve image image, header = fits.getdata( dirTreeStem + retrievalPiece + fileNameStem + str("{:0>5d}".format(fileNum)) + '.fits', 0, header=True) # find PA from header pa = header['LBT_PARA'] # derotate image_derot = rot( image, 180. - pa - pa_corrxn, [1024, 1024], order=3, pivot=False) # axis coord here is just a dummy # save hdu = fits.PrimaryHDU(image_derot, header=header) hdulist = fits.HDUList([hdu]) hdulist.writeto(dirTreeStem + depositPiece + fileNameStem + str("{:0>5d}".format(fileNum)) + '.fits', overwrite=True) t.toc() print('------------------------------')
def components( nodes ): #randomize graph and calculate connected components given number of nodes G = nx.erdos_renyi_graph(nodes, 0.3) t = TicToc() #t.tic() #create an adjacency matrix. #An = (sparse(1:nodes,assig,np.ones(1,nodes),nodes,nodes)) tables = nx.connected_components(G) largest = max(tables) t.tic() adj = G.adjacency() t.toc() return (tables, largest, adj, t.tocvalue())
def conventional_training(dataset, learner): print("[*] Training with a conventional optimizer...") # Make the training / eval splits model = learner optimizer = torch.optim.Adam(model.parameters()) criterion = torch.nn.MSELoss(reduction='sum') train_dataset, eval_dataset = dataset[0], dataset[0][1] print("[*] Evaluating with random initialization...") total_loss = 0 for i, (x, y) in enumerate(eval_dataset): y_pred = model(x.to(device)) loss = criterion(y_pred, y.to(device)) # print(f"-> Batch {i}: {loss}") total_loss += loss avg_loss = total_loss.item() / len(eval_dataset) print(f"[*] Average evaluation loss: {avg_loss}") t = TicToc() model.train() t.tic() for i in range(2000): loss = 0 optimizer.zero_grad() for x, y in train_dataset: y_pred = model(x) loss += criterion(y_pred, y) if i % 100 == 99: print(i, loss.item() / len(train_dataset)) t.toc() t.tic() loss.backward() optimizer.step() print("[*] Evaluating...") model.eval() total_loss = 0 with torch.no_grad(): for i, (x, y) in enumerate(eval_dataset): y_pred = model(x.to(device)) loss = criterion(y_pred, y.to(device)) total_loss += loss avg_loss = total_loss.item() / len(eval_dataset) print(f"[*] Average evaluation loss: {avg_loss}")
def inference_worker(graph, input_q): t = TicToc() while True: frame = input_q.get() t.tic() X = cv2.resize(frame / 255. - 0.5, dim, interpolation=cv2.INTER_NEAREST).astype(numpy.float16) graph.LoadTensor(X, None) out, _ = graph.GetResult() # do some post processing spatial_grid = out.reshape(output_dim) conf = spatial_grid.squeeze()[:, :, -1] idx = numpy.unravel_index(numpy.argmax(conf), conf.shape) val = spatial_grid[idx[0], idx[1], :] v1 = idx[0] * 32 + val[0] * 32 v2 = idx[1] * 32 + val[1] * 32 display_q.put_nowait(((X + 0.5) * 255., (v1, v2))) t.toc()
def startShiftCenter(self): t = TicToc() t.tic() for filePath in self.fileList: whileLoopCounter = 0 fileName = ntpath.basename(filePath) print(fileName) while True: whileLoopCounter += 1 numberOfSpot, returnList, imageArray = self.applySEPToImg(filePath) if whileLoopCounter > 200: break if numberOfSpot == 1: break if numberOfSpot > 1: self.searchThreshold = self.searchThreshold * 1.05 if self.debugMode: print(fileName, self.searchThreshold, "increase") if numberOfSpot < 1: self.searchThreshold = self.searchThreshold * 0.9 if self.debugMode: print(fileName, self.searchThreshold, "decrease") if whileLoopCounter > 250: xCenter, yCenter = lastxCenter, lastyCenter else: xCenter, yCenter = int(returnList[4]), int(returnList[5]) lastxCenter, lastyCenter = xCenter, yCenter if self.setIntCenter != True: intXCenter, intYCenter = xCenter, yCenter self.setIntCenter = True xShift = intXCenter - xCenter yShift = intYCenter - yCenter imageArray = shift(imageArray, [yShift, xShift]) self.saveImArrayTo(imageArray, self.dataFolderName + "ShiftCenterResult/" + fileName) t.toc()
def main(): list_size = 214748365 #int max / 10 list_one = [2 for x in range(list_size)] list_two = [3 for x in range(list_size)] list_three = [0 for x in range(list_size)] threads = [] t = TicToc() ## TicToc("name") t.tic(); for i in range(list_size): thread = Thread(target=threadAdd, args=[list_one, list_two, list_three, i]) thread.start() threads.append(thread) for thread in threads: thread.join() t.toc(); print(t.elapsed) print(list_three)
def main(): pool = mp.Pool(mp.cpu_count()) t = TicToc() t.tic() cities = [ "München", "Puchheim", "Germering", "Fürstenfeldbruck", "Olching", "Gröbenzell", "Murnau", "Miesbach", "Gersthofen", "Wolfratshausen", "Starnberg", "Gernlinden", "Eichstätt", "Maisach", "Mammendorf", "Schöngeising", "Geltendorf", "Buchenau", "Eichenau", "Holzkirchen", "Ebersberg", "Grafing", "Zorneding", "Freising", "Haar", "Wasserburg am Inn", "Rosenheim", "Augsburg", "Geretsried", "Waldkraiburg", "Ingolstadt", "Donauwörth", "Unterhaching", "Taufkirchen", "Erding", "Dachau", "Tutzing", "Feldafing", "Schrobenhausen", "Mühldorf am Inn", "Deggendorf", "Landsberg", "Landshut", "Nürnberg", "Grafrath", "Gräfelfing", "Garmisch-Partenkirchen", "Markt Schwaben", "Icking", "Kempten", "Schliersee", "Planegg", "Stockdorf", "Gauting", "Gilching", "Türkenfeld", "Petershausen", "Röhrmoos", "Hallbergmoos", "Ismaning", "Bayrischzell", "Unterföhring", "Daglfing", "Unterschleißheim", "Heimstetten", "Tegernsee", "Lenggries", "Mittenwald", "Aying", "Vaterstetten", "Baldham", "Steinebach", "Weßling", "Deisenhofen", "Sauerlach", "Otterfing", "Kreuzstraße", "Ottobrunn", "Hohenbrunn", "Oberschleißheim", "Eching", "Neufahrn", "Altomünster", "Schwabhausen", "Karlsfeld", "Kolbermoor", "Bad Aibling" ] credfile = "/home/ubuntu/sbmd/dwh.cfg" config = configparser.ConfigParser() config.read(credfile) s3k = config['AWS']['KEY'] s3ks = config['AWS']['SECRET'] [pool.apply(load_weather, args=(c, s3k, s3ks)) for c in cities] pool.close() t.toc()
def main(): print("Reading data ... ", end="") telemetry = pd.read_csv(os.path.join('..', 'data', 'telemetry.csv')) print("Done.") print("Parsing datetime...", end="") telemetry['datetime'] = pd.to_datetime(telemetry['datetime'], format="%m/%d/%Y %I:%M:%S %p") print("Done.") output_folder = os.path.join('..', 'data') window_size = 12 # how many measures to include in rolling average sensors = telemetry.columns[2:] window_sizes = [window_size] * len(sensors) # this can be changed to have individual window_sizes for each sensor machine_ids = telemetry['machineID'].unique() t = TicToc() for machine_id in machine_ids: df = telemetry.loc[telemetry.loc[:, 'machineID'] == machine_id, :] t.tic() print("Working on sensor: ") for s, sensor in enumerate(sensors): N = window_sizes[s] print(" %s " % sensor) df_ra = rolling_average(df, sensor, N) anoms_timestamps = do_ad(df_ra) df_anoms = pd.DataFrame(data={'datetime': anoms_timestamps, 'machineID': [machine_id] * len(anoms_timestamps), 'errorID': [sensor] * len(anoms_timestamps)}) # if this is the first machine and sensor, we initialize a new dataframe if machine_id == 1 and s == 0: df_anoms_all = df_anoms else: # otherwise we append the newly detected anomalies to the existing dataframe df_anoms_all = df_anoms_all.append(df_anoms, ignore_index=True) df_anoms_all.to_csv(os.path.join(output_folder, 'anoms.csv'), index=False) t.toc("Processing machine %s took" % machine_id)
async def forking(dut): """perf forking test""" t = TicToc() tb = settings() await reset(dut) clkobj = Clock(dut.clk, tb.period, 'us') cocotb.fork(clkobj.start()) t.tic() cocotb.fork(genstrobe(dut.dinA, clkobj, dut.clk, tb.dinArate)) cocotb.fork(genstrobe(dut.dinB, clkobj, dut.clk, tb.dinBrate)) dinstrobe = RisingEdge(dut.dinA) for cycle in range(tb.npoints): await dinstrobe if (cycle % 100 == 0): dut._log.info("Sim progress...{} %".format( int(100 * float(cycle) / tb.npoints))) t.toc() print(t.elapsed)
def value_iteration(self, P_a, rewards, gamma, error=1): # Initialize the value function values = np.zeros([self.n_states]) t_complete_func = TicToc() t_complete_func.tic() # estimate values while True: # Temporary copy to check find the difference between new value function calculated & current value function # to ensure improvement in value values_tmp = values.copy() t_value = TicToc() t_value.tic() for s in range(self.n_states): values[s] = max([ sum([ P_a[s, a, s1] * (rewards[s] + gamma * values_tmp[s1]) for s1 in range(self.n_states) ]) for a in range(self.n_actions) ]) # print "values ", values[s] t_value.toc('Value function section took') if max( [abs(values[s] - values_tmp[s]) for s in range(self.n_states)]) < error: break # generate deterministic policy policy = np.zeros([self.n_states]) for s in range(self.n_states): policy[s] = np.argmax([ sum([ P_a[s, a, s1] * (rewards[s] + gamma * values[s1]) for s1 in range(self.n_states) ]) for a in range(self.n_actions) ]) t_complete_func.toc('Complete function section took') return values, policy
def main(): #Create the Matrix to be tri-diagonalized n = 6 #Size of input matrix (nxn) A = SymmMat(n, density=1) #Input matrix. (Hermitian,Sparse) print(A) #Check that the matrix is symmetric. The difference should have no non-zero elements assert (A - A.T).nnz == 0 #Hamiltonian of tV Model for L = 4, N = 2, ell=2 A = -1.0 * np.array( ((0, 1, 0, 1, 0, 0), (1, 0, 1, 0, 1, 1), (0, 1, 0, 1, 0, 0), (1, 0, 1, 0, 1, 1), (0, 1, 0, 1, 0, 0), (0, 1, 0, 1, 0, 0))) #Test Sparse Matrix #A = 1.0*np.diag((1,2,3,4,5,6)) #A[-1,0] = 5 #A[0,-1] = 5 #A = -1.0*np.array(((0,0,1,0), # (0,0,1,0), # (1,1,0,1), # (0,0,1,0))) #Change print format to decimal instead of scientific notation np.set_printoptions(formatter={'float_kind': '{:f}'.format}) #Transform the matrix A to tridiagonal form via Lanczos T = LanczosTri(A) #Find Eigenvalues for Real, Symmetric, Tridiagonal Matrix via QR Iteration t2 = TicToc() t2.tic() lam = NSI(T) t2.toc() print("Eigs(T) (NSI): ", np.sort(lam)[:-1][0]) #Get eigenpairs of untransformed hermitian matrix A and time the process using blackbox function t1 = TicToc() t1.tic() e_gs_T, gs_T = eigsh(T, k=n - 1, which='SA', maxiter=1000) #e_gs_A = NSI(A,maxiter=1000) t1.toc() print("Eigs(T) (np.eigsh): ", e_gs_T[0]) #print("Eigs(A): ",np.sort(e_gs_A[:-1])) t3 = TicToc() t3.tic() e_gs_A, gs_A = eigsh(A, k=n - 1, which='SA', maxiter=1000) #e_gs_A = NSI(A,maxiter=1000) t3.toc() print("Eigs(A) (np.eigsh): ", e_gs_A[0])
async def get_ocr_results(ocr, image, max_height): """Runs OCR on a given image and returns the recognized text, text as pinyin, position and dictionary translations.""" tic_toc = TicToc() # Determine the ratio from detection coords to image coords. # Downscale if the hight exceeds the max height. image_to_screen = [1, 1] if image.shape[0] > max_height: tic_toc.tic() orig_shape = image.shape image = resize(image, height=max_height) image_to_screen = [ orig_shape[0] / image.shape[0], orig_shape[1] / image.shape[1] ] tic_toc.toc("Downscaled image in") # Detect sentences in image tic_toc.tic() print("Image shape:", image.shape, "dtype", image.dtype) result, _ = await _awaitable(ocr.run, image) sentences = [{"text": r[1], "position": r[0][:2]} for r in result.values()] tic_toc.toc("OCR in", restart=True) # Translate the detected sentences and store results results = [] for sentence in sentences: orig_text = sentence["text"] if contains_chinese(orig_text): pinyin_text = get_pinyin(orig_text) translations = get_all_phrase_translations(orig_text) translation_text = "\n".join([ "%s (%s): %s" % (t[0], get_pinyin(t[0]), ", ".join(t[1])) for t in translations ]) position = (int(sentence["position"][0] * image_to_screen[0]), int((sentence["position"][1] * image_to_screen[1]) + 20)) results.append({ "text": orig_text, "position": position, "pinyin_text": pinyin_text, "translation_text": translation_text }) tic_toc.toc("Translate in") return results
def wireframe_one_study(instance_id, study_id): t = TicToc() t.tic() study_service = StudiesService(get_conn()) study_info = study_service.query({ "instance_id": instance_id, "study_id": study_id }) t.toc("study_info", restart=True) # study_info 0.012129 seconds. export_service = ExportService(get_conn()) _, _, labels = export_service.save_onestudy_label( study_id, study_info[0], None, []) t.toc("labels gen", restart=True) # labels gen 31.750854 seconds. crossref_service = CrossRefService() label_list = crossref_service.accumulate_contours(labels) t.toc("label_list", restart=True) # label_list 32.659566 seconds. result = crossref_service.merge_dicom_orientation(label_list) t.toc("merge dicom", restart=True) # merge dicom 8.348602 seconds. return jsonify(result), 200
trainDataSetLoader, testDataSetLoader = dataLoader() bestLearningRate = 0.02 #from HW5 pr1 bestDecay = 0.01 #from HW5 pr1 bestMomentum = 0.7 #from HW5 pr1 DeeprNeuralNet = DeeperNeuralNet() numOfEpochFinal = 80 #Takes 3 hours timerObj = TicToc() #create timer class timerObj.tic() final_accStorage_train, final_accStorage_test = wholeTrainProcessor( trainDataSetLoader, bestMomentum, bestLearningRate, bestDecay, DeeprNeuralNet, testDataSetLoader, numOfEpochFinal) timerObj.toc() #plotting final learning curve epochArr_final = [] final_accStorage_train_list = [] final_accStorage_test_list = [] for k in range(numOfEpochFinal): epochArr_final.append(k + 1) #need to convert data type to list for plotting. final_accStorage_train_list.append(final_accStorage_train[0, k]) final_accStorage_test_list.append(final_accStorage_test[0, k]) plt.plot(epochArr_final, final_accStorage_train_list, label="Accuracy on train set")