pytorch实践

1、pytorch实现线性模型

import torch.nn as nn
import torch

x_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[2.0],[4.0],[6.0]])
#继承自nn.Module就是可调用的 且有计算图 可以求梯度
class ModelLinear(nn.Module):
    def __init__(self):
        super(ModelLinear,self).__init__()
        self.linear=nn.Linear(1,1)  #这也是可调用的
    def forward(self,x):
        return self.linear(x)
model=ModelLinear()
#定义损失 也是可调用的 且有计算图
loss=nn.MSELoss(reduction='mean')
optimizer=torch.optim.SGD(model.parameters(),lr=0.05)

for epoch in range(150):
    y_pred=model(x_data)
    l=loss(y_pred,y_data)  #前馈
    optimizer.zero_grad()  #清零
    l.backward()  #反馈
    optimizer.step() #更新
print('w:',model.linear.weight.item())

注意：
1、tensor 中可以迭代tensor
2、tensor对象.item() 可以将tensor转化为一个python的数值
但是tensor.data 仍然是tensor类型 但是不会有计算图了，关闭了计算图功能
3、继承自nn.Module 就是可调用的 且有计算图 可以求梯度

2、实现逻辑回归

import torch.nn as nn
import torch

x_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[0],[0],[1]])
#继承自nn.Module就是可调用的
class ModelLogsitic(nn.Module):
    def __init__(self):
        super(ModelLogsitic,self).__init__()
        self.linear=nn.Linear(1,1)  # 输入的维度 输出的维度 是一个数据的维度
    def forward(self,x):
        return torch.nn.functional.sigmoid(self.linear(x))
model=ModelLogsitic()
#定义损失 也是可调用的 且有计算图
loss=nn.BCELoss(reduction='mean')
optimizer=torch.optim.SGD(model.parameters(),lr=0.05)

for epoch in range(150):
    y_pred=model(x_data)
    l=loss(y_pred,y_data)  #前馈
    optimizer.zero_grad()  #清零
    l.backward()  #反馈
    optimizer.step() #更新
x_pre=torch.Tensor([2.1])
print('w:',model(x_pre).item())

3、加载数据集

import torch
from torch.utils.data import Dataset,DataLoader
'''
Dataset 是一个抽象类 必须实现 不能直接实例化
Dataloader 可以直接实例化
'''
class MyDataset(Dataset):
    def __init__(self):
        pass  #初始化加载文件
    def __len__(self):
        pass  #长度
    def __getitem__(self, index):
        pass  #根据index获取
dataset=MyDataset()  #数据集
#mini—batch 加载数据集
train_loader=DataLoader(dataset=dataset,shuffle=True,batch_size=4,num_workers=2)
for epoch in range(100):
    for i,data in enumerate(train_loader,0):
        inputs,label=data

4、多分类

import torch
from torch.utils.data import Dataset,DataLoader
train_loader=DataLoader()
import torch.nn as nn
#继承自nn.Module就是可调用的
class ModelLinear(nn.Module):
    def __init__(self):
        super(ModelLinear,self).__init__()
        self.linear=nn.Linear(1,1)
    def forward(self,x):
        return self.linear(x)
model=ModelLinear()
criterion=nn.CrossEntropyLoss()
optimizer=torch.optim.SGD(model.parameters(),lr=0.05)
def train(epoch):
    running_loss=0
    for i,data in enumerate(train_loader,0):
        inputs,labels=data
        y_pred=model(inputs)
        loss=criterion(y_pred,labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        running_loss+=loss.item()  #要加上item 否则会形成计算图 占内存 loss是一个标量
        if epoch%300==299:  #显示多少次迭代输出一次
            print()
            running_loss=0



def test():
    correct=0
    total=0
    with torch.no_grad():
        for i,data in enumerate(test_loader,0):
            inputs,labels=data
            y_pre=model(inputs)
            _,y_labels=torch.max(y_pre.data,dim=1)
            total+=labels.size(0)
            correct+=(y_labels==labels).sum().item()
        print(100*correct/total)
if __name__ == "__main__":
    for epoch in range(10):
        train(epoch)
        test()