PyTorch教程—B站刘二大人笔记

2023-11-02

PyTorch教程—B站刘二大人笔记

PyTorch代码笔记

PyTorch代码笔记

跟着B站刘二大人PyTorch教程写的代码笔记
完整代码+资源：
链接：https://pan.baidu.com/s/1y6Xj7yv5m9pOVuhTe6x7xg
提取码：z367

1_linear.py

线性模型

import numpy as np
import matplotlib.pyplot as plt

#线性模型

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)
    l_sum = 0
    for x_val, y_val in zip(x_data, y_data):
        y_prey_val = forward(x_val)
        loss_val = loss(x_val, y_val)
        l_sum += loss_val
        print('\t', x_val, y_val, y_prey_val, loss_val)
    print('mse = ',l_sum / 3)
    w_list.append(w)
    mse_list.append(l_sum / 3)

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

2_gradient.py

梯度下降算法

import matplotlib.pyplot as plt

#梯度下降算法

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

epoh_list = []
cost_list = []

w = 1.0

def forward(x):
    return x * w

def cost(xs, ys):
    cost = 0
    for x, y in zip(xs, ys):
        y_prey = forward(x)
        cost += (y_prey - 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))
for epoh in range(100):
    cost_val = cost(x_data, y_data)
    epoh_list.append(epoh)
    cost_list.append(cost_val)
    grad_val = gradient(x_data, y_data)
    w -= 0.01 * grad_val
    print('epoh:', epoh, ' w=', w, ' loss=', cost_val)
print('predict (after training)', 4, forward(4))

plt.plot(epoh_list, cost_list)
plt.xlabel('epoh')
plt.ylabel('cost')
plt.show()

3_back.py

反向传播

import torch
import matplotlib.pyplot as plt

#反向传播

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

def forward(x):
    return x * w

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

print ("predict (before training)",4,forward(4).item() )

epoch_list = []
loss_list = []

for epoch in range(100):
    epoch_list.append(epoch)
    for x, y in zip(x_data, y_data):
        l = loss(x, y)
        l.backward() #每进行一次反向传播，将计算图释放，梯度存在w中
        print('\tgrad:', x, y, w.grad.item())
        w.data = w.data - 0.01 * w.grad.data

        w.grad.data.zero_()

    loss_list.append(l.item())
    print("progress:", epoch, l.item())

print("predict (after training)", 4, forward(4).item())

plt.plot(epoch_list, loss_list)
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

4_pytorch.py

用PyTorch实现线性回归

import torch

x_data = torch.Tensor([[1.0], [2.0], [3.0]])
y_data = torch.Tensor([[2.0], [4.0], [6.0]])

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

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

model = LinearModel()

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)

5_logistic.py

逻辑斯蒂回归

import torchvision
import ssl
import torch
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt

ssl._create_default_https_context = ssl._create_unverified_context

#train_set = torchvision.datasets.MNIST(root='./dataset/mnist', train=True, download=True)
#test_set = torchvision.datasets.MNIST(root='./dataset/mnist', train=False, download=True)

#train_set = torchvision.datasets.CIFAR10(root='./dataset/CIFAR10', train=True, download=True)
#test_set = torchvision.datasets.CIFAR10(root='./dataset/CIFAR10', train=False, download=True)

x_data = torch.Tensor([[1.0], [2.0], [3.0]])
y_data = torch.Tensor([[0], [0], [1]])

class  LogisticRegressionModel(torch.nn.Module):
    def __init__(self):
        super( LogisticRegressionModel, self).__init__()
        self.linear = torch.nn.Linear(1, 1)

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

model = LogisticRegressionModel()

