问题：
- 深度学习训练的常规步骤
- 微调模型的几个思考方向
- 构建自己的数据集用于微调大模型
- 各种微调方式的实现
编写代码
先用一个简单的中文手写识别的深度学习例子来说明训练的过程，这里分别使用PyTorch和TenserFlow来实现，以便比较两个工具库的不同风格。
Talk is cheap， Show code.
数据存放的路径：总共15000张图片，可以去kaggle.com下载 www.kaggle.com/datasets/gp...
图片文件名最后一个数字和图片内容中的文字对应关系是：
"零一二三四五六七八九十百千万亿"\] -\> index + 1 按咱的惯例，定义数据路径： ```ini cur_path = os.getcwd() class DataPathEnum(str, Enum): ZH_HANDWRITTING_IMG_DIR = "chinese_handwritting/images" GPT2XL_TRAIN_DATA_DIR = "gpt2xl" MODEL_CHECKPOINT_DIR = "checkpoints" def __str__(self): return os.path.join(cur_path, "data", self.value) ``` 然后定义两个类库都可以使用的数据基类： ```python IMAGE_DIR = str(DataPathEnum.ZH_HANDWRITTING_IMG_DIR) # image = 64 * 64 class HWData(): def __init__(self) -> None: self.image_files = os.listdir(IMAGE_DIR) self.character_str ="零一二三四五六七八九十百千万亿" self.image_folder:str = IMAGE_DIR # 获取图片路径和标签 def get_image_path_vs_lable(self, index): image_file = self.image_files[index] image_path = os.path.join(self.image_folder, image_file) label = int(image_file.split(".")[0].split("_")[-1]) -1 return label, image_path # 在ipynb文件展示图片并显示标签，以便和预测的结果进行比较 def plot_image(self, index): label, image_path = self.get_image_path_vs_lable(index) image = Image.open(image_path) plt.title("label: " + str(label) + "/" + self.character_str[label]) plt.imshow(image) ``` 先用PyTorch库来操作, 继承自torch.utils.data.Dataset实现自定义数据集，引入图像处理torchvision库。 ```python class HWDataset(HWData, Dataset): def __init__(self) -> None: super().__init__() self.transform = torchvision.transforms.ToTensor() # 实现基类方法 def __len__(self): return len(self.image_files) # 实现基类方法 def __getitem__(self, index) -> Any: label, image_path = self.get_image_path_vs_lable(index) image_tensor = self.transform(Image.open(image_path)) # 标签向量，独热模式 target = torch.zeros((15)) target[label] = 1.0 return image_tensor, target, self.character_str[label] # 随机抽一张图，做验证比较 def get_random_item(self): index = randint(0, self.__len__() -1) return self.__getitem__(index), index ``` 继承自torch.nn.Module实现模型类： ```python class TorchClassifier(nn.Module): def __init__(self) -> None: super().__init__() # 这里只构建全连接层，以便和后面加了卷积和池化层的模型进行比较 self.model = nn.Sequential( nn.Linear(64*64, 1000), # 图片格式64x64 nn.LeakyReLU(0.02), nn.Linear(1000, 100), nn.LeakyReLU(0.02), nn.LayerNorm(100), nn.Linear(100, 15), nn.Softmax(dim = 1) ) # 定义优化函数 self.optimiser = torch.optim.Adam(self.parameters(), lr=0.001) # 定义损失函数 self.loss = nn.BCELoss() # 初始化数据集 self.dataset = HWDataset() # 训练过程数据记录 self.counter = 0 self.progress = [] # 模型参数保存路径 self.checkpoint_file = os.path.join(str(DataPathEnum.MODEL_CHECKPOINT_DIR), "zh_hw_torch.pth") # 实现基类方法 def forward(self, x): # 全连接层接受扁平的批次数据 x = x.view(x.size(0), -1) # 等同 nn.flatten(x) return self.model(x) # 训练方法 def _train(self, x, y): outputs = self.forward(x) loss = self.loss(outputs, y) # 优化过程 self.optimiser.zero_grad() #重置，否则在下个批次梯度会叠加 loss.backward() #反向传播 self.optimiser.step() #调整每层的参数 # 记录过程数据(损失函数的值) self.counter += 1 if(self.counter % 10 == 0): self.progress.append(loss.item()) # 按周期次数进行训练 def train(self, epochs: int): print('start train model...') for epochs in range(epochs): data_loader = DataLoader(self.dataset, batch_size=100, shuffle=True) for index, (data, target, target_char) in enumerate(data_loader): self._train(data, target) self._plot_progress() #绘制训练过程中损失函数的值 # 随机抽一张图，验证查看 def random_eval_model(self): (data, target, _), index = self.dataset.get_random_item() self.dataset.plot_image(index) with torch.no_grad(): output = self.forward(data) df = pd.DataFrame(output.detach().numpy()).T df.plot.barh(rot=0, legend=False, ylim=(0, 15), xlim=(0,1)) def _plot_progress(self): df = pd.DataFrame(self.progress, columns = ["loss"]) df.plot(title="counter:" + str(self.counter), ylim=(0, 1.0), figsize=(16,8), alpha=0.5, marker=".", grid=True, yticks=(0,0.25,0.5)) # 保存模型参数 def save_model_state(self): torch.save(self.model.state_dict(), self.checkpoint_file) ``` 写个ipynb文件来调用模型进行训练： ```scss from aitrain.classifier_torch import HWDataset, TorchClassifier #测试数据集 dataset = HWDataset() dataset.plot_image(2) # 训练模型并保存参数 classifier = TorchClassifier() classifier.train(3) classifier.save_model_state() ```  ```bash # 随机验证并比较预测结果 classifier.random_eval_model() ```  下面用TensorFlow2来实现相同的模块和功能，以便比较两种类库的操作区别。 继承自tensorflow.keras.utils.Sequence实现数据集 ```python class TFDataset(HWData, tf.keras.utils.Sequence): def __init__(self, batch_size) -> None: super().__init__() self.batch_size = batch_size # 实现基类方法，这里返回的批次 def __len__(self): return math.ceil(len(self.image_files)/self.batch_size) # 实现基类方法，依然是批次数据 def __getitem__(self, idx): low = idx * self.batch_size high = min(low + self.batch_size, len(self.image_files)) image_list = [] label_list = [] for index in range(low, high): label, image_path = self.get_image_path_vs_lable(index) image_array = np.array(list(Image.open(image_path).getdata())) image_list.append(image_array) # 标签的独热模式 target =[0 if label != i else 1 for i in range(15)] label_list.append(target) # 返回的是批次数据，注意shape与模型的输入参数一致 return np.array(image_list).reshape(-1,64,64,1), np.array(label_list) # 实现基类方法，每个训练周期结束后调用 def on_epoch_end(self): random.shuffle(self.image_files) ``` 使用tensorflow.keras.Sequential构建TF模型，这里添加卷积和池化层，只是比较一下两个模型的预测准确率。 ```ini class TFClassifier(): def __init__(self, data: TFDataset) -> None: model = tf.keras.Sequential() layers = tf.keras.layers model.add(layers.Rescaling(1./255)) # 压缩到0 ~ 1 model.add(layers.Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), activation='relu', input_shape=(64, 64, 1))) model.add(layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2))) model.add(layers.Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), activation='relu')) model.add(layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2))) model.add(layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), activation='relu')) model.add(layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2))) model.add(layers.Flatten()) #扁平层连接卷积层和全连接层 model.add(layers.Dense(units=1024, activation='relu')) model.add(layers.Dropout(0.2)) # 丢弃一些特征 model.add(layers.Dense(units=256, activation='relu')) model.add(layers.Dense(units=15, activation='softmax')) model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"]) self.model = model self.data = data self.checkpoint_file = os.path.join(str(DataPathEnum.MODEL_CHECKPOINT_DIR), "zh_hw_tf.h5") # 训练模型 def train(self, epochs): his = self.model.fit(self.data, epochs=epochs, verbose=2).history # self.__plot_history(his) self.model.summary() # 模型概要 # 随机选图对比验证 def random_eval_model(self): index = random.randint(0, len(self.data.image_files)-1) self.data.plot_image(index) label, image_path= self.data.get_image_path_vs_lable(index) image_array = np.array(list(Image.open(image_path).getdata())).reshape(-1, 64, 64, 1) prediction = self.model.predict(image_array) df = pd.DataFrame(prediction[0]) df.plot.barh(rot=0, legend=False, ylim=(0, 15), xlim=(0,1)) # 保存模型参数 def save_model_weights(self): self.model.save_weights(self.checkpoint_file) def load_model_weights(self): self.model.load_weights(self.checkpoint_file) # 绘制历史数据，这里没有导入验证数据集，所以没有与验证相关损失函数值 def __plot_history(self, history): fig, axs = plt.subplots(1, 2, figsize=(10, 5)) axs[0].plot(history['loss'], label='training loss') # axs[0].plot(history['val_loss'], label='validation loss') axs[0].legend(loc='upper left') axs[0].set_title('training data vs validation data') axs[1].plot(history['accuracy'], label='testing accuracy') # axs[1].plot(history['val_accuracy'], label='validation accuracy') axs[1].set_ylim([0, 1]) axs[1].legend(loc='upper left') axs[1].set_title('accuracy') axs.flat[0].set(xlabel='epochs', ylabel='loss') axs.flat[1].set(xlabel='epochs', ylabel='accuracy') plt.show() ``` 写个ipynb文件来调用模型进行训练： ```scss from aitrain.classifier_tensorflow import TFDataset, TFClassifier # 验证数据集 data = TFDataset(100) data.plot_image(5) # 训练模型 classifier = TFClassifier(data) classifier.train(3) classifier.save_model_weights() ```  ```scss classifier.random_eval_model() ```  从构建数据集和模型的方式，可见TensorFlow和PyTorch封装的方式不同，但是都能方便地实现自己的想法。后面提到的transformers可以很好的融合这两个深度学习库。 从问题解决的角度看，与问题相适应的复杂度模型会很好地平衡训练时间和预测准确度，所以说优化方法和思维方式一直都是不断提高AI能力的推动力。 下一篇谈谈巨量参数的语言模型，如何在降低参数精度载入、增加AB低秩矩阵Tuning层来节省Full Fine-Tunning全量微调的计算资源需求。 ## 完整代码地址 