devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Hello World！_从零开始大模型开发与微调 pdf

作者：Cpp五条 | 2024-04-03 21:31:51

赞

踩

从零开始大模型开发与微调 pdf

 一、minist数据集

深度学习编程特有的hello world程序：采用minist数据集完成意向特定深度学习项目

1、minist数据集介绍

MNIST数据集是一个广泛使用的手写数字识别数据集，它包含了许多不同人手写的数字图片。这个数据集被广泛用于研究手写数字识别，是深度学习领域的一个典型应用。

一共包含四个文件夹：
train-images-idx3-ubyte.gz：训练集图像（9912422 字节）55000张训练集 + 5000张验证集；
train-labels-idx1-ubyte.gz：训练集标签（28881 字节）训练集对应的标签；
t10k-images-idx3-ubyte.gz：测试集图像（1648877 字节）10000张测试集；
t10k-labels-idx1-ubyte.gz：测试集标签（4542 字节）测试集对应的标签；

2、下载

如果你手头有《从零开始大模型开发与微调》这本书，随书附赠的代码中就有这个数据集，如果你有但也想尝试自行处理数据，就可以跟着看下去。

进入官网、四个链接分别下载进一个文件夹里、解压（我用的是7z解压）

MNIST handwritten digit database, Yann LeCun, Corinna Cortes and Chris Burges

​

3、读取文件

鉴于idx-udyte文件的特殊性，我们需要一些特殊的方法读取文件中的数据：

以数据集的idx3-udyte为例，idx3-udyte文件的数据都是二进制数、由四个32位数组成的表头和具体数据组成。其中表头的四个32位数分别是魔数和第三维、行、列的数目。同理idx1-udyte由两个32位数组成表头，魔数和第三维的数目。

既然已经知道了他的格式，我们就可以进行读取：

读取方法参考（照搬）了该文章：  数据集解析 001：MNIST数据集与IDX文件（附带IDX文件提取代码Python版）_fmt_header = '>iiii-CSDN博客

首先是将文件以二进制的方式读取出：

  1. with open('MNIST/train-images.idx3-ubyte', 'rb') as f:
  2.     content = f.read()
  3. # print(content)

然后通过struct模块的unpack_from()方法提取表头：

  1. fmt_header = '>iiii'   
  2. offset = 0
  3. # 从偏移量位0的位置开始读取四个整型（4字节32位）
  4. magic_number, num_images, num_rows, num_cols = struct.unpack_from(fmt_header, content, offset)
  5. print ('幻数:%d, 图片数量: %d张, 图片大小: %d*%d' % (magic_number, num_images, num_rows, num_cols))

struct.unpack_from() 这个方法用一句话概括其功能就是：从某个文件中以特定的格式读取出相应的数据。至于fmt_header、offset这些都是提取时使用的参数，具体含义想理解的可以自行学习理解。

之后读取除了表头以外的其他数据：

剩下的数据，就是n多个x行y列的图片数据、图片数据本质上就是一个三维数组、我们的工作就是将这些实质上是三维数组的数据存储成真正的三维数组

  1. #定义一张图片需要的数据个数（每个像素一个字节，共需要行*列个字节的数据）
  2. img_size = num_rows*num_cols
  3. #struct.calcsize(fmt)用来计算fmt格式所描述的结构的大小
  4. offset += struct.calcsize(fmt_header)
  5. # '>784B'是指用大端法读取784个unsigned byte
  6. fmt_image = '>' + str(img_size) + 'B'
  7. #定义了一个三维数组，这个数组共有num_images个 num_rows*num_cols尺寸的矩阵。
  8. images = np.empty((num_images, num_rows, num_cols))
  9.  
  10. for i in range(num_images):
  11.     images[i] = np.array(struct.unpack_from(fmt_image, content, offset)).reshape((num_rows,num_cols))
  12.     offset += struct.calcsize(fmt_image)
  13. # print(images[0])   # 输出一个样例

用到的函数有：

备注：struct.calcsize()>
备注：<np.empty()>详解
备注：<np.array()>详解
备注：<np.reshape()>详解

4、举一反三：

