Pytorch

一、pytorch

1线性回归

#回归问题
import torch
x_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[11.0],[12.0],[13.0]])
class LinearModer(torch.nn.Module):
    def __init__(self):
        super(LinearModer,self).__init__()
        self.linear=torch.nn.Linear(1,1)
        
    def forward(self,x):
        y_pred=self.linear(x)
        return y_pred
model=LinearModer()
criterion = torch.nn.MSELoss(size_average=False)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(1000):
    y_pred=model(x_data)
    loss=criterion(y_pred,y_data)
    print(epoch,loss.item())
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
print('w=',model.linear.weight.item())
print('b=',model.linear.bias.item())

x_test=torch.Tensor([[4.0]])
y_test=model(x_test)
print('y_pred =',y_test.data)

2逻辑回归

#分类问题
import torch
import torch.nn.functional as F
x_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[0],[0],[1]])
class LogisticModer(torch.nn.Module):
    def __init__(self):
        super(LogisticModer,self).__init__()
        self.linear=torch.nn.Linear(1,1)
        
    def forward(self,x):
        y_pred=F.sigmoid(self.linear(x))
        return y_pred
model=LogisticModer()
criterion = torch.nn.BCELoss(size_average=False)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(2000):
    y_pred=model(x_data)
    loss=criterion(y_pred,y_data)
    print(epoch,loss.item())
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
print('w=',model.linear.weight.item())
print('b=',model.linear.bias.item())

x_test=torch.Tensor([[4.0]])
y_test=model(x_test)
print('y_pred =',y_test.data)

3多维特征输入

import torch
import numpy as np
from matplotlib import pyplot as plt
import pandas as pd
#加载数据集
xy = pd.read_csv('./pima-indians-diabetes-master/FE_pima-indians-diabetes.csv',dtype=np.float32)
a=xy.head(568)
b=xy.loc[568:768]
a=a.values
b=b.values
x_data=torch.from_numpy(a[:,:-1])
y_data=torch.from_numpy(a[:,[-1]])
x_test=torch.from_numpy(b[:,:-1])
#搭建模型
class Model(torch.nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.linear1=torch.nn.Linear(8, 6)
        self.linear2=torch.nn.Linear(6, 4)
        self.linear3=torch.nn.Linear(4, 1)
        self.sigmoid=torch.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
#设计loss,优化器
model=Model()
criterion=torch.nn.BCELoss(size_average=True)
optimizer=torch.optim.SGD(model.parameters(),lr=0.1)
#循环训练
for epoch in range(1000):
    #forword
    y_pred=model(x_data)
    loss=criterion(y_pred,y_data)
    print(epoch,loss.item())
    #backword
    optimizer.zero_grad()
    loss.backward()
    #update
    optimizer.step()
    

y_test=model(x_test)
#print('y_pred =',y_test.data)

4加载数据集

import torch
import numpy as np
from matplotlib import pyplot as plt
import pandas as pd
from torch.utils.data import Dataset,DataLoader
#加载数据集
class DiabetesDatasets(Dataset):
    def __init__(self,filepath):
        xy = pd.read_csv(filepath,dtype=np.float32)
        a=xy.head(568)
        a=a.values
        self.len=a.shape[0]
        self.x_data=torch.from_numpy(a[:,:-1])
        self.y_data=torch.from_numpy(a[:,[-1]])
    def __getitem__(self,index):
        return self.x_data[index],self.y_data[index]
    def __len__(self):
        return self.len
dataset=DiabetesDatasets('./pima-indians-diabetes-master/FE_pima-indians-diabetes.csv')
train_loader=DataLoader(dataset=dataset,
                        batch_size=32,
                        shuffle=True,
                        num_workers=0)

#搭建模型
class Model(torch.nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.linear1=torch.nn.Linear(8, 6)
        self.linear2=torch.nn.Linear(6, 4)
        self.linear3=torch.nn.Linear(4, 1)
        self.sigmoid=torch.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
#设计loss,优化器
model=Model()
criterion=torch.nn.BCELoss(size_average=True)
optimizer=torch.optim.SGD(model.parameters(),lr=0.1)
#循环训练
if __name__=='__main__':
    for epoch in range(100):
        for i ,data in enumerate(train_loader,0):
            #1.Prepare data
            inputs,labels=data
            #2.Forword
            y_pred=model(inputs)
            loss=criterion(y_pred,labels)
            print(epoch,i,loss.item())
            #3.backword
            optimizer.zero_grad()
            loss.backward()
            #4.update
            optimizer.step()
            

5多分类问题

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
#数据准备
batch_size=64
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])
train_dataset = datasets.MNIST(root='../datasets/mnist/',train=True,download=True,transform=transform)
train_loader=DataLoader(train_dataset,shuffle=True,batch_size=batch_size)
test_dataset=datasets.MNIST(root='../datasets/mnist/',train=False,download=True,transform=transform)
test_loader=DataLoader(test_dataset,shuffle=False,batch_size=batch_size)
#设计模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.l1=torch.nn.Linear(784,512)
        self.l2=torch.nn.Linear(512,256)
        self.l3=torch.nn.Linear(256,128)
        self.l4=torch.nn.Linear(128,64)
        self.l5=torch.nn.Linear(64,10)
        
    def forward(self,x):
        x=x.view(-1,784)
        x=F.relu(self.l1(x))
        x=F.relu(self.l2(x))
        x=F.relu(self.l3(x))
        x=F.relu(self.l4(x))
        return self.l5(x)
