def setup(cuda, device_id=0, wt_load='NIL'): if cuda: torch.cuda.set_device(device_id) train_data_loader = data_loader.dataloader(gv.batch_limit, gv.train_start_index, gv.train_end_index) val_data_loader = data_loader.dataloader(gv.batch_limit, gv.val_start_index, gv.val_end_index) network = GRU.network(3, gv.hidden_1_size, gv.output_size) network.cuda() # init the network with orthogonal init and gluroot. if wt_load == "NIL": network.wt_init() else: pass # load wts if required. # Optimizer optimizer = torch.optim.Adam(network.parameters(), gv.orig_lr, weight_decay=gv.weight_decay) # for le rumours cudnn.benchmark = True train_writer = SummaryWriter( os.path.join(gv.tensorboardX_dir, gv.exp_name, 'train')) val_writer = SummaryWriter( os.path.join(gv.tensorboardX_dir, gv.exp_name, 'val')) return train_data_loader, val_data_loader, network, optimizer, train_writer, val_writer
def main(config): ## TODO: This is temporary solution if config.exec_data_setter: args = config.dataset.split() call(['bash', 'data_setter.sh', args[0], args[1]]) ## TODO data_loader = dataloader(config.dataset, config.img_rootpath, config.img_size, config.batch_size) ## TODO else: data_loader = dataloader(config.dataset, config.img_rootpath, config.img_size, config.batch_size) if config.train: if config.model == 'can': trainer = Trainer(data_loader.loader(), config) trainer.train() else: ## TODO: short tester pass
def __init__(self, args): self.data_loader = dataloader(args) self.channel = args.channel self.n_feats = args.n_feats self.mode = args.mode self.batch_size = args.batch_size self.num_of_down_scale = args.num_of_down_scale self.gen_resblocks = args.gen_resblocks self.discrim_blocks = args.discrim_blocks self.vgg_path = args.vgg_path self.learning_rate = args.learning_rate self.decay_step = args.decay_step
def __init__(self, args): self.data_loader = dataloader(args) self.channel = args.channel self.scale = args.scale self.n_feats = args.n_feats self.n_ARDB = args.n_ARDB self.n_ARDG = args.n_ARDG self.kernel_size = args.kernel_size self.ratio = args.ratio self.in_memory = args.in_memory self.learning_rate = args.learning_rate self.decay_step = args.decay_step self.decay_rate = args.decay_rate self.mode = args.mode self.batch_size = args.batch_size self.rgb_mean = [0.4488, 0.4371, 0.4040]
def __init__(self,hyperparameters): super(Model,self).__init__() self.device = hyperparameters['device'] self.auxiliary_data_source = hyperparameters['auxiliary_data_source'] self.all_data_sources = ['resnet_features',self.auxiliary_data_source] self.DATASET = hyperparameters['dataset'] self.num_shots = hyperparameters['num_shots'] self.latent_size = hyperparameters['latent_size'] self.batch_size = hyperparameters['batch_size'] self.hidden_size_rule = hyperparameters['hidden_size_rule'] self.warmup = hyperparameters['model_specifics']['warmup'] self.generalized = hyperparameters['generalized'] self.classifier_batch_size = 32 self.img_seen_samples = hyperparameters['samples_per_class'][self.DATASET][0] self.att_seen_samples = hyperparameters['samples_per_class'][self.DATASET][1] self.att_unseen_samples = hyperparameters['samples_per_class'][self.DATASET][2] self.img_unseen_samples = hyperparameters['samples_per_class'][self.DATASET][3] self.reco_loss_function = hyperparameters['loss'] self.nepoch = hyperparameters['epochs'] self.lr_cls = hyperparameters['lr_cls'] self.cross_reconstruction = hyperparameters['model_specifics']['cross_reconstruction'] self.cls_train_epochs = hyperparameters['cls_train_steps'] self.dataset = dataloader( self.DATASET, copy.deepcopy(self.auxiliary_data_source) , device= self.device ) if self.DATASET=='CUB': self.num_classes=200 self.num_novel_classes = 50 elif self.DATASET=='SUN': self.num_classes=717 self.num_novel_classes = 72 elif self.DATASET=='AWA1' or self.DATASET=='AWA2': self.num_classes=50 self.num_novel_classes = 10 elif self.DATASET=='plant': self.num_classes=38 self.num_novel_classes = 13 feature_dimensions = [2048, self.dataset.aux_data.size(1)] # Here, the encoders and decoders for all modalities are created and put into dict self.encoder = {} for datatype, dim in zip(self.all_data_sources,feature_dimensions): self.encoder[datatype] = models.encoder_template(dim,self.latent_size,self.hidden_size_rule[datatype],self.device) print(str(datatype) + ' ' + str(dim)) self.decoder = {} for datatype, dim in zip(self.all_data_sources,feature_dimensions): self.decoder[datatype] = models.decoder_template(self.latent_size,dim,self.hidden_size_rule[datatype],self.device) # An optimizer for all encoders and decoders is defined here parameters_to_optimize = list(self.parameters()) for datatype in self.all_data_sources: parameters_to_optimize += list(self.encoder[datatype].parameters()) parameters_to_optimize += list(self.decoder[datatype].parameters()) self.optimizer = optim.Adam( parameters_to_optimize ,lr=hyperparameters['lr_gen_model'], betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=True) if self.reco_loss_function=='l2': self.reconstruction_criterion = nn.MSELoss(size_average=False) elif self.reco_loss_function=='l1': self.reconstruction_criterion = nn.L1Loss(size_average=False)
parser.add_argument('--bidirectional', required=False, default=True, type=bool) parser.add_argument('--dropout', required=False, default=0.5, type=float) args = parser.parse_args() print(args) # save the result into a dictionary result = dict() # training and evaluate for tokenizer_name, tokenizer in zip(tokenizer_names, tokenizers): print(f'-------------------------------------------------------------') print(f'Data loading with {tokenizer_name} tokenizer...') start_time = time.time() TEXT, LABEL, train_iterator, test_iterator = dataloader(tokenizer, args.max_vocab_size, args.batch_size, device) input_dim = len(TEXT.vocab) print(f'The number of vocabularies is {input_dim}.') end_time = time.time() data_loading_time = round(end_time - start_time,3) data_prep_mins, data_prep_secs = epoch_time(start_time, end_time) print(f'Data loading Time: {data_prep_mins}m {data_prep_secs}s') pad_idx = TEXT.vocab.stoi[TEXT.pad_token] model = RNN(input_dim, args.embedding_dim, args.hidden_dim, 1, args.n_layers, args.bidirectional, args.dropout, pad_idx) model.embedding.weight.data[pad_idx] = torch.zeros(args.embedding_dim)
def main(): print("Loading data ...") prefix = 'valid' x_train, y_train, x_valid, y_valid, train_bbox, valid_bbox, xTest, yTest, Test_bbox = data_loader.dataloader( prefix) print("Shape:", x_train.shape, y_train.shape, x_valid.shape, y_valid.shape, train_bbox.shape, valid_bbox.shape) #task = "detection" task = 'classify' # Classification #train(x_train, y_train, x_valid, y_valid, train_bbox, valid_bbox, task) np.random.seed(0) acc = test(xTest, yTest, Test_bbox, task) np.random.seed() print("Test accuracy is : " + str(acc))
def __init__(self, hyperparameters): super(Model, self).__init__() self.device = hyperparameters['device'] self.auxiliary_data_source = hyperparameters['auxiliary_data_source'] self.all_data_sources = ['resnet_features', self.auxiliary_data_source] self.DATASET = hyperparameters['dataset'] self.num_shots = hyperparameters['num_shots'] self.latent_size = hyperparameters['latent_size'] self.batch_size = hyperparameters['batch_size'] self.hidden_size_rule = hyperparameters['hidden_size_rule'] self.warmup = hyperparameters['model_specifics']['warmup'] self.generalized = hyperparameters['generalized'] self.classifier_batch_size = 32 self.img_seen_samples = hyperparameters['samples_per_class'][ self.DATASET][0] self.att_seen_samples = hyperparameters['samples_per_class'][ self.DATASET][1] self.att_unseen_samples = hyperparameters['samples_per_class'][ self.DATASET][2] self.img_unseen_samples = hyperparameters['samples_per_class'][ self.DATASET][3] self.reco_loss_function = hyperparameters['loss'] self.nepoch = hyperparameters['epochs'] self.lr_cls = hyperparameters['lr_cls'] self.cross_reconstruction = hyperparameters['model_specifics'][ 'cross_reconstruction'] self.cls_train_epochs = hyperparameters['cls_train_steps'] self.dataset = dataloader(self.DATASET, copy.deepcopy(self.auxiliary_data_source), device=self.device) self.writer = SummaryWriter() self.num_gen_iter = hyperparameters['num_gen_iter'] self.num_dis_iter = hyperparameters['num_dis_iter'] self.pretrain = hyperparameters['pretrain'] if self.DATASET == 'CUB': self.num_classes = 200 self.num_novel_classes = 50 elif self.DATASET == 'SUN': self.num_classes = 717 self.num_novel_classes = 72 elif self.DATASET == 'AWA1' or self.DATASET == 'AWA2': self.num_classes = 50 self.num_novel_classes = 10 feature_dimensions = [2048, self.dataset.aux_data.size(1)] # Here, the encoders and decoders for all modalities are created and put into dict self.encoder = {} for datatype, dim in zip(self.all_data_sources, feature_dimensions): self.encoder[datatype] = models.encoder_template( dim, self.latent_size, self.hidden_size_rule[datatype], self.device) print(str(datatype) + ' ' + str(dim)) print('latent size ' + str(self.latent_size)) self.decoder = {} for datatype, dim in zip(self.all_data_sources, feature_dimensions): self.decoder[datatype] = models.decoder_template( self.latent_size, dim, self.hidden_size_rule[datatype], self.device) # An optimizer for all encoders and decoders is defined here parameters_to_optimize = list(self.parameters()) for datatype in self.all_data_sources: parameters_to_optimize += list(self.encoder[datatype].parameters()) parameters_to_optimize += list(self.decoder[datatype].parameters()) # The discriminator network is defined here self.net_D_Att = models.Discriminator( self.dataset.aux_data.size(1) + 2048, self.device) self.net_D_Img = models.Discriminator( 2048 + self.dataset.aux_data.size(1), self.device) self.optimizer_G = optim.Adam(parameters_to_optimize, lr=hyperparameters['lr_gen_model'], betas=(0.9, 0.999), eps=1e-08, weight_decay=0.0005, amsgrad=True) self.optimizer_D = optim.Adam(itertools.chain( self.net_D_Att.parameters(), self.net_D_Img.parameters()), lr=hyperparameters['lr_gen_model'], betas=(0.5, 0.999), weight_decay=0.0005) if self.reco_loss_function == 'l2': self.reconstruction_criterion = nn.MSELoss(reduction='sum') elif self.reco_loss_function == 'l1': self.reconstruction_criterion = nn.L1Loss(reduction='sum') self.MSE = nn.MSELoss(reduction='sum') self.L1 = nn.L1Loss(reduction='sum') self.att_fake_from_att_sample = utils.Sample_from_Pool() self.att_fake_from_img_sample = utils.Sample_from_Pool() self.img_fake_from_img_sample = utils.Sample_from_Pool() self.img_fake_from_att_sample = utils.Sample_from_Pool() if self.generalized: print('mode: gzsl') self.clf = LINEAR_LOGSOFTMAX(self.latent_size, self.num_classes) else: print('mode: zsl') self.clf = LINEAR_LOGSOFTMAX(self.latent_size, self.num_novel_classes)
acc = accuracy(output, label) avg_loss += loss avg_acc += acc return (1.0 * avg_loss) / len(test_data), (1.0 * avg_acc) / len(test_data) if __name__ == '__main__': train_path = "./aclImdb/train" test_path = "./aclImdb/test" with open('./word2id.json', 'r') as f: word2id = json.load(f) train_data, test_data = dataloader(word2id, train_path, test_path) model = RNN(word2id, len(word2id), 100, 256, 1) optimizer = optim.SGD(model.parameters(), lr=1e-3) criterion = nn.BCEWithLogitsLoss() num_epochs = 20 for i in range(num_epochs): print("Training") model.to(device) criterion.to(device) train_loss, train_acc = train(train_data, model, optimizer, criterion) print("Evaluating") eval_loss, eval_acc = evaluate(test_data, model, criterion) print( "Training loss: {}, Evaluation loss: {}, Training accuracy: {}, Evlaution accuracy: {}" .format(train_loss, eval_loss, train_acc, eval_acc))
pred = torch.max(outputs, dim=1)[1] correct += pred.eq(targets.view_as(pred)).sum().item() test_loss /= len(test_loader) acc = 100. * correct / len(test_loader.dataset) print(' Epoch {}: Test Loss: {:.4f}, Test Accuracy: {}'.format(epoch + 1, test_loss, acc)) return acc if __name__ == '__main__': # Set data path img_path = './train-images-idx3-ubyte' label_path = './train-labels-idx1-ubyte' test_img_path = './t10k-images-idx3-ubyte' test_label_path = './t10k-labels-idx1-ubyte' # Initiate data loader train_data = data.DataLoader(dataloader(img_path, label_path), batch_size=512, shuffle=True) test_data = data.DataLoader(dataloader(test_img_path, test_label_path), batch_size=512, shuffle=True) # Initiate training parameters model = simpleClassifier() # model = torch.load('./simpleClassifier2_20.pth') # torch.save(model.state_dict(), './simpleClsfier_20.pth') optimizer = Adam(model.parameters()) criterion = CrossEntropyLoss() epochs = 50 pre_acc = 0 acc = 0 # Train for epoch in range(epochs): train(model, train_data, criterion=criterion, optimizer=optimizer, epoch=epoch) # Save the model if test accuracy increase acc = test(model, test_data, criterion, epoch)
if total_num > num_samples_check: break mae = sum(mae_loss_list) / total_num model.train() return mae if __name__ == '__main__': args = parser.parse_args() logger.info('Loading data...') train_dset, train_loader = dataloader(args.train_dir, 'train', use_all=args.use_all, batch_size=args.batch_size, shuffle=True, seq_len=args.seq_len, win_len=args.win_len, sample_rate=args.sample_rate, use_t=(args.t_feature_dim > 0), use_f=(args.f_feature_dim > 0), win_hand_t=args.win_hand_t, win_hand_f=args.win_hand_f) val_dset, val_loader = dataloader(args.train_dir, 'val', use_all=False, batch_size=args.batch_size, shuffle=False, seq_len=args.seq_len, win_len=args.win_len, sample_rate=args.sample_rate, use_t=(args.t_feature_dim > 0), use_f=(args.f_feature_dim > 0),