model = Sequential() model.add(Dense(nb_neuron_input, input_shape = (1,) + input_shape)) model.add(Activation('tanh')) model.add(Flatten()) model.add(Dense(nb_neuron_output, activation='softmax')) model.summary() # Create the DQN agent with the memory and policy hyper-parameters memory = SequentialMemory(limit=50000, window_length=1) policy = BoltzmannQPolicy() dqn = DQNAgent(model=model, nb_actions=nb_neuron_output, memory=memory, nb_steps_warmup=10, target_model_update=1e-2, policy=policy) dqn.compile(Adam(lr=1e-3), metrics=['mae', 'acc']) # Create the metrics and pass it to the model as a callback for training metrics = Metrics(dqn, env) dqn.fit(env, nb_steps=1000000, visualize=False, verbose=2, callbacks=[metrics]) # the filename has the form modelName_memoryType|memorySize_policy_numberOfSteps fileName = '1D__Sequential50000_BoltzmannQ_1000000steps(0)' # Write the metrics into a file for post treatment f1=open('./output/' + fileName + '.txt', 'w+') f1.write(metrics.export_to_text()) f1.close() # Optionally export figures metrics.export_figs(fileName) # Save network weights for later tests dqn.save_weights('./output/' + fileName + '.h5f', overwrite=True)
import os os.environ["CUDA_VISIBLE_DEVICES"] = "2" import h5py import numpy as np import tensorflow as tf import keras import seaborn as sn from matplotlib import pyplot as plt from market_env import MarketEnv from market_model_builder import MarketPolicyGradientModelBuilder from model_builder import AbstractModelBuilder from Metrics import Metrics M = Metrics() class bcolors: HEADER = '\033[95m' OKBLUE = '\033[94m' OKGREEN = '\033[92m' WARNING = '\033[93m' FAIL = '\033[91m' ENDC = '\033[0m' BOLD = '\033[1m' UNDERLINE = '\033[4m' class PolicyGradient: def __init__(self, env, discount=0.99,
def display_metrics(classifier_list: list, test_labels_all, pred: list, proba: list, label_list: list): """ Function that display some metrics in regard of the training results :arg self (Trainer): instance of the class classifier_list (list): List with selected classifier names test_labels_all (numpy array): Numpy array containing target values of the testing set pred (list): list of the prediction. Each index of the list contains a numpy array proba (list): list of the probability. Each index of the list contains a numpy array label_list (list): list of the name of pathologies :return None """ metrics = Metrics() plt.figure() plt.title('ROC Curve') plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') for i, value in enumerate(proba): fpr, tpr = metrics.roc_metrics(test_labels_all, value) plt.plot(fpr, tpr, label=classifier_list[i]) if len(classifier_list) > 1: mean_proba = np.dstack(proba) mean_proba = np.mean(mean_proba, axis=2) fpr, tpr = metrics.roc_metrics(test_labels_all, mean_proba) plt.plot(fpr, tpr, label='Voting classifiers') plt.legend(loc='lower right') plt.show(block=False) plt.figure() plt.title('Precision-Recall Curve') plt.xlabel('Recall') plt.ylabel('Precision') for i, value in enumerate(proba): precision, recall = metrics.precision_recall(test_labels_all, value) plt.plot(precision, recall, label=classifier_list[i]) if len(classifier_list) > 1: mean_proba = np.dstack(proba) mean_proba = np.mean(mean_proba, axis=2) fpr, tpr = metrics.precision_recall(test_labels_all, mean_proba) plt.plot(fpr, tpr, label='Voting classifiers') plt.legend(loc='lower left') plt.show(block=False) if len(classifier_list) > 1: mean_pred = np.dstack(pred) mean_pred = np.mean(mean_pred, axis=2) mean_pred[mean_pred >= 0.5] = 1 mean_pred[mean_pred < 0.5] = 0 pred = mean_pred else: pred = pred[0] cohen_kappa_score, kappa_class = metrics.cohen_kappa_score(test_labels_all, pred) f1_score, f1_class = metrics.f1_score(test_labels_all, pred) accuracy, accuracy_class = metrics.accuracy(test_labels_all, pred) precision, precision_class = metrics.precision(test_labels_all, pred) recall, recall_class = metrics.recall(test_labels_all, pred) # print('Cohen: {}'.format(cohen_kappa_score)) print('F1: {}'.format(f1_score)) print('Accuracy: {}'.format(accuracy)) print('Precision: {}'.format(precision)) print('Recall: {}'.format(recall)) titles = ['names', 'Cohen', 'F1_score', 'Accuracy', 'Precision', 'Recall'] kappa_class_disp = ['%.4f' % elem for elem in kappa_class] f1_class_disp = ['%.4f' % elem for elem in f1_class] accuracy_class_disp = ['%.4f' % elem for elem in accuracy_class] precision_class_disp = ['%.4f' % elem for elem in precision_class] recall_class_disp = ['%.4f' % elem for elem in recall_class] element = [titles] + list( zip(label_list, kappa_class_disp, f1_class_disp, accuracy_class_disp, precision_class_disp, recall_class_disp)) for i, d in enumerate(element): line = '|'.join(str(x).ljust(19) for x in d) print(line) if i == 0: print('-' * (len(line)-10))
# Settings sampleEach = 1 dataset = "bentham" useNGrams = True # main if __name__ == "__main__": # load dataset loader = DataLoader(dataset, sampleEach) print("Decoding " + str(loader.getNumSamples()) + " samples now.") print("") # metrics calculates CER and WER for dataset m = Metrics(loader.lm.getWordChars()) # write results to csv csv = Utils.CSVWriter() # decode each sample from dataset for (idx, data) in enumerate(loader): # decode matrix res = wordBeamSearch(data.mat, 10, loader.lm, useNGrams) print("Sample: " + str(idx + 1)) print("Filenames: " + data.fn) print('Result: "' + res + '"') print('Ground Truth: "' + data.gt + '"') strEditDist = str(editdistance.eval(res, data.gt)) print("Editdistance: " + strEditDist)
def computeMetrics(self, optimalPareto, solutions, functionName): self.solutionNames = [solution[0] for solution in solutions] solutionData = [solution[1] for solution in solutions] #solutionData = self._removeDominatedFromSolutionData([solution[1] for solution in solutions]) self.dim = len(solutionData[0][0][0]) self.nSolutions = len(self.solutionNames) metrics = Metrics(optimalPareto, solutionData) self.unaryMetricNames = ['Inverted Generational Distance', 'Delta P', 'Spacing', "Hypervolume"] self.unaryMetricOptType = [MetricsCalc.__MIN__, MetricsCalc.__MIN__, \ MetricsCalc.__MIN__, MetricsCalc.__MAX__] unaryMetricType = [MetricsCalc.__CONV__, MetricsCalc.__CONV__, \ MetricsCalc.__DIST__, [MetricsCalc.__CONV__, MetricsCalc.__DIST__]] unaryMetricFunction = [metrics.invertedGenerationalDistance, metrics.deltaP, \ metrics.spacing, metrics.hypervolume] self.nUnaryMetrics = len(self.unaryMetricNames) self.binaryMetricNames = ['Coverage', 'Additive Epsilon', 'Multiplicative Epsilon'] self.binaryMetricOptType = [MetricsCalc.__MAX__, MetricsCalc.__MIN__, MetricsCalc.__MIN__] binaryMetricType = [MetricsCalc.__CONV__, MetricsCalc.__CONV__, MetricsCalc.__CONV__] self.nBinaryMetrics = len(self.binaryMetricNames) self.labels = [] self.sublabels = [] self.labels += self.unaryMetricNames self.sublabels += [None] * len(self.labels) for binaryMetric in self.binaryMetricNames: self.labels += [binaryMetric] * self.nSolutions self.sublabels += self.solutionNames self.labels.append("Points") self.sublabels.append("Convergence") self.labels.append("Points") self.sublabels.append("Distribution") nLabels = len(self.labels) self.metricMean = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricStd = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricMin = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricMax = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricQ1 = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricQ3 = [[None] * (self.nSolutions) for _ in xrange(nLabels)] self.metricIsBest = [[False] * (self.nSolutions) for _ in xrange(nLabels)] nadirPoint = [-(1<<30)] * self.dim for solution in solutionData: r = 0 for run in solution: r += 1 for point in run: for d in xrange(self.dim): nadirPoint[d] = max(nadirPoint[d], math.ceil(point[d] * 10 + 0.001) / 10.0) print " Using Nadir point: " + str(nadirPoint) metrics.setHypervolumeReference(nadirPoint) maxHypervolume = metrics.maxHypervolume() mean = Utils.createListList(self.nUnaryMetrics) std = Utils.createListList(self.nUnaryMetrics) mmin = Utils.createListList(self.nUnaryMetrics) mmax = Utils.createListList(self.nUnaryMetrics) q1 = Utils.createListList(self.nUnaryMetrics) q3 = Utils.createListList(self.nUnaryMetrics) for solutionA in xrange(self.nSolutions): values = Utils.createListList(self.nUnaryMetrics) for runA in xrange(len(solutionData[solutionA])): metrics.setSolutionsToCompare(solutionA, runA, None, None) for i in xrange(self.nUnaryMetrics): value = unaryMetricFunction[i]() if math.isnan(value): if self.unaryMetricNames[i] != "Spacing": print >> sys.stderr, "Found one metric, besides Spacing, giving NaN: %s" % (self.unaryMetricNames[i]) else: # Good value if self.unaryMetricNames[i] == "Hypervolume": value /= maxHypervolume if value > 1: #print >> sys.stderr, " Normalized hypervolume of %s for %s exceeds 1.0: %f" % \ # (self.solutionNames[solutionA], functionName, value) value = 1.0 values[i].append(value) for m in xrange(len(values)): mean[m].append(numpy.mean(values[m])) std[m].append(numpy.std(values[m])) mmin[m].append(numpy.min(values[m])) mmax[m].append(numpy.max(values[m])) q1[m].append(scoreatpercentile(values[m], 25)) q3[m].append(scoreatpercentile(values[m], 75)) for metric in [MetricsCalc.COVERAGE, MetricsCalc.ADDITIVE_EPSILON, MetricsCalc.MULTIPLICATIVE_EPSILON]: meanMetric, stdMetric = self._getMetric(solutionData, metric, metrics, self.solutionNames) mean += meanMetric std += stdMetric self.convPoints = [0] * self.nSolutions self.distPoints = [0] * self.nSolutions for row in xrange(len(mean)): for column in xrange(len(mean[row])): m = mean[row][column] s = std[row][column] if m is None or s is None: continue if row < len(self.unaryMetricNames): factor = self.unaryMetricOptType[row] if abs(round(m*factor, Utils.__ROUND__) - round(min(x*factor for x in mean[row] if x is not None), Utils.__ROUND__)) < Utils.__EPS__: self.metricIsBest[row][column] = True for i in xrange(len(mean[row])): if i != column and mean[row][i] is not None and \ round(mean[row][column]*factor, Utils.__ROUND__) <= round(mean[row][i]*factor, Utils.__ROUND__): self._addMetricPoints(1.0 / (self.nSolutions - 1), column, unaryMetricType[row]) elif row >= len(self.unaryMetricNames): offset = row - (row - len(self.unaryMetricNames)) % self.nSolutions metricIdx = int((row - len(self.unaryMetricNames)) / self.nSolutions) factor = self.binaryMetricOptType[metricIdx] if round(m*factor, Utils.__ROUND__) >= round(mean[offset + column][row - offset]*factor, Utils.__ROUND__): self.metricIsBest[row][column] = True self._addMetricPoints(1.0 / (self.nSolutions - 1), column, binaryMetricType[metricIdx]) self.metricMean[row][column] = m self.metricStd[row][column] = s if row < len(self.unaryMetricNames): self.metricMin[row][column] = mmin[row][column] self.metricMax[row][column] = mmax[row][column] self.metricQ1[row][column] = q1[row][column] self.metricQ3[row][column] = q3[row][column] row = nLabels - 2 for points in [self.convPoints, self.distPoints]: maxValue = max(points) for solutionIdx in xrange(self.nSolutions): value = points[solutionIdx] if abs(value - maxValue) < Utils.__EPS__: self.metricIsBest[row][solutionIdx] = True self.metricMean[row][solutionIdx] = value row += 1
def __init__(self, args): super(NeuralNetwork, self).__init__() self.args = args self.patience = 0 self.init_clip_max_norm = 5.0 self.optimizer = None self.best_result = [0, 0, 0, 0, 0, 0] self.metrics = Metrics(self.args.score_file_path) self.device = torch.device( 'cuda:0' if torch.cuda.is_available() else 'cpu') config_class, model_class, tokenizer_class = MODEL_CLASSES[ args.model_type] self.bert_config = config_class.from_pretrained( args.config_name if args.config_name else args.model_name_or_path, finetuning_task="classification", num_labels=1) self.bert_tokenizer = BertTokenizer.from_pretrained( args.tokenizer_name if args.tokenizer_name else args.model_name_or_path, do_lower_case=args.do_lower_case) special_tokens_dict = {'eos_token': '[eos]'} num_added_toks = self.bert_tokenizer.add_special_tokens( special_tokens_dict) self.bert_model = model_class.from_pretrained( args.model_name_or_path, from_tf=bool('.ckpt' in args.model_name_or_path), config=self.bert_config) self.bert_model.resize_token_embeddings(len(self.bert_tokenizer)) self.bert_model = self.bert_model.cuda() ''' self.attn = nn.Linear(300, 300) self.rnn1 = nn.GRU( input_size=768, hidden_size=300, num_layers=1, batch_first=True, bidirectional=False ) self.bilinear=nn.Bilinear(600,600,1) ''' # multihop self.transformer_utt = TransformerBlock(input_size=768) self.transformer_eu = TransformerBlock(input_size=768) self.transformer_ru = TransformerBlock(input_size=768) self.transformer_ett = TransformerBlock(input_size=768) self.transformer_ue = TransformerBlock(input_size=768) self.transformer_re = TransformerBlock(input_size=768) self.transformer_rtt = TransformerBlock(input_size=768) self.transformer_ur = TransformerBlock(input_size=768) self.transformer_er = TransformerBlock(input_size=768) self._projection = nn.Sequential(nn.Linear(4 * 768, 200), nn.ReLU()) self.rnn2 = nn.GRU(input_size=200, hidden_size=200, num_layers=1, batch_first=True, bidirectional=True) self._classification = nn.Sequential(nn.Dropout(p=0.2), nn.Linear(2 * 6 * 200, 200), nn.Tanh(), nn.Dropout(p=0.2), nn.Linear(200, 1))
start_http_server(port) while True: for db_instance_data in config.get("DBInstances"): db_instance_identifier = db_instance_data.get("DBInstanceIdentifier") region = "us-east-1" if db_instance_data.get("Region") is None or len( db_instance_data.get("Region")) == 0 else db_instance_data.get( "Region") db_engine = db_instance_data.get("DBEngine") availability_zone = db_instance_data.get("AvailabilityZone") db_metric_object = Metrics(period=period, db_name=db_instance_identifier, db_engine=db_engine, availability_zone=availability_zone, region=region, access_key=access_key, secret_access_key=secret_access_key, monitoring_type=monitoring_type) db_metrics = db_metric_object.get_metrics_from_cloud_watch() METRICS = db_metric_object.METRICS.get(monitoring_type).get(db_engine) LABELS = db_metric_object.LABELS for metric_result in db_metrics.get("MetricDataResults"): label = metric_result.get("Label") if len(metric_result.get("Values")) > 0: gauge = METRICS.get(label)
df5 = pd.DataFrame(data5, columns=x + y) plt.subplots_adjust(bottom=0.5) df1.plot(ax=axes[0], x=x[0], y=y, kind=kind) axes[0].set_title('@1') df3.plot(ax=axes[1], x=x[0], y=y, kind=kind) axes[1].set_title('@3') df5.plot(ax=axes[2], x=x[0], y=y, kind=kind) axes[2].set_title('@5') fig.suptitle(title, fontsize=24) if __name__ == '__main__': file_name = sys.argv[1] marks_obj = extract_marks(file_name) metric_tensor = np.ndarray((len(marks_obj), 2, 3, 5)) m1 = Metrics(1) m3 = Metrics(3) m5 = Metrics(5) queries = np.array(list(map(lambda x: x[2], marks_obj))) for i, mark in enumerate(marks_obj): my_mark, es_mark, query = mark metric_tensor[i, 0, 0, :] = m1.measure(my_mark[:1]) metric_tensor[i, 0, 1, :] = m3.measure(my_mark[:3]) metric_tensor[i, 0, 2, :] = m5.measure(my_mark[:5]) metric_tensor[i, 1, 0, :] = m1.measure(es_mark[:1]) metric_tensor[i, 1, 1, :] = m3.measure(es_mark[:3]) metric_tensor[i, 1, 2, :] = m5.measure(es_mark[:5]) partial_data_extractor = partial(data_to_plot_metric, queries,
d.add_variable("cc3", 5000, 16) pymt = d.calculate() d.report() e = Expense() e.add("groceries", 1000) e.add("utilities", 500) e.add("household", 500) e.add("housing", 2000) e.add_yearly("property tax", 7000) e.add_yearly("insurance", 3600) e.add_yearly("maintenance", 2000) e.add_yearly("vacation", 6000) e.report() b = Budget() b.add(i, t, d, e) b.report() a = Assets() a.add("Cash", 30000, 2) a.add("Stocks", 80000, 8) a.add("Bonds", 0, 4) a.report() m = Metrics(i, b, e, d, a) m.calculate() m.report() ana = Analysis(p, i, d, b, e, a, m) ana.do_all()
def __init__(self, scope, num_dirs, opt="adagrad", lr=0.025): print("num_dirs:", num_dirs) sub_dir = "ecb_" + scope + "/" # init stuff print("TORCH VERSION:", torch.__version__) global args self.args = config.parse_known_args() self.args.cuda = self.args.cuda and torch.cuda.is_available() device = torch.device("cuda:0" if self.args.cuda else "cpu") torch.manual_seed(self.args.seed) random.seed(self.args.seed) print("TREELSTM:", opt, "lr:", lr) # paths train_dir = os.path.join(self.args.data, str(num_dirs), 'train/', sub_dir) dev_dir = os.path.join(self.args.data, str(num_dirs), 'dev/', sub_dir) test_dir = os.path.join(self.args.data, str(num_dirs), 'test/', sub_dir) print("train_dir:", train_dir) print("dev_dir:", dev_dir) # builds vocabulary sick_vocab_file = Helper.build_entire_vocab( os.path.join(self.args.data, str(num_dirs), 'sick.vocab'), train_dir, dev_dir, test_dir) vocab = Vocab(filename=sick_vocab_file, data=[ Constants.PAD_WORD, Constants.UNK_WORD, Constants.BOS_WORD, Constants.EOS_WORD ]) print('==> SICK vocabulary size : %d ' % vocab.size()) # loads SICKDataset: Trees, sentences, and labels self.train_dataset = Helper.load_data( train_dir, os.path.join(self.args.data, str(num_dirs), 'sick_train.pth'), vocab, self.args.num_classes) self.dev_dataset = Helper.load_data( dev_dir, os.path.join(self.args.data, str(num_dirs), 'sick_dev.pth'), vocab, self.args.num_classes) self.test_dataset = Helper.load_data( test_dir, os.path.join(self.args.data, str(num_dirs), 'sick_test.pth'), vocab, self.args.num_classes) # creates the TreeLSTM model = SimilarityTreeLSTM(vocab.size(), self.args.input_dim, self.args.mem_dim, self.args.hidden_dim, \ self.args.num_classes, self.args.sparse, self.args.freeze_embed, vocab) criterion = nn.KLDivLoss() #nn.CrossEntropyLoss() # loads glove embeddings emb = Helper.load_embeddings( self.args, os.path.join(self.args.data, str(num_dirs), 'sick_embed.pth'), vocab, device) # sets up the model model.emb.weight.data.copy_( emb) # plug these into embedding matrix inside model model.to(device) criterion.to(device) opt = optim.Adagrad(filter(lambda p: p.requires_grad, \ model.parameters()), lr=lr, weight_decay=self.args.wd) if opt == "adam": opt = optim.Adam(filter(lambda p: p.requires_grad, \ model.parameters()), lr=lr) self.metrics = Metrics(self.args.num_classes) # create trainer object for training and testing self.trainer = Trainer(self.args, model, criterion, opt, device, vocab)
def main(args): # make sure dec hidden units and layers are same FLAGS.dec_hidden_units = FLAGS.enc_hidden_units FLAGS.dec_layers = FLAGS.enc_layers # initialize the dataset and the data loader train_dataset = HagglingDataset(FLAGS.train, FLAGS) train_dataloader = DataLoader(train_dataset, batch_size=FLAGS.batch_size, shuffle=True, num_workers=10) test_dataset = HagglingDataset(FLAGS.test, FLAGS) test_dataloader = DataLoader(test_dataset, batch_size=FLAGS.batch_size, shuffle=False, num_workers=10) # set the wandb config config = FLAGS.flag_values_dict() run = wandb.init(project="Sell-It", config=config) # initialize the model, log it for visualization model = get_model() # try: # torch.onnx.export(model, next(iter(train_dataloader)), # os.path.join(FLAGS.ckpt_dir, FLAGS.model + '/model.onnx')) # wandb.save(os.path.join(FLAGS.ckpt_dir, FLAGS.model + '/model.onnx')) # except Exception as e: # print(e) starting_epoch = 0 # restore model if needed if FLAGS.resume_train: ckpt = os.path.join(FLAGS.ckpt_dir, FLAGS.model + '/') starting_epoch = model.load_model(ckpt, None) #starting_epoch = 130 # get the loss function and optimizers criterion = get_loss_fn() optimizer = get_optimizer(model.get_trainable_parameters()) p = 1.0 metrics = Metrics(FLAGS) # run the training script for epoch in range(starting_epoch + 1, FLAGS.epochs + 1): print(epoch) # initialize the total epoch loss values train_loss_logs = { 'Train/Total_Loss': 0, 'Train/Reconstruction_Loss': 0, 'Train/Regularization_Loss': 0, 'Train/CrossEntropy_Loss': 0, 'Train/VelocityRegularization': 0 } train_metric_logs = { 'Train/RightMSE': 0, 'Train/LeftMSE': 0, 'Train/RightNPSS': 0, 'Train/LeftNPSS': 0, 'Train/RightFrechet': 0, 'Train/LeftFrechet': 0, 'Train/RightSpeech': 0, 'Train/LeftSpeech': 0, 'Train/MSE': 0, 'Train/NPSS': 0, 'Train/Frechet': 0, 'Train/Speech': 0 } test_metric_logs = { 'Test/RightMSE': 0, 'Test/LeftMSE': 0, 'Test/RightNPSS': 0, 'Test/LeftNPSS': 0, 'Test/RightFrechet': 0, 'Test/LeftFrechet': 0, 'Test/RightSpeech': 0, 'Test/LeftSpeech': 0, 'Test/MSE': 0, 'Test/NPSS': 0, 'Test/Frechet': 0, 'Test/Speech': 0 } # set model to train mode model.train() # decay factor set decay_p(p, epoch, model) # run through all the batches for i_batch, batch in enumerate(train_dataloader): # zero prev gradients optimizer.zero_grad() # forward pass through the net predictions, targets = model(batch) # calculate loss losses = criterion(predictions, targets, model.parameters(), FLAGS) total_loss = losses['Total_Loss'] # calculate gradients total_loss.backward() optimizer.step() # compute train metrics with torch.no_grad(): if not FLAGS.skip_train_metrics: train_metrics = metrics.compute_and_save( predictions, targets, batch, i_batch, None) train_metric_logs = { 'Train/' + key: train_metrics[key] + train_metric_logs['Train/' + key] for key in train_metrics } train_loss_logs = { 'Train/' + key: losses[key].detach().cpu().numpy().item() + train_loss_logs['Train/' + key] for key in losses } # set the model to evaluation mode model.eval() # calculate validation loss with torch.no_grad(): for i_batch, batch in enumerate(test_dataloader): # forward pass through the net predictions, targets = model(batch) if FLAGS.model == 'bodyAE' or FLAGS.model == 'bmg': test_metric_logs['Test/MSE'] += meanJointPoseError( predictions, targets) else: # consolidate metrics test_metrics = metrics.compute_and_save( predictions, targets, batch, i_batch, None) test_metric_logs = { 'Test/' + key: test_metrics[key] + test_metric_logs['Test/' + key] for key in test_metrics } # scale the metrics train_metric_logs = { key: train_metric_logs[key] / len(train_dataloader) for key in train_metric_logs } train_loss_logs = { key: train_loss_logs[key] / len(train_dataloader) for key in train_loss_logs } test_metric_logs = { key: test_metric_logs[key] / len(test_dataloader) for key in test_metric_logs } # log all the metrics run.log({**train_metric_logs, **train_loss_logs, **test_metric_logs}) if epoch % FLAGS.ckpt == 0 and epoch > 0: ckpt = os.path.join(FLAGS.ckpt_dir, FLAGS.model + '/' + wandb.run.name + '/') model.save_model(ckpt, epoch) run.finish()
def user(self): user_input = None print("0: generate actual maze\n" "1: generate blank maze\n" "2: generate random maze from the saved mazes\n" "3: Perform Repeated forward A* in favor of larger g value\n" "4: Perform Repeated forward A* in favor of smaller g value\n" "5: Perform Repeated backward A*\n" "6: Perform Repeated Adaptive A\n" "q: Quit\n") while user_input != "q": user_input = input("Choose one of the numbers above : ") if user_input == "0": size = int(input("Enter the size of the maze : ")) actual_maze = Maze().generate_actual_maze(size) start_node_actual, goal_node_actual = Metrics().generate_random_start_and_goal_nodes( actual_maze, size) Visual(7, start_node_actual, goal_node_actual, size).showMaze(actual_maze) elif user_input == "1": size = int(input("Enter the size of the maze : ")) blank_maze = Maze().generate_blank_maze(size) start_node_actual, goal_node_actual = Metrics().generate_random_start_and_goal_nodes( blank_maze, size) Visual(7, start_node_actual, goal_node_actual, size).showMaze(blank_maze) elif user_input == "2": self.actual_maze = self.actual_mazes[random.randint(0, 50)] self.start_node_actual, self.goal_node_actual = Metrics().generate_random_start_and_goal_nodes( self.actual_maze, self.size) Visual(7, self.start_node_actual, self.goal_node_actual, self.size).showMaze(self.actual_maze) elif user_input == "3": agent_maze = Maze().generate_blank_maze(self.size) start_node = agent_maze[self.start_node_actual.x][self.start_node_actual.y] goal_node = agent_maze[self.goal_node_actual.x][self.goal_node_actual.y] RepeatedAlgo(self.size, self.actual_maze, agent_maze, start_node, goal_node, self.start_node_actual, self.goal_node_actual, 0).repeated_algorithm() elif user_input == "4": agent_maze = Maze().generate_blank_maze(self.size) start_node = agent_maze[self.start_node_actual.x][self.start_node_actual.y] goal_node = agent_maze[self.goal_node_actual.x][self.goal_node_actual.y] RepeatedAlgo(self.size, self.actual_maze, agent_maze, start_node, goal_node, self.start_node_actual, self.goal_node_actual, 1).repeated_algorithm() elif user_input == "5": agent_maze = Maze().generate_blank_maze(self.size) start_node = agent_maze[self.start_node_actual.x][self.start_node_actual.y] goal_node = agent_maze[self.goal_node_actual.x][self.goal_node_actual.y] RepeatedAlgo(self.size, self.actual_maze, agent_maze, start_node, goal_node, self.start_node_actual, self.goal_node_actual, 2).repeated_algorithm() elif user_input == "6": agent_maze = Maze().generate_blank_maze(self.size) start_node = agent_maze[self.start_node_actual.x][self.start_node_actual.y] goal_node = agent_maze[self.goal_node_actual.x][self.goal_node_actual.y] RepeatedAlgo(self.size, self.actual_maze, agent_maze, start_node, goal_node, self.start_node_actual, self.goal_node_actual, 3).repeated_algorithm()
def pipeline(fileName, nameForFiles, protectedAttribute, trueLabels, feldman, bayes, dataName): # Load data into DataSet ds = DataSet() ds.loadData(fileName, protectedAttribute, trueLabels) # Open a file for writing results f = open("results/" + nameForFiles + ".txt", "w") print("Starting DI detection") DIresult = detectDI(ds) f.write("DI results on original data: " + DIresult) # Feldman repair algorithm currDataSet = ds if feldman == "yes": print("Starting Feldman") repair = RepairData() repair.runRepair(ds.fileName, ds.protectedAttribute, ds.trueLabels, dataName, noiseScale=.01) # Pickle the Feldman-repaired data repair.dataSetCopy.savePickle("pickledObjects/repairedData/" + nameForFiles) repair.dataSetCopy.saveToCsv("dataCSVs/repairedData/" + nameForFiles + ".csv") currDataSet = repair.dataSetCopy print("Starting post-Feldman DI detection") postFeldmanDIresult = detectDI(repair.dataSetCopy) f.write("DI results after Feldman: " + postFeldmanDIresult) #Split data into test and training set currDataSet.splitIntoTrainTest() print("Split into test train") #Bayes if bayes == "naive": print("Starting Naive Bayes") bayesObject = NaiveBayes() bayesObject.train(currDataSet, bayesObject.model) bayesObject.classify(currDataSet, "test") print("Completed Naive Bayes") elif bayes == "modified": bayesObject = ModifiedBayes() bayesObject.train(currDataSet, 1) bayesObject.classify(currDataSet, "test") else: bayesObject = TwoBayes() bayesObject.train(currDataSet, 1) bayesObject.classify(currDataSet, "test") currDataSet.savePickle("pickledObjects/classifiedData/" + nameForFiles) currDataSet.saveToCsv("dataCSVs/classifiedData/" + nameForFiles + ".csv") # Metrics print("Starting metrics") metrics = Metrics() metrics.runAllMetrics(f, currDataSet, bayes, bayesObject) print("Completed metrics") f.close()
from time import sleep import argparse from datetime import datetime from AlphaVantage_Backend import AlphaVantage_Backend from Metrics import Metrics import pandas as pd from openpyxl import Workbook from openpyxl.styles.numbers import FORMAT_NUMBER_COMMA_SEPARATED1, FORMAT_CURRENCY_USD from openpyxl.utils.dataframe import dataframe_to_rows av_key = os.getenv("ALPHA_VANTAGE") backend = AlphaVantage_Backend(av_key) metrics = Metrics(backend) def analyze_ticker(ticker): assets = metrics.current_assets(ticker) liabilities = metrics.current_liabilities(ticker) al_ratio = { dt: total_assets / liabilities[dt] for dt, total_assets in assets.items() } metrics5years = pd.DataFrame([ metrics.revenues(ticker), metrics.profits(ticker), metrics.fcfs(ticker), metrics.net_profit_margins(ticker), al_ratio