import torch
from torch import nn
from torch.nn import functional as Func


class NeuralNet(nn.Module):
    def __init__(self):
        super(NeuralNet, self).__init__()
        # 兩個(gè)卷積層
        self.conv1 = nn.Conv2d(1, 6, (5, 5))
        self.conv2 = nn.Conv2d(6, 16, 5)
        # 三個(gè)全連接層
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, input_x):
        # 進(jìn)行兩次卷積、池化操作
        layer1 = Func.max_pool2d(Func.relu(self.conv1(input_x)), (2, 2))
        layer2 = Func.max_pool2d(Func.relu(self.conv2(layer1)), (2, 2))
        # 降維
        flat = self.flat_features(layer2)
        # 經(jīng)過三個(gè)全連接層
        fc1 = Func.relu(self.fc1(flat))
        fc2 = Func.relu(self.fc2(fc1))
        fc3 = self.fc3(fc2)
        return fc3

    def flat_features(self, tensor):
        features = 1
        for size in tensor.size()[1:]:
            features *= size
        flat = tensor.view(-1, features)
        return flat

# 創(chuàng)建一個(gè)neural_net對象并打印
neural_net = NeuralNet()
print(neural_net)
'''
NeuralNet(
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)
'''

x = torch.randn(1, 1, 32, 32)   # 隨機(jī)產(chǎn)生輸入數(shù)據(jù)
y_output = neural_net(x)  # 輸入數(shù)據(jù)并進(jìn)行訓(xùn)練

y_target = torch.randn(1, 10)   # 隨機(jī)產(chǎn)生目標(biāo)數(shù)據(jù)
criterion = nn.MSELoss()    # 定義評價(jià)函數(shù)
loss = criterion(y_output, y_target)  # 計(jì)算損失值

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
        -> view -> linear -> relu -> linear -> relu -> linear
        -> MSELoss
        -> loss

print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

neural_net.zero_grad()  # 清零所有參數(shù)(parameter）的梯度緩存
loss.backward()  # 反向傳播
print(neural_net.conv1.bias.grad)  # 查看梯度
# tensor([-0.0046, -0.0087,  0.0390,  0.0045, -0.0096,  0.0028])

learning_rate = 0.01
for param in neural_net.parameters():
    param.data.sub_(param.grad.data * learning_rate)

import torch.optim as optim

# 創(chuàng)建優(yōu)化器(optimizer）
optimizer = optim.SGD(neural_net.parameters(), lr=0.01)

# 在訓(xùn)練的迭代中：
for epoch in range(100):
    optimizer.zero_grad()  # 清零梯度緩存
    output = neural_net(x)
    loss = criterion(y_output, y_target)
    loss.backward()
    optimizer.step()  # 自動更新參數(shù)

import torch
import torchvision

# 定義數(shù)據(jù)預(yù)處理操作
transform=torchvision.transforms.Compose([
    torchvision.transforms.ToTensor(),
    torchvision.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# 加載數(shù)據(jù)
data_path = 'D:/Temp/MachineLearning/data'
train_set = torchvision.datasets.CIFAR10(root=data_path, train=True, download=True, transform=transform)
test_set = torchvision.datasets.CIFAR10(root=data_path, train=False, download=True, transform=transform)
# 封裝為批數(shù)據(jù)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=4, shuffle=True, num_workers=2)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=4, shuffle=False, num_workers=2)
# 定義標(biāo)簽值
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

import matplotlib.pyplot as plt
import numpy as np

# 輸出圖像的函數(shù)
def imshow(img):
    img = img / 2 + 0.5     # 反標(biāo)準(zhǔn)化
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()


# 獲取一個(gè)批次的訓(xùn)練圖片、標(biāo)簽
images, labels = iter(train_loader).next()
# 顯示圖片
imshow(torchvision.utils.make_grid(images))
# 打印圖片標(biāo)簽
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

# 定義卷積網(wǎng)絡(luò)
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):						# 輸入x：[4, 3, 32, 32]
        x = self.pool(F.relu(self.conv1(x)))	# x:[4, 6, 14, 14]
        x = self.pool(F.relu(self.conv2(x)))	# x:[4, 16, 5, 5]
        x = x.view(-1, 16 * 5 * 5)				# x：[4, 400]
        x = F.relu(self.fc1(x))					# x:[4, 120]
        x = F.relu(self.fc2(x))					# x:[4, 84]
        x = self.fc3(x)							# x:[4, 10]
        return x


net = Net()

criterion = nn.CrossEntropyLoss()   # 損失函數(shù)
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) # 優(yōu)化器

for epoch in range(2):  # 進(jìn)行兩輪迭代訓(xùn)練
    running_loss = 0.0
    # 按批次取出數(shù)據(jù)進(jìn)行訓(xùn)練
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data   # 獲取數(shù)據(jù)和標(biāo)簽
        optimizer.zero_grad()   # 清零梯度緩存
        outputs = net(inputs)   #  得到預(yù)測結(jié)果
        loss = criterion(outputs, labels)   # 計(jì)算損失
        loss.backward()     # 反向傳播
        optimizer.step()    # 更新參數(shù)

        # 每隔兩千次輸出一次平均損失值
        running_loss += loss.item()
        if i % 2000 == 1999:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')
# 保存訓(xùn)練好的模型
MODEL_PATH = './cifar_net.pth'
torch.save(net.state_dict(), MODEL_PATH)

# 加載模型
net = Net()
net.load_state_dict(torch.load(MODEL_PATH))

correct = 0
total = 0
with torch.no_grad():
    for data in test_loader:
        images, labels = data
        outputs = net(images)   # 將測試集圖片投入模型
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)     # 統(tǒng)計(jì)測試集總樣本數(shù)
        correct += (predicted == labels).sum().item()   # 累計(jì)預(yù)測正確的個(gè)數(shù)

print('在整個(gè)測試集上的準(zhǔn)確率為: %d %%' % (100 * correct / total))

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")	# 獲取GPU設(shè)備
print(device)
net = Net()
net.to(device)		# 將模型放在GPU上

for epoch in range(2):  # 進(jìn)行兩輪迭代訓(xùn)練
    running_loss = 0.0
    # 按批次取出數(shù)據(jù)進(jìn)行訓(xùn)練
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data   
        inputs, labels = inputs.to(device),labels.to(device)	# 將訓(xùn)練數(shù)據(jù)放到GPU
        ......