pytorch入门

import torch


def forward(x):
    return x*w


def loss(x, y):
    y_hat = forward(x)
    return (y-y_hat)**2


if __name__ == "__main__":
    x_data = [1., 2., 3.]
    y_data = [2., 4., 6.]
    w = torch.tensor([1.0])
    w.requires_grad = True

    for epochs in range(1000):
        for x, y in zip(x_data, y_data):
            losses = loss(x, y)
            losses.backward()

            w.data = w.data - w.grad.data * 0.001
            # w, w.grad are both tensor
            # we need to extract w.data to compute
            # if not ,we are building compute calculation diagram
            w.grad.data = w.grad.data.zero_()
            # after update， it is essential to reset grad to zero
        print(f"epochs:{epochs} \n loss:{losses.item()}  \n")

    print(f"forward(5), ", forward(5))

• 在构建进行计算的时候，如果之间进行tensor的运算，那么运算是构建计算图，如果想要不构建计算图修改tensor的值，那么应该取data属性。

import torch


class MyModel(torch.nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.linear = torch.nn.Linear(1, 1)
        # define the model

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


if __name__ == "__main__":
    x_data = torch.tensor([[1.], [2.], [3.], [4.]])
    y_data = torch.tensor([[3.], [5.], [7.], [9.]])
    # every element should use [] to contain in order to specify that it is a sample 
    # if not it means x contain only one sample with a 3-dim vector instead of 3 1-dim vectors.

    model = MyModel()
    criterion = torch.nn.MSELoss(size_average=False)
    #optimizer = torch.optim.SGD(params=model.parameters(), lr=0.001)
    optimer = torch.optim.Adam(model.parameters, lr = 0.001)
    for ep in range(10000):
        y_pred = model(x_data)
        loss = criterion(y_pred, y_data)
        print(ep, loss)

        optimizer.zero_grad()
        # don't forget to reset the grad
        loss.backward()
        optimizer.step()
    print(f'w={model.linear.weight.data}\n')
    print(f'b={model.linear.bias.data}')
    # print the weight of a and the bias of b

• 输入的训练数据必须是tensor
• torch的优化器可以和模型奋力，并不类似tensorflow，在模型编译的时候调用$model.compile(optimizer=...,loss=...)$

一点小修改就可以编程逻辑回归的分类模型

# -*-coding=utf-8
import torch
import torch.nn.functional as F


class MyModel(torch.nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.linear = torch.nn.Linear(1, 1)
        # define the model

    def forward(self, x):
        y_hat = F.sigmoid(self.linear(x))
        # add the sigmoid function
        return y_hat


if __name__ == '__main__':
    x_data = torch.tensor([[1.], [2.], [3.], [4.]])
    y_data = torch.tensor([[0.], [0.], [1.], [1.]])
    model = MyModel()
    criterion = torch.nn.BCELoss(size_average=False)
    # change the loss function
    optimizer = torch.optim.SGD(params=model.parameters(), lr=.001)
    for ep in range(1000):
        y_pred = model(x_data)
        loss = criterion(y_pred, y_data)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        print(f"epochs:{ep}\nloss:{loss.item()}")

    print(model(torch.tensor([2.4])))

同样，我们可以借此做出多层感知机模型

# -*-coding=utf-8
import torch
import numpy as np
from sklearn import datasets


class MyModel(torch.nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        # don't worry about the bias, it will be done automatically
        self.linear1 = torch.nn.Linear(9, 6)
        # the bias do not add a new dimension
        self.linear2 = torch.nn.Linear(6, 4)
        self.linear3 = torch.nn.Linear(4, 1)
        self.activate = torch.nn.Sigmoid()
        # wo can change the activation, such as relu, sign
        # define the model

    def forward(self, x):
        x = self.activate(self.linear1(x))
        x = self.activate(self.linear2(x))
        x = self.activate(self.linear3(x))
        return x


if __name__ == "__main__":
    data1 = datasets.load_diabetes()
    x = torch.from_numpy(np.array(data1.data[:, :-1], dtype=np.float32))
    y = torch.from_numpy(np.array(data1.data[:, [-1]], dtype=np.float32))

    model = MyModel()
    # we must use y = torch.from_numpy(data[:, [-1]) to build a matrix
    # instead of (data[:, -1]) which build a tensor
    criterion = torch.nn.BCELoss(size_average=False)
    optimizer = torch.optim.SGD(params=model.parameters(), lr=0.001)
    for ep in range(1000):
        y_pred = model(x)
        loss = criterion(y_pred, y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        print(f"epoch:{ep}\nloss:{loss.item()}")

DataLoader的设置

# -*-coding = utf-8
import numpy as np
import torch
from sklearn import datasets
from torch.utils.data import Dataset
# dataset is a abstract class, it can't be instantiation, its use for inherit
from torch.utils.data import DataLoader


class DiabetesDataset(Dataset):
    def __init__(self, path=None):
        da = datasets.load_diabetes()
        xy = np.array(da.data, dtype=np.float32)
        self.len = xy.shape[0]
        self.x_data = torch.from_numpy(xy[:, :-1])
        self.y_data = torch.from_numpy(xy[:, [-1]])

	# define this function to support [] implementation
    def __getitem__(self, item):
        return self.x_data[item], self.y_data[item]
    # support len(model)implementation
    def __len__(self):
        return self.len


class MyModel(torch.nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        # don't worry about the bias, it will be done automatically
        self.linear1 = torch.nn.Linear(9, 6)
        # the bias do not add a new dimension
        self.linear2 = torch.nn.Linear(6, 4)
        self.linear3 = torch.nn.Linear(4, 1)
        self.activate = torch.nn.Sigmoid()
        # wo can change the activation, such as relu, sign
        # define the model

    def forward(self, x):
        x = self.activate(self.linear1(x))
        x = self.activate(self.linear2(x))
        x = self.activate(self.linear3(x))
        return x


if __name__ == "__main__":
    data = DiabetesDataset()
    train_loader = DataLoader(dataset=data, batch_size=320, shuffle=True, num_workers=8)
    model = MyModel()
    criterion = torch.nn.BCELoss(size_average=False)
    optimizer = torch.optim.SGD(params=model.parameters(), lr=0.001)
    for ep in range(1000):
        for i, (x, y) in enumerate(train_loader):
            y_pred = model(x)
            loss = criterion(y_pred, y)

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

            print(f"epoch{ep}\nloss:{loss.item()}")