已知如何读取idx3-udyte类型的数据，那么我们就可以举一反三相对应的写出idx1-udyte类型的数据，并把这两个方法放入同一个类中

  1. import struct
  2. import numpy as np
  3. """
  4. ReadData类，其中有两个方法read_data()
  5. read_data1()  输入一个路径参数roadurl，返回该idx1-udata
  6. read_data3()  输入一个路径参数roadurl，返回该idx3-udata
  7. """
  8.  
  9.  
  10. class ReadData():
  11.     def read_data1(self, roadurl):
  12.         with open(roadurl, 'rb') as f:
  13.             content = f.read()
  14.         # print(content)
  15.  
  16.         fmt_header = '>ii'  # 网络字节序
  17.         offset = 0
  18.  
  19.         magic_number, num_images= struct.unpack_from(fmt_header, content, offset)
  20.         print('幻数:%d, 图片数量: %d张' % (magic_number, num_images))
  21.         # 图片的标签是一个int类型变量。
  22.         img_size = 1
  23.         # struct.calcsize(fmt)用来计算fmt格式所描述的结构的大小
  24.         offset += struct.calcsize(fmt_header)
  25.         # '>1B'是指用大端法读取1个unsigned byte
  26.         fmt_image = '>' + str(img_size) + 'B'
  27.         # 定义了一个数组，这个数组共有num_images个图片标签。
  28.         images = np.empty(num_images)
  29.  
  30.         for i in range(num_images):
  31.             images[i] = np.array(struct.unpack_from(fmt_image, content, offset))
  32.             offset += struct.calcsize(fmt_image)
  33.  
  34.         return images
  35.     """
  36.     ReadData类，其中只有一个方法read_data()
  38.     """
  39.     def read_data3(self, roadurl):
  40.         with open(roadurl, 'rb') as f:
  41.             content = f.read()
  42.         # print(content)
  43.  
  44.         fmt_header = '>iiii'  # 网络字节序
  45.         offset = 0
  46.  
  47.         magic_number, num_images, num_rows, num_cols = struct.unpack_from(fmt_header, content, offset)
  48.         print('幻数:%d, 图片数量: %d张, 图片大小: %d*%d' % (magic_number, num_images, num_rows, num_cols))
  49.         # 定义一张图片需要的数据个数（每个像素一个字节，共需要行*列个字节的数据）
  50.         img_size = num_rows * num_cols
  51.         # struct.calcsize(fmt)用来计算fmt格式所描述的结构的大小
  52.         offset += struct.calcsize(fmt_header)
  53.         # '>784B'是指用大端法读取784个unsigned byte
  54.         fmt_image = '>' + str(img_size) + 'B'
  55.         # 定义了一个三维数组，这个数组共有num_images个 num_rows*num_cols尺寸的矩阵。
  56.         images = np.empty((num_images, num_rows, num_cols))
  57.  
  58.         for i in range(num_images):
  59.             images[i] = np.array(struct.unpack_from(fmt_image, content, offset)).reshape((num_rows, num_cols))
  60.             offset += struct.calcsize(fmt_image)
  61.  
  62.         return images
  63.  
  64. # 试运行一下看一看
  65. if __name__ == '__main__':
  66.     a = ReadData()
  67.     print(a.read_data1("train-labels.idx1-ubyte"))

至此我们已经完成了数据的前期处理，接下来就需要请出大模型了。

二、大模型

1、选择模型

作为helloworld级别的程序，我们不需要去了解具体怎么选择模型，你只需要知道我们这里使用的是Unet模型即可。这是一种输入和输出的大小维度都相同的模型。

