刘二大人《PyTorch深度学习实践》—课程代码

课程链接：http://www.bilibili.com/video/BV1Y7411d7Ys/?share_source=copy_web&vd_source=1a32dd27a726236a74603cf06b7302aa

说明：部分代码没有完全按照老师的写法

目录

1. 线性模型

2. 梯度下降

3. 反向传播

4. 用Pytorch实现线性回归

5. 逻辑斯蒂回归

6. 处理多维输入的特征

7. 加载数据集

8. 多分类问题

9. 卷积神经网络——基础篇

10. 卷积神经网络——高级篇

inception网络

resnet网络

11. 循环神经网络-——基础篇

12. 循环神经网络-——高级篇

1. 线性模型

import matplotlib
matplotlib.use('TkAgg')

import matplotlib.pyplot as plt
import numpy as np

x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

def forward(x):
    return x * w

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

w_list = []
mse_list = []

for w in np.arange(0.0,4.1,0.1):
    print("w=",w)
    loss_sum = 0

    for x_val,y_val in zip(x_data,y_data):
        y_pred_val = forward((x_val))
        loss_val = loss(x_val,y_val)
        loss_sum += loss_val
        print("\t",x_val,y_val,y_pred_val,loss_val)
    print("MSE:",loss_sum/len(x_data))
    w_list.append(w)
    mse_list.append(loss_sum/len(x_data))

plt.plot(w_list,mse_list)
plt.ylabel("loss")
plt.xlabel("w")
plt.show()

2. 梯度下降

梯度下降时可进行并行计算因此速度快，随机梯度下降最优值好但是不能进行并行计算，如何兼顾呢？Batch（Mini-Batch）

import matplotlib.pyplot as plt
import numpy as np

# --------------------------梯度下降------------------------------------
x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

w = 1.0 #指定初始w

def forward(x):
    return x * w

def cost(xs,ys):
    cost = 0
    for x,y in zip(xs,ys):
        y_pred = forward(x)
        cost += (y_pred-y)**2
    return cost/len(xs)

def gradient(xs,ys):
    grad = 0
    for x, y in zip(xs,ys):
        grad += 2*x*(x*w-y)
    return grad/len(xs)

print("predict_before training",4,forward(4))

epoch_list = []
cost_list = []

for epoch in range(100):
    cost_val = cost(x_data,y_data)
    grad_val = gradient(x_data,y_data)
    w -= 0.01 * grad_val

    epoch_list.append(epoch)
    cost_list.append(cost_val)

    print("epoch:",epoch,"w:",w,"loss=",cost_val)

print("predict_after training", 4, forward(4))

plt.plot(epoch_list, cost_list)
plt.xlabel("epoch")
plt.ylabel("cost")
plt.show()


# --------------------------随机梯度下降------------------------------------
# x_data = [1.0,2.0,3.0]
# y_data = [2.0,4.0,6.0]
#
# w = 1.0 #指定初始w
#
# def forward(x):
#     return x * w
#
# def loss(x,y):
#     y_pred = forward(x)
#     return (y_pred - y) **2
#
# def gradient(x,y):
#     return  2*x*(x*w-y)
#
# print("predict_before training",4,forward(4))
#
# epoch_list = []
# loss_list = []
#
# for epoch in range(100):
#     for x,y in zip(x_data,y_data):
#         grad = gradient(x,y)
#         l = loss(x,y)
#         w -= 0.01 * grad
#         epoch_list.append(epoch)
#         loss_list.append(l)
#
#         print("epoch:",epoch,"w=",w,"x=",x,"y=",y,"loss=",loss)
#
# print("predict_after training", 4, forward(4))
#
# plt.plot(epoch_list, loss_list)
# plt.xlabel("epoch")
# plt.ylabel("loss")
# plt.show()

3. 反向传播

Tensor 用于保存data :w，grad

import torch

x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

w = torch.tensor([1.0])
w.requires_grad = True #需要对w计算梯度

def forward(x):
    return w * x  #w为tensor类型，相乘时x也会被转化为tensor，且结果也会保留grad

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

