【升华】一文从0到1到实际性应用大语言模型（LLM）

一、前言

相信网已经很多LLM大模型的介绍，概念，发展历史，应用场景的很多文章，但是很多文章都是缺少细节的描述，到底怎么用，需要些什么东西怎么层显出来。所以虽然看了很多大模型的介绍，也仅仅停留到了解的阶段，很难动手实施。也就是说，不能落地实施的方案，策略，其实都是嘴炮。本文尝试更加细致的总结大模型的实际用于开发，使用。

二、大语言模型(LLM)

深度学习模型

首先大语言模型(LLM)是一种深度学习模型，它能够对自然语言文本进行建模，包括词汇、语法和语义等方面。LLM在文本分类、语言生成和文本摘要等领域中都有广泛应用。它通过对大量文本数据进行训练，来学习自然语言的语法和语义规律，从而实现对文本的理解和生成。

神经网络训练策略

在训练过程中，大语言模型(LLM)使用神经网络来学习输入文本的表示和模式。这些表示和模式可以表示为向量，其中包含了文本的语法和语义信息。在训练过程中，大语言模型(LLM)不断优化模型参数和网络结构，以获得更好的分类或生成性能。

训练步骤

输入文本：大语言模型(LLM)从输入的文本数据中提取特征，包括单词、语法和语义信息等。
特征提取：大语言模型(LLM)通过神经网络来学习输入文本的特征表示，这些表示可以表示为向量。
模型训练：大语言模型(LLM)使用这些特征向量来训练分类或生成模型，不断优化模型参数和网络结构。
模型应用：大语言模型(LLM)将训练好的模型参数和网络结构应用到实际的文本分类、语言生成和文本摘要任务中，实现对输入文本的理解和生成。

具体实施

准备工作：环境配置与依赖安装

在进行大语言模型(LLM)的应用前，需要进行以下准备工作：

环境配置：搭建相应的开发环境，包括操作系统、Python和深度学习框架等。
依赖安装：根据所使用的深度学习框架，安装相应的依赖项，包括TensorFlow、PyTorch等。

核心模块实现

在搭建好开发环境后，需要进行大语言模型(LLM)的核心模块实现。核心模块包括以下几个步骤：

单词表示：将单词的发音和词义表示为向量，用于特征提取。
词法分析：通过词法分析算法，将单词的语法表示为向量，用于模型训练。
语义分析：通过语义分析算法，将单词的语义表示为向量，用于模型训练和解释。
模型训练：使用这些表示向量来训练分类或生成模型，并不断优化模型参数和网络结构。
模型部署：将训练好的模型部署到生产环境中，实现对输入文本的理解和生成。

集成与测试

在完成核心模块实现后，需要进行集成和测试，以确保大语言模型(LLM)能够在实际应用中达到预期的性能。

优化与改进

在实际应用中，大语言模型(LLM)可能会出现性能问题，需要进行优化和改进，包括以下几点：

数据预处理：预处理大语言模型(LLM)的训练数据，包括分词、词性标注和命名实体识别等。
模型调整：调整大语言模型(LLM)的模型参数和网络结构，以提高模型性能和准确度。
模型融合：将多个大语言模型(LLM)进行融合，以提高模型性能和准确度。

三、具体实现细节（操作）

1、环境准备

安装工具包

bash 复制代码

pip install numpy requests torch tiktoken matplotlib pandas

导入工具包

python 复制代码

# 导入对应的包
import os
import requests
import pandas as pd
import matplotlib.pyplot as plt
import math
import tiktoken
import torch
import torch.nn as nn

数据读取

python 复制代码

with open('sales_textbook.txt', 'r', encoding='utf-8') as f:
    text = f.read()

配置文件设置

python 复制代码

# 设置一些参数
batch_size = 4  # 批次
context_length = 16  # token 长度，最长 16 个单词
d_model = 64  # 维度
num_layers = 8  # Number of transformer blocks  ？？？
num_heads = 4  # 多头 # 我们的代码中通过 d_model / num_heads = 来获取 head_size

文本清洗

python 复制代码

# 使用 tiktoken 工具库进行处理，该工具是openAI 提供的又快又轻量级，基于原始单词

encoding = tiktoken.get_encoding("cl100k_base")
tokenized_text = encoding.encode(text) # 整个文本的单词数量 77,919
vocab_size = len(set(tokenized_text)) # 单词数：相当于哈希表里面的字典 3,771
max_token_value = max(tokenized_text) # 每个单词对应一个数值，这里找到最大值，100069

print(f"文本单词数量: {len(tokenized_text)}")
print(f"词汇表数量: {vocab_size}")
print(f"最大的单词 token 对应的编码值: {max_token_value}")

python 复制代码

作者：Cv大法代码酱
链接：https://www.zhihu.com/question/641255219/answer/3444335788
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