criterion = torch.nn.BCELoss(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 = np.linspace(0, 10, 200)
x_t = torch.Tensor(x).view((200, 1))
y_t = model(x_t)
y = y_t.data.numpy()

plt.plot(x, y)
plt.plot([0, 10], [0.5, 0.5], c='r')
plt.xlabel('Hours')
plt.ylabel('Probability of Pass')
plt.grid()
plt.show()

6_multiple.py

处理多维特征的输入

import numpy as np
import torch

xy = np.loadtxt('./dataset/diabetes.csv.gz', delimiter=',', dtype=np.float32)
x_data = torch.from_numpy(xy[:, :-1])
y_data = torch.from_numpy(xy[:, [-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

model = Model()

criterion = torch.nn.BCELoss(size_average=True)
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

for epoch in range(100):
    # forward
    y_pred = model(x_data)
    loss = criterion(y_pred, y_data)
    print(epoch, loss.item())

    # backword
    optimizer.zero_grad()
    loss.backward()

    # update
    optimizer.step()

7_data.py

加载数据集

import numpy as np
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader

class DiabetesDataset(Dataset):
    def __init__(self, filepath):
        xy = np.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, index):
        return self.x_data[index], self.y_data[index]

    def __len__(self):
        return self.len

dataset = DiabetesDataset('./dataset/diabetes.csv.gz')
train_loader = DataLoader(dataset=dataset,
                          batch_size=32,
                          shuffle=True,
                          num_workers=2)

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

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):
            # prepare data
            inputs, labels = data
            # forward
            y_pred = model(inputs)
            loss = criterion(y_pred, labels)
            print(epoch, i, loss.item())
            # backword
            optimizer.zero_grad()
            loss.backward()
            # update
            optimizer.step()

8_multiclass.py

多分类问题

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='dataset/mnist/',
                               train=True,
                               download=True,
                               transform=transform)
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)

test_dataset = datasets.MNIST(root='dataset/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
        outputs = model(inputs)
        loss = criterion(outputs, target)
        # backword
        loss.backward()
        # update
        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()

9_CNN.py

卷积神经网络CNN

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 matplotlib.pyplot as plt

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081, ))
])

train_dataset = datasets.MNIST(root='dataset/mnist',
                               train=True,
                               download=True,
                               transform=transform)
train_loader = DataLoader(dataset=train_dataset,
                          batch_size=batch_size,
                          shuffle=True)

test_dataset = datasets.MNIST(root='dataset/mnist',
                              train=False,
                              download=True,
                              transform=transform)
test_loader = DataLoader(dataset=test_dataset,
                         batch_size=batch_size,
                         shuffle=False)

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):
        # Flatten data from (n, 1, 28, 28) to (n, 784)
        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:0" if torch.cuda.is_available() else "cpu")
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)
        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 / 2000))
            running_loss = 0.0

accuracy = []
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            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 %% [%d/%d]' % (100 * correct / total, correct, total))
    accuracy.append(100 * correct / total)

if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()
    plt.plot(range(10), accuracy)
    plt.xlabel("Epoch")
    plt.ylabel("Accuracy")
    plt.show()

10_CNN_GoogLeNet.py

卷积神经网络CNN经典模型之GoogLeNet

import torch
from torch import nn
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 matplotlib.pyplot as plt

#CNN经典模型之GoogLeNet

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081, ))
])

train_dataset = datasets.MNIST(root='dataset/mnist',
                               train=True,
                               download=True,
                               transform=transform)
train_loader = DataLoader(dataset=train_dataset,
                          batch_size=batch_size,
                          shuffle=True)

test_dataset = datasets.MNIST(root='dataset/mnist',
                              train=False,
                              download=True,
                              transform=transform)
test_loader = DataLoader(dataset=test_dataset,
                         batch_size=batch_size,
                         shuffle=False)

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()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
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)
        optimizer.zero_grad()

        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 / 2000))
            running_loss = 0.0

accuracy = []
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            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 %% [%d/%d]' % (100 * correct / total, correct, total))
    accuracy.append(100 * correct / total)

if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()
    plt.plot(range(10), accuracy)
    plt.xlabel("Epoch")
    plt.ylabel("Accuracy")
    plt.show()

