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