print("predict_before training",4,forward(4).item())

for epoch in range(100):
    for x,y in zip(x_data,y_data):
        l = loss(x,y)
        l.backward() #反向传播求出grad且存在w中，计算图释放

        print("x=",x,"y=",y,"grad",w.grad.item(),"w:",w) #可以分别打印w,w.data,w.grad.data加深理解
        print("epoch:", epoch, "loss=", l.item())  # 使用item取出python标量

        print("---------------------------------")

        w.data = w.data-0.01*w.grad.data #注意使用.data
        w.grad.data.zero_() #梯度清零


print("predict_after training",4,forward(4).item())

4. 用Pytorch实现线性回归

nn.MSELoss(size_average=False) 参数size_average即是否进行平均，当最后一个batch数量和前面的batch不同时设置为True。

import torch
from torch import nn

#data
x_data = torch.tensor([[1.0],[2.0],[3.0]])
y_data = torch.tensor([[2.0],[4.0],[6.0]])

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

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

model = LinearModel()

#loss and optimizer
loss = nn.MSELoss(size_average=False) #size_average即是否平均 在最后一个batch不相同时设为TRUE
optimizer = torch.optim.SGD(model.parameters(),lr= 0.01)

#train
for epoch in range(100):
    y_pred = model(x_data)
    l = loss(y_pred,y_data)

    print("epoch",epoch, "loss:",l)

    optimizer.zero_grad() #梯度清零
    l.backward() #反向传播
    optimizer.step() #updata

print("w:",model.linear.weight.item(),"b:",model.linear.bias.item())

#test
x_test = torch.tensor([[4.0]])
y_test = model(x_test)
print("y_pred:",y_test.data)

5. 逻辑斯蒂回归

import torch
import torch.nn.functional as F
from torch import nn

#data
x_data = torch.Tensor([[1.0], [2.0], [3.0]])
y_data = torch.Tensor([[0], [0], [1]]) #注意tensor和Tensor  target需要是浮点型>>>>如果tensor报错RuntimeError: Found dtype Long but expected Float

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

    def forward(self,x):
        y_pred = F.sigmoid(self.linear(x))
        return y_pred

model = LogistModel()

#loss and optimizer
loss = nn.BCELoss(size_average=False) #size_average即是否平均 在最后一个batch不相同时设为TRUE
optimizer = torch.optim.SGD(model.parameters(),lr= 0.01)

#train
for epoch in range(1000):
    y_pred = model(x_data)
    l = loss(y_pred,y_data)

    print("epoch",epoch, "loss:",l.item())

    optimizer.zero_grad() #梯度清零
    l.backward() #反向传播
    optimizer.step() #updata


#test
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt

x = np.linspace(0,10,200) #生成从0到10的均匀分布的包含200个元素的数组x
x_t = torch.Tensor(x).view(200,1)  #.view成为(batch_size, num_features)的形状
y_t = model(x_t)
y = y_t.data.numpy() #张量结果转化为nupy型

plt.plot(x,y)
plt.plot([0, 10],[0.5,0.5], c="r")  #绘制红色直线其y值始终为0.5，x从0到10
plt.xlabel("hours")
plt.ylabel("probabability of pass")
plt.grid() #添加网格线
plt.show()

6. 处理多维输入的特征

矩阵是空间变换的函数 这个理解太牛了

import numpy as np
import torch
from torch import nn
#data
xy = np.loadtxt("diabetes.csv.gz",delimiter=",",dtype=np.float32)
x_data = torch.from_numpy(xy[:,:-1]) #注意切片操作
y_data = torch.from_numpy(xy[:,[-1]])

#model
class Model(nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.linear1 = nn.Linear(8,6) #矩阵是空间变换的函数！ 8D-6D寻找非线性的空间变换
        self.linear2 = nn.Linear(6,4)
        self.linear3 = nn.Linear(4,1)
        self.sigmoid = nn.Sigmoid()
        # self.activation = nn.ReLU()

    def forward(self,x):
        # x = self.activation(self.linear1(x))
        # x = self.activation(self.linear2(x))
        # x = self.activation(self.linear3(x))
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))
        return x

