web-dev-qa-db-fra.com

Comment inclure la taille d'un lot dans l'exemple de base de Pytorch?

Je suis nouveau sur pytorch. Ce qui suit est l'exemple de base de l'utilisation du module nn pour former un modèle simple à une couche avec des données aléatoires ( d'ici )

import torch
N, D_in, H, D_out = 64, 1000, 100, 10

x = torch.randn(N, D_in)
y = torch.randn(N, D_out)

model = torch.nn.Sequential(
    torch.nn.Linear(D_in, H),
    torch.nn.ReLU(),
    torch.nn.Linear(H, D_out),
)
loss_fn = torch.nn.MSELoss(reduction='sum')
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
for t in range(500):
    y_pred = model(x)

    loss = loss_fn(y_pred, y)
    print(t, loss.item())

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

Si je comprends bien, la taille du lot est égale à 1 dans l'exemple, en d'autres termes, un seul point (sur 64) est utilisé pour calculer les gradients et mettre à jour les paramètres. Ma question est: comment modifier cet exemple pour entraîner le modèle avec une taille de lot supérieure à un?

machine-learningpytorch
6
DeLorean88

En fait, N est la taille du lot. Il vous suffit donc de modifier N actuellement son ensemble à 64. Vous avez donc dans chaque lot de formation 64 vecteurs avec size/dim D_in.

J'ai vérifié le lien que vous avez posté, vous pouvez également consulter les commentaires - il y a aussi des explications :)

# -*- coding: utf-8 -*-
import numpy as np

# N is batch size; D_in is input dimension;
# H is hidden dimension; D_out is output dimension.
N, D_in, H, D_out = 64, 1000, 100, 10

# Create random input and output data
x = np.random.randn(N, D_in)
y = np.random.randn(N, D_out)

# Randomly initialize weights
w1 = np.random.randn(D_in, H)
w2 = np.random.randn(H, D_out)

learning_rate = 1e-6
for t in range(500):
    # Forward pass: compute predicted y
    h = x.dot(w1)
    h_relu = np.maximum(h, 0)
    y_pred = h_relu.dot(w2)

    # Compute and print loss
    loss = np.square(y_pred - y).sum()
    print(t, loss)

    # Backprop to compute gradients of w1 and w2 with respect to loss
    grad_y_pred = 2.0 * (y_pred - y)
    grad_w2 = h_relu.T.dot(grad_y_pred)
    grad_h_relu = grad_y_pred.dot(w2.T)
    grad_h = grad_h_relu.copy()
    grad_h[h < 0] = 0
    grad_w1 = x.T.dot(grad_h)

    # Update weights
    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2
1
blue-phoenox