def train(self): """ Train MemN2N model using training data for tasks. """ np.random.seed(42) # for reproducing assert self.data_dir is not None, "data_dir is not specified." print("Reading data from %s ..." % self.data_dir) # Parse training data train_data_path = glob.glob('%s/qa*_*_train.txt' % self.data_dir) dictionary = {"nil": 0} train_story, train_questions, train_qstory = parse_babi_task(train_data_path, dictionary, False) # Parse test data just to expand the dictionary so that it covers all words in the test data too test_data_path = glob.glob('%s/qa*_*_test.txt' % self.data_dir) parse_babi_task(test_data_path, dictionary, False) # Get reversed dictionary mapping index to word self.reversed_dict = dict((ix, w) for w, ix in dictionary.items()) # Construct model self.general_config = BabiConfigJoint(train_story, train_questions, dictionary) self.memory, self.model, self.loss = build_model(self.general_config) # Train model if self.general_config.linear_start: train_linear_start(train_story, train_questions, train_qstory, self.memory, self.model, self.loss, self.general_config) else: train(train_story, train_questions, train_qstory, self.memory, self.model, self.loss, self.general_config) # Save model self.save_model()
def trainer() -> None: train_on_gpu = torch.cuda.is_available() batch_size = 32 n_epochs = 50 train_data = torch.load("dev_train.pt") valid_data = torch.load("dev_valid.pt") train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, pin_memory=True) valid_loader = torch.utils.data.DataLoader(valid_data, batch_size=batch_size, pin_memory=True) model = SiAudNet() if train_on_gpu: model = model.cuda() file_name = "model_siaudnet.pt" optimizer = optim.Adadelta(model.parameters()) train( model, train_on_gpu, n_epochs, train_loader, valid_loader, optimizer, file_name, True, )
def run(): parser = GooeyParser() subs = parser.add_subparsers(help='commands', dest='commands') train_parser = subs.add_parser('train', help='Configurate model training') param_group = train_parser.add_argument_group("Model parameter option", gooey_options={'show_border': True, 'columns': 2}) args_param.add(param_group) data_group = train_parser.add_argument_group("Data Options", gooey_options={'show_border': True}, ) args_data.add(data_group) save_group = train_parser.add_argument_group("Save option", gooey_options={'show_border': True, 'columns': 2}) args_save.add(save_group) test_parser = subs.add_parser('test', help='Configurate model testining') data_group = test_parser.add_argument_group("Data Options", gooey_options={'show_border': True}, ) args_data.add(data_group) load_group = test_parser.add_argument_group("Load option", gooey_options={'show_border': True, 'columns': 1}) args_load.add(load_group, model_savefiles()) save_group = test_parser.add_argument_group("Save option", gooey_options={'show_border': True, 'columns': 2}) args_save.add(save_group) args = parser.parse_args() X, Y = load_data(args.data_path) if args.commands =='train': train(args, X, Y, save_dir) else: with open(save_dir + args.load_model, 'rb') as f: model = pickle.load(f) test(args, X, Y, save_dir, model)
def run_task(data_dir, task_id): """ Train and test for each task """ print("Train and test for task %d ..." % task_id) # Parse data train_files = glob.glob('%s/qa%d_*_train.txt' % (data_dir, task_id)) test_files = glob.glob('%s/qa%d_*_test.txt' % (data_dir, task_id)) dictionary = {"nil": 0} train_story, train_questions, train_qstory = parse_babi_task( train_files, dictionary, False) test_story, test_questions, test_qstory = parse_babi_task( test_files, dictionary, False) general_config = BabiConfig(train_story, train_questions, dictionary) memory, model, loss = build_model(general_config) if general_config.linear_start: train_linear_start(train_story, train_questions, train_qstory, memory, model, loss, general_config) else: train(train_story, train_questions, train_qstory, memory, model, loss, general_config) test(test_story, test_questions, test_qstory, memory, model, loss, general_config)
def main(): model = Seq2Seq(input_dim=40, vocab_size=len(LETTER_LIST), hidden_dim=128) optimizer = optim.Adam(model.parameters(), lr=0.001) criterion = nn.CrossEntropyLoss(reduction=None) nepochs = 25 batch_size = 64 if DEVICE == 'cuda' else 1 speech_train, speech_valid, speech_test, transcript_train, transcript_valid = load_data( ) character_text_train = transform_letter_to_index(transcript_train, LETTER_LIST) character_text_valid = transform_letter_to_index(transcript_valid, LETTER_LIST) train_dataset = Speech2TextDataset(speech_train, character_text_train) # val_dataset = test_dataset = Speech2TextDataset(speech_test, None, False) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate) # val_loader = test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_test) for epoch in range(nepochs): train(model, train_loader, criterion, optimizer, epoch) # val() test(model, test_loader, epoch)
def train_network(): # Adjust the training options as necessary training_options = { 'learning_rate': 0.0002, 'training_epochs': 10, 'batch_size': 64, 'adam_beta_1': 0.5, 'adam_beta_2': 0.999, 'save_path': './models/your_network.pth', 'continue_training_from': None, #Path to a saved neural net model 'image_transform': transforms.Compose([ transforms.Resize((224,224)), #Make sure size matches model input size # transforms.Pad(0), # transforms.CenterCrop(224) # See https://pytorch.org/docs/stable/torchvision/transforms.html # for more transforms ]), 'data_source': ['lab', 'field'], # Whether to train on data from the lab or the field, or both 'device': 'cuda:0' if torch.cuda.is_available() else 'cpu', 'printEvery': 1 #How often to print batch summaries } network = models.alexnet(pretrained=False, num_classes=185) #network = Your_Network() train(network, training_options)
def main(): train_story_set = StoryDataset(sis_train, vocab) # val_story_set = StoryDataset(sis_val, vocab) # test_story_set = StoryDataset(sis_test, vocab) train_loader = DataLoader(train_story_set, shuffle=False, batch_size=BATCH_SIZE, collate_fn=collate_story, pin_memory=False) # imgs of shape [BS, 5, 3, 224, 224] # sents BS * 5 * MAX_LEN model_v1 = ModelV1(vocab) # Learning rate is the most sensitive value to set, # will need to test what works well past 400 instances optimizer = torch.optim.Adam(model_v1.parameters(), lr=0.001) # .001 for 400 isTraining = True if isTraining: train(10, model_v1, train_loader, optimizer) else: model_v1.load_state_dict(torch.load('./Training/7')) test_loader = DataLoader(train_story_set, shuffle=False, batch_size=BATCH_SIZE, collate_fn=collate_story) test(model_v1, test_loader, device, vocab)
def main(): config_dict = config.get_config() log_dir = train_test.create_log_dir("/opt/code/my_logs") train_test.copy("/opt/code/src/config.py", log_dir) train_test.copy("/opt/code/src/models.py", log_dir) model_name = config_dict['model_name'] model = config_dict['model'] save_model = config_dict['save_model'] optimizer = config_dict['optimizer'] epoch = config_dict['epoch'] long_patience = config_dict['long_patience'] train_set = config_dict['train_set'] test_set = config_dict['test_set'] print() train_test.train( train_set, test_set, model, optimizer, log_dir, epochs=epoch, long_patience=long_patience, ) if save_model: torch.save(model, model_name)
def main(): model = Seq2Seq(input_dim=40, vocab_size=len(LETTER_LIST), hidden_dim=256, isAttended=True) # print(model) optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=5e-5) # scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=2, gamma=0.1) criterion = nn.CrossEntropyLoss(reduce=False, reduction=None) nepochs = 18 batch_size = 64 if DEVICE == 'cuda' else 1 speech_train, speech_valid, speech_test, transcript_train, transcript_valid = load_data( ) character_text_train = transform_letter_to_index(transcript_train, LETTER_LIST) character_text_valid = transform_letter_to_index(transcript_valid, LETTER_LIST) train_dataset = Speech2TextDataset(speech_train, character_text_train) val_dataset = Speech2TextDataset(speech_valid, character_text_valid) test_dataset = Speech2TextDataset(speech_test, None, False) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) #, collate_fn=collate_train) val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True) #, collate_fn=collate_train) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False) #, collate_fn=collate_test) for epoch in range(nepochs): train(model, train_loader, criterion, optimizer, epoch) # scheduler.step() val(model, val_loader, criterion, epoch) # Test and Save results test_preds = test(model, test_loader) test_preds = test_preds.cpu().numpy() results = [] for i in range(test_preds.shape[0]): result = "" for j in range(test_preds.shape[1]): if (test_preds[i, j] == 0 or (test_preds[i, j] == 33)): continue if (test_preds[i, j] == 34): break result = result + index2letter[test_preds[i, j]] results.append(result) name = "Epoch_" + str(epoch) + "_LAS_submission.csv" ids = list(range(len(test_dataset))) ids.insert(0, 'Id') results.insert(0, 'Predicted') with open(name, 'w') as f: writer = csv.writer(f) writer.writerows(zip(ids, results))
def main(): model = Seq2Seq(input_dim=40, vocab_size=len(LETTER_LIST), hidden_dim=128) optimizer = optim.SGD(model.parameters(), lr=1e-4, weight_decay=5e-4) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.93) criterion = nn.CrossEntropyLoss(reduction='none') init_epoch = 0 nepochs = 50 batch_size = 64 if DEVICE == 'cuda' else 1 speech_train, speech_valid, speech_test, transcript_train, transcript_valid = load_data( ) character_text_train = transform_letter_to_index(transcript_train, LETTER_LIST) character_text_valid = transform_letter_to_index(transcript_valid, LETTER_LIST) train_dataset = Speech2TextDataset(speech_train, character_text_train) val_dataset = Speech2TextDataset(speech_valid, character_text_valid) test_dataset = Speech2TextDataset(speech_test, None, False) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_train_val) val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_train_val) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_test) val_distances = [] exp = 27 # model.load_state_dict(torch.load('BestModel9.pth')) with open('stats_{}'.format(exp), 'w') as file: file.write('Experiment: {}\n'.format(exp)) for epoch in range(init_epoch, nepochs): train(model, train_loader, criterion, optimizer, scheduler, epoch, exp) val_distances.append(val(model, val_loader, epoch, exp)) if val_distances[-1] == min(val_distances): torch.save(model.state_dict(), 'BestModel{}.pth'.format(exp)) if epoch % 3 == 0 or epoch == nepochs - 1: test(model, test_loader, exp)
def main(): model = Seq2Seq(input_dim=40, vocab_size=len(LETTER_LIST), hidden_dim=128, value_size=128, key_size=256, isAttended=True) model.load_state_dict(torch.load('model3')) model.eval() model = model.to(DEVICE) optimizer = optim.Adam(model.parameters(), lr=0.0005) criterion = nn.CrossEntropyLoss(reduction='sum') nepochs = 10 batch_size = 64 if DEVICE == 'cuda' else 1 speech_train, speech_valid, speech_test, transcript_train, transcript_valid = load_data( ) character_text_train = transform_letter_to_index(transcript_train, LETTER_LIST) character_text_valid = transform_letter_to_index(transcript_valid, LETTER_LIST) train_dataset = Speech2TextDataset(speech_train, character_text_train) val_dataset = Speech2TextDataset(speech_valid, character_text_valid) test_dataset = Speech2TextDataset(speech_test, None, False) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_train) for x in train_loader: pass val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_train) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_test) for epoch in range(nepochs): print('==============', 'Epoch', epoch + 1, '================') train(model, train_loader, criterion, optimizer, epoch) val(model, val_loader, criterion, optimizer, epoch) torch.save(model.state_dict(), 'model3') load_model(model, test_loader)
def main(): model = Seq2Seq(input_dim=40, vocab_size=len(LETTER_LIST), hidden_dim=128, value_size=128, key_size=256, is_attended=True) # cur_model_num = 6 # model.load_state_dict(torch.load('model_{}'.format(cur_model_num))) optimizer = optim.Adam(model.parameters(), lr=0.001) criterion = nn.CrossEntropyLoss(reduction="sum") n_epochs = 30 batch_size = 64 if DEVICE == 'cuda' else 1 speech_train, speech_valid, speech_test, transcript_train, transcript_valid = load_data( ) character_text_train = transform_letter_to_index(transcript_train, LETTER2INDEX) character_text_valid = transform_letter_to_index(transcript_valid, LETTER2INDEX) train_dataset = Speech2TextDataset(speech_train, character_text_train) val_dataset = Speech2TextDataset(speech_valid, character_text_valid) test_dataset = Speech2TextDataset(speech_test, None, False) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_train) val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_train) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_test) for epoch in range(n_epochs): train(model, train_loader, criterion, optimizer, epoch) val(model, val_loader, criterion, epoch) # test(model, test_loader) torch.save(model.state_dict(), 'model_{}'.format(1)) result_gen(test_loader, 1)
def main(): model = Seq2Seq(input_dim=40, vocab_size=len(LETTER_LIST), hidden_dim=128) learningRate = 0.001 weightDecay = 5e-5 optimizer = torch.optim.Adam(model.parameters(), lr=learningRate, weight_decay=weightDecay) criterion = nn.CrossEntropyLoss(reduction='none') nepochs = 40 batch_size = 64 if DEVICE == 'cuda' else 1 speech_train, speech_valid, speech_test, transcript_train, transcript_valid = load_data( ) character_text_train = transform_letter_to_index(transcript_train, LETTER_LIST) character_text_valid = transform_letter_to_index(transcript_valid, LETTER_LIST) train_dataset = Speech2TextDataset(speech_train, character_text_train) val_dataset = Speech2TextDataset(speech_valid, character_text_valid) test_dataset = Speech2TextDataset(speech_test, None, False) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_train) val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_train) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_test) model.train() model.load_state_dict(torch.load('./new1.pth')) model.to(DEVICE) scheduler = StepLR(optimizer, step_size=10, gamma=0.5) for epoch in range(nepochs): train(model, train_loader, criterion, optimizer, epoch) scheduler.step() model.eval() data_list = test(model, test_loader) save_to_csv(data_list) print('done')
def main(epochs, batch_size, input_size, hidden_size, num_layers, spatial_num, drop_out, logged=False): DEVICE = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') print('DEVICE: ', DEVICE) date = '06_03' group = 1 sorted_ = True # sorted_ = False # load data from '.npy' file # x_train, x_test, y_train, y_test = load_group_eeg_data(date, group, sorted_=sorted_) x_train, x_test, y_train, y_test = load_combined_eeg_data(date, sorted_=sorted_) # x: (N, C, T) N: trials C: channels T: times train_num, test_num = x_train.shape[0], x_test.shape[0] # make dataset for train and test train_data = MyDataset(x_train, x_test, y_train, y_test) test_data = MyDataset(x_train, x_test, y_train, y_test, train=False) train_loader = DataLoader(train_data, batch_size=batch_size) test_loader = DataLoader(test_data, batch_size=batch_size) # model initiation # model = LSTM(num_classes=2, input_size=64, hidden_size=256, num_layers=2) # model = LSTM_CNN(num_classes=2, channels=x_train.shape[1], input_size=input_size, hidden_size=hidden_size, # num_layers=num_layers, spatial_num=spatial_num, drop_out=drop_out) # model = LSTM_CNN_Half(num_classes=2, batch_size=batch_size, T=x_train.shape[-1], # C=x_train.shape[-2], input_size=input_size, hidden_size=hidden_size, # num_layers=num_layers, spatial_num=spatial_num) model = LSTM_CNN_Spatial(num_classes=2, batch_size=batch_size, T=x_train.shape[-1], C=x_train.shape[-2], input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, spatial_num=spatial_num) model = model.to(DEVICE) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters()) log = [] if logged: log.append(f'{epochs}\t{batch_size}\t{input_size}\t{hidden_size}\t' f'{num_layers}\t{spatial_num}\t{drop_out}\t') train(model, criterion, optimizer, train_loader, DEVICE,train_num, epochs, logged) test(model, criterion, test_loader, DEVICE, test_num, log, logged)
def run_joint_tasks(data_dir): """ Train and test for all tasks but the trained model is built using training data from all tasks. """ print("Jointly train and test for all tasks ...") tasks = range(20) # Parse training data train_data_path = [] for t in tasks: train_data_path += glob.glob('%s/qa%d_*_train.txt' % (data_dir, t + 1)) dictionary = {"nil": 0} train_story, train_questions, train_qstory = parse_babi_task( train_data_path, dictionary, False) # Parse test data for each task so that the dictionary covers all words before training for t in tasks: test_data_path = glob.glob('%s/qa%d_*_test.txt' % (data_dir, t + 1)) parse_babi_task(test_data_path, dictionary, False) # ignore output for now general_config = BabiConfigJoint(train_story, train_questions, dictionary) memory, model, loss = build_model(general_config) if general_config.linear_start: train_linear_start(train_story, train_questions, train_qstory, memory, model, loss, general_config) else: train(train_story, train_questions, train_qstory, memory, model, loss, general_config) # Test on each task for t in tasks: print("Testing for task %d ..." % (t + 1)) test_data_path = glob.glob('%s/qa%d_*_test.txt' % (data_dir, t + 1)) dc = len(dictionary) test_story, test_questions, test_qstory = parse_babi_task( test_data_path, dictionary, False) assert dc == len( dictionary ) # make sure that the dictionary already covers all words test(test_story, test_questions, test_qstory, memory, model, loss, general_config)
def run(args): if USE_CUDA: print("Using cuda...") else: print("Suggest using cuda, break now...") phone_map = make_phone_map() phone2index, index2phone, index2char = make_phone_char() label = make_label(phone2index) if args.test: test(args.test, args.feature, args.model, args.hidden, args.layer, args.output, index2char, index2phone, phone_map, phone2index) elif args.loss: train_loss(args.loss) else: train(args.feature, label, args.epochs, args.model, args.layer, args.hidden, args.save, args.postfix, index2char, index2phone, phone_map, phone2index)
def main(): # Check device available device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print("Running on: {}".format(device)) # parse and print arguments args = make_args_parser() print_args(args) # Load both source and target domain datasets source_dataloader = datasets.get_source_domain(args.source) target_dataloader = datasets.get_target_domain(args.target) # Create directory to save model's checkpoints try: model_root = MODEL_CHECKPOINTS + args.source + '-' + args.target os.makedirs(model_root) except OSError as e: if e.errno == errno.EEXIST: pass else: raise # Init model if args.model == 'MultibranchLeNet': net = models.MultibranchLeNet() architectures = ['conv1_d', 'conv1_t', 'conv2_d', 'conv2_t'] if device == 'cuda': net.cuda() # Init losses class_loss = torch.nn.NLLLoss() domain_loss = torch.nn.NLLLoss() if device == 'cuda': class_criterion.cuda() domain_criterion.cuda() # Init optimizer optimizer = optim.SGD(net.parameters(), lr=constants.LR, momentum=constants.MOMENTUM) # Init all parameters to be optimized using Backpropagation for param in net.parameters(): param.requires_grad = True # Train model for epoch in range(constants.N_EPOCHS): train_test.train(net, class_loss, domain_loss, source_dataloader, target_dataloader, optimizer, epoch, model_root, device) train_test.test(net, source_dataloader, target_dataloader, device)
def main(): ''' run the experiment ''' global env logging.info("Started...") env = utils.make_env(config) n_actions = env.action_space.n qnet = Qnet(n_actions, embedding_size=config.embedding_size).to(device) target_net = Qnet(n_actions, embedding_size=config.embedding_size).to(device) target_net.load_state_dict(qnet.state_dict()) target_net.eval() replay_buffer = ReplayBuffer(config.replay_buffer_size, config.embedding_size, config.path_length) optimizer = torch.optim.Adam(qnet.parameters(), lr=config.lr) value_buffer = ValueBuffer(config.value_buffer_size) train(env, qnet, target_net, optimizer, replay_buffer, value_buffer, config, device)
def main(): args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) device = torch.device("cuda" if use_cuda else "cpu") kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {} train_loader = torch.utils.data.DataLoader(datasets.MNIST( '/tmp', train=True, download=True, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ])), batch_size=args.batch_size, shuffle=True, **kwargs) test_loader = torch.utils.data.DataLoader(datasets.MNIST( '/tmp', train=False, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ])), batch_size=args.test_batch_size, shuffle=True, **kwargs) model = fc.Net().to(device) optimizer = optim.SGD(model.parameters(), lr=args.lr) for epoch in range(1, args.epochs + 1): train(args, model, device, train_loader, optimizer, args.epochs, epoch) test(args, model, device, test_loader) print_nonzeros(model)
def main(nets, net_name, data_info, batch_size, epochs, num_iteration, logged=False): # num_classes = date_info['num_classes'] subject_id = data_info['subject_id'] edge_type = data_info['edge_type'] feature_type = data_info['feature_type'] num_features = data_info['num_features'] sorted_ = data_info['sorted'] train_loader = gen_dataloader(data_info['train_lis'], batch_size=batch_size) test_loader = gen_dataloader(data_info['test_lis'], batch_size=batch_size) for i in trange(num_iteration): # model initiation if net_name == 'tag_jk' or net_name == 'tag_jk_learn': model = nets[net_name](num_features, 4).to(device) elif net_name == 'tag_lstm': model = nets[net_name]().to(device) else: model = nets[net_name](num_features).to(device) # criterion = torch.nn.BCELoss() # criterion = torch.nn.CrossEntropyLoss(weight=torch.tensor([1.0, 0.5]).to(device)) criterion = torch.nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters()) log = [] if logged: if len(subject_id) > 2: log.append(f'{subject_id}\t{sorted_}\t{edge_type:<6s}\t{feature_type:<6s}\t' f'{net_name:<8s}\t{batch_size:<4d}\t{epochs:<4d}\t') else: log.append(f's{subject_id:02d}\t{edge_type:<6s}\t{feature_type:<6s}\t' f'{net_name:<8s}\t{batch_size:<4d}\t{epochs:<4d}\t') train(model, criterion, optimizer, train_loader, device, data_info['train_num'], epochs, logged) test(model, criterion, test_loader, device, data_info['test_num'], log, logged)
def train_new_model(): (train_data, author_frame, domain_frame, subreddit_frame) = load_data(path) (self.trained_model, cross_validation_frame, test_frame) = train(train_frame, author_frame, domain_frame, subreddit_frame) if cross_valid == 1: cross_validation(self.trained_model, cross_validation) test(trained_model, test_frame) def predict(self, X): self.trained_model.predict(X)
def train(): torch.set_default_tensor_type(torch.FloatTensor) # net = model.Net().cuda() net = torchvision.models.resnet18(pretrained=True) num_ftrs = net.fc.in_features net.fc = nn.Linear(num_ftrs, 2) net=net.cuda() criterion = nn.MSELoss() optimizer = optim.Adam(net.parameters(), lr=0.00001) dir, xy = dir_xy.get_all(img_path='data/train', label_path='data/label/train.json') loader = ImageLoader.myImageFloder(dir, xy) TrainImgLoader = torch.utils.data.DataLoader(loader,batch_size=10,shuffle = True) dir, xy = dir_xy.get_all(img_path='data/test', label_path='data/label/test.json') loader2 = ImageLoader.myImageFloder(dir, xy) TestImgLoader = torch.utils.data.DataLoader(loader2) train_test.train(net=net.cuda(), criterion=criterion, optimizer=optimizer, TrainImgLoader=TrainImgLoader, TestImgLoader=TestImgLoader)
def main(m): best_error = 100 opt = parser_params() if opt.dataset == 'cifar10': train_loader, test_loader = cifar10_dataloaders( batch_size=opt.batch_size, num_workers=opt.num_workers) n_cls = 10 else: raise NotImplementedError(opt.dataset) print(opt.model[m]) model = model_dict[opt.model[m]](num_classes=n_cls) optimizer = optim.SGD(model.parameters(), lr=opt.learning_rate, momentum=opt.momentum, weight_decay=opt.weight_decay) criterion = nn.CrossEntropyLoss() if torch.cuda.is_available(): model = model.cuda() criterion = criterion.cuda() cudnn.benchmark = True for epoch in range(1, opt.epochs + 1): if m == 4 and epoch == 1: opt.learning_rate = 0.01 else: opt.learning_rate = 0.1 adjust_learning_rate(epoch, opt, optimizer) print("==> training...") train_error, train_loss = train(epoch, train_loader, model, criterion, optimizer, list_loss_train[m]) print('epoch {} | train_loss: {}'.format(epoch, train_loss)) print('epoch {} | train_error: {}'.format(epoch, train_error)) test_error, test_loss = test(test_loader, model, criterion, list_loss_test[m]) print('epoch {} | test_loss: {}'.format(epoch, test_loss)) print('epoch {} | test_error: {}'.format(epoch, test_error)) print('iterations: {}'.format(epoch * len(train_loader))) if best_error > test_error: best_error = test_error print('Min error: ', best_error)
def run_joint_tasks(data_dir): """ Train and test for all tasks but the trained model is built using training data from all tasks. """ print("Jointly train and test for all tasks ...") tasks = range(20) # Parse training data train_data_path = [] for t in tasks: train_data_path += glob.glob('%s/qa%d_*_train.txt' % (data_dir, t + 1)) dictionary = {"nil": 0} train_story, train_questions, train_qstory = parse_babi_task(train_data_path, dictionary, False) # Parse test data for each task so that the dictionary covers all words before training for t in tasks: test_data_path = glob.glob('%s/qa%d_*_test.txt' % (data_dir, t + 1)) parse_babi_task(test_data_path, dictionary, False) # ignore output for now general_config = BabiConfigJoint(train_story, train_questions, dictionary) memory, model, loss = build_model(general_config) if general_config.linear_start: train_linear_start(train_story, train_questions, train_qstory, memory, model, loss, general_config) else: train(train_story, train_questions, train_qstory, memory, model, loss, general_config) # Test on each task for t in tasks: print("Testing for task %d ..." % (t + 1)) test_data_path = glob.glob('%s/qa%d_*_test.txt' % (data_dir, t + 1)) dc = len(dictionary) test_story, test_questions, test_qstory = parse_babi_task(test_data_path, dictionary, False) assert dc == len(dictionary) # make sure that the dictionary already covers all words test(test_story, test_questions, test_qstory, memory, model, loss, general_config)
def run_task(data_dir, task_id): """ Train and test for each task """ print("Train and test for task %d ..." % task_id) # Parse data train_files = glob.glob('%s/qa%d_*_train.txt' % (data_dir, task_id)) test_files = glob.glob('%s/qa%d_*_test.txt' % (data_dir, task_id)) dictionary = {"nil": 0} train_story, train_questions, train_qstory = parse_babi_task(train_files, dictionary, False) test_story, test_questions, test_qstory = parse_babi_task(test_files, dictionary, False) general_config = BabiConfig(train_story, train_questions, dictionary) memory, model, loss = build_model(general_config) if general_config.linear_start: train_linear_start(train_story, train_questions, train_qstory, memory, model, loss, general_config) else: train(train_story, train_questions, train_qstory, memory, model, loss, general_config) test(test_story, test_questions, test_qstory, memory, model, loss, general_config)
def run_tableQA(data_path, model_file): """ Train and test for table QA """ # Parse data train_files = glob.glob(data_path.format('train')) test_files = glob.glob(data_path.format('test')) # SV: init dict with pre-trained vectors, e.g. from fastText # dictionary = fasttext.load_model(EMBEDDINGS_MODEL_PATH) dictionary = {"nil": 0} train_story, train_questions, train_qstory = parse_babi_task( train_files, dictionary, False) test_story, test_questions, test_qstory = parse_babi_task( test_files, dictionary, False) # print test_questions print 'Dictionary:', len(dictionary) general_config = BabiConfig(train_story, train_questions, dictionary) memory, model, loss = build_model(general_config) if general_config.linear_start: train_linear_start(train_story, train_questions, train_qstory, memory, model, loss, general_config) else: train(train_story, train_questions, train_qstory, memory, model, loss, general_config) test(test_story, test_questions, test_qstory, memory, model, loss, general_config) # save_model with gzip.open(model_file, "wb") as f: print("Saving model to file %s ..." % model_file) reversed_dict = dict((ix, w) for w, ix in dictionary.items()) pickle.dump((reversed_dict, memory, model, loss, general_config), f)
def main(): # Train classifiers using training samples train_pos_dir = "VJ_dataset\\trainset\\faces" train_neg_dir = "VJ_dataset\\trainset\\non-faces" rounds = 10 cascade = train( train_pos_dir, train_neg_dir, rounds ) # Save training results save_cascade(cascade) # Test with test samples test_pos_dir = "VJ_dataset\\testset\\faces" test_neg_dir = "VJ_dataset\\testset\\faces" test( test_pos_dir, test_neg_dir, cascade, 10 )
def run(subject, steps): # ===========================PROCESSING START=============================== processing_start = time.time() X_Data, Y_Data = process_data(subject, steps) enc = preprocessing.OneHotEncoder(categories='auto') enc.fit(Y_Data) Y_Data = enc.transform(Y_Data).toarray() X_train, X_test, Y_train, Y_test = train_test_split(X_Data, Y_Data, test_size=0.25) processing_end = time.time() print("Preprocessed data in: %.2f sec\n" % (processing_end - processing_start)) # ===========================TRAINING START=============================== # train_start = time.time() model = train(X_train, Y_train) # save_model(model, "model_roi1_6steps.json") # model = load_model("model_roi1_5steps.json") f1, acc = evaluate(model, X_test, Y_test) # train_end = time.time() # print("Train and test in: %.2f sec" % (train_end - train_start)) # ===========================TRAINING END=============================== # result = { # "processing_start": processing_start, # "processing_end": processing_end, # "train_start": train_start, # "train_end": train_end # } # # with open("timestamps.json", "w") as outfile: # json.dump(result, outfile) return subject, steps, f1, acc
def run_epochs(model, train_dataloader, validation_dataloader, optimizer, scheduler, epochs): start_time = time.time() train_losses, train_accs = [], [] test_losses, test_accs = [], [] for epoch in range(epochs): print('======== Epoch %d ========' % epoch) train_loss, train_acc = train(model, train_dataloader, optimizer, scheduler) train_losses.append(train_loss) train_accs.append(train_acc) test_loss, test_acc = test(model, validation_dataloader) test_losses.append(test_loss) test_accs.append(test_acc) print("Total training took %.2f seconds" % (time.time() - start_time)) return train_losses, train_accs, test_losses, test_accs
def run(model, optimizer, criterion, train_loader, dev_loader, nepochs): train_losses, train_accs = [], [] test_losses, test_accs = [], [] epochs = [] for e in range(nepochs): print('----- EPOCH %d ------- \n' % e) start_time = time.time() # Train train_loss, train_acc = train(train_loader, model, criterion, optimizer) train_losses.append(train_loss) train_accs.append(train_acc) # Test test_loss, test_acc = test(dev_loader, model, criterion) test_losses.append(test_loss) test_accs.append(test_acc) print(train_loss, train_acc, test_loss, test_acc) return train_losses, train_accs, test_losses, test_accs
print("Loading %s" % data_cv_path) data_cv = pickle.load(open(data_cv_path, 'rb')) data_cv_splits = data_cv['cv_splits'] results = [] ### 3. Sets-Up Main Loop for k, data in data_cv_splits.items(): print("*******************************************") print("************** SPLIT (%d/%d) **************" % (k, len(data_cv_splits.items()))) print("*******************************************") if os.path.exists(os.path.join(opt.checkpoints_dir, opt.exp_name, opt.model_name, '%s_%d_patch_pred_train.pkl' % (opt.model_name, k))): print("Train-Test Split already made.") continue ### 3.1 Trains Model model, optimizer, metric_logger = train(opt, data, device, k) ### 3.2 Evalutes Train + Test Error, and Saves Model loss_train, cindex_train, pvalue_train, surv_acc_train, grad_acc_train, pred_train = test(opt, model, data, 'train', device) loss_test, cindex_test, pvalue_test, surv_acc_test, grad_acc_test, pred_test = test(opt, model, data, 'test', device) if opt.task == 'surv': print("[Final] Apply model to training set: C-Index: %.10f, P-Value: %.10e" % (cindex_train, pvalue_train)) logging.info("[Final] Apply model to training set: C-Index: %.10f, P-Value: %.10e" % (cindex_train, pvalue_train)) print("[Final] Apply model to testing set: C-Index: %.10f, P-Value: %.10e" % (cindex_test, pvalue_test)) logging.info("[Final] Apply model to testing set: cC-Index: %.10f, P-Value: %.10e" % (cindex_test, pvalue_test)) results.append(cindex_test) elif opt.task == 'grad': print("[Final] Apply model to training set: Loss: %.10f, Acc: %.4f" % (loss_train, grad_acc_train)) logging.info("[Final] Apply model to training set: Loss: %.10f, Acc: %.4f" % (loss_train, grad_acc_train)) print("[Final] Apply model to testing set: Loss: %.10f, Acc: %.4f" % (loss_test, grad_acc_test))
def train(self): """ Train MemN2N model using training data for tasks. """ #np.random.seed(42) # for reproducing np.random.seed(self.rnd_seed) # for reproducing print("np.random.seed: %d" % self.rnd_seed) assert self.data_dir is not None, "data_dir is not specified." print("Reading data from %s ..." % self.data_dir) # Parse training data train_data_path = glob.glob('%s/qa*_*_train.txt' % self.data_dir) dictionary = {"nil": 0} train_story, train_questions, train_qstory = parse_babi_task(train_data_path, dictionary, False) # Parse test data just to expand the dictionary so that it covers all words in the test data too test_data_path = glob.glob('%s/qa*_*_test.txt' % self.data_dir) parse_babi_task(test_data_path, dictionary, False) # Get reversed dictionary mapping index to word self.reversed_dict = dict((ix, w) for w, ix in dictionary.items()) # Construct model #self.general_config = Babi10kConfigJoint(train_story, train_questions, dictionary) self.general_config = BabiConfigJoint(train_story, train_questions, dictionary) self.memory, self.model, self.loss = build_model(self.general_config) # Train model if self.general_config.linear_start: print('We will use LS training') self.best_model, self.best_memory = \ train_linear_start(train_story, train_questions, train_qstory, self.memory, self.model, self.loss, self.general_config, self.log_path) else: train_logger = open(os.path.join(self.log_path, 'train.log'), 'w') train_logger.write('epoch batch_iter lr loss err\n') train_logger.flush() val_logger = open(os.path.join(self.log_path, 'val.log'), 'w') val_logger.write('epoch batch_iter lr loss err\n') val_logger.flush() global_batch_iter = 0 train_logger, val_logger, self.best_model, self.best_memory, _ = \ train(train_story, train_questions, train_qstory, self.memory, self.model, self.loss, self.general_config, train_logger, val_logger, global_batch_iter) train_logger.close() val_logger.close() # Save model self.save_model()
criterion = nn.CrossEntropyLoss(reduction='none') optim_backbone = optim.SGD(models['backbone'].parameters(), lr=LR, momentum=MOMENTUM, weight_decay=WDECAY) sched_backbone = lr_scheduler.MultiStepLR(optim_backbone, milestones=MILESTONES) optimizers = {'backbone': optim_backbone} schedulers = {'backbone': sched_backbone} if method == 'lloss': optim_module = optim.SGD(models['module'].parameters(), lr=LR, momentum=MOMENTUM, weight_decay=WDECAY) sched_module = lr_scheduler.MultiStepLR(optim_module, milestones=MILESTONES) optimizers = {'backbone': optim_backbone, 'module': optim_module} schedulers = {'backbone': sched_backbone, 'module': sched_module} # Training and testing train(models, method, criterion, optimizers, schedulers, dataloaders, args.no_of_epochs, EPOCHL) acc = test(models, EPOCH, method, dataloaders, mode='test') print('Trial {}/{} || Cycle {}/{} || Label set size {}: Test acc {}'.format(trial+1, TRIALS, cycle+1, CYCLES, len(labeled_set), acc)) np.array([method, trial+1, TRIALS, cycle+1, CYCLES, len(labeled_set), acc]).tofile(results, sep=" ") results.write("\n") if cycle == (CYCLES-1): # Reached final training cycle print("Finished.") break # Get the indices of the unlabeled samples to train on next cycle arg = query_samples(models, method, data_unlabeled, subset, labeled_set, cycle, args) # Update the labeled dataset and the unlabeled dataset, respectively labeled_set += list(torch.tensor(subset)[arg][-ADDENDUM:].numpy())