def main(model_name, label_key, slice_type, new_db): lmdb_train = os.path.join(TMP_DATA_DIR, 'lmdb_train_%s_%s' % (model_name, slice_type)) lmdb_train_lab = os.path.join(TMP_DATA_DIR, 'lmdb_train_lab_%s_%s' % (model_name, slice_type)) lmdb_test = os.path.join(TMP_DATA_DIR, 'lmdb_test_%s_%s' % (model_name, slice_type)) lmdb_test_lab = os.path.join(TMP_DATA_DIR, 'lmdb_test_lab_%s_%s' % (model_name, slice_type)) if new_db: train_data = os.path.join(PROCESSED_DATA_DIR, 'local_train') test_data = os.path.join(PROCESSED_DATA_DIR, 'local_test') print 'Creating train LMDB' create_lmdb.create_db(lmdb_train, lmdb_train_lab, train_data, frames_preproc=PREPROC, trans_generator=TRANS, label_key=label_key, slice_type=slice_type) print 'Creating test LMDB' create_lmdb.create_db(lmdb_test, lmdb_test_lab, test_data, frames_preproc=PREPROC, trans_generator=TRANS, label_key=label_key, slice_type=slice_type) print 'Creating neural net' full_model_name = '%s_%s_%s' % (model_name, label_key, slice_type) nn_models.write_model(full_model_name, MODEL_DIR, MODEL, lmdb_train, lmdb_train_lab, lmdb_test, lmdb_test_lab, BATCH_SIZE) print 'Training neural net' caffe.set_device(DEVICE_ID) caffe.set_mode_gpu() solver_path = os.path.join(MODEL_DIR, '%s_solver.prototxt' % full_model_name) solver.train(solver_path)
def main(model_name, label_key, slice_type, new_db): lmdb_train = os.path.join(TMP_DATA_DIR, 'lmdb_train_%s_%s' % (model_name, slice_type)) lmdb_train_lab = os.path.join( TMP_DATA_DIR, 'lmdb_train_lab_%s_%s' % (model_name, slice_type)) lmdb_test = os.path.join(TMP_DATA_DIR, 'lmdb_test_%s_%s' % (model_name, slice_type)) lmdb_test_lab = os.path.join( TMP_DATA_DIR, 'lmdb_test_lab_%s_%s' % (model_name, slice_type)) if new_db: train_data = os.path.join(PROCESSED_DATA_DIR, 'local_train') test_data = os.path.join(PROCESSED_DATA_DIR, 'local_test') print 'Creating train LMDB' create_lmdb.create_db(lmdb_train, lmdb_train_lab, train_data, frames_preproc=PREPROC, trans_generator=TRANS, label_key=label_key, slice_type=slice_type) print 'Creating test LMDB' create_lmdb.create_db(lmdb_test, lmdb_test_lab, test_data, frames_preproc=PREPROC, trans_generator=TRANS, label_key=label_key, slice_type=slice_type) print 'Creating neural net' full_model_name = '%s_%s_%s' % (model_name, label_key, slice_type) nn_models.write_model(full_model_name, MODEL_DIR, MODEL, lmdb_train, lmdb_train_lab, lmdb_test, lmdb_test_lab, BATCH_SIZE) print 'Training neural net' caffe.set_device(DEVICE_ID) caffe.set_mode_gpu() solver_path = os.path.join(MODEL_DIR, '%s_solver.prototxt' % full_model_name) solver.train(solver_path)
def train_models(model_name, label_key, slice_type, dbs, niter): caffe.set_device(DEVICE_ID) caffe.set_mode_gpu() base_path = os.path.join(MODEL_DIR, model_name, label_key, slice_type) subprocess.check_output(['mkdir', '-p', base_path]) for bucket_id in range(len(dbs)): print 'Creating model for bucket %s' % bucket_id lmdb_train, lmdb_test = dbs[bucket_id] model_path = os.path.join(base_path, 'bucket_%s' % bucket_id) subprocess.check_output(['mkdir', '-p', model_path]) nn_models.write_model('model', model_path, MODEL, lmdb_train, None, lmdb_test, None, BATCH_SIZE) print 'Training model for bucket %s' % bucket_id solver_path = os.path.join(model_path, 'model_solver.prototxt') stats = solver.train(solver_path, niter=niter) with open(os.path.join(model_path, 'stats'), 'w') as f: for it in sorted(stats.keys()): print >>f, 'iter %s, crps %s, loss %s, smooth: %s' % (it, stats[it]['crps'], stats[it]['loss'], stats[it]['smooth'])
def train_models(model_name, label_key, slice_type, dbs, niter): caffe.set_device(DEVICE_ID) caffe.set_mode_gpu() base_path = os.path.join(MODEL_DIR, model_name, label_key, slice_type) subprocess.check_output(['mkdir', '-p', base_path]) for bucket_id in range(len(dbs)): print 'Creating model for bucket %s' % bucket_id lmdb_train, lmdb_test = dbs[bucket_id] model_path = os.path.join(base_path, 'bucket_%s' % bucket_id) subprocess.check_output(['mkdir', '-p', model_path]) nn_models.write_model('model', model_path, MODEL, lmdb_train, None, lmdb_test, None, BATCH_SIZE) print 'Training model for bucket %s' % bucket_id solver_path = os.path.join(model_path, 'model_solver.prototxt') stats = solver.train(solver_path, niter=niter) with open(os.path.join(model_path, 'stats'), 'w') as f: for it in sorted(stats.keys()): print >> f, 'iter %s, crps %s, loss %s, smooth: %s' % ( it, stats[it]['crps'], stats[it]['loss'], stats[it]['smooth'])
def main(): # Define Arguments args = parser.parse_args() path_train = os.path.join(args.data_dir, args.train_path) path_test = os.path.join(args.data_dir, args.test_path) model_dir = args.model_dir model_path = os.path.join(args.model_dir, 'model_100000.pt') eval = args.eval batch_size = args.batch_size in_ext = "in" out_ext = "out" state = { 'hidden_dim': args.hidden_dim, 'dropout': args.dropout, 'bidirection': True if args.bidirection == 1 else False, 'num_layers': args.num_layers, 'rnn_type': args.rnn_type } print(f"Run Config State, Eval: {state}, {eval}") # Train and Test train_iter, test_iter, src, trg = load_data(path_train, path_test, in_ext, out_ext, model_dir, batch_size=batch_size) model, optimizer, criterion = load_model(src, trg, state) if eval == 0: print('Training !') model = train(model, train_iter, optimizer, criterion, model_dir=model_dir) else: print('Evaluating !') model.load_state_dict(torch.load(model_path)) test(model, test_iter, eos_index=trg.vocab.stoi[EOS_TOKEN])
train_data = data[:train_len] train_tar = target[:train_len] valid_data = data[train_len:train_len + valid_len] valid_tar = target[train_len:train_len + valid_len] test_data = data[train_len + valid_len:] test_tar = target[train_len + valid_len:] data = { 'X_train': train_data, # training data 'y_train': train_tar, # training labels 'X_val': valid_data, # validation data 'y_val': valid_tar # validation labels } model = log.LogisticClassifier(input_dim=D, hidden_dim=200, reg=0.001) solver = solver.Solver(model, data, update_rule='adam', optim_config={ 'learning_rate': 1e-3, }, lr_decay=1, num_epochs=3000, batch_size=500, print_every=1) solver.train() acc = solver.check_accuracy(test_data, test_tar) print('Test Accuracy: %f' % acc)
# In[7]: from layers import FCLayer, SigmoidLayer sigmoidMLP = Network() # Build MLP with FCLayer and SigmoidLayer # 128 is the number of hidden units, you can change by your own sigmoidMLP.add(FCLayer(784, 128)) sigmoidMLP.add(SigmoidLayer()) sigmoidMLP.add(FCLayer(128, 10)) # In[15]: sigmoidMLP, sigmoid_loss, sigmoid_acc = train(sigmoidMLP, criterion, sgd, data_train, max_epoch, batch_size, disp_freq) # In[16]: test(sigmoidMLP, criterion, data_test, batch_size, disp_freq) # ## 1.2 MLP with Euclidean Loss and ReLU Activation Function # Build and train a MLP contraining one hidden layer with 128 units using ReLU activation function and Euclidean loss function. # # ### TODO # Before executing the following code, you should complete **layers/relu_layer.py**. # In[8]: from layers import ReLULayer
coding = 'utf-8' import config import os import solver from dataset import get_loader import torch import random import numpy as np if __name__ == '__main__': random.seed(1185) np.random.seed(1185) torch.manual_seed(1185) if config.cuda: torch.cuda.set_device(config.GPUid) torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True torch.cuda.manual_seed(1185) torch.cuda.manual_seed_all(1185) if config.mode == 'train': train_loader = get_loader(config) if not os.path.exists(config.save_folder): os.mkdir(config.save_folder) train = solver.train(train_loader, config) elif config.mode == 'test': test_loader = get_loader(config, mode='test') if not os.path.exists(config.test_fold): os.mkdir(config.test_fold) test = solver.test(test_loader, config) else: print("ERROR MODE!")
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') best_rmse_list = [] ''' repeat 10 times ''' for random_seed in range(args.random_seed, args.random_seed + repeat): tr_data,te_data,num_data,input_dim,output_dim = \ load_data(args.data,args.tr_ratio,args.te_ratio,device,args) model = baseTransformer(args, num_data, input_dim, output_dim, args.HID_DIM, args.ENC_LAYERS, args.ENC_HEADS, args.ENC_PF_DIM, args.ENC_DROPOUT, device).to(device) optimizer = torch.optim.Adam(model.parameters(), lr=args.LEARNING_RATE) best_test_loss = float('inf') for epoch in range(args.N_EPOCHS): tr_pred, tr_mse, tr_rmse = train(model, tr_data, optimizer) te_pred, te_mse, te_rmse = evaluate(model, te_data) if te_rmse < best_test_loss: best_test_loss = te_rmse s = (f'Epoch: {epoch + 1:02} | ' f'Train Loss: {tr_rmse:.4f} | Test Loss: {te_rmse:.4f}') logger.info(s) best_rmse_list.append(best_test_loss) overall_mean = np.mean(best_rmse_list) overall_std = np.std(best_rmse_list) with open("overview.txt", "a") as f: f.write(args.data) f.write("|") f.write(args.att_type)
def main(): data = data_load() # for LR # data = data_load(dim=2) print('data_over') X_train = data['X_train'] y_train = data['y_train'] X_test = data['X_test'] y_test = data['y_test'] classes = 10 def one_hot(y, class_now): y_ = np.zeros(y.shape) y_[y == class_now] = 1 y_[y != class_now] = -1 return y_ SVM kernel Since SVM do not use standard SGD or SGD_momentum or Adam, this model is excluded from the solver class_test = [0,1,2,3,4,5,6,7,8,9] index_in = np.arange(X_train.shape[0]) np.random.shuffle(index_in) index_ = index_in[:2000] scores = np.zeros((y_test.shape[0],classes)) acc_list = [] # data prepare X_train = X_train/255.0 X_test = X_test/255.0 ites = [50,200, 500, 1000] for ite in ites: for class_ in class_test: # model SVM_Kernel has two types, linear kernel and RBF model = network.SVM_Kernel(max_ite= ite,kernel_name = 'linear', C = 0.3, batch_size = 20, gamma_in = 0.05) theta,b = model.train(X_train[index_],one_hot(y_train[index_],class_)) print("class {} done".format(class_)) scores[:,class_] = model.test(X_train[index_],one_hot(y_train[index_],class_),X_test,one_hot(y_test,class_),theta,b) label = np.argmax(scores,axis=1) print(label[:40]) print(y_test[:40]) acc = np.sum(label == y_test) / y_test.shape[0] print("acc = ", acc) acc_list.append(acc) print(acc_list) plt.plot(ites,acc_list) plt.show() # All the other model can be put in solver lrs = [5e-8] update_rules = ['sgd', 'sgd_momentum','adam'] for update_rule in update_rules: # model = network.LogisticRegression(input_dim=X_train.shape[1], reg= 0.5, reg_type= 'l2') # model = network.FullyConnectedNet(hidden_dims=[256, 128], weight_scale=0.01) model = network.ConvNet(weight_scale=1e-2) # model = network.SVM(input_dim=X_train.shape[1]) solver = Solver(model, data, num_epochs=10, batch_size=200, update_rule=update_rule, optim_config={'learning_rate':1e-3}, verbose=True, print_every= 50 ) solver.train() y_prob = model.loss(X_test) y_prob = np.argmax(y_prob, axis=1) test_acc = np.mean(y_prob == y_test) print('test_acc = ', test_acc) plt.title('Training loss') plt.xlabel('Iteration') plt.plot(solver.loss_history) # plt.hold(True) # plt.figure() # plt.title('Train / Validation accuracy') # plt.xlabel('Epoch') # plt.plot(solver.train_acc_history, 'o-', label='train acc') # plt.plot(solver.val_acc_history, 'o-', label='val acc') # plt.legend(loc='lower right', ncol=4) plt.legend(['sgd','sgd_momentum','adam']) plt.show()