RuntimeError

[KLAS84]

Hello, I'm having trouble trying to figure out why I'm getting this error.

• RuntimeError: Can't call numpy() on Tensor that requires grad. Use tensor.detach().numpy() instead.

This is for plotting the first values before training the model to compare it to the new values. I was trying to plot this graph again, like in the video timestamp (6:48:22), and I'm running into this error.
Here is my code :

def plot_predicitions(train_data = X_train,
                                train_labels = y_train,
                                test_data = X_test,
                                test_labels = y_test,
                                predictions = None) :
    """
    Plot training data, test data and compares predictions.
    """
    plt.figure(figsize = (10, 7))

    # Plot training data in blue
    plt.scatter(train_data, train_labels, c = "b" , s = 4, label = 'Training data')

    # Plot test data in green
    plt.scatter(test_data, test_labels, c = 'g', s = 4, label = 'Testing data')

    #Are there predictions?
    if predictions is not None:
        # Plot the predictions if they exist
        plt.scatter(test_data, predictions, c = 'r', s = 4, label = 'Predictions')
    
    # Show the legend
    plt.legend(prop = {'size' : 14})

plot_predicitions()

# Create linear regression model class
class LinearRegressionModel(nn.Module): # almost everything in PyTorch inherhits from nn.Module
    def __init__(self) :
        super().__init__()
        self.weights = nn.Parameter(torch.randn(1,
                                                                            requires_grad = True,
                                                                            dtype = torch.float))
        self.bias = nn.Parameter(torch.randn(1,
                                                                    requires_grad = True,
                                                                    dtype = torch.float))
    # Forward method to define the computation in the model
    def forward(self, x : torch.Tensor) -> torch.Tensor : #<- 'x' is the input data
            return self.weights * x + self.bias # This is the linear regression formula

# Create a random seed
torch.manual_seed(42)

# Create an instance of the model (this is a subclass of nn.Module)
model_0 = LinearRegressionModel()

# Check out the parameters
list(model_0.parameters())

print(model_0.state_dict())
print('We want to get the top numbers as close as we can to the bottom numbers...')
print(f'weight : {weight}, bias : {bias}')

I think this is where the problem lies --

# Make predictions with model.
with torch.inference_mode():
    y_preds = model_0(X_test)

'''
inference is fairly new and torch.no_grad(): may be seen in older code.

EX : 
with torch.no_grad():
    y_preds = model_0(X_test)

plot_predicitions(predictions = y_preds)
    
'''

y_preds

I get the plot here, but after I run my model

# Setup a loss function. NOTE : Measures the difference between predictions and true labels, calculating the model's error
loss_fn = nn.L1Loss()

# Setup a optimizer (stochastic gradient descent). NOTE : Adjusts the model's parameters to minimize the error and improve performance.
optimizer =  torch.optim.SGD(params = model_0.parameters(),
                                                lr =  0.01)   # lr = learning rate = possibly the most important hyperparameter you can set

# An epoch is one loop through the data ... (This is a hyperparameter because we've set it ourself)
epochs = 1

### Training
# 0. Loop through the data
for epoch in range (epochs):
    # Set the model to training mode
    model_0.train() # train mode in PyTorch sets all parameters that require gradients the require gradients

    # 1. Forward pass
    y_preds = model_0(X_train)

    # 2. Calculate the loss
    loss = loss_fn(y_preds, y_train)
    print(f'Loss : {loss}')
    # 3. Optimizer zero grad
    optimizer.zero_grad()

    # 4. Perform backpropagation on the loss with respect to the parameters of the model
    loss.backward()

    # 5.  Step the optimizer (perform gradient decent)
    optimizer.step()  # by default how the optimizer changes will accumulate through the loop so... we have to zero them above in step 3 for the next itteration of the loop

    ### Testing
    model_0.eval() #Turns off gradient tracking

# Print out model state_dict()
model_0.state_dict()

I try the comparison and can only get the y_preds_new plotted predictions not the y_preds.

with torch.inference_mode():
    y_preds_new = model_0(X_test)

plot_predicitions(predictions = y_preds_new)

Then here is where I get the error -->

plot_predicitions(predictions = y_preds)

Hopefully I made sence here! Thanks

[KLAS84]

SOLVED :
I was calling y_preds = model_0(X_train) in the forward pass instead of y_pred.