Having an issue with Tensor sizes from model while doing Udemy course

[david-bickford]

Hello! I'm loving the course! I just keep having an issue that I can't seem to wrap my head around. I keep getting this issue:

Here's my code:

class LinearRegressionModel(nn.Module):
  def __init__(self):
    super().__init__()
    self.weights = nn.Parameter(torch.randn(1, requires_grad=True))

    self.bias = nn.Parameter(torch.randn(1, requires_grad=True))

  #forward method to define the computation in the model
  def forward(self, x:torch.Tensor) -> torch.Tensor:
    return self.weights * X + self.bias

def plot_predictions(train_data = X_train,
                    train_labels = y_train,
                    test_data = x_test,
                    test_labels = y_test,
                    predictions = None):

  plt.figure(figsize=(10, 7))

  plt.scatter(train_data, train_labels, c="b", s=4, label="Training Data")

  plt.scatter(test_data, test_labels, c="g", s=4, label="Testing Data")

  if predictions is not None:
    plt.scatter(test_data, predictions, c="r", s=4, label="Predictions")

  plt.legend(prop={"size": 14});

# create train/test split
train_split = int(0.8 * len(X))
X_train, y_train = X[:train_split], y[:train_split]
x_test, y_test = X[train_split:], y[train_split:]

torch.manual_seed(42)

model_0 = LinearRegressionModel()

loss_fn = nn.L1Loss()

optimizer = torch.optim.SGD(params=model_0.parameters(), lr=0.01)

epochs = 100

for epoch in range(epochs):
  model_0.train()

  #forward pass (this calls forward method)
  y_pred = model_0(X_train)

  #calculate loss
  loss = loss_fn(y_pred, y_train)
  # print(f"loss: {loss}")

  #optimizer zero grad
  optimizer.zero_grad()

  #perform backpropagation on the loss with respect to the params of the model
  loss.backward()

  #step the optimizer (perform gradient descent)
  optimizer.step()

  model_0.eval() #turns off gradient tracking

  with torch.inference_mode():
    test_pred = model_0(x_test)
    test_loss = loss_fn(test_pred, y_test)
  if epoch %10==0:
    print(f"Epoch: {epoch} Loss: {loss}, Test Loss: {test_loss}")

For some reason whenever I call my model with a Tensor shape [40, 1] it returns a Tensor with shape [50, 1], then I can't compare.

I'm also getting something similar whenever I try to chart out the results:

[LuluW8071]

class LinearRegressionModel(nn.Module):
  def __init__(self):
    super().__init__()
    self.weights = nn.Parameter(torch.randn(1, requires_grad=True))

    self.bias = nn.Parameter(torch.randn(1, requires_grad=True))

  #forward method to define the computation in the model
  def forward(self, x:torch.Tensor) -> torch.Tensor:
    return self.weights * X + self.bias

return self.weights * X + self.bias

The original X value is being returned from original X data where it should have been x for forwarding the input data at a time as you have wrote def forward(self, x:torch.Tensor) in the model

Correct way:

class LinearRegressionModel(nn.Module):
  def __init__(self):
    super().__init__()
    self.weights = nn.Parameter(torch.randn(1, requires_grad=True))

    self.bias = nn.Parameter(torch.randn(1, requires_grad=True))

  #forward method to define the computation in the model
  def forward(self, x:torch.Tensor) -> torch.Tensor:
    return self.weights * x + self.bias

[david-bickford]

I see!!! Thank you so much!!