11_CNN_ResNet.py

卷积神经网络CNN经典模型之ResNet

import torch
from torch import nn
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 matplotlib.pyplot as plt

#CNN经典模型之ResNet

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081, ))
])

train_dataset = datasets.MNIST(root='dataset/mnist',
                               train=True,
                               download=True,
                               transform=transform)
train_loader = DataLoader(dataset=train_dataset,
                          batch_size=batch_size,
                          shuffle=True)

test_dataset = datasets.MNIST(root='dataset/mnist',
                              train=False,
                              download=True,
                              transform=transform)
test_loader = DataLoader(dataset=test_dataset,
                         batch_size=batch_size,
                         shuffle=False)

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()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
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)
        optimizer.zero_grad()

        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 / 2000))
            running_loss = 0.0

accuracy = []
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            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 %% [%d/%d]' % (100 * correct / total, correct, total))
    accuracy.append(100 * correct / total)

if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()
    plt.plot(range(10), accuracy)
    plt.xlabel("Epoch")
    plt.ylabel("Accuracy")
    plt.show()

12_RNNCell.py

循环神经网络RNNCell

import torch

input_size = 4
hidden_size = 4
batch_size = 1

#hell0->ohlol
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.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_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()))

13_RNN.py

循环神经网络RNN

import torch

input_size = 4
hidden_size = 4
num_layers = 1
batch_size = 1
seq_len = 5

# hell0->ohlol
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=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.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=%.3f' % (epoch+1, loss.item()))

14_RNN_embedding.py

使用embedding的循环神经网络RNN

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]] #(batch, seq_len)
y_data = [3, 1, 2, 3, 2] #(batch * seq_len)

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 = %.3f' % (epoch+1, loss.item()))

15_RNNClassifier.py

循环神经网络的应用，实现RNN分类器

import torch
from torch.utils.data import DataLoader
import time
import math
import gzip
import csv
import numpy as np
import matplotlib.pyplot as plt

HIDDEN_SIZE = 100
BATCH_SIZE = 256
N_LAYER = 2
N_EPOCHS = 100
N_CHARS = 128
USE_GPU = True

class NameDataset():
    def __init__(self, is_train_set=True):
        filename = 'dataset/names_train.csv.gz' if is_train_set else 'dataset/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.country_num = len(self.country_list)

    def __getitem__(self, index):
        return self.names[index], self.country_dict[self.countries[index]]

    def __len__(self):
        return self.len

    def getCountryDict(self):
        country_dict = dict()
        for idx, country_name in enumerate(self.country_list, 0):
            country_dict[country_name] = idx
        return country_dict

    def idx2country(self, index):
        return self.country_list(index)

    def getCountrysNum(self):
        return self.country_num

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=False)

N_COUNTRY = trainset.getCountrysNum()

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 create_tensor(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.cpu())

        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

def name2list(name):
    arr = [ord(c) for c in name]
    return arr, len(arr)

def create_tensor(tensor):
    if USE_GPU:
        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
        tensor = tensor.to(device)
    return tensor

def make_tensors(names, countries):
    sequences_and_lengths = [name2list(name) for name in names]
    name_sequences = [sl[0] for sl in sequences_and_lengths]
    seq_lengths = torch.LongTensor([sl[1] for sl in sequences_and_lengths])
    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 create_tensor(seq_tensor), \
           create_tensor(seq_lengths), \
           create_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}%')

    return correct / total

def time_since(since):
    s = time.time() - since
    m = math.floor(s / 60)
    s -= m * 60
    return '%dm %ds' % (m, s)

if __name__ == '__main__':
    classifier = RNNClassifier(N_CHARS, HIDDEN_SIZE, N_COUNTRY, N_LAYER)
    if USE_GPU:
        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
        classifier.to(device)

    criterion = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(classifier.parameters(), lr=0.001)

    start = time.time()
    print("Train for %d epochs..." % N_EPOCHS)
    acc_list = []
    for epoch in range(1, N_EPOCHS + 1):
        trainModel()
        acc = testModel()
        acc_list.append(acc)

    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.show()

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Pytorch