# 2、词向量 
# 把数据转成张量形式
tokenized_text=torch.tensor(tokenized_text, dtype=torch.long)

# 首先吧数据集分成训练数据和验证数据（8:2）
# Split train and validation
split_idx = int(len(tokenized_text) * 0.8) # 取出 80%的位置
train_data = tokenized_text[:split_idx]  #训练数据
val_data = tokenized_text[split_idx:]    #验证数据

# 准备训练数据
data = train_data
#随机取4个数字，范围 0-(77919*0.8-16)，为了构建批量数据
idxs = torch.randint(low=0, high=len(data) - context_length, size=(batch_size,))  
print(idxs)
# x 是一个 4*16 的结构，因为 idxs 有 4 个，每个里面都是 16 的长度 
# y比 x 移后一位 
x_batch = torch.stack([data[idx:idx + context_length] for idx in idxs])
y_batch = torch.stack([data[idx + 1:idx + context_length + 1] for idx in idxs])
print(x_batch.shape,y_batch.shape)

文本转换

python 复制代码

# 把 16 个数字转换成 64 维度（列）
# 找到最大的 token 值对应的数字
max_token_value=tokenized_text.max().item()
max_token_value
# 需要构造一个 max_token_value*64 维度的矩阵
input_embedding_lookup_table = torch.nn.Embedding(max_token_value+1, d_model)
#看下初始化权重信息，这些数据是在不断更新的
input_embedding_lookup_table.weight.data

 # 把 x_batch 与权重绑定
x_batch_embedding = input_embedding_lookup_table(x_batch)
y_batch_embedding = input_embedding_lookup_table(y_batch)
# 打印看看
x_batch_embedding.shape

 

# 先构建一个全 0编码 的 16*64 的矩阵，先把形状搞出来，16*64 方便与x_batch_embedding的形状进行@运算
position_encoding_lookup_table = torch.zeros(context_length, d_model)
# torch.arange形成一维16个数，然后扩展第二位
position = torch.arange(0, context_length, dtype=torch.float).unsqueeze(1)  # unsqueeze函数主要是对数据维度进行扩充。
#print(torch.arange(0, context_length, dtype=torch.float))
#print(position)
# 计算正玄余玄
div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
position_encoding_lookup_table[:, 0::2] = torch.sin(position * div_term) #偶数位
position_encoding_lookup_table[:, 1::2] = torch.cos(position * div_term) #奇数位

position_encoding_lookup_table = position_encoding_lookup_table.unsqueeze(0).expand(batch_size, -1, -1) #add batch to the first dimension
print("Position Encoding Look-up Table: ", position_encoding_lookup_table.shape)
pd.DataFrame(position_encoding_lookup_table[0].numpy())

# 最终输入 需要输入与位置信息加和
x=x_batch_embedding+position_encoding_lookup_table
y=y_batch_embedding+position_encoding_lookup_table
# 看看此时形状
x.shape,y.shape

训练数据

python 复制代码

# 准备 Wq、Wk、Wv，也是权重矩阵
Wq=nn.Linear(d_model,d_model)  # 64*64
Wk=nn.Linear(d_model,d_model)
Wv=nn.Linear(d_model,d_model)

# 此处相乘是 x 的后两维与 Wq 等相乘   16*64  X   64*64  =  16*64
Q=Wq(x)  # Wq*x
K=Wk(x)
V=Wv(x)




# 多头机制，为了把64 个维度进行拆分多份，每一个头里面有一部分维度，这里是 4 个头，分别进行部分计算，然后合并

#先拆 Q，里面第一维度第二维度不变，分别是 4，,16，增加第三维度4，第四维度从之前的第三维 64 变成 16；这样就变成（4，,16，4，,16）；

Q=Q.reshape(batch_size,context_length,num_heads,d_model//num_heads)
K=K.reshape(batch_size,context_length,num_heads,d_model//num_heads)
V=V.reshape(batch_size,context_length,num_heads,d_model//num_heads)

# 在把二三维度转换，变成（4，,4，,16，,16）因为接下来需要做注意力机制，关注的是 token，而不是多头
Q = Q.transpose(1, 2) # [4, 4, 16, 16]
K = K.transpose(1, 2) # [4, 4, 16, 16]
V = V.transpose(1, 2) # [4, 4, 16, 16]

# 注意力机制
# K 转置
output=Q @ K.transpose(-2,-1)/math.sqrt(d_model//num_heads)

#做 softmax之前做 mask 部分，一句话比如中国人民，在第三个字的时候，他只知道中国人，不知道第四位是民这个字，所以需要处理下，把未来的设置成 0
#形成一个三角区域
mask=torch.triu(torch.ones((context_length,context_length)),diagonal=1).bool()
output=output.masked_fill(mask,float('-inf'))
pd.DataFrame(output[0][0].detach().numpy())