def train(self, epochs=10):
Model = NN(batch_size=30)
opt = optim.Adam(Model.parameters(), lr=0.005)
criterion = nn.BCELoss()
softmax = nn.Softmax(dim=0)
loss = 0
print(self.labels.shape)
for i in range(epochs):
item_loss = 0
for i, (feat, lab) in enumerate(self.dataloader):
feat = feat[0][:, :1, :, :]
output = Model.forward(feat)
loss = criterion(output, lab.view((30)))
loss.backward()
opt.step()
item_loss += loss.item()
print("LOSS ---->", item_loss / len(self.dataloader))
torch.save(Model.state_dict(), "1")
def train(config):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Initialize the device which to run the model on
device = torch.device(device)
# Initialize the dataset and data loader (note the +1)
dataset = IMDBDataset(train_or_test='train', seq_length=config.seq_length)
data_loader = DataLoader(dataset,
config.batch_size,
shuffle=True,
num_workers=4)
# Initialize the dataset and data loader (note the +1)
test_dataset = IMDBDataset(train_or_test='test',
seq_length=config.seq_length)
test_data_loader = DataLoader(test_dataset,
config.batch_size,
shuffle=True,
num_workers=4)
# Initialize the model that we are going to use
if not (config.recurrent_dropout_model):
model = NN(dataset.vocab_size, config.embed_dim, config.hidden_dim,
config.output_dim, config.n_layers, config.bidirectional,
config.dropout, 0).to(device)
else:
model = Model(dataset.vocab_size,
output_dim=config.output_dim).to(device)
if not os.path.exists(f'runs/{config.name}'):
os.makedirs(f'runs/{config.name}')
print(config.__dict__)
with open(f'runs/{config.name}/args.txt', 'w') as f:
json.dump(config.__dict__, f, indent=2)
# Setup the loss and optimizer
criterion = nn.CrossEntropyLoss().to(device)
# criterion = torch.nn.MSELoss().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=config.learning_rate)
lowest = 100
save = []
epochs = 0
while epochs < config.train_epochs:
accuracies = []
losses = []
print('Training')
for step, (batch_inputs, batch_targets) in enumerate(data_loader):
x = batch_inputs.long().to(device)
y_target = batch_targets.long().to(device)
predictions = model(x)
loss = criterion(predictions, y_target)
optimizer.zero_grad()
loss.backward()
# torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=config.max_norm)
optimizer.step()
accuracy = (torch.argmax(predictions,
dim=1) == y_target).cpu().numpy().mean()
loss = loss.item()
accuracies.append(accuracy)
losses.append(loss)
accuracy = np.array(accuracies).mean()
loss = np.array(losses).mean()
# Test on test set
print('Testing')
with torch.no_grad():
test_accuracies = []
test_losses = []
for step, (batch_inputs,
batch_targets) in enumerate(test_data_loader):
x = batch_inputs.long().to(device)
y_target = batch_targets.long().to(device)
predictions = model(x)
test_loss = criterion(predictions, y_target)
test_accuracy = (torch.argmax(
predictions, dim=1) == y_target).cpu().numpy().mean()
test_loss = test_loss.item()
test_accuracies.append(test_accuracy)
test_losses.append(test_loss)
test_accuracy = np.array(test_accuracies).mean()
test_loss = np.array(test_losses).mean()
if (test_loss < lowest):
lowest = test_loss
torch.save(model.state_dict(), f'runs/{config.name}/model.pt')
epochs += 1
print(
"[{}] Train epochs {:04d}/{:04d}, Train Accuracy = {:.2f}, Train Loss = {:.3f}, Test Accuracy = {:.2f}, Test Loss = {:.3f}"
.format(datetime.now().strftime("%Y-%m-%d %H:%M"), epochs,
config.train_epochs, accuracy, loss, test_accuracy,
test_loss))
print('Done training.')
return accuracy, lowest, save
print("Test loss:", loss_test)
print("Test accuracy:", accuracy_test)
print()
for i in range(3):
print('Accuracy of %d : %2d / %2d (%2d %%)' %
(i, class_correct[i], class_total[i],
100 * class_correct[i] / class_total[i]))
########## Get weights of first layer and plot to see if they seem to be features for teams ##########
plot_weights_teams_tsne(
teams, model,
'%s/weights/%s' % (league, get_hyperparams_filename('tsne.pdf')), league,
"Test and training loss")
plot_weights_teams_pca(
teams, model,
'%s/weights/%s' % (league, get_hyperparams_filename('pca.pdf')), league,
"Test and training loss")
plot_weights_teams_kernel_pca(
teams, model,
'%s/weights/%s' % (league, get_hyperparams_filename('kernel_pca.pdf')),
league, "Test and training loss")
########## Save the model for later use ##########
torch.save(
model.state_dict(),
"%s/%s/%s" % (MODELS_DIR, league, get_hyperparams_filename('model.pt')))
for (words, labels) in train_loader:
words = words.to(device)
labels = labels.to(device)
#forward
outputs = model(words)
loss = criterion(outputs, labels)
#backward and optimizer step
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (epoch+1)%100 == 0:
print(f'epoch{epoch+1}/{num_epochs}, loss={loss.item():.4f}')
print(f'final loss, loss={loss.item():.4f}, time cost {(time()-start_t)/60} minutes')
data = {
"model_state": model.state_dict(),
"input_size" : input_size,
"output_size" : output_size,
"hidden_size" : hidden_size,
"all_words" : all_words,
"tags" : tags
}
FILE = "data.pth"
torch.save(data, FILE)
print(f'traning complete. model saved to {FILE}')
print('Early stopping')
break
last_loss_test = loss_test
print('epoch {}, loss - {}'.format(epoch, loss))
print('test loss - {}'.format(loss_test))
optimizer.zero_grad()
loss.backward()
optimizer.step()
if __name__ == '__main__':
data = pd.read_csv('datasets/anchor-weed.csv')
scaler.fit_transform(data[['price']])
np.random.seed(100)
nr_classes = 6
hidden_size = 12
data = pd.read_csv('datasets/anchor-weed-prepared.csv')
data = data.drop('Unnamed: 0', axis=1)
y = data['price+1'].values
X = data.drop('price+1', axis=1).values
model = NN([nr_classes, 8, 4, 1])
train(model, X, y, 30000, 0.01)
torch.save(model.state_dict(), 'model_state/state')
y_pred = model.forward(torch.from_numpy(X[275, :]).float())
y_pred = np.exp(y_pred.detach().numpy().reshape(-1, 1))
y_ = np.exp(y[275])
plot_results(model, X, y)
print("Initializing network")
network = NN()
optimizer = optim.Adam(network.parameters(), lr=0.0005)
criterion = nn.BCELoss(reduction='mean')
correct = 0
for epoch in range(5):
for i, data in enumerate(train_loader, 0):
# get the inputs
inputs, labels = data
# Forward pass: Compute predicted y by passing x to the model
y_pred = network(inputs)
# Compute and print loss
loss = criterion(y_pred, labels.view((-1, 1)))
print(f'Epoch {epoch + 1} | Batch: {i+1} | Loss: {loss.item():.4f}')
# Zero gradients, perform a backward pass, and update the weights.
optimizer.zero_grad()
loss.backward()
optimizer.step()
print("Done training")
tc.save(network.state_dict(), "model.wab")
#REDUCTION MODEL
#Based on the models of Generative Adversarial Networks, one must wonder if it's
#a viable alternative to use the inference model of a trained neural network to
#train a new network with a smaller number of layers, in order to gain speed-ups