深度学习

python

PyTorch教程—B站刘二大人笔记的相关文章

Python Pandas 滚动聚合一列列表

我有一个简单的数据框 df 和一列列表lists 我想根据以下内容生成一个附加列lists The df好像 import pandas as pd lists 1 1 2 1 2 3 3 2 9 7 9 4 2 7 3 5 create
如何把父母和孩子联系起来？

有两个简单的类一个只有parent属性并且两者兼而有之parent and children属性这意味着同时具备两者的人parent and children继承自唯一的parent 这是只有parent属性我们就这样称呼它吧Chi
如何让“conda”安装程序查找“PyPi”包

我试图使用conda http conda pydata org docs using pkgs html managing packages包管理器来安装我的 Python 包最近我遇到了 Anaconda org 存储库中不存在我需
App Engine 上的 Django 与 webapp2 [关闭]

就目前情况而言这个问题不太适合我们的问答形式我们希望答案得到事实参考资料或专业知识的支持但这个问题可能会引发辩论争论民意调查或扩展讨论如果您觉得这个问题可以改进并可能重新开放访问帮助中心 help reopen questi
从内存地址创建python对象（使用gi.repository）

有时我需要调用仅存在于 C 中的 gtk gobject 函数但返回一个具有 python 包装器的对象之前我使用过基于 ctypes 的解决方案效果很好现在我从 PyGtk import gtk 切换到 GObject intro
使用 Boto3 超时的 AWS Lambda 函数

我已经解决了我自己的问题但无论如何我都会发布它希望能节省其他人几个小时我在 AWS 上有一个无服务器项目使用 Python 将记录插入到 kinesis 队列中但是当我使用 boto3 client kinesis 或 put
使用 Python 和 lmfit 拟合复杂模型？

我想适合椭偏仪 http en wikipedia org wiki Ellipsometry使用 LMFit 将数据转换为复杂模型两个测量参数 psi and delta 是复杂函数中的变量rho 我可以尝试将问题分离为实部和虚部共享参
动态字段取决于 WTForms 的先前字段

我正在使用 WTForms 制作表格目前我有这个 class UploadForm flask wtf Form fichier wtforms fields FileField u Fichier description wtform
Python3将模块从文件夹导入到另一个文件夹

我的结构字典是 mainFolder folder1 init py file1 py file2 py folder2 init py file3 py file4 py setup py init py 我需要将 file4 py 从f
会话数据库表清理

该表是否需要清除或者由 Django 自动处理 Django 不提供自动清除功能然而有一个方便的命令可以帮助您手动完成此操作 Django 文档清除会话存储 https docs djangoproject com en dev to
如何从 python 脚本执行 7zip 命令

我试图了解如何使用 os system 模块来执行 7zip 命令现在我不想用 Popen 或 subprocess 让事情变得复杂我已经安装了 7zip 并将 7zip exe 复制到我的用户文件夹中我只想提取我的测试文件 inst
Python 在哪些系统上不使用 IEEE-754 双精度浮点数

Python 对 IEEE 754 浮点运算进行了各种引用但不保证1 https docs python org 3 tutorial floatingpoint html 2 https pythondev readthedocs io
使用 ElementTree 在 python 中解析 xml

我对 python 很陌生我需要解析一些脏的 xml 文件这些文件需要先清理我有以下 python 代码 import arff import xml etree ElementTree import re totstring wit
Python脚本从字母和两个字母组合生成单词

我正在编写一个简短的脚本它允许我使用我设置的参数生成所有可能的字母组合例如 b a 参数单词 5 个字母第三第五个字母 b a 第一个字母 ph sd nn mm 或 gh 第二第四个字母任意元音 aeiouy 和 rc 换句
数据损坏 C++ 和 Python 之间的管道