model=Net()
#设计损失函数，构建优化器
criterion=torch.nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)
#循环训练
def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs, target = data
        optimizer.zero_grad()
        #forward+backward+update
        outputs=model(inputs)
        loss=criterion(outputs,target)
        loss.backward()
        optimizer.step()
        
        running_loss+=loss.item()
        if batch_idx%300==299:
            print('[%d,%5d] loss:%.3f'%(epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0
def test():
    correct=0
    total=0
    with torch.no_grad():
        for data in test_loader:
            images,labels=data
            outputs=model(images)
            _,predicted=torch.max(outputs.data,dim=1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()
    print('Accuracy on test set:%d %%' % (100*correct/total))
if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

6卷积神经网络

TextCNN笔记

嵌入层Embedding：

将每个词改为其对应的词向量。
词向量：可以理解为词在计算机中的含义。([我]->[0.6,0.5,0.6])
特征提取：语义相近的词, 其欧氏距离或余弦距离也比较近。

卷积层Convolution：

将Embedding与kernel_sizes=(2,3,4)进行卷积（宽一样，高不同），输出3个卷积层（[6，1][5，1][4，1]）
一个卷积层：可以理解为词义、词序、其上下文

池化层MaxPolling：

将卷积层压缩为一个像素点（1-max pooling：取出值最大的一个表示该特征）

全连接层FullConnection :

将MaxPolling后的特征，进行全连接。

激活函数Softmax：

通过Softmax输出每个类别的概率

链接: 链接.

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
#数据准备
batch_size=64
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])
train_dataset = datasets.MNIST(root='../datasets/mnist/',train=True,download=True,transform=transform)
train_loader=DataLoader(train_dataset,shuffle=True,batch_size=batch_size)
test_dataset=datasets.MNIST(root='../datasets/mnist/',train=False,download=True,transform=transform)
test_loader=DataLoader(test_dataset,shuffle=False,batch_size=batch_size)
#设计模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1=torch.nn.Conv2d(1,10,kernel_size=5)
        self.conv2=torch.nn.Conv2d(10,20,kernel_size=5)
        self.pooling=torch.nn.MaxPool2d(2)
        self.fc=torch.nn.Linear(320,10)
        
    def forward(self,x):
        batch_size=x.size(0)
        x=F.relu(self.pooling(self.conv1(x)))
        x=F.relu(self.pooling(self.conv2(x)))
        x=x.view(batch_size,-1)
        x=self.fc(x)
        return x
model=Net()
#device=torch.device("cuda"if torch.cuda.is_available() else "cpu")   #使用GPU
#model.to(device)
#设计损失函数，构建优化器
criterion=torch.nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)
#循环训练
def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs, target = data
        #inputs,target=inputs.to.(device),target.to(device) #使用GPU
        optimizer.zero_grad()
        #forward+backward+update
        outputs=model(inputs)
        loss=criterion(outputs,target)
        loss.backward()
        optimizer.step()
        
        running_loss+=loss.item()
        if batch_idx%300==299:
            print('[%d,%5d] loss:%.3f'%(epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0
def test():
    correct=0
    total=0
    with torch.no_grad():
        for data in test_loader:
            images,labels=data
            outputs=model(images)
            _,predicted=torch.max(outputs.data,dim=1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()
    print('Accuracy on test set:%d %%' % (100*correct/total))
if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

7GoogLeNet_卷积神经网络

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import torch.nn as nn
#数据准备
batch_size=64
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])
train_dataset = datasets.MNIST(root='../datasets/mnist/',train=True,download=True,transform=transform)
train_loader=DataLoader(train_dataset,shuffle=True,batch_size=batch_size)
test_dataset=datasets.MNIST(root='../datasets/mnist/',train=False,download=True,transform=transform)
test_loader=DataLoader(test_dataset,shuffle=False,batch_size=batch_size)
#设计模型
class InceptionA(nn.Module):
    def __init__(self,in_channels):
        super(InceptionA,self).__init__()
        self.branch1x1=nn.Conv2d(in_channels,16,kernel_size=1)
        
        self.branch5x5_1=nn.Conv2d(in_channels,16,kernel_size=1)
        self.branch5x5_2=nn.Conv2d(16,24,kernel_size=5,padding=2)
        
        self.branch3x3_1=nn.Conv2d(in_channels,16,kernel_size=1)
        self.branch3x3_2=nn.Conv2d(16,24,kernel_size=3,padding=1)
        self.branch3x3_3=nn.Conv2d(24,24,kernel_size=3,padding=1)
        
        self.branch_pool=nn.Conv2d(in_channels,24,kernel_size=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)
        
        branch_pool=F.avg_pool2d(x,kernel_size=3,stride=1,padding=1)
        branch_pool=self.branch_pool(branch_pool)
        
        outputs=[branch1x1,branch5x5,branch3x3,branch_pool]
        return torch.cat(outputs,dim=1)
        
class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1=nn.Conv2d(1,10,kernel_size=5)
        self.conv2=nn.Conv2d(88,20,kernel_size=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)
        x=self.fc(x)
        return x
model=Net()
#设计损失函数，构建优化器
criterion=torch.nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)
#循环训练
def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs, target = data
        optimizer.zero_grad()
        #forward+backward+update
        outputs=model(inputs)
        loss=criterion(outputs,target)
        loss.backward()
        optimizer.step()
        
        running_loss+=loss.item()
        if batch_idx%300==299:
            print('[%d,%5d] loss:%.3f'%(epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0
def test():
    correct=0
    total=0
    with torch.no_grad():
        for data in test_loader:
            images,labels=data
            outputs=model(images)
            _,predicted=torch.max(outputs.data,dim=1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()
    print('Accuracy on test set:%d %%' % (100*correct/total))
if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

8ResidualNetwork_卷积神经网络

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import torch.nn as nn
#数据准备
batch_size=64
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])
train_dataset = datasets.MNIST(root='../datasets/mnist/',train=True,download=True,transform=transform)
train_loader=DataLoader(train_dataset,shuffle=True,batch_size=batch_size)
test_dataset=datasets.MNIST(root='../datasets/mnist/',train=False,download=True,transform=transform)
test_loader=DataLoader(test_dataset,shuffle=False,batch_size=batch_size)
#设计模型
class ResidualBlock(nn.Module):
    def __init__(self,channels):
        super(ResidualBlock,self).__init__()
        self.channels=channels
        self.conv1=nn.Conv2d(channels,channels,kernel_size=3,padding=1)
        self.conv2=nn.Conv2d(channels,channels,kernel_size=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,kernel_size=5)
        self.conv2=nn.Conv2d(16,32,kernel_size=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
model=Net()
#设计损失函数，构建优化器
criterion=torch.nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)
#循环训练
def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs, target = data
        optimizer.zero_grad()
        #forward+backward+update
        outputs=model(inputs)
        loss=criterion(outputs,target)
        loss.backward()
        optimizer.step()
        
        running_loss+=loss.item()
        if batch_idx%300==299:
            print('[%d,%5d] loss:%.3f'%(epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0
def test():
    correct=0
    total=0
    with torch.no_grad():
        for data in test_loader:
            images,labels=data
            outputs=model(images)
            _,predicted=torch.max(outputs.data,dim=1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()
    print('Accuracy on test set:%d %%' % (100*correct/total))
if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

9RNNcell

import torch
#Parameters
batch_size=1
seq_len=3
input_size=4
hidden_size=2

cell = torch.nn.RNNCell(input_size=input_size, hidden_size=hidden_size)
#(seq,batch,features)
dataset=torch.randn(seq_len, batch_size, input_size)
hidden=torch.zeros(batch_size, hidden_size)

for idx,input in enumerate(dataset):
    print('='*20,idx,'='*20)
    print('Input size:',input.shape)
    hidden=cell(input,hidden)
    print('outputs size:',hidden.shape)
    print(hidden)

10RNN

import torch
batch_size=1
seq_len=3
input_size=4
hidden_size=2
num_layers=1

cell = torch.nn.RNN(input_size=input_size,hidden_size=hidden_size,num_layers=num_layers)
inputs = torch.randn(seq_len,batch_size,input_size)
hidden = torch.zeros(num_layers,batch_size,hidden_size)

out,hidden=cell(inputs,hidden)

print('Output size:',out.shape)
print('Output:',out)
print('Hidden size:',hidden.shape)
print('Hidden:',hidden)

11RNNCell_hello

import torch
#构建数据
input_size=4
hidden_size=4
batch_size=1
idx2char=['e','h','l','o']
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.input_size=input_size
        self.hidden_size=hidden_size
        self.batch_size=batch_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_hidden(self):
        return torch.zeros(self.batch_size,self.hidden_size)
net=Model(input_size,hidden_size,batch_size)
#构建损失函数，搭建优化器
criterion=torch.nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(net.parameters(),lr=0.1)

for epoch in range(15):
    loss=0
    optimizer.zero_grad()
    hidden=net.init_hidden()
    print('Predicted string:',end='')
    for input,label in zip(inputs,labels):
        hidden=net(input,hidden)
        loss+=criterion(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()))
    
    
    
    
    

12RNN_hello

import torch
#构建数据
input_size=4
hidden_size=4
batch_size=1
num_layers=1
seq_len=5
idx2char=['e','h','l','o']
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(seq_len,batch_size,input_size)
labels=torch.LongTensor(y_data)
#搭建模型
class Model(torch.nn.Module):
    def __init__(self,input_size,hidden_size,batch_size,num_layers=1):
        super(Model,self).__init__()
        self.num_layers=num_layers
        self.batch_size=batch_size
        self.input_size=input_size
        self.hidden_size=hidden_size
        self.rnn=torch.nn.RNN(input_size=self.input_size,
                                  hidden_size=self.hidden_size,
                                  num_layers=self.num_layers)
    def forward(self,input):
        hidden=torch.zeros(self.num_layers,
                           self.batch_size,
                           self.hidden_size)
        out, _=self.rnn(input,hidden)
        return out.view(-1,self.hidden_size)
net=Model(input_size,hidden_size,batch_size,num_layers)
#构建损失函数，搭建优化器
criterion=torch.nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(net.parameters(),lr=0.1)
#循环训练
for epoch in range(15):
    optimizer.zero_grad()
    outputs=net(inputs)
    loss=criterion(outputs,labels)
    loss.backward()
    optimizer.step()
    
    _,idx=outputs.max(dim=1)
    idx=idx.data.numpy()
    print('Predicted:',''.join([idx2char[x] for x in idx]),end='')
    print(',Epoch [%d/15] loss=%.4f' % (epoch+1,loss.item()))
    
    
    
    
    

13RNN_embedding_hello

import torch
#构建数据
num_class=4
input_size=4
hidden_size=8
embedding_size=10
num_layers=2
batch_size=1
seq_len=5
idx2char=['e','h','l','o']
x_data=[[1,0,2,2,3]]
y_data=[3,1,2,3,2]
inputs=torch.LongTensor(x_data)
labels=torch.LongTensor(y_data)
#搭建模型
class Model(torch.nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.emb=torch.nn.Embedding(input_size,embedding_size)
        self.rnn=torch.nn.RNN(input_size=embedding_size,
                              hidden_size=hidden_size,
                              num_layers=num_layers,
                              batch_first=True)
        self.fc=torch.nn.Linear(hidden_size,num_class)
    def forward(self,x):
        hidden=torch.zeros(num_layers,x.size(0),hidden_size)
        x=self.emb(x)
        x,_=self.rnn(x,hidden)
        x=self.fc(x)
        return x.view(-1,num_class)
net=Model()
#构建损失函数，搭建优化器
criterion=torch.nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(net.parameters(),lr=0.05)
#循环训练
for epoch in range(15):
    optimizer.zero_grad()
    outputs=net(inputs)
    loss=criterion(outputs,labels)
    loss.backward()
    optimizer.step()
    
    _,idx=outputs.max(dim=1)
    idx=idx.data.numpy()
    print('Predicted:',''.join([idx2char[x] for x in idx]),end='')
    print(',Epoch [%d/15] loss=%.4f' % (epoch+1,loss.item()))
    
    
    
    
    

14name_country

import time
import math
import torch
import torch
import gzip
import csv
import numpy as np
from matplotlib import pyplot as plt
import pandas as pd
from torch.utils.data import Dataset,DataLoader
HIDDEN_SIZE=100
BATCH_SIZE=256
N_LAYER=2
N_EPOCHS=100
N_CHARS=128
USE_GPU=False

class RNNclassifier (torch.nn.Module):
    def __init__(self,input_size,hidden_size,output_size,n_layers=1,bidirectional=True):
        super(RNNclassifier,self).__init__()
        self.hidden_size=hidden_size
        self.n_layers=n_layers
        self.n_directions=2 if bidirectional else 1
        
        self.embedding = torch.nn.Embedding(input_size,hidden_size)
        self.gru=torch.nn.GRU(hidden_size,hidden_size,n_layers,
                              bidirectional=bidirectional)
        self.fc=torch.nn.Linear(hidden_size*self.n_directions,output_size)
        
    def _init_hidden(self,batch_size):
        hidden=torch.zeros(self.n_layers*self.n_directions,
                           batch_size,self.hidden_size)
        return hidden
    def forward(self,input,seq_lengths):
        input=input.t()
        batch_size=input.size(1)
        
        hidden=self._init_hidden(batch_size)
        embedding=self.embedding(input)
        
        gru_input=torch.nn.utils.rnn.pack_padded_sequence(embedding,seq_lengths)
        output,hidden=self.gru(gru_input, hidden)
        if self.n_directions==2:
            hidden_cat=torch.cat([hidden[-1],hidden[-2]],dim=1)
        else:
            hidden_cat=hidden[-1]
        fc_output=self.fc(hidden_cat)
        return fc_output

class NameDataset(Dataset):
    def __init__(self,is_train_set=True):
        filename='./PyTorch深度学习实践/names_train.csv.gz' if is_train_set else './PyTorch深度学习实践/names_test.csv.gz'
        with gzip.open(filename,'rt') as f:
            reader = csv.reader(f)
            rows = list(reader)
        self.names=[row[0] for row in rows]
        self.len=len(self.names)
        self.countries=[row[1] for row in rows]
        self.country_list=list(sorted(set(self.countries)))
        self.country_dict=self.getCountryDict()
        self.counutry_num=len(self.country_list)
        
    def getCountryDict(self):
        country_dic=dict()
        for idx,country_name in enumerate(self.country_list,0):
            country_dic[country_name]=idx
        return country_dic
    def idx2country(self,index):
        return self.country_list[index]
    def getCountriesNum(self):
        return self.counutry_num
        
    def __getitem__(self,index):
        return self.names[index],self.country_dict[self.countries[index]]
    def __len__(self):
        return self.len
    
def name2list(name):
    arr=[ord(c) for c in name]
    return arr,len(arr)
    
def make_tensors(names,countries):
    sequences_and_lengrhs=[name2list(name) for name in names]
    name_sequences = [s1[0] for s1 in sequences_and_lengrhs]
    seq_lengths=torch.LongTensor([s1[1] for s1 in sequences_and_lengrhs])
    countries = countries.long()
    
    seq_tensor = torch.zeros(len(name_sequences),seq_lengths.max()).long()
    for idx,(seq,seq_len) in enumerate(zip(name_sequences,seq_lengths),0):
        seq_tensor[idx, :seq_len]=torch.LongTensor(seq)
        
    seq_lengths,perm_idx=seq_lengths.sort(dim=0,descending=True)
    seq_tensor = seq_tensor[perm_idx]
    countries = countries[perm_idx]
    return creadte_tensor(seq_tensor),\
           creadte_tensor(seq_lengths),\
           creadte_tensor(countries)
    
def trainModel():
    total_loss=0
    for i,(names,countries) in enumerate(trainloader,1):
        inputs,seq_lengths,target = make_tensors(names,countries)
        output = classifier(inputs,seq_lengths)
        loss = criterion(output,target)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        total_loss+=loss.item()
        if i%10==0:
            print(f'[{time_since(start)}] Epoch {epoch}',end='')
            print(f'[{i*len(inputs)}/{len(trainset)}]',end='')
            print(f'loss={total_loss/(i*len(inputs))}')
        return total_loss
    
def testModel():
    correct=0
    total=len(testset)
    print("evaluating trained model...")
    with torch.no_grad():
        for i,(names,countries) in enumerate(testloader,1):
            inputs,seq_lengths,target=make_tensors(names,countries)
            output=classifier(inputs,seq_lengths)
            pred=output.max(dim=1,keepdim=True)[1]
            correct+=pred.eq(target.view_as(pred)).sum().item()
            
        percent = '%.2f'%(100*correct/total)
        print(f'Test set:Accuracy {correct}/{total} {percent}%')
        
def time_since(since):
    s=time.time()-since
    m=math.floor(s/60)
    s-=m*60
    return '%dm %s' % (m,s)
        
    
trainset = NameDataset(is_train_set=True)
trainloader = DataLoader(trainset,batch_size=BATCH_SIZE,shuffle=True)
testset = NameDataset(is_train_set=False)
testloader = DataLoader(testset,batch_size=BATCH_SIZE,shuffle=True)

N_COUNTRY = trainset.getCountriesNum()

def creadte_tensor(tensor):
    if USE_GPU:
        device=torch.device("cuda:0")
        tensor=tensor.to(device)
    return tensor

if __name__=='__main__':
    classifier=RNNclassifier(N_CHARS,HIDDEN_SIZE,N_COUNTRY,N_LAYER)
    
        
    criterion=torch.nn.CrossEntropyLoss()
    optimizer=torch.optim.Adam(classifier.parameters(),lr=0.001)
    
    start=time.time()
    print("Training for %d epochs..."%N_EPOCHS)
    acc_list=[]
    for epoch in range(1,N_EPOCHS+1):
        trainModel()
        acc=testModel()
        acc_list.append(acc)
        


    
import matplotlib.pyplot as plt
import numpy as np
epoch=np.arange(1,len(acc_list)+1,1)
acc_list=np.array(acc_list)
plt.plot(epoch,acc_list)
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.grid()
plt.show()

二、pytorch_torch.nn

嵌入层_Sparse Layers

nn.Embedding

线性层_Linear Layers

nn.Linear

卷积层_Convolution Layers

nn.Conv1d

nn.Conv2d

nn.Conv3d

循环层_Recurrent Layers

nn.RNN

nn.GRU

nn.LSTM

Transformer层_Transformer Layers

nn.Transformer

nn.TransformerEncoder

nn.TransformerDecoder

nn.TransformerEncoderLayer

nn.TransformerDecoderLayer

Dropout 层_Dropout Layers

nn.Dropout

池化层_Pooling layers

nn.MaxPool1d

nn.AvgPool1d

填充层_Padding Layers

nn.ZeroPad2d

归一化层_Normalization Layers

nn.BatchNorm1d

激活函数_Non-linear Activations

nn.ReLU

nn.Sigmoid

nn.Tanh

Non-linear Activations (other)

nn.Softmax

损失函数_Loss Functions

nn.MSELoss

nn.BCELoss

编辑距离_Distance Functions

nn.CosineSimilarity

nn.PairwiseDistance

链接: pytorch文档.