torch学习笔记之————多分类任务小例

1，多分类任务小例

2，以及Himmmelblau fauction 函数函数介绍

3，结果分析及一些小结

Himmmelblau fauction 函数

介绍：这个函数是一个专门检测优化器有没有很好的收敛的函数（它有4个极值点，可以用来检测你的优化器有没有更好的性能去取得收敛效果）

 代码：

import  numpy as np
from    mpl_toolkits.mplot3d import Axes3D
from    matplotlib import pyplot as plt
import  torch

def himmelblau(x):
    return (x[0] ** 2 + x[1] - 11) ** 2 + (x[0] + x[1] ** 2 - 7) ** 2
x = np.arange(-6, 6, 0.1)
y = np.arange(-6, 6, 0.1)
print('x,y range:', x.shape, y.shape)
X, Y = np.meshgrid(x, y)
print('X,Y maps:', X.shape, Y.shape)
Z = himmelblau([X, Y])

fig = plt.figure('himmelblau')
ax = fig.gca(projection='3d')
ax.plot_surface(X, Y, Z)
ax.view_init(60, -30)
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.show()

# [1., 0.], [-4, 0.], [4, 0.]
x = torch.tensor([-4., 0.], requires_grad=True)
optimizer = torch.optim.Adam([x], lr=1e-3)
for step in range(20000):
    pred = himmelblau(x)
    optimizer.zero_grad()
    pred.backward()
    optimizer.step()

    if step % 2000 == 0:
        print ('step {}: x = {}, f(x) = {}'
               .format(step, x.tolist(), pred.item()))

使用torch实现一个多分类问题的列子

结构：

代码：

batch_size=200
learning_rate=0.01
epochs=10

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=False, transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])),
    batch_size=batch_size, shuffle=True)


# 注意 pytorch定义w的习惯chout在前chin在后边，点乘的时候要转置
w1, b1 = torch.randn(200, 784, requires_grad=True),\
         torch.zeros(200, requires_grad=True)
w2, b2 = torch.randn(200, 200, requires_grad=True),\
         torch.zeros(200, requires_grad=True)
w3, b3 = torch.randn(10, 200, requires_grad=True),\
         torch.zeros(10, requires_grad=True)
# print(w1)

# # 凯明初始化
torch.nn.init.kaiming_normal_(w1)
torch.nn.init.kaiming_normal_(w2)
torch.nn.init.kaiming_normal_(w3)
# print(w1)


def forward(x):
    x = x@w1.t() + b1
    x = F.relu(x)
    x = x@w2.t() + b2
    x = F.relu(x)
    x = x@w3.t() + b3
    x = F.relu(x) #对于LR 可激活函数也可不用
    return x


# 定义优化器，优化的变量是w1, b1,   w2, b2,   w3, b3
optimizer = optim.SGD([w1, b1, w2, b2, w3, b3], lr=learning_rate)
criteon = nn.CrossEntropyLoss() # = f.crossEntrypy  都包含了最后一层的softmax,log,null_loss操作
# 因为使用了crossEntropyloss 里边包含了softmax所以定义网络层不需要softmax。
for epoch in range(epochs):

    for batch_idx, (data, target) in enumerate(train_loader):
        data = data.view(-1, 28*28)

        logits = forward(data)
        loss = criteon(logits, target)

        optimizer.zero_grad()  # 梯度清零用于更新梯度
        loss.backward()  # 从后往反向计算要更新参数值
        optimizer.step()  # 更新参数值变成新的值

        if batch_idx % 100 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))

    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data = data.view(-1, 28 * 28)
        logits = forward(data)
        test_loss += criteon(logits, target).item()

        pred = logits.data.max(1)[1]
        correct += pred.eq(target.data).sum()

    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

 结果分析和优化技巧

 计算acc 准确度练习代码示例：

import torch.nn.functional as F

# 计算acc 准确度练习

# [4,10]  假设4张照片 的最后线性层10个输出
logits = torch.rand(4,10)

pred = F.softmax(logits,dim=1)
pred_label = pred.argmax(dim=1)
print(pred_label) #tensor([6, 5, 3, 3])
# 不经过softmax的label值也是一样
pred_label_2= logits.argmax(dim=1)
print(pred_label_2) #tensor([6, 5, 3, 3])

real_label = torch.tensor([1,8,5,2])
correct = torch.eq(pred_label_2, real_label)

print(correct.sum().float().item()/4) # 0.0

 选择test的时间一般两种：一种是每有限个batch后进行一次test,一种是在epoch后进行test。根据项目实际情况灵活安置。