我正在编写一些代码从 Python 获取二进制数据将其通过管道传输到 C 对数据进行一些处理在本例中计算互信息度量然后将结果通过管道传输回 Python 在测试时我发现如果我发送的数据是一组尺寸小于 1500 X 1500 的 2
类返回语句不打印任何输出

我正在学习课程但遇到了问题return语句它是语句吗我希望如此程序什么也没有打印出来它只是结束而不做任何事情 class className def createName self name self name name def
从给定的项目列表创建子列表

我首先要说的是以下问题不是为了家庭作业目的即使因为我几个月前就完成了软件工程师的工作无论如何今天我正在工作一位朋友向我询问了这个奇怪的排序问题我有一个包含 1000 行的列表每行代表一个数字我想创建 10 个子列表每个子列表都
用 pandas DataFrame 替换 mysql 数据库表中的行

Python 版本 2 7 6 熊猫版本 0 17 1 MySQLdb 版本 1 2 5 在我的数据库中 PRODUCT 我有一张桌子 XML FEED 表 XML FEED 很大数百万条记录我有一个 pandas DataFrame
ProcessPoolExecutor 传递多个参数

ESPN播放器免费 class ESPNPlayerFree def init self player id match id match id team 团队名单1 277906 cA2i150s81HI3qbq1fzi za1Oq5CG
PyObjC + Python 3.0 问题

默认情况下 Cocoa Python 应用程序使用默认的 Python 运行时版本 2 5 如何配置我的 Xcode 项目以便它使用较新的 Python 3 0 运行时我尝试用新版本替换项目中包含的Python framework 但它不

随机推荐

2023年江西省赣州市技能大赛网络安全竞赛试题任务书

2023年江西省赣州市技能大赛网络安全竞赛试题任务书 A模块基础设施设置安全加固 200分 A 1任务一登录安全加固 A 2任务二本地安全策略设置 A 3任务三流量完整性保护 A 4任务四事件监控 A 5任务五服务加固 B模块
Vmware16 下载与安装

Vmware16 下载与安装 vmware16 密钥 ZF3R0 FHED2 M80TY 8QYGC NPKYF YF390 0HF8P M81RQ 2DXQE M2UT6 ZF71R DMX85 08DQY 8YMNC PPHV8 Vmw
tshark解析本地pcap数据包提取五元组{src_ip,src_port,proto,dst_ip,dst_port}与时间戳，包长

tshark官方文档 https www wireshark org docs man pages tshark html wireshark官方特征参考 https www wireshark org docs dfref 前提需要安装w
利用递归求斐波那契数列

斐波那契额是二级递推数列从第三项起每项为前两项的和利用函数的递归可以很好实现只需每次返回n 1 和 n 2 即可上代码 define CRT SECURE NO WARNINGS 1 include
C#使用多线程并发之异步委托

阻塞式编程我们一边编写的代码都是同步代码也就是从上到下按照顺序执行例如 public delegate void DoWorkHandler class Program static void Main string args Con
vsflexgrid单元格换行后自动使用行高_大咖分享办公秘籍:Word和Excel换行

我们在日常办公和学习中对文档进行整理和粘贴数据的过程中经常会用到的就是换行功能了那么怎么实现自动换行呢下面就由非凡学院商务办公培训专业的付老师和大家分享一下在Word和Excel中简单的实现过程赶紧来看看和学习一下吧 1 硬回
虚拟机网络配置、防火墙、克隆

一修改虚拟机的网络配置在虚拟机开启的情况下配置选中虚拟机hadoop100 编辑虚拟网络编辑器更改设置 NAT模式 NAT设置网关改为192 168 1 2 连点两次确定二修改windows的网络配置 1 点击电脑右下角的网
华为OD机试 - 靠谱的车 - 逻辑分析（Java 2023 B卷 100分）

