---

前引

---

入门深度学习找到正确的课程了 强推这种可以自己去动手写各种代码
而且从底层去推导代码 训练demo的这种 我觉得这个才是真正的学习路径 且我一路学计算机确实也是这样学习过来的

如果不自己一个个动手手搓这些底层的东西 对这些函数的实现根本没有深刻的理解

真的还好看到了这门课 感谢！

---

从零开始的推荐系统学习之路（十）---- 动手学深度学习系列 从零实现SoftMax回归函数 & 从零实现感知机模型

---

这里没啥很多的理论推导部分 因为之前机器学习那边已经学习过很多相关的概念了 所以相对而言对于完全没有接触过的 上手起来很快

---

1、SoftMax部分

---

1、从零实现SoftMax回归函数（裸代码）

---

%matplotlib inline

import torch 
import torchvision
import time
from torchvision import transforms
from torch.utils import data
from d2l import torch as d2l
from IPython import display

d2l.use_svg_display()


trans = transforms.ToTensor()
mnist_train = torchvision.datasets.FashionMNIST(root="./FashionMNiSt", train=True, transform=trans, download=True)
mnist_test = torchvision.datasets.FashionMNIST(root="./FashionMNiSt", train=False, transform=trans, download=True)


len(mnist_train), mnist_train[0][0].shape


def get_fashion_mnist_labels(labels):
    """ 返回Fashion-MNiSt Labels """

    text_labels = ["t-shirt", "trouser", "pullover", "dress", "coat", "sandal", "shirt", "sneaker", "bag", "ankle boot"]
    return list(text_labels[int(i)] for i in labels)

def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5):
    """ Plot a list of imgs """

    # 画像大小
    figsize = (num_cols * scale, num_rows * scale) 
    # 创建多子图
    _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)

    # 平铺开
    axes = axes.flatten()
    for i, (ax, img) in enumerate(zip(axes, imgs)):
        if torch.is_tensor(img):
            ax.imshow(img.numpy())
        else:
            ax.imshow(img)
        ax.axis('off')
        ax.set_title(titles[i], fontsize=10)

    # plt.tight_layout()



batch_size = 18

X, y = next(iter(data.DataLoader(mnist_train, batch_size=batch_size)))
print(X.shape, y.shape) # 第一个向量 feature_len 第二个 通道数 第三/四 长/宽
print(get_fashion_mnist_labels(y))
show_images(X.reshape(batch_size, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y))




batch_size = 256

def get_dataloader_worker(workers=8):
    """ 默认用4进程去跑 """
    return workers
    
train_iter = iter(data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=get_dataloader_worker()))

start_time = time.time()
for _, _ in train_iter:
    continue
print(f"{time.time() - start_time:.2f} sec")





def load_data_fashion_mnist(batch_size, resize=None):
    trans = [transforms.ToTensor()]
    if resize:
        trans.insert(0, transforms.Resize(resize))

    trans = transforms.Compose(trans)

    mnist_train = torchvision.datasets.FashionMNIST(root="./FashionMNiSt", train=True, transform=trans, download=True)
    mnist_test = torchvision.datasets.FashionMNIST(root="./FashionMNiSt", train=False, transform=trans, download=True)

    return (data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=get_dataloader_worker()),
            data.DataLoader(mnist_test, batch_size=batch_size, shuffle=True, num_workers=get_dataloader_worker()))



batch_size = 256

train_iter, test_iter = load_data_fashion_mnist(batch_size)




num_inputs = 28 * 28
num_outputs = 10 # 10个分类