2、Unet模型的整体结构

  1. import torch
  2.  
  3.  
  4. class Unet(torch.nn.Module):
  5.     def __init__(self):
  6.         super(Unet, self).__init__()
  7.  
  8.         # 模块化结构，这也是后面常用到的模型结构
  9.         self.first_block_down = torch.nn.Sequential(
  10.             torch.nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1), torch.nn.GELU(),
  11.             torch.nn.MaxPool2d(kernel_size=2, stride=2)
  12.         )
  13.  
  14.         self.second_block_down = torch.nn.Sequential(
  15.             torch.nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1), torch.nn.GELU(),
  16.             torch.nn.MaxPool2d(kernel_size=2, stride=2)
  17.         )
  18.  
  19.         self.latent_space_block = torch.nn.Sequential(
  20.             torch.nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1), torch.nn.GELU(),
  21.         )
  22.  
  23.         self.second_block_up = torch.nn.Sequential(
  24.             torch.nn.Upsample(scale_factor=2),
  25.             torch.nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, padding=1), torch.nn.GELU(),
  26.         )
  27.  
  28.         self.first_block_up = torch.nn.Sequential(
  29.             torch.nn.Upsample(scale_factor=2),
  30.             torch.nn.Conv2d(in_channels=64, out_channels=32, kernel_size=3, padding=1), torch.nn.GELU(),
  31.         )
  32.  
  33.         self.convUP_end = torch.nn.Sequential(
  34.             torch.nn.Conv2d(in_channels=32, out_channels=1, kernel_size=3, padding=1),
  35.             torch.nn.Tanh()
  36.         )
  37.  
  38.     def forward(self, img_tensor):
  39.         image = img_tensor
  40.  
  41.         image = self.first_block_down(image)  # ;print(image.shape)     # torch.Size([5, 32, 14, 14])
  42.         image = self.second_block_down(image)  # ;print(image.shape)    # torch.Size([5, 16, 7, 7])
  43.         image = self.latent_space_block(image)  # ;print(image.shape)   # torch.Size([5, 8, 7, 7])
  44.  
  45.         image = self.second_block_up(image)  # ;print(image.shape)      # torch.Size([5, 16, 14, 14])
  46.         image = self.first_block_up(image)  # ;print(image.shape)       # torch.Size([5, 32, 28, 28])
  47.         image = self.convUP_end(image)  # ;print(image.shape)           # torch.Size([5, 32, 28, 28])
  48.         return image
  49.  
  50.  
  51. if __name__ == '__main__':
  52.     image = torch.randn(size=(5, 1, 28, 28))
  53.     unet_model = Unet()
  54.     torch.save(unet_model, './unet_model.pth')

3、模型的损失函数与优化函数

损失函数的主要目的是评估模型的预测结果与实际结果之间的不一致程度，优化函数是用来指导模型如何通过调整参数来最小化损失函数的函数。

简而言之，损失函数评估模型准确率的，优化函数是提高模型准确率的。

损失函数就是在样本集中选一批数据，然后只给输入让模型给输出，然后根据输出与样本集的标签作对比得出一个数值，这个数值越小越好。我们这里使用的是均方损失函数MSEless

  1.         # 模型的损失函数
  2.         pred = model(x_imgs_batch)  # 对模型进行正向计算
  3.         loss = torch.nn.MSELoss(reduction="sum")(pred, y_batch) * 100.  # 使用损失函数进行计算

优化函数同理不在讲解，这里选择的是adam优化器。我们只需要知道这些都是很重要的内容即可

optimizer = torch.optim.Adam(model.parameters(), lr=2e-5)  # 设定优化函数，学习率为lr

 4、模型训练参数

先介绍他的一些主要内容：

导入数据集方法的调用：

  1. # 载入数据 如果你使用这里给的数据集可以用这个方法
  2. x_train = np.load("../dataset/mnist/x_train.npy")
  3. y_train_label = np.load("../dataset/mnist/y_train_label.npy")
  4. # 如果用的是自己找的数据集则要用
  5. x_train = rdOne.read_data3("G:/机械学习/数据集/minist/MNIST/train-images.idx3-ubyte")
  6. y_train_label = rdOne.read_data1("G:/机械学习/数据集/minist/MNIST/train-labels.idx1-ubyte")

报错：“ AttributeError: module ‘backend_interagg‘ has no attribute ‘FigureCanvas‘ “：

  1. # import matplotlib.puplot as plt
  2. import matplotlib
  3. # 切换为图形界面显示的终端TkAgg
  4. matplotlib.use('TkAgg')
  5. # 导入matplotlib的pyplot
  6. import matplotlib.pyplot as plt