目录专栏导读一题目描述二输入描述三输出描述四解题思路五 Java算法源码六效果展示 1 输入 2 输出 3 说明华为OD机试 2023B卷题库疯狂收录中刷题点这里专栏导读本专栏收录于华为OD机试 JAVA
DBeaver报Public Key Retrieval is not allowed 错误

解决方法 1 选择报错的链接按F4 出现编辑链接弹窗切换到驱动属性标签页 2 修改allowPublicKeyRetrieval属性的值为TRUE 3 重启DBeaber
Git+TortoiseGit详细安装教程（HTTP方式）

Git是核心 TortoiseGit是个外壳 git需要使用命令行可以简单理解为TortoiseGit是git的GUI展现形式使用TortoiseGit操作就不用记住git命令了 Git可以使用HTTP和SSH方式 HTTP方式配置更
素数筛

素数又称质数是指除了1和它本身再也没有其他的因子合数是除了1和它本身以外还有其他的因子 1既不是素数也不是合数此题为洛谷上的一道题以此题为例题讲解素数筛埃氏筛法时间复杂度O nlogn 得分 80 include
html比较字符数字大小,JavaScript怎么比较字符串？

javascript怎么比较字符串下面本篇文章就来给大家介绍使用javascript比较字符串的几种方法希望对大家有所帮助一大于 gt 小于 javascript字符串在进行大于小于比较时会根据第一个不同的字符的ascii值码
预训练模型、迁移学习

预训练模型把迁移学习很好地用起来了让我们感到眼前一亮这和小孩子读书一样一开始语文数学化学都学读书网上游戏等在脑子里积攒了很多当他学习计算机时实际上把他以前学到的所有知识都带进去了如果他以前没上过中学没上过小学突然学
linux 查看文件个数

要查看 Linux 系统中某个目录下的文件数量可以使用 ls 命令结合管道和 wc 命令来完成具体来说可以使用 ls 命令的 l 参数来列出目录中的文件和子目录的详细信息然后将输出结果通过管道传递给 wc 命令使用 l 参数来统
sort()函数与qsort()函数及其头文件

sort 函数是C 中的排序函数其头文件为 include
vscode路径别名文件跳转解决办法

第一步下载 1 在jsconfig json中配置 compilerOptions target es5 module esnext baseUrl moduleResolution node paths src lib esnext d
Code Llama: Open Foundation Models for Code

Paper name Code Llama Open Foundation Models for Code Paper Reading Note Paper URL https ai meta com research publicatio
SpringBoot + mybatis + mysql8.0.11 构建项目

前几天在阐释使用mysql8 0 11 刚解决第三方工具链接没数据库的问题然后兴高采烈的去搭建项目进行使用然后又是一种一种的问题冒出具体出现的问题以及相关的解决方式如下主要是在建立链接的时候一些配置参数的问题本人使用的是Int
都2023年了，为什么大家还都在吹捧 Python？

2023 年 Python 还可学吗答案当然是可近些年间 Python 的火热有目共睹作为一种功能强大的高级编程语言在 2018 年的时候它的流行程度就得到了大幅提高图源 Stack Overflow 网站编程语言浏览量统计数字
PyTorch教程—B站刘二大人笔记

PyTorch教程 B站刘二大人笔记 PyTorch代码笔记 1 linear py 2 gradient py 3 back py 4 pytorch py 5 logistic py 6 multiple py 7 data py 8

PyTorch教程—B站刘二大人笔记

PyTorch教程—B站刘二大人笔记

PyTorch代码笔记

1_linear.py

2_gradient.py

3_back.py

4_pytorch.py

5_logistic.py

6_multiple.py

7_data.py

8_multiclass.py

9_CNN.py

10_CNN_GoogLeNet.py

11_CNN_ResNet.py

12_RNNCell.py

13_RNN.py

14_RNN_embedding.py

15_RNNClassifier.py

PyTorch教程—B站刘二大人笔记 的相关文章

随机推荐

热门标签

PyTorch教程—B站刘二大人笔记的相关文章