w = torch.normal(0, 1.0, (num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)
w.shape, b.shape




def softmax(X, dim=1):
    X_exp = torch.exp(X)
    return X_exp / X_exp.sum(dim, keepdims=True)

y_hat = torch.tensor([[0.99, 0.01], [0.9, 0.1]])
softmax(y_hat, 1), torch.softmax(y_hat, 1), '', softmax(y_hat, 0), torch.softmax(y_hat, 0)



def net(X):
    return softmax(torch.matmul(X.reshape(-1, w.shape[0]), w) + b)
net(next(iter(train_iter))[0]).shape



def cross_entropy(y_hat, y):
    return -torch.log(y_hat[range(len(y_hat)), y])

y_hat = torch.tensor([[0.90, 0.01], [0.98, 0.02]])
cross_entropy(y_hat, [0, 0]), cross_entropy(y_hat, [0, 1]).mean()



def updater():
    return torch.optim.SGD(params=(w, b), lr=0.15)

updater = updater()
updater.param_groups




def accuracy(y_hat, y): 
    """计算预测正确率"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = torch.argmax(y_hat, dim=1)
    cmp = y_hat.type(y.dtype) == y
    return int(cmp.type(y.dtype).sum())

accuracy(y_hat, torch.tensor([0, 1]))



def evaluate_accuracy(net, data_iter):
    # net.eval()
    metric = Accumulator(2)  # 正确预测数、预测总数
    with torch.no_grad():
        for X, y in data_iter:
            metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]



class Accumulator:  
    """ 在n个变量上累加 """
    def __init__(self, n):
        self.data = [0.0] * n

    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]

    def reset(self):
        self.data = [0.0 for i in len(self.data)]

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

accu = Accumulator(2)
accu.add(1, 2), accu.add(2, 4)
accu[0], accu[1]


def train_epoch_ch3(net, train_iter, loss, updater): 
    # net.train()
    accu = Accumulator(3)
    for X, y in train_iter:
        # print(y.numel())
        l = loss(net(X), y)
        updater.zero_grad()
        l.mean().backward()
        updater.step()

        
        accu.add(l.sum(), accuracy(net(X), y), y.numel())
        # print("train_loss:{:.2f}, accuracy:{:.2f}".format(accu[0] / accu[2], accu[1] / accu[2]))
    return accu[0] / accu[2], accu[1] / accu[2]


def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    for epoch in range(num_epochs):
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        test_acc = evaluate_accuracy(net, test_iter)
        animator.add(epoch + 1, train_metrics + (test_acc, ))
    train_loss, train_acc = train_metrics




class Animator:  #@save
    """在动画中绘制数据"""
    def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None,
                 ylim=None, xscale='linear', yscale='linear',
                 fmts=('-', 'm--', 'g-.', 'r:'), nrows=1, ncols=1,
                 figsize=(3.5, 2.5)):
        # 增量地绘制多条线
        if legend is None:
            legend = []
        d2l.use_svg_display()
        self.fig, self.axes = d2l.plt.subplots(nrows, ncols, figsize=figsize)
        if nrows * ncols == 1:
            self.axes = [self.axes, ]
        # 使用lambda函数捕获参数
        self.config_axes = lambda: d2l.set_axes(
            self.axes[0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
        self.X, self.Y, self.fmts = None, None, fmts

    def add(self, x, y):
        # 向图表中添加多个数据点
        if not hasattr(y, "__len__"):
            y = [y]
        n = len(y)
        if not hasattr(x, "__len__"):
            x = [x] * n
        if not self.X:
            self.X = [[] for _ in range(n)]
        if not self.Y:
            self.Y = [[] for _ in range(n)]
        for i, (a, b) in enumerate(zip(x, y)):
            if a is not None and b is not None:
                self.X[i].append(a)
                self.Y[i].append(b)
        self.axes[0].cla()
        for x, y, fmt in zip(self.X, self.Y, self.fmts):
            self.axes[0].plot(x, y, fmt)
        self.config_axes()
        display.display(self.fig)
        display.clear_output(wait=True)



num_epochs = 10
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)




def predict_ch3(net, test_iter, n=20):  #@save
    """预测标签（定义见第3章）"""
    for X, y in test_iter:
        break
    trues = d2l.get_fashion_mnist_labels(y)
    preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
    titles = [true +'\n' + pred for true, pred in zip(trues, preds)]
    d2l.show_images(
        X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n])

predict_ch3(net, test_iter)

---

---

2、从零实现SoftMax回归函数（pytorch代码）

---

net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))
net[1].weight.data.normal_(0, 1), net[1].bias.data.fill_(0)

loss = nn.CrossEntropyLoss()
updater = torch.optim.SGD(params=net.parameters(), lr=0.1)

num_epochs = 10
train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)

---

---

2、感知机模型部分

---

1、理论部分

---

---

2、MLP多层感知机（裸代码）

---

基本上代码都复用上面的代码

def relu(X):
    zero_max = torch.zeros_like(X)
    return torch.max(X, zero_max)

num_input = 28 * 28
num_hidden_layer = 256
num_output = 10

w1 = nn.Parameter(torch.normal(0, 0.1, (num_input, num_hidden_layer)), requires_grad=True)
b1 = nn.Parameter(torch.zeros(num_hidden_layer), requires_grad=True)
w2 = nn.Parameter(torch.normal(0, 0.1, (num_hidden_layer, num_output)), requires_grad=True)
b2 = nn.Parameter(torch.zeros(num_output), requires_grad=True)

parameters = [w1, b1, w2, b2]



def net(X):
    h = relu(torch.matmul(X.reshape(-1, w1.shape[0]), w1) + b1)
    # print(torch.matmul(h, w2) + b2)
    return softmax(torch.matmul(h, w2) + b2)


loss = cross_entropy
updater = torch.optim.SGD(params=parameters, lr=0.1)


num_epochs = 10
train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)

---

3、MLP多层感知机（pytorch简单实现）

---

num_input = 28 * 28
num_hidden_layer = 256
num_output = 10

net = nn.Sequential(nn.Flatten(), nn.Linear(784, 256), nn.ReLU(), nn.Linear(256, 10))
net[1].weight.data.normal_(0, 0.1), net[1].bias.data.zero_()
net[3].weight.data.normal_(0, 0.1), net[3].bias.data.zero_()

loss = nn.CrossEntropyLoss(reduction="none")
updater = torch.optim.SGD(params=net.parameters(), lr=0.1)


num_epochs = 10
train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)