model = Model()

#loss and optimizer
loss = nn.BCELoss()
opyimizer = torch.optim.SGD(model.parameters(),lr=0.01)

for epoch in range(1000):
    y_pred = model(x_data)
    l = loss(y_pred,y_data)

    print("epoch：",epoch,"loss:",l.item())

    opyimizer.zero_grad()
    l.backward()
    opyimizer.step()

7. 加载数据集

构建数据集时继承Dataset 抽象类

import numpy
import numpy as np
import torch
from torch.utils.data import Dataset, DataLoader
from torch import nn
#data
class Data(Dataset): #抽象类 只能继承不能实例化
    def __init__(self,filepath):
        xy = numpy.loadtxt(filepath,delimiter=",",dtype=np.float32)
        self.len = xy.shape[0]
        self.x_data = torch.from_numpy(xy[:,:-1])
        self.y_data = torch.from_numpy(xy[:,[-1]])

    def __getitem__(self, idx):
        return self.x_data[idx],self.y_data[idx]

    def __len__(self):
        return self.len

data = Data("diabetes.csv.gz")
train_loader = DataLoader(data,batch_size=8,shuffle=True)

#model
class Model(nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.linear1 = nn.Linear(8,6)
        self.linear2 = nn.Linear(6,4)
        self.linear3 = nn.Linear(4,1)
        self.sigmoid = nn.Sigmoid()

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

model = Model()

#loss and optimize
loss = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(),lr=0.01)

#train
for epoch in range(1000):
    # for datas in train_loader:
    for i,datas in enumerate(train_loader,0):
        inputs , labels = datas
        y_pred = model(inputs)
        l = loss(y_pred,labels)

        print("epoch:",epoch,"i：",i,"loss:",l.item())

        optimizer.zero_grad()
        l.backward()
        optimizer.step()

8. 多分类问题

import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets,transforms
from torch import nn
from torch.utils.tensorboard import SummaryWriter

#mean,std提前计算使得MINIST满足01分布，元组只包含一个元素，需要在后面加上逗号来表示它是一个元组 也可以使用元组或者张量表示
trans = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])

#data
train_data = datasets.MNIST("./MINIST",train=True,transform=trans,download=True)
test_data = datasets.MNIST("./MINIST",train=False,transform=trans,download=True)

print(len(train_data),len(test_data))

train_loader = DataLoader(train_data,batch_size=8,shuffle=True)
test_loader = DataLoader(test_data,batch_size=8,shuffle=True)

#model
class Model(nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.linear1 = nn.Linear(784,512)
        self.linear2 = nn.Linear(512,256)
        self.linear3 = nn.Linear(256,128)
        self.linear4 = nn.Linear(128, 64)
        self.linear5 = nn.Linear(64, 10)
        # self.activation = F.relu()

    def forward(self,x):
        x = x.view(-1,784)  #view重塑张量维度  -1自动计算
        x = F.relu(self.linear1(x))
        x = F.relu(self.linear2(x))
        x = F.relu(self.linear3(x))
        x = F.relu(self.linear4(x))
        x =self.linear5(x)
        return x

model = Model()

#loss and optimize
loss = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(),lr=0.01,momentum=0.5) #动量在更新参数时会考虑之前的梯度信息

#for tensorboard
writer = SummaryWriter("logs")

#train＆test
def train(epoch):
    running_loss = 0
    for i,data in enumerate(train_loader,0):
        inputs,targets = data
        outputs = model(inputs)
        l = loss(outputs,targets)

        optimizer.zero_grad()
        l.backward()
        optimizer.step()

        running_loss += l.item()
        if i % 300 == 299: #300张打印一次
            print("[%d, %5d] loss: %.3f" % (epoch+1,i+1,running_loss/300))
            writer.add_scalar("train_loss", running_loss/300,epoch)
            running_loss = 0
            """
            %格式化运算符
            %d 将 (epoch+1) 格式化为整数，并插入到字符串中。
            %5d 将 (i+1) 格式化为宽度为5的整数，并插入到字符串中。
            %.3f 将 running_loss/300 格式化为小数点后保留3位的浮点数，并插入到字符串中。
            """
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images,targets = data
            outputs = model(images)
            _,predicted = torch.max(outputs.data,dim=1) #返回最大值和最大值对应的索引

            total += targets.size(0) #0维度为样本数量 1为每个样本的类别信息
            correct += (predicted==targets).sum().item()
            accuracy =100 * correct / total
    writer.add_scalar("test_accuracy",accuracy,epoch)
    print("Accuracy on test set: %.2f %%" % (100 * correct / total)) #%% 表示百分号本身

