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

一、前言

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

二、大语言模型(LLM)

深度学习模型

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

神经网络训练策略

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

训练步骤

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

具体实施

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

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

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

2. 核心模块实现

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

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

3. 集成与测试

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

4. 优化与改进

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

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

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

1、环境准备

安装工具包

pip install numpy requests torch tiktoken matplotlib pandas

导入工具包

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

 

数据读取

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

配置文件设置

# 设置一些参数
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
 

文本清洗

# 使用 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}")

作者：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)

文本转换

# 把 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

 

 训练数据

# 准备 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())