一、visdom可视化工具
安装: pip install visdom
启动: 命令行直接运行visdom
打开WEB: 在浏览器使用http://localhost:8097打开visdom界面
二、使用visdom
# 导入Visdom类
from visdom import Visdom
# 定义一个env叫Mnist的board,如果不指定,则默认归于main
viz = Visdom(env='Mnist')
# 在window Accuracy中画train acc和test acc,x坐标都是epoch
viz.line(Y=np.column_stack((acc, test_acc)),
X=np.column_stack((epoch, epoch)),
win='Accuracy',
update='append',
opts=dict(markers=False, legend=['Acc', 'Test Acc']))
# 在window Loss中画train loss和test loss,x坐标都是epoch
viz.line(Y=np.column_stack((loss.cpu().item(), test_loss.cpu().item())),
X=np.column_stack((epoch, epoch)),
win='Loss',
update='append',
opts=dict(markers=False, legend=['Loss', 'Test Loss']))
三、使用正则化
正则化也叫权重衰减(Weight Decay)
L1和L2正则化可以参考:https://blog.csdn.net/red_stone1/article/details/80755144
在代码中,我们只需要在优化器中使用weight_decay参数就可以启用L2正则化
# 选择一个优化器,指定需要优化的参数,学习率,以及正则化参数
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, weight_decay=0.01)
由于在Pytorch中没有纳入L1正则化,我们可以通过手工实现:
# 正则化超参数lambda
lambd = 0.01
# 所有参数的绝对值的和
regularization_loss = 0
for param in model.parameters():
regularization_loss += torch.sum(torch.abs(param))
# 自己手动在loss函数后添加L1正则项 lambda * sum(abs)
loss = F.cross_entropy(z, target) + lambd * regularization_loss
optimizer.zero_grad()
loss.backward()
四、使用Momentum动量
使用Momentum,即在使用SGD时指定momentum参数,如果不指定,默认为0,即不开启动量优化模式。
# 选择一个优化器,指定需要优化的参数,学习率,以及正则化参数,是否使用momentum
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9, weight_decay=0.01)
使用Adam时,由于Adam包含了Monmentum,所以他自己指定了Momentum参数的大小,无需我们指定。
五、学习率衰减 Learning rate decay
当学习率太小时,梯度下降很慢。当学习率太大时,可以在某个狭窄区间震荡,难以收敛。
学习率衰减就是为了解决学习率多大这种情况。
当我们在训练一个模型时,发现Loss在某个时间不发生变化(在一个平坦区),则我们要考虑是否是在一个狭窄区间震荡,导致的难以收敛。
我们在pytorch中可以使用ReducelROnPlateau(optimizer,‘min’)来监控loss的值:
from torch.optim.lr_scheduler import ReduceLROnPlateau
# 选择一个优化器,指定需要优化的参数,学习率,以及正则化参数,是否使用momentum
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9, weight_decay=0.01)
# 使用一个高原监控器,将optimizer交给他管理,LR衰减参数默认0.1即一次缩小10倍,patience是监控10次loss看是否变化
scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10)
# 后面的optimizer.step()使用scheduler.step(loss)来代替,每次step都会监控一下loss
# 当loss在10次(可以设置)都未变化,则会使LR衰减一定的比例
另外,除了上述使用ReducelROnPlateau,还可以使用更为粗暴的StepLR函数,我们可以直接指定在多少step后下降一次LR的值:
from torch.optim.lr_scheduler import StepLR
# 选择一个优化器,指定需要优化的参数,学习率,以及正则化参数,是否使用momentum
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9, weight_decay=0.01)
# 使用StepLR,指定step_size即每多少步衰减一次,gamma为衰减率,0.1代表除以10
scheduler = StepLR(optimizer, step_size = 10000, gamma=0.1)
# 后面的optimizer.step()使用scheduler.step()
六、在全连接层使用batchnorm
# -*- coding:utf-8 -*-
__author__ = 'Leo.Z'
import torch
from visdom import Visdom
import numpy as np
import torch.nn.functional as F
from torch.nn import Module, Sequential, Linear, LeakyReLU, BatchNorm1d
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
batch_size = 200
learning_rate = 0.001
epochs = 100
train_data = datasets.MNIST('../data', train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
test_data = datasets.MNIST('../data', train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
train_db, val_db = torch.utils.data.random_split(train_data, [50000, 10000])
train_loader = DataLoader(train_db,
batch_size=100, shuffle=True)
val_loader = DataLoader(val_db,
batch_size=10000, shuffle=True)
test_loader = DataLoader(test_data,
batch_size=10000, shuffle=True)
# 网络结构
class MLP(Module):
def __init__(self):
super(MLP, self).__init__()
self.model = Sequential(
Linear(784, 200),
#===================== BN-start ======================
# 这里对第一层全连接层使用BN1d,在多个样本上对每一个神经元做归一化
BatchNorm1d(200, eps=1e-8),
# ===================== BN-end =======================
LeakyReLU(inplace=True),
Linear(200, 200),
#===================== BN-start ======================
# 这里对第二层全连接层使用BN1d,在多个样本上对每一个神经元做归一化
BatchNorm1d(200, eps=1e-8),
# ===================== BN-end =======================
LeakyReLU(inplace=True),
Linear(200, 10),
LeakyReLU(inplace=True)
)
def forward(self, x):
x = self.model(x)
return x
# 定义一个env叫Mnist的board,如果不指定,则默认归于main
viz = Visdom(env='TestBN')
# 定义GPU设备
device = torch.device('cuda')
# model放到GPU
net = MLP().to(device)
# 选择一个优化器,指定需要优化的参数,学习率,以及正则化参数,是否使用momentum
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9, weight_decay=0.01)
for idx, (val_data, val_target) in enumerate(val_loader):
val_data = val_data.view(-1, 28 * 28)
val_data, val_target = val_data.to(device), val_target.to(device)
for epoch in range(epochs):
for batch_idx, (data, target) in enumerate(train_loader):
# data转换维度为[200,784],target的维度为[200]
data = data.view(-1, 28 * 28)
# 将data和target放到GPU
data, target = data.to(device), target.to(device)
# data为输入,net()直接执行forward
# 跑一次网络,得到z,维度为[200,10],200是batch_size,10是类别
# 由于net在GPU,data也在GPU,计算出的z就在GPU
# 调用net(data)的时候相当于调用Module类的__call__方法
z = net(data).to(device)
# 将loss放到GPU
loss = F.cross_entropy(z, target).to(device)
# 每次迭代前将梯度置0
optimizer.zero_grad()
# 反向传播,计算梯度
loss.backward()
# 相当于执行w = w - dw,也就是更新权值
optimizer.step()
### 每一轮epoch,以下代码是使用分割出的val dataset来做测试
# 先计算在train dataset上的准确率
eq_mat = torch.eq(z.argmax(dim=1), target)
acc = torch.sum(eq_mat).float().item() / eq_mat.size()[0]
print('Loss:', loss)
print('Accuracy:', acc)
# 用val跑一遍网络,并计算在val dataset上的准确率
# ===================== BN-start =====================
# 跑网络之前,先将BN层设置为validation模式
# BN层会自动使用在训练时累计的running_mean和running_var
net.eval()
#net.model[1].eval()
#net.model[4].eval()
# ===================== BN-end =======================
val_z = net(val_data).to(device)
val_loss = F.cross_entropy(val_z, val_target).to(device)
val_eq_mat = torch.eq(val_z.argmax(dim=1), val_target)
val_acc = torch.sum(val_eq_mat).float().item() / val_eq_mat.size()[0]
print('Val Loss:', val_loss)
print('Val Accuracy:', val_acc)
# 将loss和acc画到visdom中
viz.line(Y=np.column_stack((acc, val_acc)),
X=np.column_stack((epoch, epoch)),
win='Accuracy',
update='append',
opts=dict(markers=False, legend=['Acc', 'Val Acc']))
# 将val loss和val acc画到visdom中
viz.line(Y=np.column_stack((loss.cpu().item(), val_loss.cpu().item())),
X=np.column_stack((epoch, epoch)),
win='Loss',
update='append',
opts=dict(markers=False, legend=['Loss', 'Val Loss']))
使用BN时的ACC和LOSS:
未使用BN时的ACC和LOSS:
从上述结果可以看出,使用BN后,收敛速度变快。
如何学习大模型 AI ?
由于新岗位的生产效率,要优于被取代岗位的生产效率,所以实际上整个社会的生产效率是提升的。
但是具体到个人,只能说是:
“最先掌握AI的人,将会比较晚掌握AI的人有竞争优势”。
这句话,放在计算机、互联网、移动互联网的开局时期,都是一样的道理。
我在一线互联网企业工作十余年里,指导过不少同行后辈。帮助很多人得到了学习和成长。
我意识到有很多经验和知识值得分享给大家,也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑,所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限,很多互联网行业朋友无法获得正确的资料得到学习提升,故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。
😝有需要的小伙伴,可以点击下方链接免费领取或者V扫描下方二维码免费领取🆓
第一阶段(10天):初阶应用
该阶段让大家对大模型 AI有一个最前沿的认识,对大模型 AI 的理解超过 95% 的人,可以在相关讨论时发表高级、不跟风、又接地气的见解,别人只会和 AI 聊天,而你能调教 AI,并能用代码将大模型和业务衔接。
- 大模型 AI 能干什么?
- 大模型是怎样获得「智能」的?
- 用好 AI 的核心心法
- 大模型应用业务架构
- 大模型应用技术架构
- 代码示例:向 GPT-3.5 灌入新知识
- 提示工程的意义和核心思想
- Prompt 典型构成
- 指令调优方法论
- 思维链和思维树
- Prompt 攻击和防范
- …
第二阶段(30天):高阶应用
该阶段我们正式进入大模型 AI 进阶实战学习,学会构造私有知识库,扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架,抓住最新的技术进展,适合 Python 和 JavaScript 程序员。
- 为什么要做 RAG
- 搭建一个简单的 ChatPDF
- 检索的基础概念
- 什么是向量表示(Embeddings)
- 向量数据库与向量检索
- 基于向量检索的 RAG
- 搭建 RAG 系统的扩展知识
- 混合检索与 RAG-Fusion 简介
- 向量模型本地部署
- …
第三阶段(30天):模型训练
恭喜你,如果学到这里,你基本可以找到一份大模型 AI相关的工作,自己也能训练 GPT 了!通过微调,训练自己的垂直大模型,能独立训练开源多模态大模型,掌握更多技术方案。
到此为止,大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗?
- 为什么要做 RAG
- 什么是模型
- 什么是模型训练
- 求解器 & 损失函数简介
- 小实验2:手写一个简单的神经网络并训练它
- 什么是训练/预训练/微调/轻量化微调
- Transformer结构简介
- 轻量化微调
- 实验数据集的构建
- …
第四阶段(20天):商业闭环
对全球大模型从性能、吞吐量、成本等方面有一定的认知,可以在云端和本地等多种环境下部署大模型,找到适合自己的项目/创业方向,做一名被 AI 武装的产品经理。
- 硬件选型
- 带你了解全球大模型
- 使用国产大模型服务
- 搭建 OpenAI 代理
- 热身:基于阿里云 PAI 部署 Stable Diffusion
- 在本地计算机运行大模型
- 大模型的私有化部署
- 基于 vLLM 部署大模型
- 案例:如何优雅地在阿里云私有部署开源大模型
- 部署一套开源 LLM 项目
- 内容安全
- 互联网信息服务算法备案
- …
学习是一个过程,只要学习就会有挑战。天道酬勤,你越努力,就会成为越优秀的自己。
如果你能在15天内完成所有的任务,那你堪称天才。然而,如果你能完成 60-70% 的内容,你就已经开始具备成为一名大模型 AI 的正确特征了。
这份完整版的大模型 AI 学习资料已经上传CSDN,朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费
】
😝有需要的小伙伴,可以Vx扫描下方二维码免费领取==🆓