Pytorch linear regression

1、 Import table data

filename = "./data.csv"
data = pd.read_csv(filename)
features = data.iloc[:,1:]
labels = data.iloc[:,0]

2、 Turn into Tensor form

''' DataFrame ----> Tensor '''
features = torch.tensor(features.values, dtype=torch.float32)

labels = torch.tensor(labels.values, dtype=torch.float32)
labels = torch.reshape(labels,(-1,1))

3、 Generate iterators , Read data in batches

from torch.utils import data
def load_array(data_arrays , batch_size , is_train = True):
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset , batch_size , shuffle = is_train)

batch_size = 10
data_iter = load_array((features,labels),batch_size)

next(iter(data_iter))

4、 Define neural networks

class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.layer1 = nn.Linear(2, 1)

    def forward(self, x):
        return self.layer1(x)

5、 Training network

model = LinearRegression()
gpu = torch.device('cuda')
mse_loss = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.003)
Loss = []
epochs = 1000
def train():
    for i in range(epochs):
        for X , y in data_iter:
            y_hat = model(X)  #  Calculation model output results 
            loss = mse_loss(y_hat, y)  #  Loss function 
            loss_numpy = loss.detach().numpy()
            Loss.append(loss_numpy)
            optimizer.zero_grad()  #  Gradient clear 
            loss.backward()  #  Calculate weights 
            optimizer.step()  #  Modify weights 
        print(i, loss.item(), sep='\t')
train()  #  Training 
for parameter in model.parameters():
    print(parameter)
plt.plot(Loss)

6 The overall code

import matplotlib.pyplot as plt
import pandas as pd
import torch
from torch import nn, optim
from torch.utils import data


class LinearRegression (nn.Module):
    def __init__(self, feature_nums):
        super (LinearRegression, self).__init__ ()
        self.layer1 = nn.Linear (feature_nums, 1)

    def forward(self, x):
        return self.layer1 (x)


def load_array(data_arrays, batch_size, is_train=True):
    dataset = data.TensorDataset (*data_arrays)
    return data.DataLoader (dataset, batch_size, shuffle=is_train)


def Linear_Regression_pytorch(filepath, feature_nums, batch_size, learning_rate, epochs):
    filename = filepath
    data = pd.read_csv (filename)

    features = data.iloc[:, 1:]
    labels = data.iloc[:, 0]

    features = torch.tensor (features.values)
    features = torch.tensor (features, dtype=torch.float32)
    labels = torch.tensor (labels.values)
    labels = torch.tensor (labels, dtype=torch.float32)
    labels = torch.reshape (labels, (-1, 1))

    batch_size = batch_size
    data_iter = load_array ((features, labels), batch_size)
    next (iter (data_iter))

    model = LinearRegression (feature_nums)
    gpu = torch.device ('cuda')
    mse_loss = nn.MSELoss ()
    optimizer = optim.Adam (model.parameters (), lr=learning_rate)
    Loss = []

    epochs = epochs

    for i in range (epochs):
        for X, y in data_iter:
            y_hat = model (X)  #  Calculation model output results 
            loss = mse_loss (y_hat, y)  #  Loss function 
            loss_numpy = loss.detach ().numpy ()

            optimizer.zero_grad ()  #  Gradient clear 
            loss.backward ()  #  Calculate weights 
            optimizer.step ()  #  Modify weights 
        print (i, loss.item (), sep='\t')

        Loss.append (loss.item ())
    for parameter in model.parameters ():
        print (parameter)

    plt.plot (Loss)
    plt.title("Loss")
    plt.show ()


if __name__ == "__main__":
    Linear_Regression_pytorch (filepath="data.csv",
                               feature_nums=2,
                               batch_size=10,
                               learning_rate=0.05,
                               epochs=1000
                               )