def __init__(self, sess, n_features, n_actions, lr=0.001):
self.sess = sess
self.s = tf.placeholder(tf.float32, n_features, "state")
self.a = tf.placeholder(tf.int32, None, "act")
self.td_error = tf.placeholder(tf.float32, None, "td_error") # TD_error
with tf.variable_scope('Actor'):
with tf.variable_scope('Actor_net'):
# CNN network
cnn = CNN(inputs=self.s, n_features=n_features)
cnn_explore = cnn * EXPLORATION_FACTOR
# Output layer
self.acts_prob = tf.layers.dense(
inputs=cnn_explore,
units=n_actions, # output units
activation=tf.nn.softmax, # get action probabilities
kernel_initializer=tf.random_normal_initializer(0., .1), # weights
name='acts_prob')
with tf.variable_scope('a_loss'):
log_prob = tf.log(self.acts_prob[0, self.a]) # log(Pi(s,a))
exp_v = tf.reduce_mean(log_prob * self.td_error) # advantage (TD_error) guided loss: log(Pi(s,a)) * td
entropy = -tf.reduce_sum(self.acts_prob * tf.log(self.acts_prob + ENTROPY_CONSTANT)) # entropy is small when uniform
self.a_loss = -tf.reduce_sum((exp_v + ENTROPY_BETA * entropy))
with tf.name_scope('grad'):
self.a_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Actor')
self.a_grads = tf.gradients(self.a_loss, self.a_params)
with tf.name_scope('train'):
self.train_op = tf.train.AdamOptimizer(lr).apply_gradients(zip(self.a_grads, self.a_params))
def __init__(self, sess, n_features, lr=0.001):
self.sess = sess
self.s = tf.placeholder(tf.float32, n_features, "state")
self.v_ = tf.placeholder(tf.float32, [1, 1], "v_next")
self.r = tf.placeholder(tf.float32, None, 'r')
with tf.variable_scope('Critic'):
with tf.variable_scope('Critic_Net'):
# Convolutional Neutral network
cnn = CNN(inputs=self.s, n_features=n_features)
# Output layer
self.v = tf.layers.dense(
inputs=cnn,
units=1, # output units
activation=None, # linear
kernel_initializer=tf.random_normal_initializer(0., .1), # weights
name='V')
with tf.variable_scope('squared_TD_error'):
GAMMA = 0.9 # reward discount in TD error
self.td_error = (self.r + GAMMA * self.v_) - self.v # TD_error = (r+gamma*V_next) - V_curr
self.c_loss = tf.square(self.td_error)
with tf.name_scope('grad'):
self.c_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Critic')
self.c_grads = tf.gradients(self.c_loss, self.c_params)
with tf.name_scope('train'):
self.train_op = tf.train.AdamOptimizer(lr).apply_gradients(zip(self.c_grads, self.c_params))
def test(run):
print('Testing ' + str(run))
# getting the test data
test_set = torchvision.datasets.FashionMNIST(root='./data/FashionMNIST',
train=False,
download=True,
transform=transforms.Compose(
[transforms.ToTensor()]))
# load the dataset
test_loader = torch.utils.data.DataLoader(test_set,
batch_size=100,
shuffle=False)
# loading the specified model
cnn = CNN()
cnn.load(run)
test_loss = 0
test_total_correct = 0
test_accuracy = 0
for batch in test_loader:
images, labels = batch
preds = cnn(images)
loss = F.cross_entropy(preds, labels)
test_loss += loss.item()
test_total_correct += F.softmax(
preds, dim=1).argmax(dim=1).eq(labels).sum().item()
test_loss /= len(test_set)
test_accuracy = test_total_correct / len(test_set)
print('Testing ended.. total_correct: {}, loss: {}, accuracy: {}'.format(
test_total_correct, test_loss, test_accuracy))
def demo_cnn():
X,y,w = load2d()
y = flatten_except_1dim(y,ndim=3)
w = flatten_except_1dim(w,ndim=2)
print(X.shape)
print(y.shape)
print(w.shape)
model = CNN()
hist = model.fit(X, y, sample_weight=w, epochs=EPOCH,batch_size=128, validation_split=0.2)
# plot_loss(hist.history,"CNN model",plt)
# plt.legend()
# plt.grid()
# plt.yscale("log")
# plt.xlabel("epoch")
# plt.ylabel("loss")
# plt.show()
model.save('./models/cnn_weighted_model.h5')
X_test,_,_ = load2d(test=True)
# y_test = model.predict(X_test)
# fig = plt.figure(figsize=(10, 7))
# fig.subplots_adjust(
# left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)
# for i in range(16):
# axis = fig.add_subplot(4, 4, i+1, xticks=[], yticks=[])
# plot_sample(X_test[i], y_test[i], axis)
# plt.show()
df_y_pred = predict_single(model, X_test)
prepare_submission(df_y_pred,"cnn_weighted")
def main():
seed = 1
learning_rate = 0.1
batch_size = 64
epochs = 5
torch.manual_seed(seed)
device = torch.device("cpu")
kwargs = {'num_workers': 1, 'pin_memory': True}
train_loader = torch.utils.data.DataLoader(datasets.MNIST(
'data',
train=True,
download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])),
batch_size=batch_size,
shuffle=True,
**kwargs)
model = CNN().to(device)
optimizer = optim.Adadelta(model.parameters(), lr=learning_rate)
scheduler = StepLR(optimizer, step_size=1, gamma=0.7)
for epoch in range(1, epochs + 1):
train(model, device, train_loader, optimizer, epoch)
scheduler.step()
torch.save(model.state_dict(), "mnist_model.pt")
def make_model(conn, uid, ptype, epochs, batch, learning_rate, project,
classes):
#retriveing data after Image augmentation
message_to_send = "Loading Dataset...".encode("UTF-8")
conn.send(len(message_to_send).to_bytes(2, byteorder='big'))
conn.send(message_to_send)
data, labels = make_dataset(uid, ptype, project, classes)
data = np.array(data)
#one-hot encoding
labels = pd.Series(labels)
labels = pd.get_dummies(labels).values
x_train, x_test, y_train, y_test = train_test_split(data,
labels,
test_size=0.2,
random_state=42)
message_to_send = "Training Model...".encode("UTF-8")
conn.send(len(message_to_send).to_bytes(2, byteorder='big'))
conn.send(message_to_send)
CNN(conn, x_train, x_test, y_train, y_test, int(epochs), int(batch),
float(learning_rate), len(classes), project, uid, ptype)
def evaluate(config):
# define model
if config.model.name == 'mlp':
model = MLP(config)
elif config.model.name == 'cnn':
model = CNN(config)
# load model & statistics
model = load_model(config, model)
loss, accuracy = load_statistics(config)
# print performance graphs
display_model_performance(loss, accuracy)
# load mnist dataset
train_loader, test_loader = load_mnist(config)
test_iter = iter(test_loader)
images, labels = test_iter.next()
# evaluate accuracy and loss on test data
logits = model.forward(images)
test_loss = nn.CrossEntropyLoss()(logits, labels).detach().numpy()
test_acc = calculate_accuracy(logits.detach().numpy(), labels)
print("test loss: ", test_loss)
print("test accuracy: ", test_acc)
def main():
parser = setup_parser()
args = parser.parse_args()
subprocess.run(f"mkdir {args.model}", shell=True)
torch.manual_seed(42)
# device="cuda" if args.gpus == -1 else "cpu"
k_data_loaders = create_k_splitted_data_loaders(args)
if args.model == "MLP":
model = MLP(args)
elif args.model == "CNN":
model = CNN(args)
model.apply(reset_weights)
acc_results, logs = [], []
for fold, train_loader, test_loader in k_data_loaders:
print(f"FOLD {fold}\n-----------------------------")
print("Starting training...")
model, log = train_loop(train_loader, model, args)
logs.append(log)
print("Training process has finished. Saving trained model.")
torch.save(model.state_dict(), f"./{args.model}/model_fold_{fold}.pth")
print("Starting testing...")
correct_rate = test_loop(test_loader, model, fold)
acc_results.append(correct_rate)
print("Resetting the model weights...")
reset_weights(model)
print(
f"K-FOLD CROSS VALIDATION RESULTS FOR {args.k_folds} FOLDS\n----------------------"
)
print(f"Average: {sum(acc_results) / len(acc_results):.3g}%")
def __init__(
self,
loss_flag=False,
checkpoint_name='./final_checkpoint/re3_final_checkpoint.pth'):
self.device = device
self.CNN = CNN(1, 1).to(self.device)
self.RNN = RNN(CNN_OUTPUT_SIZE, 1, 1, True).to(self.device)
if os.path.isfile(checkpoint_name):
checkpoint = torch.load(checkpoint_name, map_location='cpu')
self.CNN.load_state_dict(checkpoint['cnn_model_state_dict'])
self.RNN.load_state_dict(checkpoint['rnn_model_state_dict'])
else:
print("Invalid/No Checkpoint. Aborting...!!")
sys.exit()
self.CNN = self.CNN.to(device)
self.RNN = self.RNN.to(device)
self.forward_count = -1
self.previous_frame = None
self.cropped_input = np.zeros((2, 3, CROP_SIZE, CROP_SIZE),
dtype=np.float32)
self.calculate_loss = loss_flag
self.criterion = nn.MSELoss()
self.MSE_loss = 0
def run():
df = pd.read_csv(config.TRAIN_PATH)
kfold = KFold(n_splits=5, random_state=config.SEED, shuffle=True)
fold_losses = []
for i, (train_idx, val_idx) in enumerate(kfold.split(df)):
print("-------------------------------------------------------")
print(f"Training fold {i}")
print("-------------------------------------------------------")
train = df.iloc[train_idx]
validation = df.iloc[val_idx]
train_dataset = PicDataset(train)
train_data_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=config.BATCH_SIZE)
val_dataset = PicDataset(validation)
val_data_loader = torch.utils.data.DataLoader(
val_dataset, batch_size=config.BATCH_SIZE)
device = 'cuda:0' if torch.cuda.is_available() else "cpu"
model = CNN()
model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=config.LR)
loss = 0
for _ in range(config.EPOCHS):
engine.train_fn(train_data_loader, model, optimizer, device)
loss = engine.eval_fn(val_data_loader, model, device)
print(f"Loss on fold {i} is {loss}")
fold_losses.append(loss)
torch.save(model.state_dict(), f'./models/model_{i}.bin')
print(f"Average loss on cross validation is {sum(fold_losses) / 5}")
def test_update_parameters():
''' (5 points) update_parameters'''
x = th.zeros(2,1,64,64) # a mini-batch of 2 gray-scale images (1 channel) of size 64 X 64
y = th.zeros(2,1)
m = CNN()
m.conv1.bias.data = th.zeros(10)
m.conv2.bias.data = th.zeros(20)
m.conv3.bias.data = th.zeros(30)
m.fc.bias.data = th.zeros(1)
optimizer = th.optim.SGD(m.parameters(), lr=0.1)
z=m(x)
L = compute_L(z,y)
assert np.allclose(L.data,0.6931,atol=0.01)
L.backward()
update_parameters(optimizer)
assert np.allclose(m.fc.bias.data,[-0.05],atol=0.01)
assert np.allclose(m.conv3.bias.data,np.zeros(30),atol=0.01)
x = th.ones(4,1,64,64)
y = th.tensor([[1.],[0.],[1.],[0.]])
m.conv1.bias.data = th.zeros(10)
m.conv2.bias.data = th.zeros(20)
m.conv3.bias.data = th.zeros(30)
m.fc.bias.data = th.zeros(1)
optimizer = th.optim.SGD(m.parameters(), lr=1.)
z=m(x)
L = compute_L(z,y)
L.backward()
update_parameters(optimizer)
assert not np.allclose(m.conv3.bias.data,np.zeros(30))
th.save(m,"cnn.pt") # save the CNN for demo
def init_model(self):
print(self.model_type)
if os.path.exists(self.model_dir):
pass
else:
os.makedirs(self.model_dir)
if self.model_type == 'simple_model':
self.model = Simple_model(env = self.env)
if not self.loading_model:
self.simple_train()
#self.train()
elif self.model_type == 'simple_cnn':
self.model = CNN(env = self.env)
if not self.loading_model:
self.simple_train()
# self.train()
else:
self.model = Freezing_CNN(env = self.env)
if not self.loading_model:
self.train(freezing = True)
self.saver = tf.train.Saver()
self.load_model()
def webcam():
model = CNN()
model.load_state_dict(torch.load('outputs/model'))
transform = torchvision.transforms.Compose([
torchvision.transforms.ToPILImage(),
torchvision.transforms.Resize(150, interpolation=Image.BILINEAR),
torchvision.transforms.CenterCrop((150, 200)),
torchvision.transforms.ToTensor()
])
cap = cv2.VideoCapture(0)
while cap.isOpened():
ret, frame = cap.read()
if ret:
img = transform(frame)
img_batch = img.unsqueeze(0)
outputs, _ = model(img_batch)
bbxs = find_batch_bounding_boxes(outputs)[0]
img = util.draw_bounding_boxes(img, bbxs[Label.ROBOT.value], (0, 0, 255))
img = util.draw_bounding_boxes(img, bbxs[Label.BALL.value], (255, 0, 0))
util.stream_image(img, wait=25, scale=4)
if cv2.waitKey(25) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
def main():
cnn = CNN()
cnn.eval()
cnn.load_state_dict(torch.load('model.pkl'))
print("load cnn net.")
eval_dataloader = dataset.get_eval_data_loader()
correct = 0
total = 0
for i, (images, labels) in enumerate(eval_dataloader):
image = images
vimage = Variable(image)
predict_label = cnn(vimage)
c0 = setting.ALL_CHAR_SET[np.argmax(
predict_label[0, 0:setting.ALL_CHAR_SET_LEN].data.numpy())]
c1 = setting.ALL_CHAR_SET[np.argmax(
predict_label[0, setting.ALL_CHAR_SET_LEN:2 * setting.ALL_CHAR_SET_LEN].data.numpy())]
c2 = setting.ALL_CHAR_SET[np.argmax(
predict_label[0, 2 * setting.ALL_CHAR_SET_LEN:3 * setting.ALL_CHAR_SET_LEN].data.numpy())]
c3 = setting.ALL_CHAR_SET[np.argmax(
predict_label[0, 3 * setting.ALL_CHAR_SET_LEN:4 * setting.ALL_CHAR_SET_LEN].data.numpy())]
predict_label = '%s%s%s%s' % (c0, c1, c2, c3)
true_label = encoding.decode(labels.numpy()[0])
total += labels.size(0)
if (predict_label == true_label):
correct += 1
if (total % 200 == 0):
print('Test Accuracy of the model on the %d eval images: %f %%' %
(total, 100 * correct / total))
print('Test Accuracy of the model on the %d eval images: %f %%' %
(total, 100 * correct / total))
return correct / total
def test_model(null_split):
use_cuda = torch.cuda.is_available()
torch.manual_seed(1)
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
test_data = train_files('/home/hansencb/MNIST/Test')
test_dataset = Test_Dataset(test_data)
batch_size = 128
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, **kwargs)
model = CNN(1,10).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)
model_file = 'models/saved_model_split_{}'.format(null_split)
model.load_state_dict(torch.load(model_file))
loss, accuracy, conf_matrix, correct, incorrect = test(model, device, test_loader)
correct_file = 'correct_lists/list_correct_model_split_{}'.format(null_split)
with open(correct_file, 'w') as f:
for i in correct:
line = '{} {} {}\n'.format(i[0], str(i[1]), str(i[2]))
f.write(line)
for i in incorrect:
line = '{} {} {}\n'.format(i[0], str(i[1]), str(i[2]))
f.write(line)
return accuracy
def main():
# Data Loader (Input Pipeline)
print('loading dataset...')
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
num_workers=4,
drop_last=True,
shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
num_workers=4,
drop_last=True,
shuffle=False)
# Define models
print('building model...')
cnn = CNN(input_channel=input_channel, n_outputs=num_classes)
cnn.cuda()
cnn.load_state_dict(torch.load(args.model))
# evaluate models with random weights
test_acc = evaluate(test_loader, cnn)
print(
'=========> Test Accuracy on the %s test images: %.4f %% <==========='
% (len(test_dataset), test_acc))
def main():
cnn = CNN()
cnn.eval()
cnn.load_state_dict(torch.load('model.pkl'))
print("load cnn net.")
predict_dataloader = dataset.get_predict_data_loader()
# vis = Visdom()
for i, (images, labels) in enumerate(predict_dataloader):
image = images
vimage = Variable(image)
predict_label = cnn(vimage)
c0 = captcha_setting.ALL_CHAR_SET[np.argmax(
predict_label[0, 0:captcha_setting.ALL_CHAR_SET_LEN].data.numpy())]
c1 = captcha_setting.ALL_CHAR_SET[np.argmax(
predict_label[0, captcha_setting.ALL_CHAR_SET_LEN:2 *
captcha_setting.ALL_CHAR_SET_LEN].data.numpy())]
c2 = captcha_setting.ALL_CHAR_SET[np.argmax(
predict_label[0, 2 * captcha_setting.ALL_CHAR_SET_LEN:3 *
captcha_setting.ALL_CHAR_SET_LEN].data.numpy())]
c3 = captcha_setting.ALL_CHAR_SET[np.argmax(
predict_label[0, 3 * captcha_setting.ALL_CHAR_SET_LEN:4 *
captcha_setting.ALL_CHAR_SET_LEN].data.numpy())]
c = '%s%s%s%s' % (c0, c1, c2, c3)
print(c)
def main():
args = load_arg()
print(f"Run:{args.lang}")
args.device = torch.device(
"cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
train_dataset, dev_dataset = load_shinra_data(args)
dataset = ShinraTargetDataset(args,
labels=train_dataset.labels,
chars=train_dataset.chars)
model = CNN(args,
train_dataset.num_labels,
class_weight=train_dataset.get_class_weight())
state_dict = torch.load(
os.path.join(args.pretrained_model, args.lang, "pytorch_model.bin"))
model.load_state_dict(state_dict)
model.to(args.device)
if args.fp16:
model = to_fp16(args, model)
model = to_parallel(args, model)
_, results = eval(args, dataset, model)
os.makedirs(args.output_dir, exist_ok=True)
save_result(f"{args.output_dir}/{args.lang}.json", results)
def get_cnn(in_channels, out_channels, kernel_heights, stride, padding, dropout_prob):
"""
Creates a new CNN and tokenizer using the given parameters
:return:
"""
# Load english model with 25k word-pieces
tokenizer = BPEmb(lang='en', dim=300, vs=25000)
# Extract the embeddings and add a randomly initialized embedding for our extra [PAD] token
pretrained_embeddings = np.concatenate([tokenizer.emb.vectors, np.zeros(shape=(1, 300))], axis=0)
# Extract the vocab and add an extra [PAD] token
vocabulary = tokenizer.emb.index2word + ['[PAD]']
tokenizer.pad_token_id = len(vocabulary) - 1
model = CNN(
torch.tensor(pretrained_embeddings).type(torch.FloatTensor),
n_labels=2,
in_channels=in_channels,
out_channels=out_channels,
kernel_heights=kernel_heights,
stride=stride,
padding=padding,
dropout=dropout_prob
).to(device)
return model, tokenizer
def train(args):
assert args.num_classes
common.make_dir(args.checkout_dir)
nnet = CNN(args.left_context + args.right_context + 1, args.feat_dim, num_maps, pooling_size,
filter_size, conn_dim, args.num_classes)
print(nnet)
nnet.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = th.optim.Adam(nnet.parameters(), lr=args.learning_rate)
train_dataset = THCHS30(root=args.data_dir, data_type='train', left_context=left_context,
right_context=right_context, model_type='cnn')
train_loader = data.DataLoader(dataset=train_dataset, batch_size=args.min_batch,
shuffle=True, num_workers=6)
test_dataset = THCHS30(root=args.data_dir, data_type='test', left_context=left_context,
right_context=right_context, model_type='cnn')
test_loader = data.DataLoader(dataset=test_dataset, batch_size=args.min_batch,
shuffle=True, num_workers=6)
cross_validate(-1, nnet, test_dataset, test_loader)
for epoch in range(args.num_epochs):
common.train_one_epoch(nnet, criterion, optimizer, train_loader)
cross_validate(epoch, nnet, test_dataset, test_loader)
th.save(nnet, common..join_path(args.checkout_dir, 'cnn.{}.pkl'.format(epoch + 1)))
def train(data_loader, alpha=0.001, n_epoch=100):
m = CNN() # initialize the model
optimizer = th.optim.SGD(m.parameters(), lr=alpha) # create an SGD optimizer
for _ in range(n_epoch): # iterate through the dataset n_epoch times
for mini_batch in data_loader: # iterate through the dataset, with one mini-batch of random training samples (x,y) at a time
x=mini_batch[0] # the gray-scale images in a mini-batch
y=mini_batch[1] # the labels of the images in a mini-batch
#########################################
## INSERT YOUR CODE HERE (5 points)
z = compute_z(x, m)
L = compute_L(z, y)
L.backward()
update_parameters(optimizer)
#########################################
return m
#-----------------
'''
TEST: Now you can test the correctness of your code above by typing the following in the terminal:
---------------------------------------------------
nosetests -v test3.py:test_train
--- OR ----
python3 -m nose -v test3.py:test_train
--- OR ----
python -m nose -v test3.py:test_train
---------------------------------------------------
'''
'''
def main(iexp, itheory, ifeature, output, fmodel):
start = time.time()
L, idset = readTestData(iexp, itheory, ifeature)
L_idx = [i for i in range(len(L))]
test_data = DefineTestDataset(L_idx, L)
device = torch.device("cuda")
model = mymodel(CNN(), Net())
model.cuda()
model = nn.DataParallel(model)
model.to(device)
#model.load_state_dict(torch.load('./temp_model_second/epoch148.pt', map_location=lambda storage, loc: storage))
model.load_state_dict(
torch.load(fmodel, map_location=lambda storage, loc: storage))
y_pred = test_model(model, test_data, device)
print(time.time() - start)
# f = open('./marine2/OSU_D2_FASP_Elite_02262014_' + str(i) + '.pin')
# fw=open('./marine2/OSU_rerank_'+str(i)+'.csv','w')
# fw_test = open('prob' + str(i) + '.txt', 'w')
fw_test = open(output, 'w')
count = 0
for line_id, line in enumerate(idset):
# if line_id == 0:
# fw.write('rerank_score' + ',' + line)
# continue
# fw.write(str(y_pred[line_id - 1]) + ',' + line)
if line == False:
fw_test.write(str(line) + ':' + 'None' + '\n')
else:
fw_test.write(line + ':' + str(y_pred[count]) + '\n')
count += 1
# f.close()
# fw.close()
fw_test.close()
def main():
cnn = CNN()
cnn.train()
criterion = nn.MultiLabelSoftMarginLoss()
optimizer = torch.optim.Adam(cnn.parameters(), lr=learning_rate)
max_eval_acc = -1
train_dataloader = dataset.get_train_data_loader()
for epoch in range(num_epochs):
for i, (images, labels) in enumerate(train_dataloader):
images = Variable(images)
labels = Variable(labels.float())
predict_labels = cnn(images)
loss = criterion(predict_labels, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (i + 1) % 10 == 0:
print("epoch:", epoch, "step:", i, "loss:", loss.item())
if (i + 1) % 100 == 0:
# current is model.pkl
torch.save(cnn.state_dict(), "./model.pkl")
print("save model")
print("epoch:", epoch, "step:", i, "loss:", loss.item())
eval_acc = evaluate()
if eval_acc > max_eval_acc:
# best model save as best_model.pkl
torch.save(cnn.state_dict(), "./best_model.pkl")
print("save best model")
torch.save(cnn.state_dict(), "./model.pkl")
print("save last model")
def main(cfg):
if cfg['model'] == 'mlp':
net = MLP(300, 768, cfg['class_num'])
elif cfg['model'] == 'cnn':
net = CNN(300, 768, cfg['class_num'])
elif cfg['model'] == 'lstm':
net = LSTM(300, cfg['class_num'], cfg['device'])
elif cfg['model'] == 'gru':
net = GRU(300, cfg['class_num'], cfg['device'])
else:
raise Exception(f'model {args.model} not available')
if cfg['device'] == 'cuda':
if len(cfg['gpu_ids']) == 1:
torch.cuda.set_device(cfg['gpu_ids'][0])
net = net.cuda()
else:
net = net.cuda()
net = nn.DataParallel(net, device_ids=cfg['gpu_ids'])
torch.backends.cudnn.benchmark = True
if cfg['mode'] == 'train':
train(cfg, net)
elif cfg['mode'] == 'predict':
predict(cfg, net, 'checkpoints/{}.pth'.format(cfg['model']))
def run_func():
conf = json.load(open('config.json'))
print(conf)
if conf['data_name'] == "NYT":
config = NYT_Config(conf)
else:
config = WebNLG_Config(conf)
train = dataset(config.question_train, config.context_train,
config.answer_train, config.cnn_output_train,
config.cnn_list_train)
dev = dataset(config.question_dev, config.context_dev, config.answer_dev,
config.cnn_output_dev, config.cnn_list_dev)
test = dataset(config.question_test, config.context_test,
config.answer_test, config.cnn_output_test,
config.cnn_list_test)
print(len(train))
print(len(dev))
print(len(test))
encoder = Encoder(config.hidden_state_size)
decoder = Decoder(config.hidden_state_size)
cnn = CNN(config, is_training=True)
qa = QASystem(encoder, decoder, cnn, config)
sess = tf.Session()
qa.initialize_model(sess, config.train_dir)
qa.train(sess, [train, dev, test], config.train_dir, config)
def main():
args = load_arg()
print(f"Run:{args.lang}")
args.device = torch.device(
"cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
args.n_gpu = torch.cuda.device_count()
set_seed(args)
train_dataset, dev_dataset = load_shinra_data(args)
model = CNN(args, train_dataset.num_labels, \
emb_freeze=args.emb_freeze, \
class_weight=train_dataset.get_class_weight())
model.to(args.device)
scores = {}
model, scores["train"], scores["dev"], best_epoch = train(
args, train_dataset, dev_dataset, model)
model.to("cpu")
if args.output_dir is not None:
output_dir = f"{args.output_dir}/{args.lang}"
os.makedirs(output_dir, exist_ok=True)
save_model(output_dir, model)
save_json(f"{output_dir}/score.json", scores)
def main(args):
transform = transforms.ToTensor()
args.dataset_root.mkdir(parents=True, exist_ok=True)
train_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_train.pkl', mode=args.mode),
batch_size=32, shuffle=True,
num_workers=8, pin_memory=True)
test_loader = torch.utils.data.DataLoader(
UrbanSound8KDataset('UrbanSound8K_test.pkl', mode=args.mode),
batch_size=32, shuffle=False,
num_workers=8, pin_memory=True)
# Change the input dimensions if we are using MLMC.
# Direct user to correct file if they want to use TSCNN.
if args.mode == "LMC" or args.mode == "MC":
model = CNN(height=85, width=41, channels=1, class_count=10, dropout=args.dropout, mode=args.mode)
elif args.mode == "MLMC":
model = CNN(height=145, width=41, channels=1, class_count=10, dropout=args.dropout, mode=args.mode)
elif args.mode == "TSCNN":
print("Use file late_fusion.py to run TSCNN with trained LMCNet and MCNet")
criterion = nn.CrossEntropyLoss()
# Paper specifies "variant of stochastic gradient descent" with reference
# pointing to Adam. Weight decay used for L2 regularisation.
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay)
log_dir = get_summary_writer_log_dir(args)
print(f"Writing logs to {log_dir}")
summary_writer = SummaryWriter(
str(log_dir),
flush_secs=5
)
trainer = Trainer(
model, train_loader, test_loader, criterion, optimizer, summary_writer,
DEVICE, args.checkpoint_path, args.checkpoint_frequency
)
trainer.train(
args.epochs,
args.val_frequency,
print_frequency=args.print_frequency,
log_frequency=args.log_frequency,
)
summary_writer.close()
def main(argv):
conf = configparser.ConfigParser()
print(conf.read(argv))
max_smi_len = conf.getint('model', 'max_smi_len')
max_seq_len = conf.getint('model', 'max_seq_len')
data_path = conf.get('model', 'data_path')
ligands = pd.read_csv(data_path + 'ligands.csv', header=None)
proteins = pd.read_csv(data_path + 'proteins.csv', header=None)
inter = pd.read_csv(data_path + 'inter.csv', header=None)
inter = np.asarray(inter)
print(ligands.shape, proteins.shape, inter.shape)
char_smi_set = json.load(open(conf.get('model', 'char_smi')))
char_seq_set = json.load(open(conf.get('model', 'char_seq')))
cv_num = conf.getint('cv', 'cv_num', fallback=5)
problem_type = conf.getint('cv', 'problem_type', fallback=1)
if problem_type == 1:
cv_train, cv_valid = new_pair_fold(inter, cv_num)
elif problem_type == 2:
cv_train, cv_valid = new_protein_fold(inter, cv_num)
elif problem_type == 3:
cv_train, cv_valid = new_ligand_fold(inter, cv_num)
print(cv_train[0].shape, cv_valid[0].shape)
sess = tf.InteractiveSession(config=tf.ConfigProto(
allow_soft_placement=True))
model = CNN(filter_num=conf.getint('model', 'filter_num'),
smi_window_len=conf.getint('model', 'smi_window_len'),
seq_window_len=conf.getint('model', 'seq_window_len'),
max_smi_len=max_smi_len,
max_seq_len=max_seq_len,
char_smi_set_size=len(char_smi_set),
char_seq_set_size=len(char_seq_set),
embed_dim=conf.getint('model', 'embed_dim'))
for cv_id in range(cv_num):
print('start cv', cv_id)
model_path = os.path.join(conf.get('model', 'path', fallback='tmp'),
'cv-' + str(cv_id) + '.model')
trainX, trainy = get_feature(ligands, proteins, inter, cv_train[cv_id],
max_smi_len, char_smi_set, max_seq_len,
char_seq_set)
validX, validy = get_feature(ligands, proteins, inter, cv_valid[cv_id],
max_smi_len, char_smi_set, max_seq_len,
char_seq_set)
print(trainX.shape, trainy.shape, validX.shape, validy.shape)
model.train(sess,
trainX,
trainy,
validX,
validy,
nb_epoch=conf.getint('model', 'num_epoch'),
batch_size=conf.getint('model', 'batch_size'),
model_path=model_path)
def train_model(x_train, x_test, L, Y, weight):
LR = 1e-4
start_time = time.time()
train_data = DefineDataset(x_train, L, Y, weight)
test_data = DefineDataset(x_test, L, Y, weight)
device = torch.device("cuda")
model = mymodel(CNN(), Net())
model.cuda()
model = nn.DataParallel(model)
model.to(device)
# criterion = nn.CrossEntropyLoss(size_average=False)
#model.load_state_dict(torch.load('./temp_model/epoch54.pt', map_location=lambda storage, loc: storage))
criterion = my_loss()
optimizer = torch.optim.Adam(model.parameters(), lr=LR, weight_decay=1e-4)
best_acc = 0.0
Train_acc = []
Test_acc = []
for epoch in range(0, 150):
# load the training data in batch
batch_count = 0
batch_time = time.time()
model.train()
train_loader = Data.DataLoader(train_data,batch_size=6)
start = time.time()
for x_batch, y_batch, feature, weight in train_loader:
end = time.time()
batch_count = batch_count + 1
inputs, targets, feature, weight = Variable(x_batch), Variable(y_batch), Variable(feature), Variable(weight)
inputs, targets, feature, weight = inputs.to(device), targets.to(device), feature.to(device), weight.to(
device)
optimizer.zero_grad()
outputs = model(inputs, feature) # forward computation
loss = criterion(outputs, targets, weight)
# backward propagation and update parameters
loss.backward()
optimizer.step()
# print("batch"+str(batch_count)+" :"+str(get_time_dif(batch_time)))
# evaluate on both training and test dataset
train_acc, train_loss, train_Posprec, train_Negprec = evaluate(train_data, model, criterion, device)
test_acc, test_loss, test_PosPrec, test_Negprec = evaluate(test_data, model, criterion, device)
if test_acc > best_acc:
# store the best result
best_acc = test_acc
torch.save(model.state_dict(), 'benchmark.pt')
name = './temp_model/epoch' + str(epoch) + '.pt'
torch.save(model.state_dict(), name)
time_dif = get_time_dif(start_time)
msg = "Epoch {0:3}, Train_loss: {1:>7.2}, Train_acc {2:>6.2%}, Train_Posprec {3:>6.2%}, Train_Negprec {" \
"4:>6.2%}, " + "Test_loss: {5:>6.2}, Test_acc {6:>6.2%},Test_Posprec {7:6.2%}, Test_Negprec {8:6.2%} " \
"Time: {9} "
print(msg.format(epoch + 1, train_loss, train_acc, train_Posprec, train_Negprec, test_loss, test_acc,
test_PosPrec, test_Negprec, time_dif))
Train_acc.append(train_acc)
Test_acc.append(test_acc)
# torch.save(model.state_dict(), 'cnn_pytorch.pt')
test_model(model, test_data, device)
return Test_acc, Train_acc
def load_model(lr):
model = CNN()
loss_fnc = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=lr)
return model, loss_fnc, optimizer