writer.close()


if __name__ == "__main__":
    for epoch in range(10):
        train(epoch)
        test()

9. 卷积神经网络——基础篇

import torch
import torchvision
from torch.utils.data import DataLoader
from torchvision import transforms
from torch import nn
from torch.nn import functional as F

trans = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])

#prepare data
train_data = torchvision.datasets.MNIST("./MINIST",train=True,transform=trans,download=True)
test_data = torchvision.datasets.MNIST("./MINIST",train=False,transform=trans,download=True)

#dataloader
train_loader = DataLoader(train_data,batch_size=8,shuffle=True,drop_last=False)
test_loader = DataLoader(test_data,batch_size=8,shuffle=True,drop_last=False)

#lena＆size
print(len(train_data),len(test_data))
print(train_data.data.shape)
print(test_data.data.shape)

#device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

#Net
class Net (nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1 = nn.Conv2d(1,10,kernel_size=5)
        self.maxpool = nn.MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(10,20,5)
        self.flattten = nn.Flatten()
        self.linear = nn.Linear(320,10)

    def forward(self,x):
        batch_sz = x.size(0)
        x = F.relu(self.maxpool(self.conv1(x)))
        x = F.relu(self.maxpool(self.conv2(x)))
        # x = self.flattten(x)
        x = x.view(batch_sz,-1)
        x = self.linear(x)
        return x

net = Net()
net.to(device)

#loss＆optimizer
loss = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(),lr=0.01,momentum=0.5)

#train
def train(epoch):
    runing_loss = 0
    # for datas in train_loader:
    for i, datas in enumerate(train_loader,0): #->return idx and data
        imgs,lables = datas
        imgs,lables = imgs.to(device),lables.to(device)
        pred = net(imgs)
        l = loss(pred,lables)

        optimizer.zero_grad()
        l.backward()
        optimizer.step()

        runing_loss += l.item()
        if i % 300 == 299:
            print("[%.2d,%.5d], loss:%.3f" % (epoch+1, i+1, runing_loss/300))

# def test():
#     correct = 0
#     total = 0
#     with torch.no_grad():
#         for datas in test_loader:
#             imgs, lables = datas
#             imgs, lables = imgs.to(device), lables.to(device)
#             pred = net(imgs)
#             total += lables.size(0)
#             correct += (pred.argmax(1) == lables).sum().item()
#             accuracy =100 * correct / total
#     print("accuracy on test:{}".format(accuracy))

def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images,targets = data
            images, targets = images.to(device),targets.to(device)
            outputs = net(images)
            _,predicted = torch.max(outputs.data,dim=1) #返回最大值和最大值对应的索引

            total += targets.size(0) #0维度为样本数量 1为每个样本的类别信息
            correct += (predicted==targets).sum().item()
    print("Accuracy on test set: %.2f %%" % (100 * correct / total)) #%% 表示百分号本身


if __name__ =="__main__":
    for epoch in range(10):
        train(epoch)
        test()

# accuracy on test:98.95

10. 卷积神经网络——高级篇

inception网络

import torch
import torchvision
from torch.utils.data import DataLoader
from torchvision import transforms
from torch import nn
from torch.nn import functional as F

trans = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])

#prepare data
train_data = torchvision.datasets.MNIST("./MINIST",train=True,transform=trans,download=True)
test_data = torchvision.datasets.MNIST("./MINIST",train=False,transform=trans,download=True)

