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()