def parse_command_line(): parser = argparse.ArgumentParser( description="""Train, validate, and test a face detection classifier that will determine if two faces are the same or different.""") parser.add_argument("--test_data", help="Use preTrain model on test data, calcu the accuracy and ROC.", action="store_true") parser.add_argument("--test_val", help="Use preTrain model on validation data, calcu the accuracy and ROC.", action="store_true") parser.add_argument("--weights", help="""The trained model weights to use; if not provided defaults to the network that was just trained""", type=str, default=None) parser.add_argument("-t", "--threshold", help="The margin of two dense", type=int, default=80) args = vars(parser.parse_args()) if os.environ.get("CAFFEHOME") == None: print "You must set CAFFEHOME to point to where Caffe is installed. Example:" print "export CAFFEHOME=/usr/local/caffe" exit(1) # Ensure the random number generator always starts from the same place for consistent tests. random.seed(0) lfw = data.Lfw() lfw.load_data() lfw.pair_data() if args["weights"] == None: args["weights"] = constants.TRAINED_WEIGHTS if args["test_data"] == True: test_pairings(lfw, weight_file=args["weights"], is_test=True, threshold=args["threshold"]) elif args["test_val"] == True: test_pairings(lfw, weight_file=args["weights"], threshold=args["threshold"]) else: train(True, data=lfw)
def main(): print "In Main Experiment\n" # get the classnames from the directory structure directory_names = list(set(glob.glob(os.path.join("train", "*"))).difference(set(glob.glob(os.path.join("train", "*.*"))))) # get the number of rows through image count numberofImages = parseImage.gestNumberofImages(directory_names) num_rows = numberofImages # one row for each image in the training dataset # We'll rescale the images to be 25x25 maxPixel = 25 imageSize = maxPixel * maxPixel num_features = imageSize + 2 + 128 # for our ratio X = np.zeros((num_rows, num_features), dtype=float) y = np.zeros((num_rows)) # numeric class label files = [] namesClasses = list() #class name list # Get the image training data parseImage.readImage(True, namesClasses, directory_names,X, y, files) print "Training" # get test result train.train(X, y, namesClasses) print "Testing" test.test(num_rows, num_features, X, y, namesClasses = list())
def start_offline(dataset): #sys.path.append(envpath) os.chdir(envpath) import prepare prepare.prepare(dataset) import train train.train(dataset)
def main(): flags = parse_flags() hparams = parse_hparams(flags.hparams) if flags.mode == 'train': utils.resample(sample_rate=flags.sample_rate, dir=flags.train_clip_dir, csv_path=flags.train_csv_path) train.train(model_name=flags.model, hparams=hparams, class_map_path=flags.class_map_path, train_csv_path=flags.train_csv_path, train_clip_dir=flags.train_clip_dir+'/resampled', train_dir=flags.train_dir, sample_rate=flags.sample_rate) elif flags.mode == 'eval': #TODO uncomment #utils.resample(sample_rate=flags.sample_rate, dir=flags.eval_clip_dir, csv_path=flags.eval_csv_path) evaluation.evaluate(model_name=flags.model, hparams=hparams, class_map_path=flags.class_map_path, eval_csv_path=flags.eval_csv_path, eval_clip_dir=flags.eval_clip_dir+'/resampled', checkpoint_path=flags.checkpoint_path) else: assert flags.mode == 'inference' utils.resample(sample_rate=flags.sample_rate, dir=flags.test_clip_dir, csv_path='test') inference.predict(model_name=flags.model, hparams=hparams, class_map_path=flags.class_map_path, test_clip_dir=flags.test_clip_dir, checkpoint_path=flags.checkpoint_path, predictions_csv_path=flags.predictions_csv_path)
def main(): from train import train lr = NeuralNet(n_features=2, n_hidden=10) lr.optimizer.lr = 0.2 train(model=lr, data='lin') train(model=lr, data='xor')
def main(FLAGS): """ """ if FLAGS.mode == "train": train(FLAGS) elif FLAGS.mode == "infer": infer(FLAGS) else: raise Exception("Choose --mode=<train|infer>")
def test_train_success(self): train_root_dir = self._config['train_root_dir'] if not tf.gfile.Exists(train_root_dir): tf.gfile.MakeDirs(train_root_dir) for stage_id in train.get_stage_ids(**self._config): tf.reset_default_graph() real_images = provide_random_data() model = train.build_model(stage_id, real_images, **self._config) train.add_model_summaries(model, **self._config) train.train(model, **self._config)
def train_model(db_file, entity_db_file, vocab_file, word2vec, **kwargs): db = AbstractDB(db_file, 'r') entity_db = EntityDB.load(entity_db_file) vocab = Vocab.load(vocab_file) if word2vec: w2vec = ModelReader(word2vec) else: w2vec = None train.train(db, entity_db, vocab, w2vec, **kwargs)
def train_PNet(base_dir, prefix, end_epoch, display, lr): """ train PNet :param dataset_dir: tfrecord path :param prefix: :param end_epoch: :param display: :param lr: :return: """ net_factory = P_Net train(net_factory,prefix, end_epoch, base_dir, display=display, base_lr=lr)
def main(): """main function""" # flag = True util.check_tensorflow_version() util.check_and_mkdir() #util.TRAIN_YAML = yaml config = load_yaml() check_config(config) hparams = create_hparams(config) print(hparams.values()) log = Log(hparams) hparams.logger = log.logger train.train(hparams)
def predict(corpusPath, modelsPath, dummy, corpusId=None, connection=None, directed="both"): for model in getModels(corpusPath, modelsPath, corpusId, directed): if os.path.exists(model["model"]): print "Skipping existing target", model["model"] continue print "Processing target", model["model"], "directed =", model["directed"] if dummy: continue train.train(model["model"], task=CORPUS_ID, corpusDir=model["corpusDir"], connection=connection, exampleStyles={"examples":model["exampleStyle"]}, parse="McCC", classifierParams={"examples":"c=1,10,100,500,1000,1500,2500,3500,4000,4500,5000,7500,10000,20000,25000,27500,28000,29000,30000,35000,40000,50000,60000,65000"}) for dataset in ("devel", "test"): if os.path.exists(model[dataset]): evaluate(model[dataset], model[dataset + "-gold"], model[dataset + "-eval"])
def main(): """ Args: data_dir save_dir logs_dir """ args = sys.argv data_dir = args[1] save_dir = args[2] logs_dir = args[3] sess = tf.Session() with sess.as_default(): train_data, test_data = arrows.get_input_producers(data_dir) train.train(arrows.build_net, train_data, test_data, logs_dir=logs_dir, save_dir=save_dir)
def main(): """ Args: data_dir save_dir logs_dir """ args = sys.argv data_dir = args[1] save_dir = args[2] logs_dir = args[3] sess = tf.Session() with sess.as_default(): train_data, test_data = movie.get_input_producers(data_dir) train.train(movie.build_net, train_data, test_data, logs_dir=logs_dir, save_dir=save_dir, need_load=True, init_rate=0.0005, test_only=False)
def train_dataset(dataset, train_params): temp_dataset_dir = dataset_dir data_dir = os.path.join(temp_dataset_dir, dataset) print("Data Directory: %s" % data_dir) # Model name (layers_size_model_time) model_name = "%d_%d_%s" % (train_params.num_layers, train_params.rnn_size, train_params.model) model_dir = os.path.join(data_dir, models_dir, model_name) print("Model Dir: %s" % model_dir) train_args = train_params.get_training_arguments(data_dir, model_dir) tf.reset_default_graph() train.train(train_args) return model_name
def main(): x, y = load_train_data('../data/cifar-10-batches-py') parse = build_argparser() for seed in xrange(int(sys.argv[1])): hp = { 'model': 'cp2f1d', 'batch_size': 512, 'n_train_steps': int(sys.argv[2]), 'np_seed': seed, 'checkpoint_dir': 'checkpoints/train_order/cp2f1d-s%i' % seed, } str_hp = sum(map(lambda k: ['--%s' % k, '%s' % hp[k]], hp), []) + ['--restart'] print '* arguments' print str_hp args = parse.parse_args(str_hp) train(x, y, vars(args))
def handle_predict(shop_id, pay_fn, view_fn, start_date, end_date): pay_action_count = load_action_stat(pay_fn) view_action_count = load_action_stat(view_fn) week_sample = handle_sample(pay_action_count, view_action_count, start_date, end_date, "%Y-%m-%d") predict_list = [] for week_num, sample_list in week_sample.items(): p = train.train(sample_list) if p == None: predict_list.append(0) continue sample = get_latest_sample_pay("2016-10-24", "2016-10-31", pay_action_count) sample = map(int, sample) rt = np.sum(np.multiply(p, sample)) predict_list.append(rt) predict_list = map(post_handle, predict_list) result = [] result.append(shop_id) result += predict_list[1:] # 周二到周日 result += predict_list # 周一到周日 result += predict_list[0:1] # 周一 result = map(str, result) print(",".join(result))
def main(): hmm = HMM(*train(sys.argv[1])) with open(sys.argv[2]) as f: correct = 0 wrong = 0 correct_sents = 0 wrong_sents = 0 correct_known = 0 wrong_known = 0 for i, sent in enumerate(Reader(f)): prob, path = hmm.decode([word for (word, pos) in sent]) correct1 = 0 wrong1 = 0 for (gold, predicted) in zip(sent, path): if gold == predicted: correct1 += 1 else: wrong1 += 1 print('%e\t%.3f\t%s' % (prob, correct1 / (correct1 + wrong1), ' '.join('%s/%s' % pair for pair in path))) if prob > 0: correct_sents += 1 correct_known += correct1 wrong_known += wrong1 else: wrong_sents += 1 correct += correct1 wrong += wrong1 print("Correctly tagged words: %s" % (correct / (correct + wrong))) print("Sentences with non-zero probability: %s" % (correct_sents / (correct_sents + wrong_sents))) print("Correctly tagged words when only considering sentences with non-zero probability: %s" % (correct_known / (correct_known + wrong_known)))
def main(_): if not tf.gfile.Exists(FLAGS.train_root_dir): tf.gfile.MakeDirs(FLAGS.train_root_dir) config = _make_config_from_flags() logging.info('\n'.join(['{}={}'.format(k, v) for k, v in config.iteritems()])) for stage_id in train.get_stage_ids(**config): tf.reset_default_graph() with tf.device(tf.train.replica_device_setter(FLAGS.ps_tasks)): real_images = None with tf.device('/cpu:0'), tf.name_scope('inputs'): real_images = _provide_real_images(**config) model = train.build_model(stage_id, real_images, **config) train.add_model_summaries(model, **config) train.train(model, **config)
def main(): db = MySQLdb.connect(host="localhost",user="******",passwd="123456",db="xataka") X_train = getX(db,0,20) ## getX returns the X matrix to by constructing it from posts starting with offset 0 and limited up to 20(1st and 2nd argument respectively) Y_train = getY(db,0,20) ## getY returns the Y matrix to by constructing it from post catgories starting with posts from offset 0 and limited up to 20(1st and 2nd argument respectively) X_test = getX(db,20,6) Y_test = getY(db,20,6) train(X_train,Y_train,100) ## train takes as arguments X,Y and batchsize pred = predict(X_test,Y_test,1000) ## predict takes as arguments X,Y and batchsize acc = prcntagaccurcy(pred,Y_test) ## calculate the accuracy of classifier print "Accuracy :", acc , "%" stop = timeit.default_timer() ## calculate time taken by program to run print stop-start, "seconds"
def k_result(k): train_k = random.sample(train_set,k) scp_k = os.path.join(tempdir,'scp_k') with open(scp_k,'w') as f: f.writelines(train_k) final_dir = train(outdir, config, scp_k, proto, htk_dict, words_mlf, monophones, tempdir) return test(outdir, final_dir, wdnet, htk_dict, monophones, scp_test, words_mlf, tempdir)
def main(params): train_set, valid_set, test_set = df.datasets.mnist.data() train_set_x, train_set_y = train_set test_set_x, test_set_y = test_set model = lenet() criterion = df.ClassNLLCriterion() optimiser = df.SGD(lr=params['lr']) for epoch in range(100): model.training() train(train_set_x, train_set_y, model, optimiser, criterion, epoch, params['batch_size'], 'train') train(train_set_x, train_set_y, model, optimiser, criterion, epoch, params['batch_size'], 'stats') model.evaluate() validate(test_set_x, test_set_y, model, epoch, params['batch_size'])
def main(model='cnn', input_var = T.tensor4('inputs'), target_var = T.ivector('targets'), num_epochs=10, lrn_rate=0.00004): # Load the dataset print("Loading data...") X_train, y_train, X_val, y_val, X_test, y_test = load_dataset() # Prepare Theano variables for inputs and targets #input_var = T.tensor4('inputs') #target_var = T.ivector('targets') # Create neural network model (depending on first command line parameter) print("Building model and compiling functions...") if model == 'cnn': network = build_cnn(input_var) elif model.startswith('custom_cnn:'): depth, width, drop_in, drop_hid, box_size = model.split(':', 1)[1].split(',') print(box_size) network = build_custom_cnn(input_var, int(depth), int(width), float(drop_in), float(drop_hid), int(box_size)) else: print("Unrecognized model type %r." % model) return network = train(network, num_epochs, lrn_rate, input_var, target_var, X_train, y_train, X_val, y_val, X_test, y_test) return network
def run(train_file, valid_file, test_file, output_file): '''The function to run your ML algorithm on given datasets, generate the output and save them into the provided file path Parameters ---------- train_file: string the path to the training file valid_file: string the path to the validation file test_file: string the path to the testing file output_file: string the path to the output predictions to be saved ''' ## your implementation here # read data from input train_samples, word2num = train_data_prepare(train_file) valid_samples = test_data_prepare(valid_file, word2num, 'valid') # your training algorithm model = train(train_samples, valid_samples, word2num) # your prediction code test(test_file, output_file, word2num, model)
def run(inPath, outPath, subDirs, model, connection, numJobs, subTask=3, posTags=None, useTestSet=False, clear=True, debug=False, force=False, training=True, preprocessorSteps=None, subset=None): # Remove existing non-empty work directory, if requested to do so if os.path.exists(outPath) and len(os.listdir(outPath)) > 0 and clear: if force or ask("Output directory '" + outPath + "' exists, remove?"): print >> sys.stderr, "Output directory exists, removing", outPath shutil.rmtree(outPath) # Create work directory if needed if not os.path.exists(outPath): print >> sys.stderr, "Making output directory", outPath os.makedirs(outPath) # Begin logging logPath = beginLog(outPath) # Collect the parse files parseDir = os.path.join(outPath, "parses") if not os.path.exists(parseDir) or len(os.listdir(parseDir)) == 0: parseDir = combineParses(inPath, parseDir, subDirs) else: print >> sys.stderr, "Using collected parses from", parseDir # Import the parses corpusDir = os.path.join(outPath, "corpus") if not os.path.exists(corpusDir): if preprocessorSteps == None: preprocessorSteps = ["MERGE_SETS", "REMOVE_ANALYSES", "REMOVE_HEADS", "MERGE_SENTENCES", "IMPORT_PARSE", "SPLIT_NAMES", "FIND_HEADS", "DIVIDE_SETS"] preprocessor = Preprocessor(preprocessorSteps) #preprocessor = Preprocessor(["MERGE-SETS", "REMOVE-ANALYSES", "REMOVE-HEADS", "MERGE-SENTENCES", "IMPORT-PARSE", "VALIDATE", "DIVIDE-SETS"]) preprocessor.setArgForAllSteps("debug", debug) preprocessor.getStep("IMPORT_PARSE").setArg("parseDir", parseDir) preprocessor.getStep("IMPORT_PARSE").setArg("posTags", posTags) modelPattern = model + ".+\.xml" if useTestSet else model + "-devel\.xml|" + model + "-train\.xml" preprocessor.process(modelPattern, os.path.join(corpusDir, model), logPath=None) else: print >> sys.stderr, "Using imported parses from", corpusDir # Train the model if training: connection = connection.replace("$JOBS", str(numJobs)) if subTask > 0: model = model + "." + str(subTask) train(outPath, model, parse="McCC", debug=debug, connection=connection, corpusDir=corpusDir, subset=subset, log=None) #classifierParams={"examples":None, "trigger":"150000", "recall":None, "edge":"7500", "unmerging":"2500", "modifiers":"10000"}) # Close the log endLog(logPath)
def run(optim): progress = make_progressbar("Training with " + str(optim), 5) progress.start() model = net() model.training() for epoch in range(5): train(Xtrain, ytrain, model, optim, criterion, batch_size, "train") train(Xtrain, ytrain, model, optim, criterion, batch_size, "stats") progress.update(epoch + 1) progress.finish() model.evaluate() nll, _ = test(Xtrain, ytrain, model, batch_size) _, nerr = test(Xval, yval, model, batch_size) print("Trainset NLL: {:.2f}".format(nll)) print("Testset errors: {}".format(nerr))
def parse_command_line(): parser = argparse.ArgumentParser( description="""Train, validate, and test a face detection classifier that will determine if two faces are the same or different.""") parser.add_argument("-p", "--prepare-data", help="Prepare training and validation data.", action="store_true") parser.add_argument("-t", "--train", help="""Train classifier. Use --graph to generate quality graphs""", action="store_true") parser.add_argument("-g", "--graph", help="Generate training graphs.", action="store_true") parser.add_argument("--weights", help="""The trained model weights to use; if not provided defaults to the network that was just trained""", type=str, default=None) parser.add_argument("--note", help="Adds extra note onto generated quality graph.", type=str) parser.add_argument("-s", "--is_same", help="""Determines if the two images provided are the same or different. Provide relative paths to both images.""", nargs=2, type=str) parser.add_argument("--visualize", help="""Writes out various visualizations of the facial images.""", action="store_true") args = vars(parser.parse_args()) if os.environ.get("CAFFE_HOME") == None: print "You must set CAFFE_HOME to point to where Caffe is installed. Example:" print "export CAFFE_HOME=/usr/local/caffe" exit(1) # Ensure the random number generator always starts from the same place for consistent tests. random.seed(0) webface = WebFace() if args["prepare_data"] == True: webface.load_data() webface.pair_data() if args["visualize"] == True: # TODO: Adapt this to WebFace, not just LFW. visualize() if args["train"] == True: train(args["graph"], data=webface, weight_file=args["weights"], note=args["note"]) if args["is_same"] != None: # TODO: Fill this out once we have a threshold and neural network trained. images = args["is_same"] predict(images[0], images[1])
def cross_validation(): list=[] total_accuracy=0 fold_size=file_size()//10 fileee=open('stage2_result.txt') for f in fileee: f=re.sub('\n', '', f) list.append(f) fileee.close() for i in range(9,-1,-1): test_set=list[i*fold_size:][:fold_size] training_set=list[0:i*fold_size] + list[(i+1) * fold_size:] train.train(training_set) correct,tp,tn,fp,fn=test(training_set,test_set,find_total_count('vocabulary_bigram_positive.txt'),find_total_count('vocabulary_bigram_negative.txt')) accuracy = float(tp+tn)/float(tp+tn+fp+fn) print (accuracy*100) total_accuracy+=accuracy print ((total_accuracy/10)*100)
def main(): """Train model and run inference on coco test set to output metrics""" os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu) if(args.is_train == 1): train(args) bestmodelfn = osp.join(args.model_dir, 'bestmodel.pth') if(osp.exists(bestmodelfn)): if(args.beam_size == 1): scores = test(args, 'test', modelfn=bestmodelfn) else: scores = test_beam(args, 'test', modelfn=bestmodelfn) print('TEST set scores') for k, v in scores[0].iteritems(): print('%s: %f' % (k, v)) else: raise Exception('No checkpoint found %s' % bestmodelfn)
def main(): """Main""" if(len(sys.argv) != 9): print "Usage: python generate.py -font <font name> -l <language> " + \ "-s <size> -a <input alphabet directory>" exit() if(sys.argv[1] == "-font"): font_name = sys.argv[2] else: print "Usage: python generate.py -font <font name> -l <language> " + \ "-s <size> -a <input alphabet directory>" exit() if(sys.argv[3] == "-l"): lang = sys.argv[4] else: print "Usage: python generate.py -font <font name> -l <language> " + \ "-s <size> -a <input alphabet directory>" exit() if(sys.argv[5] == "-s"): font_size = sys.argv[6] else: print "Usage: python generate.py -font <font name> -l <language> " + \ "-s <size> -a <input alphabet directory>" exit() if(sys.argv[7] == "-a"): alphabet_dir = sys.argv[8] else: print "Usage: python generate.py -font <font name> -l <language> " + \ "-s <size> -a <input alphabet directory>" exit() draw(font_name, int(font_size), lang, tatfile.read_file(alphabet_dir)) # Begin training # Reads all fonts in the directory font_dir and trains train.train(lang, lang + "." + font_name + ".exp%2d" % (int(font_size)))
def main (): x = time.clock () # trainPath = '/Users/robertabbott/Desktop/CS/projects/kaggle/pizza/pizza_request_dataset.json' trainPath = '/Users/robertabbott/Desktop/CS/projects/kaggle/pizza/train.json' testPath = '/Users/robertabbott/Desktop/CS/projects/kaggle/pizza/pizza_request_dataset.json' # testPath = '/Users/robertabbott/Desktop/CS/projects/kaggle/pizza/test.json' testData = train (testPath) trainData = train (trainPath) trainData.mapData () # trainData.addDataSet (trainPath) c = classify (trainData) # y = getProbability (testData, c) y = c.getProbability (testData) print y[0:2] print 'positives: ' + str(y[2]), 'negatives: ' + str(y[3]) print 'false positives: ' + str(y[4]), 'false negatives: ' + str(y[5]) print 'recall = ' + str(float(y[2])/float(y[2]+y[4])) print 'precision = ' + str(float(y[2])/float(y[2]+y[5])) print 'accuracy = ' + str(float(y[0]) / (float(y[0])+float(y[1])))
dropout = 0. load_path = None num_gen_samples = 100 num_gen_conditions = 10 num_images_per_condition = 1 final_num_gen_samples = 1000 final_num_gen_conditions = 1000 final_num_images_per_condition = 10 evals_to_stop = 100 eval_only = False preprocessed_data, xa_mappings = read_data(dataset, num_train_examples, sample_train_randomly, identity_features, num_bond_types, num_atom_types, num_max_nodes) for lr, gcn_layer, autoregressive, gcn_relu, gcn_batch_norm, graphite_layer, z_dim, use_pos_weight in \ product(v_lrs, v_gcn_layers, v_autoregressives, v_gcn_relus, v_gcn_batch_norms, v_graphite_layers, v_z_dims, v_use_pos_weights): gcn_hiddens = [] gcn_aggs = [] gcn_relus = [] for l in range(gcn_layer): gcn_hiddens.append(z_dim) gcn_aggs.append('mean') gcn_relus.append(True if gcn_relu == 'all' or (gcn_relu == 'last' and l == gcn_layer - 1) else False) train(dataset, num_train_examples, sample_train_randomly, identity_features, num_bond_types, num_atom_types, num_max_nodes, model_type, lr, epochs, autoregressive, encode_features, gcn_batch_norm, gcn_hiddens, gcn_aggs, gcn_relus, graphite_relu, graphite_layer, z_dim, z_agg, dropout, num_gen_samples, num_gen_conditions, evals_to_stop, eval_only, load_path, use_pos_weight, preprocessed_data, xa_mappings, num_images_per_condition, final_num_gen_samples, final_num_gen_conditions, final_num_images_per_condition)
''' # music parser.add_argument('--dataset', type=str, default='music', help='which dataset to use') parser.add_argument('--n_epochs', type=int, default=10, help='the number of epochs') parser.add_argument('--dim', type=int, default=4, help='dimension of user and entity embeddings') parser.add_argument('--L', type=int, default=2, help='number of low layers') parser.add_argument('--H', type=int, default=1, help='number of high layers') parser.add_argument('--batch_size', type=int, default=256, help='batch size') parser.add_argument('--l2_weight', type=float, default=1e-6, help='weight of l2 regularization') parser.add_argument('--lr_rs', type=float, default=1e-3, help='learning rate of RS task') parser.add_argument('--lr_kge', type=float, default=2e-4, help='learning rate of KGE task') parser.add_argument('--kge_interval', type=int, default=2, help='training interval of KGE task') ''' show_loss = False show_topk = True args = parser.parse_args() start = time.time() data = load_data(args) end = time.time() print("Loading data time : ", end-start) start = time.time() train(args, data, show_loss, show_topk) end = time.time() print("Training time : ", end-start)
n_workers = 4 train_loader = DataLoader(train_dataset, batch_size=args.batch_size, num_workers=n_workers) val_loader = DataLoader(val_dataset, batch_size=args.batch_size, num_workers=n_workers) test_loader = DataLoader(test_dataset, batch_size=args.batch_size, num_workers=n_workers) show_loss = False print(f""" datast: {args.dataset} vector dim: {args.dim} batch_size: {args.batch_size} lr: {args.lr} """) datainfo = {} datainfo['train'] = train_loader datainfo['val'] = val_loader datainfo['test'] = test_loader datainfo['feature_num'] = feature_num datainfo['data_num'] = [ len(train_dataset), len(val_dataset), len(test_dataset) ] train(args, datainfo, show_loss)
import generate_walk_path import motif_random_walk import train from neo4j import GraphDatabase import pipline_config if __name__ == "__main__": generate_walk_path.main(pipline_config) generate_walk_path.train_node2vec(pipline_config.raw_walk_path) # # generate_walk_path.change_emb_index( # # pipline_config.raw_emb_path, pipline_config.uid2idx_path) motif_random_walk.main(pipline_config.raw_train_data_path, pipline_config.train_data_path) motif_random_walk.main(pipline_config.raw_test_data_path, pipline_config.test_data_path) train.train() train.eval()
from neural_nets import Model from tensorboardX import SummaryWriter from train import train from utils import DataLoader from cfg import Cfg DEBUG = False TRAIN = True TEST = False ONTONOTES = False list_cfgs = list() cfg = Cfg(DEBUG, TRAIN, TEST, ONTONOTES) cfg.ADD_FEATURES = False list_cfgs.append((cfg, 'ADD_FEATURES='+str(cfg.ADD_FEATURES))) # cfg = Cfg(DEBUG, TRAIN, TEST, ONTONOTES) # cfg.ADD_FEATURES = True # list_cfgs.append((cfg, 'ADD_FEATURES='+str(cfg.ADD_FEATURES))) for cfg in list_cfgs: print(cfg[1]) writer = SummaryWriter(comment=cfg[1]) cfg = cfg[0] model = Model(cfg) data_training = DataLoader(cfg.TRAINING_PATH, cfg.BATCH_SIZE, endless_iterator=True, shuffle=True, debug=cfg.DEBUG) data_eval = DataLoader(cfg.VAL_PATH, cfg.BATCH_SIZE, endless_iterator=False, shuffle=True, debug=cfg.DEBUG) train(model, data_training, data_eval, cfg, writer)
For both G and D we pass the correct particle-type as label. ''' gan_input_particle = Input(shape=(1,), name='gan_input_particle') gan_input_energy = Input(shape=(1,), name='gan_input_energy') gan_input_noise = Input(shape=(1, args['latent_size']),name='gan_input_noise') generated_image = G([gan_input_particle, gan_input_energy, gan_input_noise]) d_proba = D([generated_image, gan_input_particle, gan_input_energy]) GAN = Model(input=[gan_input_particle, gan_input_energy, gan_input_noise], output=d_proba) # temporarily making D untrainable so the summary shows that D won't be trainale during the GAN. # We reset it during training, and the freeze it every cycle. train.make_trainable(D, False) GAN.compile(optimizer=train.optimizer(), loss=train.wasser_loss) print 'GAN' print GAN.summary() train.make_trainable(D, True) return GAN if __name__ == '__main__': # parse args path2config = sys.argv[1] args = train.parse_config(path2config) G = small_generator(args) D = small_discriminator(args) GAN = gan(G, D, args) train.train(G, D, GAN, args)
train_data, test_start = data[:cutoff], data[cutoff] # CONFIGURE PLOTS fig1 = plt.figure() ax1 = plt.axes(projection='3d') # TRAIN MODELS AND PLOT time_steps = 50 epochs = 20 num_predict = 30 start_time = time.time() for i in range(1): print("Model", i, "| elapsed time:", "{:5.2f}".format( (time.time() - start_time) / 60), "min") model = rnn_ode.RNN_ODE(2, 6, 2, device_params, time_steps) losses = train.train(train_data, model, epochs) # model.node_rnn.observe(True) model.use_cb(True) output, times = train.test(test_start[0][0], test_start[0][1], num_predict, model) # model.use_cb(False) o1, o2, o3 = output[:, 0].squeeze(), output[:, 1].squeeze(), times.squeeze() ax1.plot3D(o1, o2, o3, 'gray') d1, d2, d3 = y[0, :].squeeze(), y[1, :].squeeze(), x.squeeze() ax1.plot3D(d1, d2, d3, 'orange') #fig1.savefig('output/fig6/1.png', dpi=600, transparent=True) plt.show()
## Train loop trainiter = iter(dataloaders['train']) features, labels = next(trainiter) chk_pt = cutils.checkpoint(config["checkpoint_folder"]) print("Checkpoint_path: {}".format(chk_pt)) for pg in optimizer.param_groups: print("LR {}".format(pg['lr'])) if config["train"]: model, history = train.train( model, criterion, optimizer, dataloaders['train'], valid_loader=dataloaders['validate'], save_file_name=chk_pt, max_epochs_stop=5, n_epochs=config["epochs"], print_every=1, validate_every=config["validate_every_X_epochs"], train_on_gpu=train_on_gpu, early_stopping=config["early_stopping"]) if config["test"]: train.validate(model, criterion, dataloaders["train"], train_on_gpu=train_on_gpu)
def run_experiments(exp_names, pretrained): for exp_name in exp_names: print("=========================================================================") print("Experiment:", exp_name) print("=========================================================================") if exp_name == "resnet50_baseline": if pretrained: url = 'https://cloud.dfki.de/owncloud/index.php/s/GnBNwtfkDZQRMeb/download?path=%2F&files=cifar100_exp_3282.h5' file_path = '../models/resnet50_baseline.h5' get_model(url, file_path, exp_name) updates = {'epochs': 80, 'learning_rate': 0.088, 'momentum': 0.93, 'aux_weight': [], 'aux_depth': [], 'grouping': [], 'num_coarse_classes': [], 'with_aux': False, 'optimize': False, 'aux_layouts': [], 'with_augmentation': True, 'batch_size': 64, 'network': 'resnet50', 'use_pretrained': file_path if pretrained else None } elif exp_name == "resnet50_ssal": if pretrained: url = 'https://cloud.dfki.de/owncloud/index.php/s/GnBNwtfkDZQRMeb/download?path=%2F&files=cifar100_exp_676.h5' file_path = '../models/resnet50_ssal.h5' get_model(url, file_path, exp_name) updates = {'epochs': 80, 'learning_rate': 0.092, 'momentum': 0.93, 'aux_weight': [0.42, 0.59, 0.76], 'aux_depth': [[1, -1], [2, -1], [3, -1]], 'grouping': ['20_group_similar_v2', '33_group_similar_v2', '50_group_similar_v2'], 'num_coarse_classes': [20, 33, 50], 'with_aux': True, 'optimize': False, 'aux_layouts': [ [['cbr', 128, 5, 2], ['cbr', 128, 3], ['inception'], ['gap']], [['cbr', 128, 5], ['cbr', 128, 3], ['inception'], ['gap']], [['cbr', 128, 3], ['cbr', 128, 3], ['inception'], ['gap']]], 'with_augmentation': True, 'batch_size': 64, 'network': 'resnet50', 'exp_combination_factor': 0.3, 'use_pretrained': file_path if pretrained else None } elif exp_name == "wrn28-10_baseline": if pretrained: url = 'https://cloud.dfki.de/owncloud/index.php/s/GnBNwtfkDZQRMeb/download?path=%2F&files=cifar100_exp_3060.h5' file_path = '../models/wrn28-10_baseline.h5' get_model(url, file_path, exp_name) updates = {'epochs': 80, 'learning_rate': 0.016, 'momentum': 0.9, 'weight_decay': 7e-4, 'aux_weight': [], 'aux_depth': [], 'grouping': [], 'num_coarse_classes': [], 'with_aux': False, 'optimize': False, 'aux_layouts': [], 'with_augmentation': True, 'batch_size': 64, 'network': 'WRN', 'wide_depth': 28, 'wide_width': 10, 'mean_std_norm': True, 'nesterov': True, 'use_pretrained': file_path if pretrained else None } elif exp_name == "wrn28-10_ssal": if pretrained: url = 'https://cloud.dfki.de/owncloud/index.php/s/GnBNwtfkDZQRMeb/download?path=%2F&files=cifar100_exp_3421.h5' file_path = '../models/wrn28-10_ssal.h5' get_model(url, file_path, exp_name) updates = {'epochs': 80, 'learning_rate': 0.021, 'momentum': 0.9, 'weight_decay': 7e-4, 'aux_weight': [0.8, 0.9, 1.0], 'aux_depth': [[2, 2], [3, 2], [3, -1]], 'grouping': ['20_group_similar_v2', '33_group_similar_v2', '50_group_similar_v2'], 'num_coarse_classes': [20, 33, 50], 'with_aux': True, 'optimize': False, 'aux_layouts': [ [['cbr', 128, 5, 2], ['cbr', 128, 3], ['cbr'], ['cbr'], ['inception'], ['inception'], ['gap']], [['cbr', 128, 5], ['cbr', 128, 3], ['cbr'], ['cbr'], ['gap'], ['dense']], [['cbr', 128, 3], ['cbr', 128, 3], ['inception'], ['inception'], ['gap']]], 'with_augmentation': True, 'batch_size': 64, 'network': 'WRN', 'wide_depth': 28, 'wide_width': 10, 'aux_weight_decay': 3e-4, 'mean_std_norm': True, 'nesterov': True, 'exp_combination_factor': 0.4, 'use_pretrained': file_path if pretrained else None } elif exp_name == "densenet190-40_baseline": if pretrained: url = 'https://cloud.dfki.de/owncloud/index.php/s/GnBNwtfkDZQRMeb/download?path=%2F&files=cifar100_exp_153.h5' file_path = '../models/densenet190-40_baseline.h5' get_model(url, file_path, exp_name) updates = {'epochs': 100, 'learning_rate': 0.08, 'momentum': 0.9, 'weight_decay': 3e-4, 'aux_weight': [], 'aux_depth': [], 'grouping': [], 'num_coarse_classes': [], 'with_aux': False, 'optimize': False, 'aux_layouts': [], 'with_augmentation': True, 'batch_size': 32, 'network': 'DenseNet', 'dense_depth': 190, 'dense_growth': 40, 'mean_std_norm': True, 'nesterov': True, 'label_smoothing': True, 'use_pretrained': file_path if pretrained else None } elif exp_name == "densenet190-40_ssal": if pretrained: url = 'https://cloud.dfki.de/owncloud/index.php/s/GnBNwtfkDZQRMeb/download?path=%2F&files=cifar100_exp_55.h5' file_path = '../models/densenet190-40_ssal.h5' get_model(url, file_path, exp_name) updates = {'epochs': 100, 'learning_rate': 0.08, 'momentum': 0.9, 'weight_decay': 3e-4, 'aux_weight': [0.8, 0.9, 1.0], 'aux_depth': [[1, -1], [2, 0], [3, 0]], 'grouping': ['20_group_similar_v2', '33_group_similar_v2', '50_group_similar_v2'], 'num_coarse_classes': [20, 33, 50], 'with_aux': True, 'optimize': False, 'aux_layouts': [ [['cbr', 128, 5, 2], ['cbr', 128, 3], ['cbr'], ['cbr'], ['inception'], ['inception'], ['gap']], [['cbr', 128, 5], ['cbr', 128, 3], ['cbr'], ['cbr'], ['gap'], ['dense']], [['cbr', 128, 3], ['cbr', 128, 3], ['inception'], ['inception'], ['gap']]], 'with_augmentation': True, 'batch_size': 32, 'network': 'DenseNet', 'dense_depth': 190, 'dense_growth': 40, 'aux_weight_decay': 1e-4, 'mean_std_norm': True, 'nesterov': True, 'label_smoothing': True, 'exp_combination_factor': 0.5, 'use_pretrained': file_path if pretrained else None } else: raise NotImplementedError(str(exp_name) + "is not a valid experiment identifier") train(**updates)
import torch import data import train task_id = int(os.environ['SLURM_PROCID']) if "SLURM_PROCID" in os.environ else 0 with open('hyperparameters.tsv') as csvfile: readCSV = csv.reader(csvfile, delimiter='\t') hp_choices = [row for row in readCSV] row = hp_choices[task_id] bs, lr, hd = int(row[0]), float(row[1]), int(row[2]) print(bs, lr, hd) LIMIT=100 EPOCHS=1 TEMP=1.0 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # def get_data(train_file, batchsize, limit, sort, cc): batched_parses, training_labels, glove = data.get_data("data/snli_1.0/snli_1.0_train.jsonl", bs, LIMIT, True, "data/snli_1.0/cc") start_time = time.time() #def train(batched_parses, training_labels, glove, device, batchsize, hd, lr, num_epochs, initial_temperature, show_zero_ops, experiment): final_mean_loss = train.train(batched_parses, training_labels, glove, device, bs, hd, lr, EPOCHS, TEMP, False, None) end_time = time.time() print(f"result: loss={final_mean_loss}, time={end_time-start_time}")
def cross_validation(config, checkpoint=None): dataset_name = config['dataset_name'] dataset_path = osp.join(config['data_path'], dataset_name) dataset = TUDataset(dataset_path, name=dataset_name) if checkpoint is None: dataset_permutation = torch.randperm(len(dataset)) else: dataset_permutation = checkpoint['dataset_permutation'] dataset = dataset[dataset_permutation] prepare_config_for_dataset(config, dataset) cross_validation_batches = config['cross_validation_batches'] cross_validation_batch_size = len(dataset) // cross_validation_batches results = [] if checkpoint is None else checkpoint['results'] train_histories = [] if checkpoint is None else checkpoint[ 'train_histories'] test_histories = [] if checkpoint is None else checkpoint['test_histories'] start_cross_validation_batch = 0 if checkpoint is None else checkpoint[ 'current_cross_validation_batch'] for i in range(start_cross_validation_batch, cross_validation_batches): #save_cross_validation_progress(config, i, results, train_histories, test_histories) print('%s cross validation batch %d/%d' % ('Starting' if checkpoint is None else 'Continuing', i + 1, cross_validation_batches)) start_index = i * cross_validation_batch_size end_index = ( i + 1 ) * cross_validation_batch_size if i + 1 < cross_validation_batches else len( dataset) test_dataset = dataset[start_index:end_index] if start_index == 0: train_dataset = dataset[end_index:] elif end_index == len(dataset): train_dataset = dataset[:start_index] else: train_dataset = dataset[:start_index] + dataset[end_index:] if config['node_features'] == 'categorical': test_loader = DataLoader(test_dataset, batch_size=config['batch_size']) train_loader = DataLoader(train_dataset, batch_size=config['batch_size']) elif config['node_features'] == 'node_degree': test_loader = NodeDegreeFeatureDataLoader( test_dataset, config['max_node_degree'], batch_size=config['batch_size']) train_loader = NodeDegreeFeatureDataLoader( train_dataset, config['max_node_degree'], batch_size=config['batch_size']) elif config['node_features'] == 'same': test_loader = SameFeatureDataLoader( test_dataset, batch_size=config['batch_size']) train_loader = SameFeatureDataLoader( train_dataset, batch_size=config['batch_size']) save_data = { 'dataset_permutation': dataset_permutation, 'results': results, 'train_histories': train_histories, 'test_histories': test_histories, 'current_cross_validation_batch': i } if i > start_cross_validation_batch: checkpoint = None train_history, test_history = train(config, train_loader, test_loader, save_data, checkpoint=checkpoint) train_histories.append(train_history) test_histories.append(test_history) best_epoch = np.argmax(test_history) + 1 results.append(test_history[best_epoch - 1]) print('Cross validation batch %d/%d: %f in epoch %d' % (i + 1, cross_validation_batches, results[-1], best_epoch)) avg = np.mean(results) std = np.std(results) details = { 'results': results, 'train_history': train_histories, 'test_history': test_histories } return avg, std, details
def main(): global args args = parser.parse_args() modelpath = os.path.join(os.path.abspath('../Exps'), args.exp) train_data = np.load(os.path.join(modelpath, 'train_split.npy')) val_data = np.load(os.path.join(modelpath, 'val_split.npy')) with open(os.path.join(modelpath, 'train_attack.txt'), 'r') as f: train_attack = f.readlines() train_attack = [ attack.split(' ')[0].split(',')[0].split('\n')[0] for attack in train_attack ] sys.path.append(modelpath) model = import_module('model') config, net = model.get_model() start_epoch = args.start_epoch save_dir = args.save_dir if args.resume: checkpoint = torch.load(args.resume) if start_epoch == 0: start_epoch = checkpoint['epoch'] + 1 if not save_dir: save_dir = checkpoint['save_dir'] else: save_dir = os.path.join(modelpath, 'results', save_dir) net.load_state_dict(checkpoint['state_dict']) else: if start_epoch == 0: start_epoch = 1 if not save_dir: exp_id = time.strftime('%Y%m%d-%H%M%S', time.localtime()) save_dir = os.path.join(modelpath, 'results', exp_id) else: save_dir = os.path.join(modelpath, 'results', save_dir) print(save_dir) if args.test == 1 or args.test_e4 == 1: net = net.net if args.debug: net = net.cuda() else: net = DataParallel(net).cuda() cudnn.benchmark = True if args.test == 1 or args.test_e4 == 1: test_attack = [] if args.test == 1: with open(os.path.join(modelpath, 'test_attack.txt'), 'r') as f: test_attack += f.readlines() if args.test_e4 == 1: with open(os.path.join(modelpath, 'test_attack_e4.txt'), 'r') as f: test_attack += f.readlines() test_attack = [ attack.split(' ')[0].split(',')[0].split('\n')[0] for attack in test_attack ] test_data = np.load(os.path.join(modelpath, 'test_split.npy')) dataset = DefenseDataset(config, 'test', test_data, test_attack) test_loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.resume != '': resumeid = args.resume.split('.')[-2].split('/')[-1] else: resumeid = 0 print(args.defense) args.defense = args.defense == 1 if args.defense: name = 'test_result/result_%s_%s' % (args.exp, resumeid) else: name = 'test_result/result_%s_%s_nodefense' % (args.exp, resumeid) if args.test_e4: name = name + '_e4' test(net, test_loader, name, args.defense) return dataset = DefenseDataset(config, 'train', train_data, train_attack) train_loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) dataset = DefenseDataset(config, 'val', val_data, train_attack) val_loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) if not os.path.exists(save_dir): os.makedirs(save_dir) logfile = os.path.join(save_dir, 'log') sys.stdout = Logger(logfile) pyfiles = [f for f in os.listdir('./') if f.endswith('.py')] for f in pyfiles: shutil.copy(f, os.path.join(save_dir, f)) if isinstance(net, DataParallel): params = net.module.net.denoise.parameters() else: params = net.net.denoise.parameters() if args.optimizer == 'sgd': optimizer = optim.SGD(params, lr=args.lr, momentum=0.9, weight_decay=args.weight_decay) elif args.optimizer == 'adam': optimizer = optim.Adam(params, lr=args.lr, weight_decay=args.weight_decay) else: exit('Wrong optimizer') def get_lr(epoch): if epoch <= args.epochs * 0.6: return args.lr elif epoch <= args.epochs * 0.9: return args.lr * 0.1 else: return args.lr * 0.01 for epoch in range(start_epoch, args.epochs + 1): requires_control = epoch == start_epoch train(epoch, net, train_loader, optimizer, get_lr, config['loss_idcs'], requires_control=requires_control) val(epoch, net, val_loader, requires_control=requires_control) if epoch % args.save_freq == 0: try: state_dict = net.module.state_dict() except: state_dict = net.state_dict() for key in state_dict.keys(): state_dict[key] = state_dict[key].cpu() torch.save( { 'epoch': epoch, 'save_dir': save_dir, 'state_dict': state_dict, 'args': args }, os.path.join(save_dir, '%03d.ckpt' % epoch))
val_loss_step = [] print_every = 100 plot_every = 1000 n_iters = len(train_loader_vi) while epoch < n_epochs: epoch += 1 plot_losses = [] print_loss_avg = 0 plot_loss_total = 0 # Get training data for this cycle for i, (input_batches, input_lengths, target_batches, target_lengths) in enumerate(train_loader_vi): input_batches, input_lengths, target_batches, target_lengths = input_batches.to(device), input_lengths.to(device), target_batches.to(device), target_lengths.to(device) loss = train( input_batches, input_lengths, target_batches, target_lengths, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion ) plot_loss_total += loss.item() print_loss_avg += loss.item() if i > 0 and i % print_every == 0: print_loss_avg = plot_loss_total / print_every plot_loss_total = 0 print('%s (%d %d%%) %.4f' % (time_since(start, i / n_iters), i, i / n_iters * 100, print_loss_avg)) if i > 0 and i % plot_every == 0: plot_loss_avg = plot_loss_total / plot_every plot_losses.append(plot_loss_avg) plot_loss_total = 0
0.7, 0.8, 0.9, 1 ] MODELS = {} rnn = RNN(3, 5, 12, HN, HL) init_state = copy.deepcopy(rnn.state_dict()) for lr in LR: rnn.load_state_dict(init_state) training_inputs = training_data[:, 0:5] training_labels = training_data[:, 5:] test_inputs = testing_data[:, 0:5] test_labels = testing_data[:, 5:] training_inputs = np.split(training_inputs, 606) training_labels = np.split(training_labels, 606) test_inputs = np.split(test_inputs, 2) test_labels = np.split(test_labels, 2) train(rnn, training_inputs, training_labels, EPOCHS, lr, BATCH_SIZE) avg_mse = test(test_inputs, test_labels, rnn) MODELS['{a}_{x}-{y}_{z}_{b}'.format(a=HL, x=HN, y=HN, z=EPOCHS, b=lr)] = np.array(avg_mse) with open('Data2/Search/manual_search_results_{x}HL_lr.csv'.format(x=HL), 'w') as f: for key in MODELS.keys(): f.write("%s: %s\n" % (key, MODELS[key])) print(MODELS)
args.kernel_sizes = [int(k) for k in args.kernel_sizes.split(',')] args.save_dir = os.path.join( args.save_dir, datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) print("\n Parameters:") for attr, value in sorted(args.__dict__.items()): print("\t{}={}".format(attr.upper(), value)) # model if args.model_type.lower() == "cnn": cnn = model.CNN_Text(args) elif args.model_type.lower() == "lstm": cnn = model.LSTM_Text(args) static_cnn = None if args.cuda: torch.cuda.set_device(args.device) cnn = cnn.cuda() train.train(train_iter, dev_iter, dev_adv_iter, cnn, args, static_cnn, args.eps, lp_norm='inf', model_eps_ball=False)
def launch_training(model_name, **kwargs): # Launch training train.train(model_name, **d_params)
def main(): # Pre-trained model VALID_ARCH_CHOICES = ("vgg16", "vgg13", "densenet121") # Parse command line arguments ap = argparse.ArgumentParser() ap.add_argument("data_dir", help="Directory containing the dataset (default: data)", default="data", nargs="?") ap.add_argument( "--arch", help="Model architecture from 'torchvision.models' (default: vgg16)", choices=VALID_ARCH_CHOICES, default=VALID_ARCH_CHOICES[0]) # ap.add_argument("--hidden-units", # help="Number of units the hidden layer should consist of (default: 512)", # default=512, # type=int) ap.add_argument( "--cpu", help="Use CPU (else GPU) for training (default if not set: GPU)", action="store_true") args = ap.parse_args() device = "cpu" if args.cpu else "cuda" args.device = device args.noise = 0.25 args.clip = 1.0 args.batch_size = 64 args.hidden_units = 256 args.delta = 1e-4 # Build model: chose loss function, optimizer, processor support # # Done later to reset the model # model = hybrid_model(arch=args.arch, hidden_units=args.hidden_units) criterion = nn.NLLLoss() device = "cpu" if args.cpu else "cuda" # ===== TUNING =========================================================== # Hyperparameters to test lr_range = [1e-4] ##### <== choice (enumeration) batch_size_range = [ 32, 16, 8, 2 ] #, 32, 128, 8, 4, 1] ##### <== choice (enumeration) epochs = 30 ##### <== choice (1 value=max) # Number of iteration for each parameter iter = 1 ##### <== choice (single value) # DP or not DP, that is the question args.disable_dp = False ##### <== choice (boolean) # ======================================================================== # File to export results dp_or_not = "noDP_" if args.disable_dp else "DP_" file = "experiment_stats/accuracy_data_" + dp_or_not file += str(datetime.datetime.today()).replace(' ', '_') + ".csv" steps = len(lr_range) * len(batch_size_range) * iter step = 0 # Write column titles with open(file, 'w') as f: f.write( 'learning_rate, batch_size, n_epochs, accuracy, n_times_for_avg\n') # Experiment loops for lr in lr_range: args.learning_rate = lr for bs in batch_size_range: args.batch_size = bs # Load the dataset into a dataloader ### default test batch size ### trainloader, testloader, mapping = get_data( data_folder=args.data_dir, batch_size=bs) args.sample_size = len(trainloader.dataset) #for epochs in epochs_range: accuracy_sum = [] for _ in range(iter): # Reset the model model, optimizer = hybrid_model(arch=args.arch, hidden_units=args.hidden_units, args=args) step += 1 _, acc = train( model=model, trainloader=trainloader, testloader=testloader, epochs=epochs, print_every=None, criterion=criterion, optimizer=optimizer, device=device, arch=args.arch, model_dir='', serialize=False, detail=False, args=args, ) acc = np.multiply(acc, 100) accuracy_sum.append(acc) print(f' {step}/{steps}\tlr={lr}, bs={bs},') for n_epoch, accur in enumerate(acc, start=1): line = f'{lr}, {bs}, {n_epoch}, {accur:.2f}, 1\n' with open(file, 'a') as f: f.write(line) print(f'\t. ×{n_epoch} epoch{"s" if n_epoch > 1 else " "}' f' => accuracy = {accur:.2f}%') # Sum up for identical settings, repeted `iter` times if iter > 1: acc_avg = np.average(accuracy_sum, axis=0) for n_epoch, accur in enumerate(acc_avg, start=1): line = f'{lr}, {bs}, {n_epoch}, {accur:.2f}, {iter}\n' with open(file, 'a') as f: f.write(line) print( f'\t\t>>> Average on {iter} iterations >>>\tlr={lr}, bs={bs},' f' ×{n_epoch} epoch{"s" if n_epoch > 1 else " "}' f' => accuracy = {accur:.2f}%')
self.log(f'test_p_loss_t_{i}', p_loss, on_step=False, on_epoch=True, prog_bar=False) self.log(f'test_T_loss_t_{i}', T_loss, on_step=False, on_epoch=True, prog_bar=False) self.log(f'test_rh_loss_t_{i}', rh_loss, on_step=False, on_epoch=True, prog_bar=False) self.log(f'test_wv_loss_t_{i}', wv_loss, on_step=False, on_epoch=True, prog_bar=False) def configure_optimizers(self): return torch.optim.Adam(self.parameters()) if __name__ == "__main__": train( LSTM(input_size=len(features), hidden_size=32, target_size=len(targets), num_layers=2))
def main(_): parser = setup_options() opt = parser.parse_args() print(opt) inner_epoches = opt.inner_epoches default_channel = opt.default_channel default_sr_method = opt.default_sr_method test_dataset_path = opt.test_dataset_path gpu_id = opt.gpu_id epoches = opt.epoches batch_size = opt.batch_size dataset_dir = opt.dataset_dir g_ckpt_dir = opt.g_ckpt_dir g_log_dir = opt.g_log_dir debug = opt.debug upscale_factor = opt.upscale_factor filter_num = opt.filter_num continued_training = opt.continued_training defalut_model_path = opt.defalut_model_path results_file = "./tmp/results-{}-scale-{}-{}.txt".format(default_sr_method, upscale_factor, time.strftime('%Y-%m-%d-%H-%M',time.localtime(time.time()))) results_pkl_file = "./tmp/results-{}-scale-{}-{}.pkl".format(default_sr_method, upscale_factor, time.strftime('%Y-%m-%d-%H-%M',time.localtime(time.time()))) f = open(results_file, 'w') f.write(str(opt)) f.close() pkl_results = [] # for batch_size:32 # hyper_params = [[0.00005, 0.1, 0.01, 1e-4], [0.0001, 0.1, 0.01, 1e-4], [0.00015, 0.50, 0.01, 1e-3], [0.0002, 0.70, 0.01, 1e-3], [0.00025, 0.90, 0.01, 1e-3]] # for batch_size:16 # hyper_params = [[0.0001, 0.1, 0.05, 1e-4], [0.0001, 0.2, 0.01, 1e-4], [0.00015, 0.50, 0.01, 1e-3], [0.0002, 0.70, 0.01, 1e-3], [0.00025, 0.80, 0.01, 1e-3], [0.00035, 0.95, 0.01, 1e-3]] # for batch_size:8 # lr_list = [0.0003, 0.0004] # g_decay_rate_list = [0.2, 0.8] # reg_list = [1e-4] # decay_final_rate_list = [0.05, 0.01] # for reg in reg_list: # for decay_final_rate in decay_final_rate_list: # for decay_rate in g_decay_rate_list: # for lr in lr_list: # for k207 with these params: # CUDA_VISIBLE_DEVICES=0 python solver.py --gpu_id=0 --dataset_dir=./dataset/mat_train_391_x4_x200.h5 --g_log_dir=./log/EDSR_v106 --g_ckpt_dir=./ckpt/EDSR_v106 --default_sr_method='EDSR_v106' --test_dataset_path=./dataset/mat_test/set5/mat --epoches=1 --inner_epoches=1 --default_channel=1 --upscale_factor=4 --filter_num=64 --batch_size=4 # archived best results with [0.0002, 0.1, 0.05, 1e-4] hyper_params = [[0.0001, 0.1, 0.05, 1e-4], [0.00015, 0.1, 0.01, 1e-4], [0.0002, 0.1, 0.05, 1e-4], [0.0002, 0.2, 0.01, 1e-4], [0.00025, 0.50, 0.01, 1e-3], [0.0003, 0.70, 0.01, 1e-3], [0.00035, 0.80, 0.01, 1e-3]] # for k40 # hyper_params = [[0.0002, 0.1, 0.05, 1e-4], [0.0002, 0.1, 0.05, 1e-3], [0.0002, 0.1, 0.01, 1e-4], [0.0004, 0.5, 0.01, 1e-4]] # hyper_params = [[0.0001, 0.1, 0.05, 1e-4], [0.00025, 0.50, 0.01, 1e-3], [0.0003, 0.70, 0.01, 1e-3], [0.00035, 0.80, 0.01, 1e-3]] # step-num and residual-depth trade-off params # hyper_params = [[0.00015, 0.1, 0.01, 1e-4], [0.00025, 0.50, 0.01, 1e-3], [0.00035, 0.80, 0.01, 1e-3]] for lr, decay_rate, decay_final_rate, reg in hyper_params: model_list = [] results = [] print("===> Start Training for one parameters set") setup_project(dataset_dir, g_ckpt_dir, g_log_dir) for epoch in range(epoches): dataset = TrainDatasetFromHdf5(file_path=dataset_dir, batch_size=batch_size, upscale=upscale_factor) g_decay_steps = np.floor(np.log(decay_rate)/np.log(decay_final_rate) * (dataset.batch_ids*epoches*inner_epoches)) model_path = model_list[-1] if len(model_list) != 0 else defalut_model_path saved_model = train(batch_size, upscale_factor, inner_epoches, lr, reg, filter_num, decay_rate, g_decay_steps, dataset_dir, g_ckpt_dir, g_log_dir, gpu_id, continued_training, default_sr_method, model_path, debug) model_list.append(saved_model) print("===> Testing model") print(model_list) for model_path in model_list: PSNR, SSIM, MSSSIM, EXEC_TIME = SR(test_dataset_path, 2, upscale_factor, default_channel, filter_num, default_sr_method, model_path, gpu_id) results.append([model_path, PSNR, SSIM, EXEC_TIME, lr, decay_rate, reg, decay_final_rate]) pkl_results.append([model_path, PSNR, SSIM, EXEC_TIME, lr, decay_rate, reg, decay_final_rate]) print("===> a training round ends, lr: %f, decay_rate: %f, reg: %f. The saved models are\n"%(lr, decay_rate, reg)) print("===> Saving results") save_results(results, results_file, upscale_factor) print("===> Saving results to pkl at {}".format(results_pkl_file)) pickle.dump(pkl_results, open(results_pkl_file, "w"))
import config from utils import create_dirs, fix_seeds from train import train def parse_args(): parser = ArgumentParser() parser.add_argument('-t', '--train', action='store_true', help='train model') parser.add_argument('--epochs', default=40, type=int) parser.add_argument('--episodes', default=100, type=int) parser.add_argument('--n-train', default=1, type=int) parser.add_argument('--n-eval', default=1, type=int) parser.add_argument('--k-train', default=60, type=int) parser.add_argument('--k-eval', default=5, type=int) parser.add_argument('--q-train', default=5, type=int) parser.add_argument('--q-eval', default=1, type=int) args = parser.parse_args() return args, parser if __name__ == '__main__': args, parser = parse_args() fix_seeds(1234) create_dirs(config.BASE_PATH) if args.train: train(args.epochs, args.n_train, args.k_train, args.q_train, n_eval=args.n_eval, k_eval=args.k_eval, q_eval=args.q_eval, episodes_per_epoch=args.episodes) else: parser.print_help()
utils.load_checkpoint(wrn, args.model_dir, best=True) utils.validate(wrn, test_dataset, test_size=args.test_size, cuda=cuda, verbose=True) else: train( wrn, train_dataset, test_dataset=test_dataset, model_dir=args.model_dir, lr=args.lr, lr_decay=args.lr_decay, lr_decay_epochs=args.lr_decay_epochs, weight_decay=args.weight_decay, gamma1=args.gamma1, gamma2=args.gamma2, gamma3=args.gamma3, batch_size=args.batch_size, test_size=args.test_size, epochs=args.epochs, checkpoint_interval=args.checkpoint_interval, eval_log_interval=args.eval_log_interval, loss_log_interval=args.loss_log_interval, weight_log_interval=args.weight_log_interval, resume_best=args.resume_best, resume_latest=args.resume_latest, cuda=cuda, )
def do_experiment(model_config): tf.reset_default_graph() experiment_id = ex.current_run._id print('Experiment ID: {eid}'.format(eid=experiment_id)) # Prepare data print('Preparing dataset') train_data, val_data, test_data = dataset.prepare_datasets(model_config) print('Dataset ready') # Start session tf_config = tf.ConfigProto() #tf_config.gpu_options.allow_growth = True tf_config.gpu_options.visible_device_list = str(model_config['GPU']) sess = tf.Session(config=tf_config) #sess = tf.Session() #sess = tf_debug.LocalCLIDebugWrapperSession(sess, ui_type="readline") print('Session started') # Create iterators handle = tf.placeholder(tf.string, shape=[]) iterator = tf.data.Iterator.from_string_handle(handle, train_data.output_types, train_data.output_shapes) mixed_spec, voice_spec, mixed_audio, voice_audio = iterator.get_next() training_iterator = train_data.make_initializable_iterator() validation_iterator = val_data.make_initializable_iterator() testing_iterator = test_data.make_initializable_iterator() training_handle = sess.run(training_iterator.string_handle()) validation_handle = sess.run(validation_iterator.string_handle()) testing_handle = sess.run(testing_iterator.string_handle()) print('Iterators created') # Create variable placeholders and model is_training = tf.placeholder(shape=(), dtype=bool) if model_config['mag_phase']: mixed_mag = tf.expand_dims(mixed_spec[:, :, :-1, 0], 3) mixed_phase = tf.expand_dims(mixed_spec[:, :, :-1, 1], 3) voice_mag = tf.expand_dims(voice_spec[:, :, :-1, 0], 3) print('Creating model') model = audio_models.MagnitudeModel(mixed_mag, voice_mag, mixed_phase, mixed_audio, voice_audio, model_config['model_variant'], is_training, model_config['learning_rate'], name='Magnitude_Model') else: mixed_spec_trim = mixed_spec[:, :, :-1, :] voice_spec_trim = voice_spec[:, :, :-1, :] print('Creating model') model = audio_models.ComplexNumberModel(mixed_spec_trim, voice_spec_trim, mixed_audio, voice_audio, model_config['model_variant'], is_training, model_config['learning_rate'], name='Complex_Model') sess.run(tf.global_variables_initializer()) if model_config['loading']: print('Loading checkpoint') checkpoint = os.path.join(model_config['model_base_dir'], model_config['checkpoint_to_load']) restorer = tf.train.Saver() restorer.restore(sess, checkpoint) # Summaries model_folder = str(experiment_id) writer = tf.summary.FileWriter(os.path.join(model_config["log_dir"], model_folder), graph=sess.graph) # Get baseline metrics at initialisation test_count = 0 if model_config['initialisation_test']: print('Running initialisation test') initial_test_loss, test_count = test(sess, model, model_config, handle, testing_iterator, testing_handle, writer, test_count, experiment_id) # Train the model model = train(sess, model, model_config, model_folder, handle, training_iterator, training_handle, validation_iterator, validation_handle, writer) # Test trained model mean_test_loss, test_count = test(sess, model, model_config, handle, testing_iterator, testing_handle, writer, test_count, experiment_id) print('{ts}:\n\tAll done with experiment {exid}!'.format( ts=datetime.datetime.now(), exid=experiment_id)) if model_config['initialisation_test']: print('\tInitial test loss: {init}'.format(init=initial_test_loss)) print('\tFinal test loss: {final}'.format(final=mean_test_loss))
import argparse, os import numpy as np import tensorflow as tf from math import floor from train import train from test import test from read import load_train_data, load_valid_data, load_test_data if __name__ == '__main__': parser = argparse.ArgumentParser('') parser.add_argument('--gpus', type=str) #determine gpu to use parser.add_argument('--path', type=str) #determine path to save parser.add_argument('--mode', type=str) args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = args.gpus if args.mode == 'train': data = load_train_data() Test_data = load_valid_data() #Test_data = load_test_data() train(data, Test_data, args.path) elif args.mode == 'test': data = load_test_data() test(data, args.path)
def main(): args = parse_args() os.makedirs('./checkpoint', exist_ok=True) log_name = './checkpoint/%s_%s' % (args.experiment_name, args.id) stats_log = open(log_name + '_stats.txt', 'w') test_log = open(log_name + '_acc.txt', 'w') test_log.flush() loader = dataloader.clothing_dataloader(root=args.data_path, batch_size=args.batch_size, num_workers=5, num_batches=args.num_batches, log=stats_log) print('| Building net') if args.method == 'reg': create_model = create_model_reg elif args.method == 'selfsup': create_model = create_model_selfsup else: raise ValueError() net1 = create_model(net='resnet50', num_class=args.num_class) net2 = create_model(net='resnet50', num_class=args.num_class) cudnn.benchmark = True optimizer1 = optim.AdamW(net1.parameters(), lr=args.lr, weight_decay=1e-3) optimizer2 = optim.AdamW(net2.parameters(), lr=args.lr, weight_decay=1e-3) CE = nn.CrossEntropyLoss(reduction='none') CEloss = nn.CrossEntropyLoss() conf_penalty = NegEntropy() best_acc = [0, 0] for epoch in range(args.num_epochs + 1): lr = args.lr if epoch >= 40: lr /= 10 for param_group in optimizer1.param_groups: param_group['lr'] = lr for param_group in optimizer2.param_groups: param_group['lr'] = lr if epoch < args.warmup: # warm up train_loader = loader.run('warmup') print('Warmup Net1') warmup(epoch, net1, optimizer1, train_loader, CEloss, conf_penalty, args.device, 'clothing', None, args.num_epochs, None) train_loader = loader.run('warmup') print('\nWarmup Net2') warmup(epoch, net2, optimizer2, train_loader, CEloss, conf_penalty, args.device, 'clothing', None, args.num_epochs, None) if epoch > 1: print('\n\nEval Net2') pred2 = (prob2 > args.p_threshold) labeled_trainloader, unlabeled_trainloader = loader.run( 'train', pred2, prob2, paths=paths2) # co-divide else: pred1 = (prob1 > args.p_threshold) # divide dataset pred2 = (prob2 > args.p_threshold) print('\n\nTrain Net1') labeled_trainloader, unlabeled_trainloader = loader.run( 'train', pred2, prob2, paths=paths2) # co-divide train(epoch, net1, net2, None, optimizer1, labeled_trainloader, unlabeled_trainloader, 0, args.batch_size, args.num_class, args.device, args.T, args.alpha, args.warmup, 'clothing', None, None, args.num_epochs, smooth_clean=True) # train net1 print('\nTrain Net2') labeled_trainloader, unlabeled_trainloader = loader.run( 'train', pred1, prob1, paths=paths1) # co-divide train(epoch, net2, net1, None, optimizer2, labeled_trainloader, unlabeled_trainloader, 0, args.batch_size, args.num_class, args.device, args.T, args.alpha, args.warmup, 'clothing', None, None, args.num_epochs, smooth_clean=True) # train net2 val_loader = loader.run('val') # validation acc1 = val(net1, val_loader, best_acc, 1, args.id, args.experiment_name) acc2 = val(net2, val_loader, best_acc, 2, args.id, args.experiment_name) test_log.write('Validation Epoch:%d Acc1:%.2f Acc2:%.2f\n' % (epoch, acc1, acc2)) test_log.flush() print('\n==== net 1 evaluate next epoch training data loss ====') eval_loader = loader.run( 'eval_train') # evaluate training data loss for next epoch prob1, paths1 = eval_train(epoch, net1, eval_loader, CE, args.num_batches, args.batch_size, stats_log) print('\n==== net 2 evaluate next epoch training data loss ====') eval_loader = loader.run('eval_train') prob2, paths2 = eval_train(epoch, net2, eval_loader, CE, args.num_batches, args.batch_size, stats_log) test_loader = loader.run('test') net1.load_state_dict( torch.load('./checkpoint/%s_%s_net1.pth.tar' % (args.id, args.experiment_name))) net2.load_state_dict( torch.load('./checkpoint/%s_%s_net2.pth.tar' % (args.id, args.experiment_name))) acc = run_test(net1, net2, test_loader) test_log.write('Test Accuracy:%.2f\n' % (acc)) test_log.flush()
def parse_command_line(): __print_header() # Parses the arguments. parser = ArgumentParser(description="Run triUMPF.") parser.add_argument( '--display-interval', default=2, type=int, help='display intervals. -1 means display per each iteration.') parser.add_argument('--random_state', default=12345, type=int, help='Random seed. (default value: 12345).') parser.add_argument('--num-jobs', type=int, default=1, help='Number of parallel workers. (default value: 1).') parser.add_argument('--batch', type=int, default=30, help='Batch size. (default value: 30).') parser.add_argument( '--max-inner-iter', default=5, type=int, help='Number of inner iteration. 5. (default value: 5)') parser.add_argument( '--num-epochs', default=10, type=int, help='Number of epochs over the training set. (default value: 10).') # Arguments for path parser.add_argument( '--ospath', default=fph.OBJECT_PATH, type=str, help='The path to the data object that contains extracted ' 'information from the MetaCyc database. The default is ' 'set to object folder outside the source code.') parser.add_argument( '--dspath', default=fph.DATASET_PATH, type=str, help='The path to the dataset after the samples are processed. ' 'The default is set to dataset folder outside the source code.') parser.add_argument( '--dsfolder', default="SAG", type=str, help='The dataset folder name. The default is set to SAG.') parser.add_argument( '--mdpath', default=fph.MODEL_PATH, type=str, help='The path to the output models. The default is set to ' 'train folder outside the source code.') parser.add_argument( '--rspath', default=fph.RESULT_PATH, type=str, help='The path to the results. The default is set to result ' 'folder outside the source code.') parser.add_argument( '--rsfolder', default="Prediction_triUMPF", type=str, help='The result folder name. The default is set to Prediction_triUMPF.' ) parser.add_argument('--logpath', default=fph.LOG_PATH, type=str, help='The path to the log directory.') # Arguments for file names and models parser.add_argument( '--object-name', type=str, default='biocyc.pkl', help='The biocyc file name. (default value: "biocyc.pkl")') parser.add_argument( '--pathway2ec-name', type=str, default='pathway2ec.pkl', help= 'The pathway2ec association matrix file name. (default value: "pathway2ec.pkl")' ) parser.add_argument( '--pathway2ec-idx-name', type=str, default='pathway2ec_idx.pkl', help= 'The pathway2ec association indices file name. (default value: "pathway2ec_idx.pkl")' ) parser.add_argument( '--features-name', type=str, default='path2vec_cmt_tf_embeddings.npz', help= 'The features file name. (default value: "path2vec_cmt_tf_embeddings.npz")' ) parser.add_argument( '--hin-name', type=str, default='hin_cmt.pkl', help='The hin file name. (default value: "hin_cmt.pkl")') parser.add_argument( '--pathway-gexf-name', type=str, default='pathway_graph.gexf', help= 'The pathway graph file name. (default value: "pathway_graph.gexf")') parser.add_argument( '--ec-gexf-name', type=str, default='ec_graph.gexf', help='The ec graph file name. (default value: "ec_graph.gexf")') parser.add_argument( '--M-name', type=str, default='M.pkl', help= 'The pathway2ec association matrix file name. (default value: "M.pkl")' ) parser.add_argument('--W-name', type=str, default='W.pkl', help='The W file name. (default value: "W.pkl")') parser.add_argument('--H-name', type=str, default='H.pkl', help='The H file name. (default value: "H.pkl")') parser.add_argument( '--X-name', type=str, default='golden_Xe.pkl', help='The X file name. (default value: "golden_Xe.pkl")') parser.add_argument( '--y-name', type=str, default='golden_y.pkl', help='The y file name. (default value: "golden_y.pkl")') parser.add_argument( '--P-name', type=str, default='P.pkl', help='The pathway features file name. (default value: "P.pkl")') parser.add_argument( '--E-name', type=str, default='E.pkl', help='The EC features file name. (default value: "E.pkl")') parser.add_argument( '--A-name', type=str, default='A.pkl', help= 'The pathway to pathway association file name. (default value: "A.pkl")' ) parser.add_argument( '--B-name', type=str, default='B.pkl', help='The EC to EC association file name. (default value: "B.pkl")') parser.add_argument( '--samples-ids', type=str, default=None, help='The samples ids file name. (default value: "ids.pkl")') parser.add_argument( '--file-name', type=str, default='triUMPF', help= 'The file name to save various scores and communities files. (default value: "triUMPF")' ) parser.add_argument( '--model-name', type=str, default='triUMPF', help= 'The file name, excluding extension, to save an object. (default value: "triUMPF")' ) # Arguments for preprocessing dataset parser.add_argument('--preprocess-dataset', action='store_true', default=False, help='Preprocess dataset. (default value: False).') parser.add_argument( '--white-links', action='store_true', default=False, help= 'Add no noise to Pathway-Pathway and EC-EC associations. (default value: False).' ) # Arguments for training and evaluation parser.add_argument( '--train', action='store_true', default=False, help='Whether to train the triUMPF model. (default value: False).') parser.add_argument( '--predict', action='store_true', default=False, help='Whether to predict labels from inputs. (default value: False).') parser.add_argument( '--pathway-report', action='store_true', default=False, help= 'Whether to generate a detailed report for pathways for each instance. ' '(default value: False).') parser.add_argument( '--parse-pf', action='store_true', default=False, help= 'Whether to parse Pathologic format file (pf) from a folder (default value: False).' ) parser.add_argument( '--build-features', action='store_true', default=False, help='Whether to construct features (default value: False).') parser.add_argument( '--plot', action='store_true', default=False, help='Whether to produce various plots from predicted outputs. ' '(default value: False).') parser.add_argument('--num-components', default=100, type=int, help='Number of components. (default value: 100).') parser.add_argument( '--num-communities-p', default=90, type=int, help='Number of communities for pathways. (default value: 90).') parser.add_argument( '--num-communities-e', default=100, type=int, help='Number of communities for ecs. (default value: 100).') parser.add_argument( '--proxy-order-p', type=int, default=3, help= 'Higher order proxy for pathway-pathway adjacency. (default value: 1).' ) parser.add_argument( '--proxy-order-e', type=int, default=1, help='Higher order proxy for EC-EC adjacency. (default value: 1).') parser.add_argument( '--mu-omega', type=float, default=0.1, help= 'Weight for the higher order proxy for pathway-pathway adjacency. (default value: 0.3).' ) parser.add_argument( '--mu-gamma', type=float, default=0.3, help= 'Weight for the higher order proxy for EC-EC adjacency. (default value: 0.3).' ) parser.add_argument( '--no-decomposition', action='store_true', default=False, help= 'Whether to decompose pathway-EC association matrix. (default value: False).' ) parser.add_argument( '--fit-features', action='store_true', default=False, help='Whether to fit by external features. (default value: False).') parser.add_argument( '--fit-comm', action='store_true', default=False, help='Whether to fit community. (default value: False).') parser.add_argument( '--fit-pure-comm', action='store_true', default=False, help='Whether to fit community excluding data. (default value: False).' ) parser.add_argument( '--binarize', action='store_true', default=False, help= 'Whether to binarize data (set feature values to 0 or 1). (default value: False).' ) parser.add_argument( '--normalize', action='store_true', default=False, help='Whether to normalize data. (default value: False).') parser.add_argument( '--use-external-features', action='store_true', default=False, help='Whether to use external features that are included in data. ' '(default value: False).') parser.add_argument( '--cutting-point', type=int, default=3650, help= 'The cutting point after which binarize operation is halted in data. ' '(default value: 3650).') parser.add_argument( '--fit-intercept', action='store_false', default=True, help= 'Whether the intercept should be estimated or not. (default value: True).' ) parser.add_argument( '--penalty', default='l21', type=str, choices=['l1', 'l2', 'elasticnet', 'l21', 'none'], help= 'The penalty (aka regularization term) to be used. (default value: "none")' ) parser.add_argument( '--alpha-elastic', default=0.0001, type=float, help='Constant that multiplies the regularization term to control ' 'the amount to regularize parameters and in our paper it is lambda. ' '(default value: 0.0001)') parser.add_argument( '--l2-ratio', default=0.35, type=float, help= 'The elastic net mixing parameter, with 0 <= l2_ratio <= 1. l2_ratio=0 ' 'corresponds to L1 penalty, l2_ratio=1 to L2. (default value: 0.35)') parser.add_argument( "--alpha", type=float, default=1e9, help= "A hyper-parameter to satisfy orthogonal condition. (default value: 1e9)." ) parser.add_argument( "--beta", type=float, default=1e9, help= "A hyper-parameter to satisfy orthogonal condition. (default value: 1e9)." ) parser.add_argument( "--rho", type=float, default=0.01, help= "A hyper-parameter to fuse coefficients with association matrix. (default value: 0.01)." ) parser.add_argument( "--lambdas", nargs="+", type=float, default=[0.01, 0.01, 0.01, 0.01, 0.01, 0.01], help= "Six hyper-parameters for constraints. Default is [0.01, 0.01, 7, 0.01, 0.01, 0.01]." ) parser.add_argument( '--eps', default=1e-4, type=float, help= 'Truncate all values less then this in output to zero. (default value: 1e-4).' ) parser.add_argument( "--early-stop", action='store_true', default=False, help="Whether to terminate training based on relative change " "between two consecutive iterations. (default value: False).") parser.add_argument( "--loss-threshold", type=float, default=0.005, help= "A hyper-parameter for deciding the cutoff threshold of the differences " "of loss between two consecutive rounds. (default value: 0.005).") parser.add_argument( "--decision-threshold", type=float, default=0.5, help="The cutoff threshold for triUMPF. (default value: 0.5)") parser.add_argument('--top-k', type=int, default=10, help='Top k features. (default value: 10).') parser.add_argument( '--ssample-input-size', default=0.05, type=float, help='The size of input subsample. (default value: 0.05)') parser.add_argument( '--ssample-label-size', default=1000, type=int, help='Maximum number of labels to be sampled. (default value: 1000).') parser.add_argument( '--learning-type', default='optimal', type=str, choices=['optimal', 'sgd'], help='The learning rate schedule. (default value: "optimal")') parser.add_argument('--lr', default=0.0001, type=float, help='The learning rate. (default value: 0.0001).') parser.add_argument( '--lr0', default=0.0, type=float, help='The initial learning rate. (default value: 0.0).') parser.add_argument( '--fr', type=float, default=0.9, help= 'Forgetting rate to control how quickly old information is forgotten. The value should ' 'be set between (0.5, 1.0] to guarantee asymptotic convergence. (default value: 0.7).' ) parser.add_argument( '--delay', type=float, default=1., help='Delay factor down weights early iterations. (default value: 1).') parser.add_argument( '--estimate-prob', action='store_true', default=False, help='Whether to return prediction of labels and bags as probability ' 'estimate or not. (default value: False).') parser.add_argument( '--apply-tcriterion', action='store_true', default=False, help= 'Whether to employ adaptive strategy during prediction. (default value: False).' ) parser.add_argument( '--adaptive-beta', default=0.45, type=float, help= 'The adaptive beta parameter for prediction. (default value: 0.45).') parser.add_argument( '--shuffle', action='store_false', default=True, help= 'Whether or not the training data should be shuffled after each epoch. ' '(default value: True).') parse_args = parser.parse_args() args = __internal_args(parse_args) train(arg=args)
def train_zhwiki(): opts = get_train_options() opts.input_file = settings.ZHWIKI_CLEANED_PATH opts.name_prefix = 'zhwiki' train(opts)
def train_epochs(epochs, batch_size, token_size, hidden_size, embedding_size): # Read data x_train_full = open("../input/wili-2018/x_train.txt").read().splitlines() y_train_full = open("../input/wili-2018/y_train.txt").read().splitlines() x_test_full = open("../input/wili-2018/x_test.txt").read().splitlines() y_test_full = open("../input/wili-2018/y_test.txt").read().splitlines() # Get encoders char_vocab = Dictionary().char_dict(x_train_full) lang_vocab = Dictionary().lang_dict(y_train_full) # Convert data x_train_idx, y_train_idx = Encoder().encode_labeled_data( x_train_full, y_train_full, char_vocab, lang_vocab) x_test_idx, y_test_idx = Encoder().encode_labeled_data( x_test_full, y_test_full, char_vocab, lang_vocab) x_train, x_val, y_train, y_val = train_test_split(x_train_idx, y_train_idx, test_size=0.15) train_data = [(x, y) for x, y in zip(x_train, y_train)] val_data = [(x, y) for x, y in zip(x_val, y_val)] test_data = [(x, y) for x, y in zip(x_test_idx, y_test_idx)] device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if not torch.cuda.is_available(): logging.warning("WARNING: CUDA is not available.") criterion = torch.nn.CrossEntropyLoss(reduction='sum') bidirectional = False ntokens = len(char_vocab) nlabels = len(lang_vocab) pad_index = char_vocab.pad_index model, optimizer = get_model( ntokens, embedding_size, hidden_size, nlabels, bidirectional, pad_index, device) with mlflow.start_run(): mlflow.log_metrics( { "train samples": len(train_data), "val samples": len(val_data), "test samples": len(test_data) } ) mlflow.log_dict(lang_vocab.token2idx, "lang_vocab.json") mlflow.log_dict(char_vocab.token2idx, "char_vocab.json") params = {'epochs': epochs, 'batch_size': batch_size, 'token_size': token_size, 'hidden_size': hidden_size, 'embedding_size': embedding_size} mlflow.log_dict(params, "params.json") logging.info(f'Training cross-validation model for {epochs} epochs') for epoch in range(epochs): train_acc = train(model, optimizer, train_data, batch_size, token_size, criterion, device) logging.info(f'| epoch {epoch:02d} | train accuracy={train_acc:.1f}%') validate(model, val_data, batch_size, token_size, device, lang_vocab, tag='val', epoch=epoch) validate(model, test_data, batch_size, token_size, device, lang_vocab, tag='test', epoch=epoch) mlflow.pytorch.log_model(model, f'{epoch:02d}.model') mlflow.pytorch.log_model(model, 'model')
def main(opt): if opt.disable_cudnn: torch.backends.cudnn.enabled = False print('Cudnn is disabled.') logger = Logger(opt) opt.device = torch.device('cuda:{}'.format(opt.gpus[0])) Dataset = dataset_factory[opt.dataset] train, val = task_factory[opt.task] model, optimizer, start_epoch = create_model(opt) if len(opt.gpus) > 1: model = torch.nn.DataParallel(model, device_ids=opt.gpus).cuda(opt.device) else: model = model.cuda(opt.device) val_loader = torch.utils.data.DataLoader(Dataset(opt, 'val'), batch_size=1, shuffle=False, num_workers=1, pin_memory=True) if opt.test: log_dict_train, preds = val(0, opt, val_loader, model) sio.savemat(os.path.join(opt.save_dir, 'preds.mat'), mdict={'preds': preds}) return train_loader = torch.utils.data.DataLoader( Dataset(opt, 'train'), batch_size=opt.batch_size * len(opt.gpus), shuffle=True, # if opt.debug == 0 else False, num_workers=opt.num_workers, pin_memory=True) best = -1 for epoch in range(start_epoch, opt.num_epochs + 1): mark = epoch if opt.save_all_models else 'last' log_dict_train, _ = train(epoch, opt, train_loader, model, optimizer) for k, v in log_dict_train.items(): logger.scalar_summary('train_{}'.format(k), v, epoch) logger.write('{} {:8f} | '.format(k, v)) if opt.val_intervals > 0 and epoch % opt.val_intervals == 0: save_model(os.path.join(opt.save_dir, 'model_{}.pth'.format(mark)), epoch, model, optimizer) log_dict_val, preds = val(epoch, opt, val_loader, model) for k, v in log_dict_val.items(): logger.scalar_summary('val_{}'.format(k), v, epoch) logger.write('{} {:8f} | '.format(k, v)) if log_dict_val[opt.metric] > best: best = log_dict_val[opt.metric] save_model(os.path.join(opt.save_dir, 'model_best.pth'), epoch, model) else: save_model(os.path.join(opt.save_dir, 'model_last.pth'), epoch, model, optimizer) logger.write('\n') if epoch in opt.lr_step: lr = opt.lr * (0.1**(opt.lr_step.index(epoch) + 1)) print('Drop LR to', lr) for param_group in optimizer.param_groups: param_group['lr'] = lr logger.close()
def run(): soccer_env = UnityEnvironment(file_name="Soccer.app") env = SoccerEnvWrapper(env=soccer_env, train_mode=True) buffer_size = int(1e5) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") learning_rate_actor = 1e-4 learning_rate_critic = 1e-3 seed = 2 episodes_before_train = 50 batch_size = 128 tau = 1e-3 full_action_dim = env.goalie_action_size * env.num_goalies + env.striker_action_size * env.num_strikers def create_actor(action_dim): return Actor(state_dim=env.state_size, action_dim=action_dim, fc1_units=256, fc2_units=128, seed=seed) def create_critic(): return Critic(state_dim=env.state_size * env.num_agents, action_dim=full_action_dim, fc1_units=256, fc2_units=128, seed=seed) def create_noise(action_dim): return RandomUniformNoise(size=action_dim, seed=seed) def create_agent(action_dim): noise = create_noise(action_dim=action_dim) agent = Agent(create_actor=lambda: create_actor(action_dim), create_critic=create_critic, state_dim=env.state_size, noise=noise, device=device, lr_actor=learning_rate_actor, lr_critic=learning_rate_critic, tau=tau, seed=seed) return agent def create_agents(): agents = [] for _ in range(env.num_goalies): agents.append(create_agent(action_dim=env.goalie_action_size)) for _ in range(env.num_strikers): agents.append(create_agent(action_dim=env.striker_action_size)) return agents replay_buffer = ReplayBuffer(buffer_size=buffer_size, seed=seed) multi_agent = MultiAgent(agents=create_agents(), replay_buffer=replay_buffer, full_action_dim=full_action_dim, episodes_before_train=episodes_before_train, device=device, batch_size=batch_size, discount=0.99, initial_noise_scale=1.0, noise_reduction=0.98, seed=seed) scores = train(env=env, agent=multi_agent) plot_scores(scores)
config.use_tau = use_tau config.train_cases = arrangement config.weights = config.save_path + '/best_checkpoint.tar' #makedirs(config.save_path) ## ''' config.dest_dir = h + '/' + str(arrangement) config.data_file = h + '/' + str(arrangement) makedirs(config.dest_dir) ''' ## # Make dataset for mode in ['train', 'test']: parse_raw_data(mode, config) create_lmdb(mode, config) # Train on dataset train(config) # Delete dataset rmtree(config.dest_dir) makedirs(config.dest_dir) # eval if config.sim: evaluate(config) rmtree(config.dest_dir)