def pipeline(path, start, end): moni = Monitor.Monitor(path) moni.creat_json_file() anchor = start while anchor < end: # print(anchor, end) if anchor == 0: GeoOPt.geo_opt(path, moni) elif anchor == 1: if start == 1: HF1.hf1_start(path, moni) else: HF1.hf1(path, moni) elif anchor == 2: Localization.localization(path, moni) elif anchor == 3: HF2.hf2(path, moni) elif anchor == 4: LMP2.lmp2(path, moni) if if_skip_rpa() == 1: anchor += 1 elif anchor == 5: RPA.rpa(path, moni) elif anchor == 6: Cluster.cluster(path) elif anchor == 7: Correction.correction(path, moni) elif anchor == 8: Results.results(path) anchor += 1 end_programm(path)
def ativabotoes(botoes_jogo, errados, alterados, jogo, mat, strart_time, times, n_select, linha, coluna, ecra, tempo, best_results, dificuldade): result = False if botoes_jogo[0]: errados = Logic.constroi_errados(alterados, jogo, mat) strart_time = time.time() botoes_jogo[0] = False else: actual_time = time.time() - strart_time if actual_time >= times: errados = [] if botoes_jogo[1]: jogo = Logic.copia_matriz(mat) botoes_jogo[1] = False if botoes_jogo[2] and n_select: jogo[linha][coluna] = mat[linha][coluna] botoes_jogo[2] = False if botoes_jogo[3]: ecra = 5 tempo = time.time() - tempo result = Print.correto(jogo) if result: Results.adiciona_lista(tempo, dificuldade, best_results) Results.gravar_resultados(best_results) botoes_jogo[3] = False return errados, strart_time, jogo, ecra, tempo, best_results, result
def query(self, query): if query is None: return Results.list_commands() # print query query_segments = query.lower().split(" ", 1) command = query_segments[0] if len(query_segments) == 2: args = query_segments[1] else: args = None command_suggestions = QueryParser.parse_command(command) print(command_suggestions) if args is not None and len(command_suggestions) == 1: if not self.ensure_connection(): return return Results.list_music(self.__client, self.__album_art_cache, command_suggestions[0], args) else: return Results.list_commands(command_suggestions)
def load_model(model_filename): print(model_filename) try: hdf5_route = "/highest_validation_likelihood/parameters" params = Results.Results(model_filename).get(hdf5_route) except: hdf5_route = "/final_model/parameters" params = Results.Results(model_filename).get(hdf5_route) model_class = getattr(NADE, params["__class__"]) return model_class.create_from_params(params)
def __init__(self, options): """ Constructor. Take the command line options as a parameter """ self.options = options # Initialize some instance vars self.consumer_config = None self.config = None self.logger = None self.proxy = None # For any messages that won't go through the logger self.quiet = 0 if self.options.verbose == 0: self.quiet = 1 # Instantiate our helper objects self.sysutils = Sysutils.Sysutils(self) self.results = Results.Results(self, options) # Setup the logger self.init_logging(self.options.verbose) # Setup the initial configuration self.setup_config() self.setup_consumer_config() return
def __init__(self, #Set an error value error: float, #Set the k number of neighbors k: int, #Pass in the data type data_type: str, #Set the categorical features categorical_features: list, #Set a list of features in the regression data set regression_data_set: bool, #Set the alpha float alpha:float, #Set the beta float beta:float, #set the width value h:float, #Set the dimensionality d:int): # initialize a knn object self.knn = kNN.kNN(k, data_type, categorical_features, regression_data_set, alpha, beta, h, d) self.nn = kNN.kNN(1, data_type, categorical_features, regression_data_set, alpha, beta, h, d) # error threshhold for regression classification self.error = error # store if this data set is a regression data set (True) or not (False) self.regression_data_set = regression_data_set self.results = Results.Results()
def calc(datasetIndex, multiplierInt): csv = pd.DataFrame(columns=['dataset', 'bins', 'f1', 'zero-one']) exp = ((multiplierInt + 1) / 2) bins = math.ceil(2**exp) results = [] for k in range(trials): dp = DataProcessor.DataProcessor(bin_count=bins) binnedDataset = dp.StartProcess(datasets[datasetIndex]) N, Q, F, testData = train(binnedDataset) model = Classifier.Classifier(N, Q, F) classifiedData = model.classify(testData) stats = Results.Results() zeroOne = stats.ZeroOneLoss(classifiedData) macroF1Average = stats.statsSummary(classifiedData) datapoint = { 'dataset': dataset_names[datasetIndex], 'bins': bins, 'f1': macroF1Average, 'zero-one': zeroOne / 100 } print(datapoint) csv = csv.append(datapoint, ignore_index=True) # trial = {"zeroOne": zeroOne, "F1": macroF1Average} # results.append(trial) # print(trial) data.append(csv)
def __init__(self, connections, main_connection, recording): self.connections = connections self.main_connection = main_connection self.results = Results.Results() self.recording = recording self.standby = Standby.Standby() self.target_identification = TargetIdentification.TargetIdentification( self.connections, self.results, self.standby) self.message_counter = 0
def showResults(self): self.loadData() self.__calc.compute() gg = self.__calc.getGG() pg = self.__calc.getPG() tg = self.__calc.getTG() gb = self.__calc.getGB() pb = self.__calc.getPB() tb = self.__calc.getTB() neg = self.__calc.getNEG() nke = self.__calc.getNKE() nkyp = self.__calc.getNKYP() degp = self.__calc.getDEGP() sgp = self.__calc.getSGP() nkyr = self.__calc.getNKYR() debp = self.__calc.getDEBP() sbp = self.__calc.getSBP() fgp = self.__calc.getFGP() fbp = self.__calc.getFBP() fsum = self.__calc.getFSUM() tgres = self.__calc.getTGRES() tbres = self.__calc.getTBRES() dltpg = self.__calc.getDLTPG() dpg = self.__calc.getDPG() dltpb = self.__calc.getDLTPB() dpb = self.__calc.getDPB() qogp = self.__calc.getQOGP() qbp = self.__calc.getQBP() ril = self.__calc.getReinoldsInputColdThermofor() rihg = self.__calc.getReinoldsInputHotThermofor() resr = self.__calc.getRESR() rebsr = self.__calc.getREBSR() mat = self.__calc.getMAT() betact1 = self.__calc.getBETACT1() cped1 = self.__calc.getCPED1() cped2 = self.__calc.getCPED2() count = self.__calc.getCOUNT() alfag = self.__calc.getHeatCoefColdThermofor() alfab = self.__calc.getHeatCoefHotThermofor() nusseltg = self.__calc.getNusseltColdThermofor() nusseltb = self.__calc.getNusseltHotThermofor() prandtlg = self.__calc.getPrandtlColdThermofor() prandtlb = self.__calc.getPrandtlHotThermofor() self.__resDialog = Results.Results(self.__calc.getCOE()) self.__resDialog.updateContent(gg, pg, tg, gb, pb, tb, neg, nke, nkyp, degp, sgp, nkyr, debp, sbp, fgp, fbp, \ fsum, tgres, tbres, dltpg, dpg, dltpb, dpb, qogp, qbp, ril, rihg, resr, rebsr, \ mat, betact1, cped1, cped2, count, alfag, alfab, nusseltg, nusseltb, prandtlg, \ prandtlb) self.__resDialog.show()
def __init__(self): self.main_connection = ConnectionPostOfficeEnd.MainConnection() self.connections = MasterConnection.MasterConnection() self.options = None self.results = Results.Results() self.standby_state = None self.standby_freq = None self.no_standby = None self.recorded_signals = [None for _ in range(7)] self.prev_results = [] self.prev_results_counter = {} self.actual_results = [] self.actual_results_counter = {} self.need_new_target = None self.message_counter = None self.waitConnections()
def main(): print "DEBUG: Entering Driver.main()" expGUI = ExperimentGUI() # create new ExperimentGUI object using default values res = Results() # create new Results object using default value res.writeToFile(expGUI.window.get_title() + " Experiment\n") res.writeToFile("Experiment started at: " + str(datetime.now()) + "\n\n") gtk.main() # http://www.pygtk.org/dist/pygtk2-tut.pdf catA = ImageCategory("A", ["A0.jpg", "A1.jpg", "A2.jpg", "A3.jpg", "A4.jpg", "A5.jpg"]) catB = ImageCategory("B", ["B0.jpg", "B1.jpg", "B2.jpg", "B3.jpg", "B4.jpg"]) categories = [catA, catB] lb1 = LearningBlock(["A0.jpg", "A1.jpg", "B2.jpg"], 10.0) lb2 = LearningBlock(["B3.jpg", "B4.jpg", "A1.jpg"], 15.0) tb1 = TestingBlock(["A0.jpg", "A1.jpg", "B2.jpg"]) tb2 = TestingBlock(["A3.jpg", "B4.jpg"]) lblockList = [lb1, lb2] tblockList = [tb1, tb2] lp = LearningPhase(lblockList) tp = TestingPhase(tblockList) phaseList = [lp, tp] exp = Experiment(phaseList) exp.runPhases(categories, res) print "DEBUG: Entering gtk.main()" #gtk.main() print "DEBUG: Exiting gtk.main()" res.writeToFile("Experiment ended at: " + str(datetime.now())) print "DEBUG: Exiting Driver.main()"
def run(self, screen): self.start(screen) while not self.gameover: self.move(screen) pygame.display.flip() if self.Output.score % 1720 == 0: self.update_seeds() if self.Output.dead == 1: self.gameover = True with open('nickname.txt', 'r') as f: self.Highscore.insert(f.readline(), self.Output.scorenum) with open('nickname.txt', 'w') as f1: f1.write('\n') res = Results.Results() res.draw(screen) game = True while game: for events in pygame.event.get(): if events.type == pygame.KEYDOWN: if events.key == pygame.K_ESCAPE or events.key == pygame.K_SPACE: game = False elif events.type == pygame.QUIT: game = False sys.exit()
def main(argv): testname = '' HlayerSize = 100 HlayerCount = 2 nsplits = 3 try: opts, args = getopt.getopt(argv,"hi:o:",["tname=","stname="]) except getopt.GetoptError: print 'test.py -t <testname> -hls <Hidden Layer Size> -hlc <Hidden Layer Count> -n <nsplits>' sys.exit(2) for opt, arg in opts: if opt == '-h': print 'test.py -t <testname> -hls <Hidden Layer Size> -hlc <Hidden Layer Count> -n <nsplits>' sys.exit() elif opt in ("-t", "--tname"): testname = arg elif opt in ("-hls"): HlayerSize = arg elif opt in ("-hlc"): HlayerCount = arg elif opt in ("-n"): nsplits = arg Hlayer = [HlayerSize] * HlayerCount NB = nb.NaiveBayes(testname = testname,subtestname='naivebayes') X,Y= NB.loadMatrixFromFile() res.getResults(NB) RF = rf.RandomForest(testname=testname,subtestname='randomforest') X,Y = RF.loadMatrixFromFile() res.getResults(RF) NN = nn.NeuralNetwork(testname=testname,subtestname='neuralnetwork',HlayerSizes=Hlayer, nsplits=nsplits) X,Y = NN.loadMatrixFromFile() res.getResults(NN)
# Initializing NN deep_font = DeepFont(shape + (3, ), opt_name='sgd', use_augmentations=True) deep_font.summarize() # Training model_filename_full = model_filename + '.h5' results = deep_font.train(train_x, train_y, epochs, batch_size, validate_x, validate_y) print('Model Loss: {L} ; Accuracy: {A}'.format(L=results['evaluation'][0], A=results['evaluation'][1])) deep_font.save(model_filename) plt.figure('Training results: Accurracy & Loss') for k in results['history']: #if k.find('accuracy') != -1: plt.plot(results['history'][k], label=k) plt.legend() plt.title('Training results: Accurracy & Loss') plt.show() if len(validation_filenames) > 0: # Executing evaluation predictions = deep_font.predict(validate_x) # Printing & saving results evaluation = deep_font.evaluate(validate_x, validate_y) print('Validation Loss: {L} ; Accuracy: {A}'.format(L=evaluation[0], A=evaluation[1])) Results.store(validate_results_file, predictions, validate_filenames, validate_letters)
"\n") print "Running %s runs each for %s samples and %s cols" % (num_runs, sample_range, col_range) app.create_R(out_dir) all_results = [] completed = 0 smallest_max_otu_value = app.compute_smallest_max() for i in range(len(col_range)): num_cols = col_range[i] taxa_tree = app.create_tree(app.find_usable_length(num_cols, bits) / bits, type = 'T') assert app.is_binary_tree(taxa_tree) == True for j in range(len(sample_range)): num_samples = sample_range[j] sample_trees = [None] * num_runs for dist in dists: results = Results(num_samples, num_cols, dist) all_results.append(results) ranges = None if dist == 'normal': ranges = app.get_range_from_normal(num_cols, bits, mean, sd, smallest_max_otu_value) else: ranges = app.get_range_from_gamma(num_cols, bits, gamma_shape, gamma_scale, smallest_max_otu_value) for k in range(num_runs): status = "%d/%d: running %d samples and %d cols (%s) %s" % ( completed + 1, num_runs * len(dists) * len(sample_range) * len(col_range), num_samples, num_cols, dist, str(timer)) print status log_file.write("%s\n" % status) log_file.flush()
def main(): #What trial number we are on Trial = 0 #Which set of the data is being used to test TestData = 0 #Print data to the screen so the user knows the program is starting print("Program Starting") #Prepocessed datasets stored in an array for iteration and experiments, Nosie included data_sets = [ 'PreProcessedVoting.csv', 'PreProcessedIris.csv', 'PreProcessedGlass.csv', 'PreProcessedCancer.csv', 'PreProcessedSoybean.csv', 'PreProcessedVoting_Noise.csv', 'PreProcessedIris_Noise.csv', 'PreProcessedGlass_Noise.csv', 'PreProcessedCancer_Noise.csv', 'PreProcessedSoybean_Noise.csv' ] #The 5 Data set names are stored in the array, Noise included dataset_names = [ "Vote", "Iris", "Glass", "Cancer", "Soybean", "Vote_Noise", "Iris_Noise", "Glass_Noise", "Cancer_Noise", "Soybean_Noise" ] ####################################################### MACHINE LEARNING PROCESS ##################################################### #Set the total number of runs to be 10 TotalRun = 10 #Create a dataframe that is going to hold key valuesf from the experiment finalDataSummary = pd.DataFrame(columns=["Dataset", "F1", "ZeroOne"]) #For each of the datasets and the data sets including noise for dataset in data_sets: #Create an empty array AvgZeroOne = [] #Create a second empty array AvgF1 = [] #Get the name of the dataset being experimented on datasetName = dataset_names[data_sets.index(dataset)] #Print the dataset name so the user knows what data set is being experimented print(datasetName) #Load in the dataframe from the preprocessed data df = pd.read_csv(dataset) #Create a Training algorithm Object ML = TrainingAlgorithm.TrainingAlgorithm() #Bin the data frame into a list of 10 similar sized dataframes for traning and one set to test tenFoldDataset = ML.BinTestData(df) #Set the total number of runs to be 10 for now for i in range(10): #Set an empty dataframe object TrainingDataFrame = pd.DataFrame() #Make One dataframe that is our test Dataframe TestingDataFrame = copy.deepcopy(tenFoldDataset[i]) #For each of the dataframes generated above for j in range(10): #If the dataframe being accessed is the test dataframe if i == j: #Skip it continue #Append the training dataframe to one dataframe to send to the ML algorithm TrainingDataFrame = TrainingDataFrame.append(copy.deepcopy( tenFoldDataset[j]), ignore_index=True) # print('************************************************') # print(TrainingDataFrame) # print(TestingDataFrame) # print('************************************************') # calculate the N, Q, and F probabiliies N, Q, F = train(ML, TrainingDataFrame) #Create a Classifier Object to classify our test set model = Classifier.Classifier(N, Q, F) #Reassign the testing dataframe to the dataframe that has our Machine learning classification guesses implemented classifiedDataFrame = model.classify(TestingDataFrame) #Create a Results object Analysis = Results.Results() #Run the 0/1 Loss function on our results zeroOnePercent = Analysis.ZeroOneLoss(classifiedDataFrame) #Get the F1 score for the given dataset macroF1Average = Analysis.statsSummary(classifiedDataFrame) #Print the zero one loss and F1 calculation to the screen print("Zero one loss: ", zeroOnePercent, "F1: ", macroF1Average) print("\n") #append the zero one loss and F1 average to the list to calculate the average score AvgZeroOne.append(zeroOnePercent) AvgF1.append(macroF1Average) #Increment the trial number and the position in the array to use the dataframe to test on Trial += 1 TestData += 1 #If we are at 10 we only have 10 dataframes 0 - 9 accessed in the array so on the 10th trial go back to the beginning if TestData == 10: #Set the value to 0 TestData = 0 #Gather the dataset name the average scores for ZOloss and F1 score and put them into a data structure AvgStats = { "Dataset": datasetName, "F1": sum(AvgF1) / len(AvgF1), "ZeroOne": sum(AvgZeroOne) / len(AvgZeroOne) } #Set a variavle to hold all of the statistics for each of the trials so we can print them to one file finalDataSummary = finalDataSummary.append(AvgStats, ignore_index=True) #Write the data set, the trial number and statistics of a trial to be printed to a file WriteToAFile(datasetName, AvgStats, Trial) finalDataSummary.to_csv("ExperimentalSummary.csv") print("Program Finish: \n", finalDataSummary)
def CmdLine( args ): seriesFileName = None if args.series: seriesFileName = args.series try: with open(seriesFileName, 'rb') as fp: SeriesModel.model = pickle.load( fp ) except IOError: print u'cannot open series file "{}".'.format(seriesFileName) return 1 SeriesModel.model.postReadFix() races = [] for r in args.races: # Parse the points structure. pos = r.rfind( '=' ) if pos >= 0: pointStructuresName = r[pos+1:].strip() r = r[:pos] else: pointStructuresName = None fileName, sheetName = None, None # Now, parse the file reference. if r.endswith( '.cmn' ): # This is a crossmgr file. fileName = r else: # This must be a spreadsheet. components = r.split( '::' ) if len(components) == 2: fileName, sheetName = components else: fileName = components[0] if not any( fileName.endswith(suffix) for suffix in ('.xlsx', 'xlsm', '.xls') ): print u'unrecognized file suffix "{}".'.format(fileName) return 2 pointStructures = None for ps in SeriesModel.model.pointStructures: if pointStructuresName is None or ps.name == pointStructuresName: pointStructures = ps break if pointStructures is None: print u'cannot find points structure "{}".'.format(pointStructuresName) return 3 races.append( SeriesModel.Race(fileName, pointStructures) ) if races: SeriesModel.model.races = races score_by_points, score_by_time, score_by_percent = True, False, False if args.score_by_time: score_by_points, score_by_time, score_by_percent = False, True, False if args.score_by_percent: score_by_points, score_by_time, score_by_percent = False, False, True output_file = args.output or ((os.path.splitext(args.series)[0] + '.html') if args.series else 'SeriesMgr.html') with open( output_file, 'wb' ) as f: f.write( Results.getHtml(seriesFileName) ) return 0
if (__name__ == '__main__'): try: opts, args = getopt.getopt(sys.argv[1:], "ve", ["verbose", "errors"]) except getopt.GetoptError, err: # print help information and exit: print str(err) # will print something like "option -a not recognized" sys.exit(2) verbose = False list_errors = False for o, a in opts: if o in ("-v", "--verbose"): verbose = True elif o in ("-e", "--errors"): list_errors = True s = Simulation('Estimator', verbose) r = Results(s, verbose) ########################################### ########################################### # Set type of simulations that need to be run elist = {} ########################################### elist['Cyclic'] = [['1']] #elist['Cyclic'][0] += ['mhop'] elist['Cyclic'][0] += [ ['seq', 4, 5, 6] ] ########################################### #elist['Cyclic'] += [['1']] #elist['Cyclic'][1] += ['mhop'] #elist['FastCyclic'][1] += [ ['seq', 1, 2, 3, 4, 5] ] ########################################### #elist['Consensus'] = [['2']] #elist['Consensus'][0] += ['unsync']
csv = pd.DataFrame(columns=['dataset', 'bins', 'f1', 'zero-one']) for j in range(2): for i in range(25): exp = ((i+1)/2) bins = math.ceil(2**exp) results = [] for k in range(trials): dp = DataProcessor.DataProcessor(bin_count=bins) binnedDataset = dp.StartProcess(datasets[j]) N, Q, F, testData = train(binnedDataset) model = Classifier.Classifier(N, Q, F) classifiedData = model.classify(testData) stats = Results.Results() zeroOne = stats.ZeroOneLoss(classifiedData) macroF1Average = stats.statsSummary(classifiedData) csv = csv.append({ 'dataset': dataset_names[j], 'bins': bins, 'f1': macroF1Average, 'zero-one':zeroOne/100 }, ignore_index=True) trial = {"zeroOne": zeroOne, "F1": macroF1Average} results.append(trial) print(trial) z1 = 0 f1 = 0 for n in results: