def main():
# random seed
seed = 1234
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
# load dataset
if args.dataset[0] == 'deepfashion':
ds = pd.read_csv('./Anno/df_info.csv')
from dataset import DeepFashionDataset as DataManager
elif args.dataset[0] == 'fld':
ds = pd.read_csv('./Anno/fld_info.csv')
from dataset import FLDDataset as DataManager
else:
raise ValueError
print('dataset : %s' % (args.dataset[0]))
if not args.evaluate:
train_dm = DataManager(ds[ds['evaluation_status'] == 'train'],
root=args.root)
train_dl = DataLoader(train_dm,
batch_size=args.batchsize,
shuffle=True)
if os.path.exists('models') is False:
os.makedirs('models')
test_dm = DataManager(ds[ds['evaluation_status'] == 'test'],
root=args.root)
test_dl = DataLoader(test_dm, batch_size=args.batchsize, shuffle=False)
# Load model
print("Load the model...")
net = Network(dataset=args.dataset, flag=args.glem).cuda()
if not args.weight_file == None:
weights = torch.load(args.weight_file)
if args.update_weight:
weights = utils.load_weight(net, weights)
net.load_state_dict(weights)
# evaluate only
if args.evaluate:
print("Evaluation only")
test(net, test_dl, 0)
return
# learning parameters
optimizer = torch.optim.Adam(net.parameters(), lr=args.learning_rate)
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 5, 0.1)
print('Start training')
for epoch in range(args.epoch):
lr_scheduler.step()
train(net, optimizer, train_dl, epoch)
test(net, test_dl, epoch)
def main_unsupervised_new(used_labels=None):
trainset = MNIST('train', used_labels)
validset = MNIST('valid', used_labels)
net = Network(trainset.n_classes, feature_size=128)
params = net.parameters()
criterion = LossUnsupervisedNew()
optimizer = optim.SGD
lr_scheduler = MultiStepLR
trainer = SupervisedTrainer(configer,
net,
params,
trainset,
validset,
criterion,
optimizer,
lr_scheduler,
num_to_keep=5,
resume=False,
valid_freq=1,
show_embedding=True)
trainer.train()
del trainer
prox=1).cuda()
elif dim == 3:
model = Network_MLP_Triple(num_ps,
num_qs,
num_rs,
args.embedding_dim,
args.weight_decay,
prox=1).cuda()
elif args.mode == 'proxydarts':
model = Network_MLP(num_users,
num_items,
args.embedding_dim,
args.weight_decay,
prox=2).cuda()
optimizer = torch.optim.Adagrad(model.parameters(), args.lr)
arch_optimizer = torch.optim.Adam(model.arch_parameters(),
args.arch_lr)
losses = []
for train_epoch in range(args.train_epochs):
if dim == 2:
g, gp, loss, loss_valid = train_search(train_queue,
valid_queue, model,
optimizer,
arch_optimizer, args)
elif dim == 3:
g, gp, loss, loss_valid = train_search_triple(
train_queue, valid_queue, model, optimizer, arch_optimizer,
args)
losses.append(loss)
+ '.pth'
model_url = fnmatch.filter(model_urls, pattern)[0]
model_weights_path, results_path = download_model(model_url, ckpt_dir)
df = pd.read_csv(results_path)
row = df.iloc[0]
if args.model in [
'VGG11_bn', 'Resnet18', 'DenseNet3_40', 'LeNet', 'MobileNet'
]:
model = Network().construct(args.model, row)
else:
raise Exception('Unknown model argument: {}'.format(args.model))
if args.print_layers:
total_params = sum(p.numel() for p in model.parameters()
if p.requires_grad)
print('Total number of parameters: ', total_params, '\nlayers:')
pp.pprint(list(name for (name, _) in model.named_parameters()))
exit(code=0)
state_dict = torch.load(model_weights_path,
map_location=lambda storage, loc: storage)
if args.new:
state_dict = state_dict['model']
model.load_state_dict(state_dict, strict=True)
model = model.to(device)
model = model.eval()
mean, std = get_mean_std(args.dataset)
def main(args):
# Device
device = ("cuda" if torch.cuda.is_available() else "cpu")
print("Device: ", device)
# Transform, Dataset and Dataloaders
transform = transforms.Compose([transforms.ToTensor()])
train_datasets, test_datasets = {}, {}
train_loaders, test_loaders = {}, {}
permute_idx = [i for i in range(28 * 28)]
for i in range(args.num_tasks):
train_datasets[i] = PermutedMNIST(transform=transform,
train=True,
permute_idx=permute_idx)
train_loaders[i] = torch.utils.data.DataLoader(
train_datasets[i], batch_size=args.batch_size, shuffle=True)
test_datasets[i] = PermutedMNIST(transform=transform,
train=False,
permute_idx=permute_idx)
test_loaders[i] = torch.utils.data.DataLoader(
test_datasets[i], batch_size=args.batch_size, shuffle=True)
random.shuffle(permute_idx)
# Model, Optimizer, Criterion, ewc_class if needed
model = Network().to(device)
optimizer = optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()
ewc_class = None
# Recoders
train_losses, train_accs, test_losses, test_accs = {}, {}, {}, {}
# Train Proper
for i in range(args.num_tasks):
print("Currently Training on Task {}".format(i + 1))
curr_task = i
# Initialize per task recorders
train_losses[i], train_accs[i], test_losses[i], test_accs[
i] = [], [], [], []
NUM_EPOCHS = args.num_epochs_per_task
for epoch in range(NUM_EPOCHS):
# Train
train_loss, train_acc = train(model, optimizer, criterion,
train_loaders[i], device,
args.ewc_train, ewc_class,
args.ewc_weight, curr_task)
print("[Train Epoch {:>5}/{}] loss: {:>0.4f} | acc: {:>0.4f}".
format(epoch, NUM_EPOCHS, train_loss, train_acc))
# Record Loss
train_losses[i].append(train_loss)
train_accs[i].append(train_acc)
# Test
for j in range(i + 1):
test_loss, test_acc = test(model, criterion, test_loaders[j],
device)
print(
"[ Test Epoch {:>5}/{}] loss: {:>0.4f} | acc: {:>0.4f} [Task {}]"
.format(epoch, NUM_EPOCHS, test_loss, test_acc, j))
test_losses[j].append(test_loss)
test_accs[j].append(test_acc)
if (args.ewc_train):
# Consolidate
ewc_class = EWC(model, train_loaders, curr_task, device)
# Save Losses and Accuracies
suffixes = "{}_{}_{}_{}_{}".format(str(args.num_tasks),
str(args.num_epochs_per_task),
str(args.ewc_weight),
"ewc" if args.ewc_train else "std",
args.custom_suffix)
torch.save(train_losses, "train_losses_{}.txt".format(suffixes))
torch.save(train_accs, "train_accs_{}.txt".format(suffixes))
torch.save(test_losses, "test_losses_{}.txt".format(suffixes))
torch.save(test_accs, "test_accs_{}.txt".format(suffixes))
def train(train_feats,
train_caps,
val_feats,
val_caps,
train_prefix="",
val_prefix="",
epochs=EPOCHS,
batch_size=BATCH_SIZE,
max_seq_len=MAX_LEN,
hidden_dim=HIDDEN_DIM,
emb_dim=EMB_DIM,
enc_seq_len=ENC_SEQ_LEN,
enc_dim=ENC_DIM,
clip_val=CLIP_VAL,
teacher_force=TEACHER_FORCE_RAT,
dropout_p=0.1,
attn_activation="relu",
epsilon=0.0005,
weight_decay=WEIGHT_DECAY,
lr=LEARNING_RATE,
early_stopping=True,
scheduler="step",
attention=None,
deep_out=False,
checkpoint="",
out_dir="Pytorch_Exp_Out",
decoder=None):
print("EXPERIMENT START ", time.asctime())
if not os.path.exists(out_dir):
os.mkdir(out_dir)
# 1. Load the data
train_captions = open(train_caps, mode='r', encoding='utf-8') \
.read().strip().split('\n')
train_features = open(train_feats, mode='r').read().strip().split('\n')
train_features = [os.path.join(train_prefix, z) for z in train_features]
assert len(train_captions) == len(train_features)
if val_caps:
val_captions = open(val_caps, mode='r', encoding='utf-8') \
.read().strip().split('\n')
val_features = open(val_feats, mode='r').read().strip().split('\n')
val_features = [os.path.join(val_prefix, z) for z in val_features]
assert len(val_captions) == len(val_features)
# 2. Preprocess the data
train_captions = normalize_strings(train_captions)
train_data = list(zip(train_captions, train_features))
train_data = filter_inputs(train_data)
print("Total training instances: ", len(train_data))
if val_caps:
val_captions = normalize_strings(val_captions)
val_data = list(zip(val_captions, val_features))
val_data = filter_inputs(val_data)
print("Total validation instances: ", len(val_data))
vocab = Vocab()
vocab.build_vocab(map(lambda x: x[0], train_data), max_size=10000)
vocab.save(path=os.path.join(out_dir, 'vocab.txt'))
print("Vocabulary size: ", vocab.n_words)
# 3. Initialize the network, optimizer & loss function
net = Network(hid_dim=hidden_dim,
out_dim=vocab.n_words,
sos_token=0,
eos_token=1,
pad_token=2,
teacher_forcing_rat=teacher_force,
emb_dim=emb_dim,
enc_seq_len=enc_seq_len,
enc_dim=enc_dim,
dropout_p=dropout_p,
deep_out=deep_out,
decoder=decoder,
attention=attention)
net.to(DEVICE)
if checkpoint:
net.load_state_dict(torch.load(checkpoint))
optimizer = torch.optim.Adam(net.parameters(),
lr=lr,
weight_decay=weight_decay)
loss_function = nn.NLLLoss()
scheduler = set_scheduler(scheduler, optimizer)
# 4. Train
prev_val_l = sys.maxsize
total_instances = 0
total_steps = 0
train_loss_log = []
train_loss_log_batches = []
train_penalty_log = []
val_loss_log = []
val_loss_log_batches = []
val_bleu_log = []
prev_bleu = sys.maxsize
train_data = DataLoader(captions=map(lambda x: x[0], train_data),
sources=map(lambda x: x[1], train_data),
batch_size=batch_size,
vocab=vocab,
max_seq_len=max_seq_len)
if val_caps:
val_data = DataLoader(captions=map(lambda x: x[0], val_data),
sources=map(lambda x: x[1], val_data),
batch_size=batch_size,
vocab=vocab,
max_seq_len=max_seq_len,
val_multiref=True)
training_start_time = time.time()
for e in range(1, epochs + 1):
print("Epoch ", e)
tfr = _teacher_force(epochs, e, teacher_force)
# train one epoch
train_l, inst, steps, t, l_log, pen = train_epoch(
model=net,
loss_function=loss_function,
optimizer=optimizer,
data_iter=train_data,
max_len=max_seq_len,
clip_val=clip_val,
epsilon=epsilon,
teacher_forcing_rat=tfr)
if scheduler is not None:
scheduler.step()
# epoch logs
print("Training loss:\t", train_l)
print("Instances:\t", inst)
print("Steps:\t", steps)
hours = t // 3600
mins = (t % 3600) // 60
secs = (t % 60)
print("Time:\t{0}:{1}:{2}".format(hours, mins, secs))
total_instances += inst
total_steps += steps
train_loss_log.append(train_l)
train_loss_log_batches += l_log
train_penalty_log.append(pen)
print()
# evaluate
if val_caps:
val_l, l_log, bleu = evaluate(model=net,
loss_function=loss_function,
data_iter=val_data,
max_len=max_seq_len,
epsilon=epsilon)
# validation logs
print("Validation loss: ", val_l)
print("Validation BLEU-4: ", bleu)
if bleu > prev_bleu:
torch.save(net.state_dict(), os.path.join(out_dir, 'net.pt'))
val_loss_log.append(val_l)
val_bleu_log.append(bleu)
val_loss_log_batches += l_log
#sample model
print("Sampling training data...")
print()
samples = sample(net,
train_data,
vocab,
samples=3,
max_len=max_seq_len)
for t, s in samples:
print("Target:\t", t)
print("Predicted:\t", s)
print()
# if val_caps:
# print("Sampling validation data...")
# print()
# samples = sample(net, val_data, vocab, samples=3, max_len=max_seq_len)
# for t, s in samples:
# print("Target:\t", t)
# print("Predicted:\t", s)
# print()
if val_caps:
# If the validation loss after this epoch increased from the
# previous epoch, wrap training.
if prev_bleu > bleu and early_stopping:
print("\nWrapping training after {0} epochs.\n".format(e + 1))
break
prev_val_l = val_l
prev_bleu = bleu
# Experiment summary logs.
tot_time = time.time() - training_start_time
hours = tot_time // 3600
mins = (tot_time % 3600) // 60
secs = (tot_time % 60)
print("Total training time:\t{0}:{1}:{2}".format(hours, mins, secs))
print("Total training instances:\t", total_instances)
print("Total training steps:\t", total_steps)
print()
_write_loss_log("train_loss_log.txt", out_dir, train_loss_log)
_write_loss_log("train_loss_log_batches.txt", out_dir,
train_loss_log_batches)
_write_loss_log("train_penalty.txt", out_dir, train_penalty_log)
if val_caps:
_write_loss_log("val_loss_log.txt", out_dir, val_loss_log)
_write_loss_log("val_loss_log_batches.txt", out_dir,
val_loss_log_batches)
_write_loss_log("val_bleu4_log.txt", out_dir, val_bleu_log)
print("EXPERIMENT END ", time.asctime())
src = (Path(__file__) / "..").resolve()
for f in glob(str(src / "*.py")):
shutil.copy(f, dst)
if __name__ == "__main__":
wandb_logger = WandbLogger(project="nnsplit")
parser = ArgumentParser()
parser = Network.add_model_specific_args(parser)
parser = Trainer.add_argparse_args(parser)
parser.set_defaults(
gpus=1, max_epochs=1, reload_dataloaders_every_epoch=True, logger=wandb_logger,
)
hparams = parser.parse_args()
if hparams.logger:
store_code(wandb_logger.experiment)
model = Network(hparams)
n_params = np.sum([np.prod(x.shape) for x in model.parameters()])
trainer = Trainer.from_argparse_args(hparams)
print(f"Training model with {n_params} parameters.")
trainer.fit(model)
if hparams.logger:
model.store(Path(wandb_logger.experiment.dir) / "model")
if __name__ == '__main__':
print('Cross Entropy Test:', \
cross_entropy_with_logits(torch.tensor([0.0088, 0.1576, -0.0345, -0.0805]), \
torch.tensor([0.0000, 0.1429, 0.4286, 0.4286])))
in_shape = (8 * 3, 96, 96)
action_space_size = 4
network = Network(in_shape, action_space_size, 'cuda')
batch_size = 3
rollout_len = 5
batch = []
for i in range(batch_size):
img = np.ones(in_shape)
actions = [Action(2) for _ in range(rollout_len)]
# (value, reward, empirical_policy)
targets = [(0.7, 0.5, [0.25, 0.25, 0.25, 0.25])
for _ in range(rollout_len + 1)]
batch.append((img, actions, targets))
optimizer = optim.SGD(network.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=1e-4)
for i in range(1000):
batch_update_weights(optimizer, network, batch)
class Agent():
def __init__(self, state_size, action_size, seed):
self.state_size = state_size
self.action_size = action_size
self.seed = random.seed(seed)
self.Q = Network(self.state_size, self.action_size, self.seed)
self.Q_dash = Network(self.state_size, self.action_size, self.seed)
self.optimizer = optim.Adam(self.Q.parameters(), lr=LR)
self.replay = ReplayBuffer(self.seed)
self.t_step = 0
def step(self, state, action, reward, next_state, done):
self.replay.add(state, action, reward, next_state, done)
self.t_step = (self.t_step + 1) % UPDATE_EVERY
if self.t_step == 0:
if len(self.replay) > BATCH_SIZE:
experiences = self.replay.sample()
self.learn_ddqn(experiences, GAMMA)
def act(self, state, eps=0.):
state = torch.from_numpy(state).float().unsqueeze(0).to(device)
self.Q.eval()
with torch.no_grad():
# done to avoid bt
action_values = self.Q(state)
self.Q.train()
# Epsilon-greedy action selection
if random.random() > eps:
return np.argmax(action_values.cpu().data.numpy())
else:
return random.choice(np.arange(self.action_size))
def learn_dqn(self, experiences, gamma):
'''
Simple dqn with fixed target Q' and experience replay
'''
states, actions, rewards, next_states, dones = experiences
# Get max predicted Q values (for next states) from target model
Q_targets_next = self.Q_dash(next_states).detach().max(1)[0].unsqueeze(
1)
# Compute Q targets for current states
# only get reward if its done
Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))
# Get expected Q values from local model
Q_expected = self.Q(states).gather(1, actions)
# Compute loss
loss = F.mse_loss(Q_expected, Q_targets)
# Minimize the loss
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
self.soft_update(self.Q, self.Q_dash, TAU)
def learn_ddqn(self, experiences, gamma):
#double deep q learning
states, actions, rewards, next_states, dones = experiences
best_action_arg = self.Q(next_states).detach()
a_best = best_action_arg.max(1)[1]
Q_targets_next = self.Q_dash(next_states).detach().gather(
1, a_best.unsqueeze(1))
#Q_targets_next = Q_targets_all[np.arange(BATCH_SIZE), a_best].unsqueeze(1)
Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))
# Get expected Q values from local model
Q_expected = self.Q(states).gather(1, actions)
# Compute loss
loss = F.mse_loss(Q_expected, Q_targets)
# Minimize the loss
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
self.soft_update(self.Q, self.Q_dash, TAU)
def soft_update(self, local_model, target_model, tau):
"""Soft update model parameters.
θ_target = τ*θ_local + (1 - τ)*θ_target
Params
======
local_model (PyTorch model): weights will be copied from
target_model (PyTorch model): weights will be copied to
tau (float): interpolation parameter
"""
for target_param, local_param in zip(target_model.parameters(),
local_model.parameters()):
target_param.data.copy_(tau * local_param.data +
(1.0 - tau) * target_param.data)
