线性神经网络
一. 机器学习
1.解决问题
1）分类问题：离散值相关，预测属于那个分类
2）回归问题：一般预测单个数值问题相关，解决多少的问题
3）聚类问题
2. 建模流程
二. 优化算法
1.损失函数
作用：模型预测结果和实际结果的差距。
目标：差距越小，损失越小，说明模型越精准
2.梯度
下降最快的方向
3.梯度下降
逐步找到loss最小的解，由于函数是波峰的，所以找到的是局部最优解，而不是全局最优解。学习率为超参，既不能太小也不能太大
4.小批量梯度下降（默认求解方法）
随机采样b个样本近似损失，b=批量大小，也是超参数，既不能太大也不能太小，太大容易内容消耗增加，太小计算量太小不利于利用资源
三.线性回归实现
1.函数
reshape()
改变形状大小，比如10个元素，reshape((2,5))意思是转成2行5列的形状。
reshape((-1,1))转成5列的形状，行数适配。（1，-1）同理
normal()
#生成均值为0、标准差为0.01的正态分布中采样随机数，来初始化权重， 并将偏置初始化为0。
w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)
matmul（）
def linreg(X, w, b): #@save
"""线性回归模型"""
return torch.matmul(X, w) + b
表示Xw+b
no_grad()
requires_grad
在pytorch中，tensor有一个requires_grad参数，如果设置为True，则反向传播时，该tensor就会自动求导。tensor的requires_grad的属性默认为False,若一个节点（叶子变量：自己创建的tensor）requires_grad被设置为True，那么所有依赖它的节点requires_grad都为True（即使其他相依赖的tensor的requires_grad = False）
当requires_grad设置为False时,反向传播时就不会自动求导了，因此大大节约了显存或者说内存。
with torch.no_grad的作用：
在该模块下，所有计算得出的tensor的requires_grad都自动设置为False。
即使一个tensor（命名为x）的requires_grad = True，在with torch.no_grad计算，由x得到的新tensor（命名为w-标量）requires_grad也为False，且grad_fn也为None,即不会对w求导。
x = torch.randn(10, 5, requires_grad = True)
y = torch.randn(10, 5, requires_grad = True)
z = torch.randn(10, 5, requires_grad = True)
with torch.no_grad():
w = x + y + z
print(w.requires_grad)
print(w.grad_fn)
n=x+y
print(w.requires_grad)
print(n.requires_grad)
print(n.grad_fn)
运行结果：
同样还可以用 torch.set_grad_enabled()来实现不计算梯度。
原文链接：https://blog.csdn.net/sazass/article/details/116668755
2.步骤
1.初始化数据集此处练习使用手工生成模拟数据集
2.读取数据
# 小批量迭代方法,取批量大小的数据，但该方法执行效率低
#batchsize 批量大小；feature和label表示特征和标签，x,y
def data_iter(batch_size, features, labels):
num_examples = len(features)
#0-n
indices = list(range(num_examples))
# 这些样本是随机读取的，没有特定的顺序
# 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]
pytorch API
def load_array(data_arrays, batch_size, is_train=True): #@save
"""构造一个PyTorch数据迭代器"""
dataset = data.TensorDataset(*data_arrays)
#DataLoader加载数据集
return data.DataLoader(dataset, batch_size, shuffle=is_train)
3.模型定义
线性回归模型
def linreg(X, w, b): #@save
"""线性回归模型"""
return torch.matmul(X, w) + b
线性神经网络
# nn是神经网络的缩写
from torch import nn
net = nn.Sequential(nn.Linear(2, 1))
Sequential类将多个层串联在一起。 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入
4.损失函数
def squared_loss(y_hat, y): #@save
"""均方损失"""（y的预测值-实际值）的平方/2
return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2
神经网络损失函数定义
loss = nn.MSELoss()
5.优化方法
#小批量梯度下降，lr：学习率，超参
def sgd(params, lr, batch_size): #@save
"""小批量随机梯度下降"""
with torch.no_grad():
for param in params:
#根据参数计算损失的梯度，并进行更新
param -= lr * param.grad / batch_size
param.grad.zero_()
pytorch定义优化方法
trainer = torch.optim.SGD(net.parameters(), lr=0.03)
6.训练
for epoch in range(num_epochs):
for X, y in data_iter(batch_size, features, labels):
# X和y的小批量损失
l = loss(net(X, w, b), y)
# 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起，
# 并以此计算关于[w,b]的梯度
#计算反向传播时需要使用sum
l.sum().backward()
# 使用参数的梯度更新参数
sgd([w, b], lr, batch_size)
with torch.no_grad():
train_l = loss(net(features, w, b), labels)
print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')
torch版
for epoch in range(num_epochs):
for X, y in data_iter:
# 计算批量梯度损失
l = loss(net(X) ,y)
#梯度置为0
trainer.zero_grad()
#反向传播
l.backward()
#更新参数的值
trainer.step()
#预测值与真实值的损失
l = loss(net(features), labels)
print(f'epoch {epoch + 1}, loss {l:f}')
w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)
小结：
以上包含未使用api的和使用pytorchapi实现线性回归功能。使用api有更多便捷的操作，可以减少代码量。
一些api中包含_结尾的方法，和不带_的差别是有_可以直接替换原数据
data模块处理数据
nn包含了神经网络相关的一些方法，如损失函数等
下图为“_”结尾方法的示例
四.softmax实现
1. 函数
sum()
对张量某个维度求和
X = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
X.sum(0, keepdim=True), X.sum(1, keepdim=True)
结果：
(tensor([[5., 7., 9.]]),
tensor([[ 6.],
[15.]]))
交叉熵实现方法
y = torch.tensor([1, 1])
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
#表示y_hat[0,1]每行中对应y中索引的位置，比如
# y=[1,1],y_hat[0,1], 下面的代码表示y_hat0行中y[0]=1列的数据，即0.3;y_hat[1]行中y[0]=1列的数据即0.2
y_hat[[0, 1], y]
y表示真实值的索引，
y_hat表示样本预测概率
2.步骤
1.读取数据集Fashion-MNIST数据集， 并设置数据迭代器的批量大小为256。
import torch
from IPython import display
from d2l import torch as d2l
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
2. 初始化模型参数
图片为28*28，展平为一个向量为784。10个分类，所以输出有10个分类
W=torch.normal(0,0.01,(784,10), requires_grad=True)
b=torch.zeros(10, requires_grad=True)
3.实现softmax
我们将每个元素变成一个非负数。 此外，依据概率原理，每行总和为1
#定义softmax,存在问题：矩阵中的非常大或非常小的元素可能造成数值上溢或下溢
def softmax(X):
X_exp = torch.exp(X)
patition=X_exp.sum(1,keepdim=True)
return X_exp/patition
4.定义模型
def net(X):
return softmax(torch.matmul(X.reshape((-1,W.shape[0])),W)+b)
5.定义损失函数
交叉熵损失函数
def cross_entropy(y_hat, y):
return - torch.log(y_hat[range(len(y_hat)), y])
cross_entropy(y_hat, y)
6.分类问题-分类精度
描述分类是否准确
def accuracy(y_hat, y): #@save
"""计算预测正确的数量"""
if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
y_hat = y_hat.argmax(axis=1)
cmp = y_hat.type(y.dtype) == y
return float(cmp.type(y.dtype).sum())
accuracy(y_hat, y) / len(y)
def evaluate_accuracy(net, data_iter): #@save
"""计算在指定数据集上模型的精度"""
if isinstance(net, torch.nn.Module):
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]
Accumulator实现
class Accumulator: #@save
"""在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] * len(self.data)
def __getitem__(self, idx):
return self.data[idx]
7.训练
迭代训练
def train_epoch_ch3(net, train_iter, loss, updater): #@save
# 将模型设置为训练模式
if isinstance(net, torch.nn.Module):
net.train()
# 训练损失总和、训练准确度总和、样本数
metric = Accumulator(3)
for X, y in train_iter:
# 计算梯度并更新参数
y_hat = net(X)
l = loss(y_hat, y)
if isinstance(updater, torch.optim.Optimizer):
# 使用PyTorch内置的优化器和损失函数
updater.zero_grad()
l.mean().backward()
updater.step()
else:
# 使用定制的优化器和损失函数
l.sum().backward()
updater(X.shape[0])
metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
# 返回训练损失和训练精度
return metric[0] / metric[2], metric[1] / metric[2]
绘图
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater): #@save
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
assert train_loss < 0.5, train_loss
assert train_acc <= 1 and train_acc > 0.7, train_acc
assert test_acc <= 1 and test_acc > 0.7, test_acc
定义更新函数
#学习率
lr = 0.1
def updater(batch_size):
return d2l.sgd([W, b], lr, batch_size)
开始训练，迭代10次
num_epochs = 10
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)
预测分类
def predict_ch3(net, test_iter, n=6): #@save
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)
参考视频
线性回归：https://www.bilibili.com/video/BV1PX4y1g7KC/?vd_source=4cc9f0023dddad3ba6f7edc17eb3040d
softmax：https://www.bilibili.com/video/BV1K64y1Q7wu/?p=1&vd_source=4cc9f0023dddad3ba6f7edc17eb3040d
扫一扫
803
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
