**DATA_LOADER_PARAM)
# 2. Instantiate a model, loss function, and optimizer
model = MyCNN(word2vec.vectors).to(dev)
loss_func = F.cross_entropy
optimizer = torch.optim.Adadelta(model.parameters(), **OPTIMIZER_PARAM)
print(
'* The number of model parameters: ',
sum([np.prod(p.size()) for p in model.parameters()
if p.requires_grad]))
# 3. Train the model
loss_list = []
start = time.time()
for epoch in range(1, EPOCH_MAX + 1):
train_loss = train(model, train_dloader, loss_func, optimizer)
valid_loss, valid_accuracy = evaluate(model, tests_dloader, loss_func)
loss_list.append([epoch, train_loss, valid_loss, valid_accuracy])
if epoch % EPOCH_LOG == 0:
elapse = time.time() - start
print(
f'{epoch:>6} ({elapse:>6.2f} sec), TrLoss={train_loss:.6f}, VaLoss={valid_loss:.6f}, VaAcc={valid_accuracy:.3f}'
)
elapse = time.time() - start
# 4. Visualize the loss curves
plt.title(
f'Training and Validation Losses (time: {elapse:.2f} [sec] @ CUDA: {USE_CUDA})'
)
loss_array = np.array(loss_list)
data, targets, target_names = load_name_dataset(glob.glob(DATA_PATH))
data_train = [(text2onehot(data[i], device=dev), torch.LongTensor(
[targets[i]]).to(dev)) for i in range(len(data))]
random.shuffle(data_train)
# 2. Instantiate a model, loss function, and optimizer
model = MyRNN(len(LETTER_DICT), len(target_names)).to(dev)
loss_func = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), **OPTIMIZER_PARAM)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, **SCHEDULER_PARAM)
# 3.1. Train the model
loss_list = []
start = time.time()
for epoch in range(1, EPOCH_MAX + 1):
train_loss = train(model, data_train, loss_func, optimizer)
scheduler.step()
loss_list.append([epoch, train_loss])
if epoch % EPOCH_LOG == 0:
elapse = (time.time() - start) / 60
print(f'{epoch:>6} ({elapse:>6.2f} min), TrainLoss={train_loss:.6f}, lr={scheduler.get_last_lr()}')
elapse = (time.time() - start) / 60
# 3.2. Save the trained model if necessary
if SAVE_MODEL:
torch.save(model.state_dict(), SAVE_MODEL)
# 4.1. Visualize the loss curves
plt.title(f'Training Loss (time: {elapse:.2f} [min] @ CUDA: {USE_CUDA})')
loss_array = np.array(loss_list)
x.append(onehot_table[vocab[tokens[1]]])
y.append(vocab[tokens[0]])
x.append(onehot_table[vocab[tokens[1]]])
y.append(vocab[tokens[2]])
x = torch.tensor(x, dtype=torch.float32, device=dev)
y = torch.tensor(y, dtype=torch.long, device=dev)
# 2. Instantiate a model, loss function, and optimizer
embedding_size = 2
model = Word2Vec(len(vocab), embedding_size).to(dev)
loss_func = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), **OPTIMIZER_PARAM)
# 3. Train the model
for epoch in range(1, EPOCH_MAX + 1):
train_loss = train(model, [[x, y]], loss_func, optimizer)
if epoch % EPOCH_LOG == 0:
print(f'{epoch:>6}), TrLoss={train_loss:.6f}')
# 4. Visualize the Word2Vec table
W, Wt = model.parameters()
for i, word in enumerate(words):
x, y = W[0][i].item(), W[1][i].item()
plt.scatter(x, y)
plt.annotate(word,
xy=(x, y),
xytext=(5, 2),
textcoords='offset points',
ha='right',
va='bottom')
plt.show()
train_tensors = torch.sparse_coo_tensor([train_vectors.row, train_vectors.col], train_vectors.data, train_vectors.shape, dtype=torch.float32).to(dev)
train_targets = torch.LongTensor(train_raw.target).to(dev)
tests_tensors = torch.sparse_coo_tensor([tests_vectors.row, tests_vectors.col], tests_vectors.data, tests_vectors.shape, dtype=torch.float32).to(dev)
tests_targets = torch.LongTensor(tests_raw.target).to(dev)
# 2. Instantiate a model, loss function, and optimizer
model = MyTwoLayerNN(train_tensors.shape[1]).to(dev)
loss_func = F.cross_entropy
optimizer = torch.optim.Adadelta(model.parameters(), **OPTIMIZER_PARAM)
print('* The number of model parameters: ', sum([np.prod(p.size()) for p in model.parameters() if p.requires_grad]))
# 3. Train the model
loss_list = []
start = time.time()
for epoch in range(1, EPOCH_MAX + 1):
train_loss = train(model, [(train_tensors, train_targets)], loss_func, optimizer)
valid_loss, valid_accuracy = evaluate(model, [(tests_tensors, tests_targets)], loss_func)
loss_list.append([epoch, train_loss, valid_loss, valid_accuracy])
if epoch % EPOCH_LOG == 0:
elapse = time.time() - start
print(f'{epoch:>6} ({elapse:>6.2f} sec), TrLoss={train_loss:.6f}, VaLoss={valid_loss:.6f}, VaAcc={valid_accuracy:.3f}')
elapse = time.time() - start
# 4. Visualize the loss curves
plt.title(f'Training and Validation Losses (time: {elapse:.2f} [sec] @ CUDA: {USE_CUDA})')
loss_array = np.array(loss_list)
plt.plot(loss_array[:,0], loss_array[:,1] * 1e4, 'r-', label='Training loss')
plt.plot(loss_array[:,0], loss_array[:,2] * 1e4, 'g-', label='Validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss values [1e-4]')
train=False,
transform=preproc)
loader_train = torch.utils.data.DataLoader(data_train, **DATA_LOADER_PARAM)
loader_valid = torch.utils.data.DataLoader(data_valid, **DATA_LOADER_PARAM)
# 2. Instantiate a model, loss function, and optimizer
model = MyCNN().to(dev)
loss_func = F.cross_entropy
optimizer = torch.optim.SGD(model.parameters(), **OPTIMIZER_PARAM)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, **SCHEDULER_PARAM)
# 3.1. Train the model
loss_list = []
start = time.time()
for epoch in range(1, EPOCH_MAX + 1):
train_loss = train(model, loader_train, loss_func, optimizer)
valid_loss, valid_accuracy = evaluate(model, loader_valid, loss_func)
scheduler.step()
loss_list.append([epoch, train_loss, valid_loss, valid_accuracy])
if epoch % EPOCH_LOG == 0:
elapse = (time.time() - start) / 60
print(
f'{epoch:>6} ({elapse:>6.2f} min), TrLoss={train_loss:.6f}, VaLoss={valid_loss:.6f}, VaAcc={valid_accuracy:.3f}, lr={scheduler.get_last_lr()}'
)
elapse = (time.time() - start) / 60
# 3.2. Save the trained model if necessary
if SAVE_MODEL:
torch.save(model.state_dict(), SAVE_MODEL)