5、基于深度学习的模型训练

  1. import os
  2.  
  3. os.environ['CUDA_VISIBLE_DEVICES'] = '0'  # 指定GPU编
  4. import torch
  5. import numpy as np
  6. import unet
  7. from tqdm import tqdm
  8.  
  9. from read_data import ReadData as rdOne
  10. import matplotlib
  11. matplotlib.use('TkAgg')
  12. import matplotlib.pyplot as plt
  13. # 切换为图形界面显示的终端TkAgg
  14. # 导入matplotlib的pyplot
  15.  
  16. batch_size = 320  # 设定每次训练的批次数
  17. epochs = 1024  # 设定训练次数
  18.  
  19. # device = "cpu"                         #Pytorch的特性，需要指定计算的硬件，如果没有GPU的存在，就使用CPU进行计算
  20. device = "cuda"  # 在这里读者默认使用GPU，如果读者出现运行问题可以将其改成cpu模式
  21.  
  22. model = unet.Unet()  # 导入Unet模型
  23. model = model.to(device)  # 将计算模型传入GPU硬件等待计算
  24. # model = torch.compile(model)            #Pytorch2.0的特性，加速计算速度 选择使用内容
  25. optimizer = torch.optim.Adam(model.parameters(), lr=2e-5)  # 设定优化函数，学习率为lr
  26.  
  27. # 载入数据 如果你使用这里给的数据集可以用这个方法
  28. # x_train = np.load("../dataset/mnist/x_train.npy")
  29. # y_train_label = np.load("../dataset/mnist/y_train_label.npy")
  30. # 如果用的是自己找的数据集则要用
  31. x_train = rdOne.read_data3("G:/机械学习/数据集/minist/MNIST/train-images.idx3-ubyte")
  32. y_train_label = rdOne.read_data1("G:/机械学习/数据集/minist/MNIST/train-labels.idx1-ubyte")
  33.  
  34. x_train_batch = []
  35. for i in range(len(y_train_label)):
  36.     if y_train_label[i] <= 10:  # 为了加速演示作者只对数据集中的小于2的数字，也就是0和1进行运行，读者可以自行增加训练个数
  37.         x_train_batch.append(x_train[i])
  38.  
  39. x_train = np.reshape(x_train_batch, [-1, 1, 28, 28])  # 修正数据输入维度：([30596, 28, 28])
  40. x_train /= 512.
  41. train_length = len(x_train) * 20  # 增加数据的单词循环次数
  42.  
  43. # state_dict = torch.load("./saver/unet.pth")
  44. # model.load_state_dict(state_dict)
  45. for epoch in range(30): # 循环30次
  46.     train_num = train_length // batch_size  # 计算有多少批次数
  47.  
  48.     train_loss = 0  # 用于损失函数的统计
  49.     for i in tqdm(range(train_num)):  # 开始循环训练
  50.         x_imgs_batch = []  # 创建数据的临时存储位置
  51.         x_step_batch = []
  52.         y_batch = []
  53.         # 对每个批次内的数据进行处理
  54.         for b in range(batch_size):
  55.             img = x_train[np.random.randint(x_train.shape[0])]  # 提取单个图片内容
  56.             x = img
  57.             y = img
  58.  
  59.             x_imgs_batch.append(x)
  60.             y_batch.append(y)
  61.  
  62.         # 将批次数据转化为Pytorch对应的tensor格式并将其传入GPU中
  63.         x_imgs_batch = torch.tensor(x_imgs_batch).float().to(device)
  64.         y_batch = torch.tensor(y_batch).float().to(device)
  65.  
  66.         # 模型的损失函数
  67.         pred = model(x_imgs_batch)  # 对模型进行正向计算
  68.         loss = torch.nn.MSELoss(reduction="sum")(pred, y_batch) * 100.  # 使用损失函数进行计算
  69.  
  70.         # 这里读者记住下面就是固定格式，一般而言这样使用即可
  71.         optimizer.zero_grad()  # 对结果进行优化计算
  72.         loss.backward()  # 损失值的反向传播
  73.         optimizer.step()  # 对参数进行更新
  74.  
  75.         train_loss += loss.item()  # 记录每个批次的损失值
  76.     # 计算并打印损失值
  77.     train_loss /= train_num
  78.     print("train_loss:", train_loss)
  79.     if epoch % 6 == 0:
  80.         torch.save(model.state_dict(), "./saver/unet.pth")
  81.  
  82.     # 下面是对数据进行打印
  83.     image = x_train[np.random.randint(x_train.shape[0])]  # 随机挑选一条数据进行计算
  84.     image = np.reshape(image, [1, 1, 28, 28])  # 修正数据维度
  85.  
  86.     image = torch.tensor(image).float().to(device)  # 挑选的数据传入硬件中等待计算
  87.     image = model(image)  # 使用模型对数据进行计算
  88.  
  89.     image = torch.reshape(image, shape=[28, 28])  # 修正模型输出结果
  90.     image = image.detach().cpu().numpy()  # 将计算结果导入CPU中进行后续计算或者展示
  91.  
  92.     # 展示或计算数据结果
  93.     plt.imshow(image)
  94.     plt.savefig(f"./img/img_{epoch}.jpg")

三、总结

1、文件总览

共有：

1个img文件夹用以存储图片文件

1个saver文件夹用以存储模型

1个read_data.py文件：功能是读取idx3-udyte数据

1个train.py文件：功能是训练模型

1个Unet.py文件：unet模型

2、训练结果

完整的训练时间可能需要很久，这里只训练了很短的时间，所以只出了部分结果。

 

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号