#dataloader
train_loader = DataLoader(train_data,batch_size=8,shuffle=True,drop_last=False)
test_loader = DataLoader(test_data,batch_size=8,shuffle=True,drop_last=False)

#device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

#Net
class InceptionA (nn.Module):
    def __init__(self,in_channels):
        super(InceptionA,self).__init__()
        self.branch1x1 = nn.Conv2d(in_channels,16,1)

        self.branch5x5_1 = nn.Conv2d(in_channels,16,1)
        self.branch5x5_2 = nn.Conv2d(16,24,5,padding=2)

        self.branch3x3_1 = nn.Conv2d(in_channels,16,1)
        self.branch3x3_2 = nn.Conv2d(16,24,3,padding=1)
        self.branch3x3_3 = nn.Conv2d(24,24,3,padding=1)

        self.branchpool_2 = nn.Conv2d(in_channels,24,1)

    def forward(self,x):
        branch1x1 = self.branch1x1(x)

        branch5x5 = self.branch5x5_1(x)
        branch5x5 = self.branch5x5_2(branch5x5)

        branch3x3 = self.branch3x3_1(x)
        branch3x3 = self.branch3x3_2(branch3x3)
        branch3x3 = self.branch3x3_3(branch3x3)

        branchpool = F.avg_pool2d(x,kernel_size=3,stride=1,padding=1)
        branchpool = self.branchpool_2(branchpool)

        outputs = [branch1x1,branch3x3,branch5x5,branchpool]
        return torch.cat(outputs,dim=1)

class Net (nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1 = nn.Conv2d(1,10,5)
        self.conv2 = nn.Conv2d(88,20,5)

        self.incep1 = InceptionA(in_channels=10)
        self.incep2 = InceptionA(in_channels=20)

        self.mp = nn.MaxPool2d(2)
        self.fc = nn.Linear(1408,10)

    def forward(self,x):
        in_size = x.size(0)
        x = F.relu(self.mp(self.conv1(x)))
        x = self.incep1(x)
        x = F.relu(self.mp(self.conv2(x)))
        x = self.incep2(x)
        x = x.view(in_size,-1)
        # print(x.shape)
        x = self.fc(x)
        return x

net = Net()
net.to (device)

#loss and optimizer
loss = nn.CrossEntropyLoss()
loss.to(device)
optimizer = torch.optim.SGD(net.parameters(),lr=0.01)

#train
def train(epoch):
    runing_loss = 0
    i = 0
    for data in train_loader:
        imgs,labels = data
        imgs,labels = imgs.to(device),labels.to(device)
        output = net(imgs)
        l = loss(output,labels)

        optimizer.zero_grad()
        l.backward()
        optimizer.step()

        runing_loss += l.item()
        i += 1
        if i % 300 ==0:
            print("epoch:{},i:{},loss:{}".format(epoch,i,runing_loss))

def test():
    correct = 0
    total = len(test_data)
    with torch.no_grad():
        for data in test_loader:
            imgs, labels = data
            imgs, labels = imgs.to(device), labels.to(device)
            output = net(imgs)
            l = loss(output,labels)

            # correct += (torch.argmax(output,dim=1)==labels).sum().item()
            correct += (output.argmax(1) == labels).sum().item()

    accuracy = 100*correct/total
    print("Accuracy in test:",accuracy,"%",  correct,"/",total)


if __name__ =="__main__":
    for epoch in range(10):
        train(epoch)
        test()
# Accuracy in test: 99.08 % 9908 / 10000

resnet网络

import torch
import torchvision
from torch.utils.data import DataLoader
from torchvision import transforms
from torch import nn
from torch.nn import functional as F

trans = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])

#prepare data
train_data = torchvision.datasets.MNIST("./MINIST",train=True,transform=trans,download=True)
test_data = torchvision.datasets.MNIST("./MINIST",train=False,transform=trans,download=True)

#dataloader
train_loader = DataLoader(train_data,batch_size=8,shuffle=True,drop_last=False)
test_loader = DataLoader(test_data,batch_size=8,shuffle=True,drop_last=False)

#device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

