---

前引

---

对于之前的机器学习项目 天池比赛的项目完成意愿相对而言比较低了
因为昨晚在学习的过程中 我原先的业务是小店的同学 然后刚好有朋友是小店的算法同学 然后聊了很多吧 收获可能是这段时间学习机器学习 想迈入推荐算法这个道路 最多的

第一个 我觉得从下决心去做这个方向的尝试 我肯定是10000%的投入去做 而且我也发自内心的相信 做这个东西是可以落地出项目的
第二个 我也不觉得 转算法是一个多么困难的事情 只是需要我再像大学一样 对于一个之前只接触了一点点的方向 再投入大量的时间精力 去花时间研究的一个方向而已
第三个 我觉得最快的成长路线 肯定不是去做玩具demo 也不是去做一些玩具的像找实习的项目 而是真实的接触到工业界 实际算法项目落地全链路 这个应该是最快能做出项目的路线 但确实我刚好去找了小店的同事 同时也有了小店目前推荐模型的代码 这个真的也算值万金吧

不仅可以在实际的学习的过程中 可以去接触实际算法落地的代码 且也可以根据我们公司目前的基建 去看一下目前落地 增量 全量更新 全链路是怎么做的
然后照猫画虎去把整套流程搬运过来 然后再去把整块链路的代码啃懂 我觉得这个才是真正我看见的可行性 学习路线 后面也要去找一下那边算法的同学和ld 吃个饭 聊一下天 收获一些实践的东西

师傅领进门 修行靠个人

---

然后我看了一下 深度学习 李宏毅教授的课 我觉得可能代码上手的部分确实可能少了一些 但我确实更喜欢一些能上手代码的课程 我觉得参考着动手 才是最好的实践！

做多于说 做所有的事情都是有风险的 没有任何的东西 谁知道一定能成功 一定能做出来 但我觉得有机会 有冲劲 有明确的方向 我就必须要去做到彻底做不了为止

且有个非常明确的东西 即 AI时代 即是大势所趋 必须要去接触 尝试学习 紧跟着这方面去做

---

从零开始的推荐系统学习之路（九）---- 动手学深度学习系列 从零实现线性回归

---

1、理论推导

---

1、链式求导简单示例

---

举例子 计算链式求导

---

2、计算图 & 预测房价case 推导 线性回归解

---

---

2、代码部分

---

---

1、pytorch 入门简单代码

---

import torch

x = torch.arange(11)
x

x.shape

X = torch.zeros((3, 2))
print(X.shape, X)

X = X.reshape(2, -1)
print(X.shape, X)

X1 = torch.arange(12).reshape(3, 4)
X2 = torch.arange(12, 24).reshape(3, 4)

# 列 参考pd axis
Xdim1 = torch.concat((X1, X2), dim=1)
print(Xdim1)
#
Xdim0 = torch.concat((X1, X2), dim=0)
print(Xdim0)

a = torch.arange(3).reshape(3, 1)
b = torch.arange(6).reshape(1, -1)
print(a)
print(b)
a + b

A = torch.arange(12).reshape(4, -1)
print(A)

A.T

B = A
B = [1, 2, 3]
print(A, B)

print(A.sum(), A.sum(axis=0), A.numel())


print(A.sum(axis=1).shape)
print(A.sum(axis=1, keepdims=True).shape)

print(A)
print(A / A.sum(axis=1, keepdims=True))
print(A)
print(A / A.sum(axis=0, keepdims=True))


x = torch.tensor([1, 2, 3, 4])
X = torch.arange(8).reshape(2, 4)
y = x

print(torch.sum(x * y), torch.dot(x, y))
X, x, torch.mv(X, x)


X1 = X
X2 = X

torch.mm(X1, X2.T)


# L2范数

X = torch.tensor([3.0, -4.0])
torch.norm(X)


X = torch.ones((4, 9)) # 4 * 9 = 36 36开sqrt
X.norm()


b = X.norm()
b

---

---

---

---

2、从零实现线性回归（裸代码）

---

%matplotlib inline

import torch
import numpy as np
from d2l import torch as d2l


def synthetic_data(w, b, num_examples):
    """ 生成 y = w * X + b + 噪声 """
    X = torch.normal(0, 1, (num_examples, len(w)))
    y = torch.mv(X, w) + b
    y += np.random.normal(0, 0.01, len(y))

    return X, y.reshape(-1,1)

# 不妨假设w = [2, -3.4]T, b = 4.2)
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 10000)
features.shape, labels.shape, features, labels


d2l.set_figsize()
""" 约等于可以看出 w = -3.4 或者 w = 2  """
d2l.plt.scatter(features[:, 0].numpy(), labels.numpy(), c="b")
d2l.plt.scatter(features[:, 1].numpy(), labels.numpy(), c="r")



# batch 小批量随机选取
def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    np.random.shuffle(indices)
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(indices[i:min(i + batch_size, num_examples)])
        yield features[batch_indices], labels[batch_indices]
    
for X, y in data_iter(10, features, labels):
    print(X, "\n", y)
    break



# 初始化参数

w = torch.normal(0, 10.0, size=(features.shape[1], 1), requires_grad=True)
b = torch.tensor(np.random.rand(), requires_grad=True)
w, b


def lineregression(X, w, b):
    return torch.matmul(X, w) + b

def squared_loss(y_hat, y):
    return ((y_hat - y.reshape(y_hat.shape)) ** 2) / 2.0 / len(y)

def sgd(params, lr, batch_size):
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad
            param.grad.zero_()





lr = 0.01
num_epochs = 3
net = lineregression
loss = squared_loss
batch_size = 32

for i in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y) # 算损失标量
        # print(w, b, true_w, true_b, net(X, w, b), "\n", y, )
        l.backward() # 链式反向求导
    
        sgd([w, b], lr, batch_size) # 梯度下降
    with torch.no_grad():
        train_loss = loss(net(features, w, b), labels)
        print("epoch:{}, loss:{:.10f}, w:{}, true_w:{}, b:{}, true_b:{}".format(i, train_loss, w, true_w, b, true_b))
  

---

---

3、从零实现线性回归（torch代码）

---

import torch
import numpy
from torch.utils import data
from d2l import torch as d2l

true_w = torch.tensor([2, -3.4])
true_b = torch.tensor(4.2)

features, labels = d2l.synthetic_data(true_w, true_b, 10000)
features.shape, labels.shape

batch_size = 100

def load_array(data_arrays, batch_size, is_train=True):
    """ 构建一个Pytorch的数据迭代器 """

    # *data_arrays 解元组
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size=batch_size, shuffle=is_train)

data_iter = load_array((features, labels), batch_size)

from torch import nn

net = nn.Sequential(nn.Linear(2, 1))

net[0].weight.data.normal_(0, 0.01), net[0].bias.data.fill_(2)


loss = nn.MSELoss()

trainer = torch.optim.SGD(net.parameters(), lr=0.03)

num_epoch = 3

for epoch in range(num_epoch):
    for X, y in data_iter:
        l = loss(net(X), y)
        trainer.zero_grad()
        l.backward()
        trainer.step()

    l1 = loss(net(features), labels)
    # print("epoch:{} loss:{:.20f} w:{}, b:{}".format(epoch, l1, trainer.param_groups, net.weight.data.flatten(), net.bias.data.item()))
    print("epoch:{} loss:{:.20f} w:{}, b:{}".format(
        epoch, 
        l1.item(), 
        net[0].weight.data.flatten(),
        net[0].bias.data.item()
    ))

---