End-to-end example

Here is an end-to-end pytorch example. For more information on getting started, see details on the Comet config file.

For more examples using pytorch, see our Comet Examples Github repository.

```python from comet_ml import Experiment

import torch import torch.nn as nn import torchvision.datasets as dsets import torchvision.transforms as transforms from torch.autograd import Variable

hyper_params = { "sequence_length": 28, "input_size": 28, "hidden_size": 128, "num_layers": 2, "num_classes": 10, "batch_size": 100, "num_epochs": 2, "learning_rate": 0.01 }

experiment = Experiment(project_name="pytorch") experiment.log_parameters(hyper_params)

MNIST Dataset

train_dataset = dsets.MNIST(root='./data/', train=True, transform=transforms.ToTensor(), download=True)

test_dataset = dsets.MNIST(root='./data/', train=False, transform=transforms.ToTensor())

Data Loader (Input Pipeline)

train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=hyper_params['batch_size'], shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=hyper_params['batch_size'], shuffle=False)

RNN Model (Many-to-One)

class RNN(nn.Module): def init(self, input_size, hidden_size, num_layers, num_classes): super(RNN, self).init() self.hidden_size = hidden_size self.num_layers = num_layers self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True) self.fc = nn.Linear(hidden_size, num_classes)

def forward(self, x):
    # Set initial states
    h0 = Variable(torch.zeros(self.num_layers, x.size(0), self.hidden_size))
    c0 = Variable(torch.zeros(self.num_layers, x.size(0), self.hidden_size))

    # Forward propagate RNN
    out, _ = self.lstm(x, (h0, c0))

    # Decode hidden state of last time step
    out = self.fc(out[:, -1, :])
    return out

rnn = RNN(hyper_params['input_size'], hyper_params['hidden_size'], hyper_params['num_layers'], hyper_params['num_classes'])

Loss and Optimizer

criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(rnn.parameters(), lr=hyper_params['learning_rate'])

Train the Model

with experiment.train(): step = 0 for epoch in range(hyper_params['num_epochs']): correct = 0 total = 0 for i, (images, labels) in enumerate(train_loader): images = Variable(images.view(-1, hyper_params['sequence_length'], hyper_params['input_size'])) labels = Variable(labels)

        # Forward + Backward + Optimize
        optimizer.zero_grad()
        outputs = rnn(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # Compute train accuracy
        _, predicted = torch.max(outputs.data, 1)
        batch_total = labels.size(0)
        total += batch_total

        batch_correct = (predicted == labels.data).sum()
        correct += batch_correct

        # Log batch_accuracy to Comet.ml; step is each batch
        step += 1
        experiment.log_metric("batch_accuracy", batch_correct / batch_total, step=step)

        if (i + 1) % 100 == 0:
            print('Epoch [%d/%d], Step [%d/%d], Loss: %.4f'
                  % (epoch + 1, hyper_params['num_epochs'], i + 1, len(train_dataset) // hyper_params['batch_size'], loss.item()))

# Log epoch accuracy to Comet.ml; step is each epoch
    experiment.log_metric("batch_accuracy", correct / total, step=epoch)

with experiment.test(): # Test the Model correct = 0 total = 0 for images, labels in test_loader: images = Variable(images.view(-1, hyper_params['sequence_length'], hyper_params['input_size'])) outputs = rnn(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum()

experiment.log_metric("accuracy", correct / total)
print('Test Accuracy of the model on the 10000 test images: %d %%' % (100 * correct / total))

```

Pytorch Distributed Data Parallel

You can find an example of Pytorch DDP + Comet Python SDK in the comet-example repository here: https://github.com/comet-ml/comet-examples/tree/master/pytorch#using-cometml-with-pytorch-parallel-data-training.