#Net
class Residualblock (nn.Module):
    def __init__(self,channels):
        super(Residualblock,self).__init__()
        self.channels = channels
        self.conv1 = nn.Conv2d(channels,channels,3,padding=1)
        self.conv2 = nn.Conv2d(channels,channels,3,padding=1)

    def forward(self,x):
        y = F.relu(self.conv1(x))
        y = self.conv2(y)
        return F.relu(x+y)

class Net (nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1 = nn.Conv2d(1,16,5)
        self.conv2 = nn.Conv2d(16,32,5)
        self.mp = nn.MaxPool2d(2)

        self.rblock1 = Residualblock(16)
        self.rblock2 = Residualblock(32)

        self.fc = nn.Linear(512,10)

    def forward(self,x):
        in_size = x.size(0)
        x = self.mp(F.relu(self.conv1(x)))
        x = self.rblock1(x)
        x = self.mp(F.relu(self.conv2(x)))
        x = self.rblock2(x)
        x = x.view(in_size,-1)
        x = self.fc(x)
        return x

net = Net()
net.to (device)

#loss and optimizer
loss = nn.CrossEntropyLoss()
loss.to(device)
optimizer = torch.optim.SGD(net.parameters(),lr=0.01)

#train
def train(epoch):
    runing_loss = 0
    i = 0
    for data in train_loader:
        imgs,labels = data
        imgs,labels = imgs.to(device),labels.to(device)
        output = net(imgs)
        l = loss(output,labels)

        optimizer.zero_grad()
        l.backward()
        optimizer.step()

        runing_loss += l.item()
        i += 1
        if i % 300 ==0:
            print("epoch:{},i:{},loss:{}".format(epoch,i,runing_loss))

def test():
    correct = 0
    total = len(test_data)
    with torch.no_grad():
        for data in test_loader:
            imgs, labels = data
            imgs, labels = imgs.to(device), labels.to(device)
            output = net(imgs)
            l = loss(output,labels)

            # correct += (torch.argmax(output,dim=1)==labels).sum().item()
            correct += (output.argmax(1) == labels).sum().item()

    accuracy = 100*correct/total
    print("Accuracy in test:",accuracy,"%",  correct,"/",total)


if __name__ =="__main__":
    for epoch in range(10):
        train(epoch)
        test()
# Accuracy in test: 99.34 % 9934 / 10000

11. 循环神经网络-——基础篇

import torch

input_size = 4
hidden_size = 4
batch_size = 1

idx2char = ['e','h','l','0']  #seg to seg  'hello'----->'ohlol'
x_data = [1,0,2,2,3]
y_data = [3,1,2,3,2]

one_hot_lookup = [[1,0,0,0],
                  [0,1,0,0],
                  [0,0,1,0],
                  [0,0,0,1]]
x_one_hot = [one_hot_lookup[x] for x in x_data]  #转化为独热编码

inputs = torch.Tensor(x_one_hot).view(-1,batch_size,input_size)
labels = torch.LongTensor(y_data).view(-1,1)

class Model(torch.nn.Module):
    def __init__(self,input_size,hidden_size,batch_size):
        super(Model, self).__init__()
        self.batch_size = batch_size
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.rnncell = torch.nn.RNNCell(input_size=self.input_size,hidden_size=self.hidden_size)

    def forward(self,input,hidden):
        hidden = self.rnncell(input,hidden)
        return hidden

    def init_hideen(self):
        return torch.zeros(self.batch_size,self.hidden_size)

net = Model(input_size,hidden_size,batch_size)

criteerion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(),lr=0.01)

for epoch in range(15):
    loss = 0
    optimizer.zero_grad()
    hidden = net.init_hideen()
    print('predicted sting:', end='') #end输出内容之后不换行
    for input,label in zip (inputs,labels):
        hidden = net(input,hidden)
        loss += criteerion(hidden,label)
        _,idx = hidden.max(dim=1)
        print(idx2char[idx.item()],end='')
    loss.backward()
    optimizer.step()
    print(',Epoch [%d/15],loss = %.4f' % (epoch+1,loss.item()))

12. 循环神经网络-——高级篇

烂尾了。。。之后有时间再补