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