Written by Karol Majek• 2 grudnia, 2022• 8:32 am• Made by AI

ChatGPT trenuje MLP na zbiorze MNIST

Czy możemy wykorzystać model ChatGPT do wygenerowania kodu do treningu w PyTorchu? Tak i nie. Robi błędy, ale część umie poprawić. Ostatecznie proste MLP działa, po poprawkach związanych z importami. Są też problemy nie do przeskoczenia o czym niżej.

Zapytanie które wpisałem wyglądało następująco:

I need a simple pytorch training example on MNIST
Prompt

Here is a simple PyTorch example for training a model on the MNIST dataset.

First, we need to load the MNIST dataset. We can do this using PyTorch’s torchvision package.

import torch
import torchvision

# load the MNIST dataset
mnist = torchvision.datasets.MNIST(root="./data", train=True, transform=transforms.ToTensor(), download=True)

Next, we need to split the dataset into a training set and a validation set. We can do this using PyTorch’s DataLoader class.

Copy code<code># split the dataset into a training set and a validation set
train_loader = torch.utils.data.DataLoader(mnist, batch_size=64, shuffle=True)
val_loader = torch.utils.data.DataLoader(mnist, batch_size=64, shuffle=False)
</code>

Now, we can define our model. For this example, we will use a simple multilayer perceptron (MLP) with two hidden layers.

Copy code<code># define the model
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 28*28)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = MLP()
</code>

Next, we need to define a loss function and an optimizer. For this example, we will use cross-entropy loss and the Adam optimizer.

Copy code<code># define the loss function and the optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
</code>

Now, we can train the model. This involves looping over the training data, computing the loss, and updating the model’s parameters.

Copy code<code># train the model
for epoch in range(10):
    for data, target in train_loader:
        # forward pass
        output = model(data)
        loss = criterion(output, target)

        # backward pass
        optimizer.zero_grad()
        loss.backward()

        # update the model's parameters
        optimizer.step()
</code>

Finally, we can evaluate the model on the validation set. This involves looping over the validation data, computing the loss, and printing the average loss.

Copy code<code># evaluate the model
val_loss = 0.0
for data, target in val_loader:
    # forward pass
    output = model(data)
    loss = criterion(output, target)
    val_loss += loss.item()

val_loss /= len(val_loader)
print("Validation loss: {:.4f}".format(val_loss))
</code>

That’s it! This is a simple example for training

Sprawdźmy w praktyce

W pierwszej komórce z kodem jest oczywiście błąd:

Zapytajmy ChatGPT co z tym zrobić:

Po poprawce jest już ok:

Co na to ChatGPT?

lepiej, ale będzie draka z F:

No to prosimy o poprawkę:

I faktycznie jest poprawka:

Hura, trenuje się bez problemu:

Super – z dokładnością do przełączenia modelu w eval oraz wykorzystania no_grad/inference_mode przy eval 🙂

Przydałoby się accuracy…

To ciekawe – wygląda na pomyłkę max i argmax

Walczymy dalej:

Tu porażka na całej linii… Nie wiem jak zapytać by dostać dobrą odpowiedź, więc tu poprawiam ja.

prawidłowo jest oczywiscie tak:

# evaluate the model
val_loss = 0.0
val_acc = 0.0
for data, target in val_loader:
    # forward pass
    output = model(data)
    loss = criterion(output, target)
    val_loss += loss.item()

    # calculate the accuracy
    predicted = torch.argmax(output, 1)
    correct = (predicted == target).sum().item()
    val_acc += correct / len(target)

val_loss /= len(val_loader)
val_acc /= len(val_loader)
print("Validation loss: {:.4f}".format(val_loss))
print("Validation accuracy: {:.4f}".format(val_acc))