pytorch
  1. pytorch-prediction-linear-class
PreviousNext

Prediction & Linear Class - ( Linear Regression with PyTorch )

Heading h2

Syntax

import torch
import torch.nn as nn
import numpy as np

# Create random dataset
X = np.random.rand(100, 1)
y = 2*X + 0.5*np.random.rand(100, 1)

# Convert numpy arrays to PyTorch tensors
X_tensor = torch.from_numpy(X).float()
y_tensor = torch.from_numpy(y).float()

# Define linear regression model
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        out = self.linear(x)
        return out

model = LinearRegression()

# Define loss function and optimizer
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# Train the model
num_epochs = 1000
for epoch in range(num_epochs):
    # Forward pass
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    # Backward and optimize
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch+1) % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# Predict
with torch.no_grad():
    predicted = model(X_tensor).detach().numpy()

Example

Consider a simple example where we have a dataset of 100 records with one independent variable and one dependent variable. We will train a linear regression model using the PyTorch framework and predict the dependent variable values based on the independent variable.

Output

Epoch [100/1000], Loss: 0.0533
Epoch [200/1000], Loss: 0.0484
Epoch [300/1000], Loss: 0.0445
Epoch [400/1000], Loss: 0.0415
Epoch [500/1000], Loss: 0.0392
Epoch [600/1000], Loss: 0.0374
Epoch [700/1000], Loss: 0.0360
Epoch [800/1000], Loss: 0.0349
Epoch [900/1000], Loss: 0.0341
Epoch [1000/1000], Loss: 0.0335

Explanation

The above code defines a linear regression model using PyTorch. First, we create a random dataset with one input variable and one output variable. Then we convert the numpy arrays to PyTorch tensors. The linear regression model is created as a class inheriting from the nn.Module class.

During the training phase, we forward propagate the inputs through the model and compute the loss using the mean squared error (MSE) function. We then backpropagate the loss to adjust the model parameters through stochastic gradient descent (SGD) optimization. This process is repeated for a fixed number of epochs.

Finally, we predict the output values using the trained model.

Use

Linear regression is a powerful technique for making predictions and can be used in various fields such as finance, economics, and engineering. By using PyTorch, we can easily implement linear regression models and train them on large datasets to make accurate predictions.

Important Points

  • PyTorch is a popular deep learning framework that can be used for linear regression modeling.
  • Linear regression is a useful technique for making predictions based on independent variables.
  • PyTorch provides built-in loss functions and optimizers for training linear regression models.
  • Training a linear regression model involves forward propagation of inputs, computation of loss, and optimization of model parameters through backpropagation.

Summary

In conclusion, PyTorch provides an efficient and easy-to-use framework for linear regression modeling. By following the above steps, users can implement and train a linear regression model with good accuracy. Linear regression is a powerful technique for making predictions and can be used in various fields.

Introduction to Linear RegressionCustom Module
Published on: