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