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)
