最近在准备AI大模型相关面试时发现很多同学对深度学习模型的工作原理理解不够深入特别是当面试官问到详细说一下AI大模型深度学习模型工作原理这类问题时往往只能回答表面概念。本文将从神经网络基础到Transformer架构完整拆解深度学习模型的工作原理帮助你在AI大模型面试中脱颖而出。1. 深度学习模型基础概念1.1 什么是深度学习模型深度学习模型是一种基于人工神经网络的机器学习方法它通过多层非线性变换来学习数据的层次化特征表示。与传统的机器学习算法相比深度学习模型具有更强的特征学习能力和更高的准确率。从数学角度理解深度学习模型实际上是一个复杂的函数映射$y f(x; \theta)$其中$x$是输入数据$y$是输出结果$\theta$是模型参数。深度学习的目标就是找到最优的参数$\theta^*$使得模型在训练数据上的预测误差最小。1.2 深度学习与机器学习的关系深度学习是机器学习的一个子领域但两者在特征工程方面存在显著差异。传统机器学习需要人工设计特征提取器而深度学习能够自动从原始数据中学习特征表示。传统机器学习流程原始数据 → 特征工程 → 机器学习算法 → 结果 深度学习流程原始数据 → 深度学习模型 → 结果这种端到端的学习方式使得深度学习在处理图像、语音、文本等复杂数据时具有明显优势。1.3 深度学习模型的核心组件一个完整的深度学习模型包含三个核心组件网络架构定义神经元之间的连接方式如全连接网络、卷积网络、循环网络等损失函数衡量模型预测结果与真实值之间的差异优化算法通过梯度下降等方法更新模型参数2. 神经网络基本原理2.1 单个神经元的工作原理神经元是神经网络的基本单元其数学模型可以表示为$$z w_1x_1 w_2x_2 \cdots w_nx_n b$$ $$a \sigma(z)$$其中$x_i$是输入特征$w_i$是权重参数$b$是偏置项$\sigma$是激活函数$a$是神经元的输出import numpy as np class Neuron: def __init__(self, input_size): self.weights np.random.randn(input_size) self.bias np.random.randn() def forward(self, inputs): # 线性计算 z np.dot(inputs, self.weights) self.bias # 激活函数 a self.sigmoid(z) return a def sigmoid(self, x): return 1 / (1 np.exp(-x)) # 使用示例 neuron Neuron(3) inputs np.array([0.5, 0.3, 0.2]) output neuron.forward(inputs) print(f神经元输出: {output})2.2 激活函数的作用与类型激活函数为神经网络引入非线性因素使其能够学习复杂模式。常见的激活函数包括Sigmoid函数 $$\sigma(x) \frac{1}{1 e^{-x}}$$ 特点输出范围(0,1)适合二分类问题但容易梯度消失。ReLU函数 $$ReLU(x) max(0, x)$$ 特点计算简单缓解梯度消失但存在神经元死亡问题。Tanh函数 $$tanh(x) \frac{e^x - e^{-x}}{e^x e^{-x}}$$ 特点输出范围(-1,1)零中心化梯度消失问题比Sigmoid轻。import matplotlib.pyplot as plt def plot_activation_functions(): x np.linspace(-5, 5, 100) sigmoid 1 / (1 np.exp(-x)) relu np.maximum(0, x) tanh np.tanh(x) plt.figure(figsize(12, 4)) plt.subplot(1, 3, 1) plt.plot(x, sigmoid) plt.title(Sigmoid函数) plt.subplot(1, 3, 2) plt.plot(x, relu) plt.title(ReLU函数) plt.subplot(1, 3, 3) plt.plot(x, tanh) plt.title(Tanh函数) plt.tight_layout() plt.show() plot_activation_functions()2.3 前向传播过程前向传播是数据从输入层流向输出层的过程。以三层神经网络为例class SimpleNeuralNetwork: def __init__(self, input_size, hidden_size, output_size): # 初始化权重和偏置 self.W1 np.random.randn(input_size, hidden_size) * 0.01 self.b1 np.zeros((1, hidden_size)) self.W2 np.random.randn(hidden_size, output_size) * 0.01 self.b2 np.zeros((1, output_size)) def forward(self, X): # 第一层前向传播 self.z1 np.dot(X, self.W1) self.b1 self.a1 np.tanh(self.z1) # 隐藏层使用tanh激活 # 第二层前向传播 self.z2 np.dot(self.a1, self.W2) self.b2 self.a2 self.softmax(self.z2) # 输出层使用softmax return self.a2 def softmax(self, x): exp_x np.exp(x - np.max(x, axis1, keepdimsTrue)) return exp_x / np.sum(exp_x, axis1, keepdimsTrue) # 示例手写数字识别10分类 nn SimpleNeuralNetwork(784, 128, 10) X_sample np.random.randn(1, 784) # 模拟一个手写数字图像 output nn.forward(X_sample) print(f预测概率分布: {output})3. 模型训练与优化3.1 损失函数衡量模型性能损失函数量化模型预测与真实值之间的差异常见的损失函数包括均方误差MSE适用于回归问题 $$MSE \frac{1}{n}\sum_{i1}^n(y_i - \hat{y}_i)^2$$交叉熵损失适用于分类问题 $$CrossEntropy -\frac{1}{n}\sum_{i1}^n\sum_{j1}^c y_{ij}log(\hat{y}_{ij})$$def mean_squared_error(y_true, y_pred): return np.mean((y_true - y_pred) ** 2) def cross_entropy_loss(y_true, y_pred, epsilon1e-12): # 防止log(0)的情况 y_pred np.clip(y_pred, epsilon, 1. - epsilon) return -np.mean(np.sum(y_true * np.log(y_pred), axis1)) # 示例计算 y_true_classification np.array([[0, 0, 1]]) # 真实标签第三类 y_pred_classification np.array([[0.1, 0.2, 0.7]]) # 预测概率 ce_loss cross_entropy_loss(y_true_classification, y_pred_classification) print(f交叉熵损失: {ce_loss:.4f})3.2 反向传播算法反向传播是深度学习训练的核心通过链式法则计算损失函数对每个参数的梯度。class NeuralNetworkWithBackprop(SimpleNeuralNetwork): def backward(self, X, y, output): m X.shape[0] # 样本数量 # 输出层梯度 dz2 output - y dW2 (1/m) * np.dot(self.a1.T, dz2) db2 (1/m) * np.sum(dz2, axis0, keepdimsTrue) # 隐藏层梯度 dz1 np.dot(dz2, self.W2.T) * (1 - np.power(self.a1, 2)) # tanh导数 dW1 (1/m) * np.dot(X.T, dz1) db1 (1/m) * np.sum(dz1, axis0, keepdimsTrue) return {dW1: dW1, db1: db1, dW2: dW2, db2: db2} def update_parameters(self, grads, learning_rate0.01): self.W1 - learning_rate * grads[dW1] self.b1 - learning_rate * grads[db1] self.W2 - learning_rate * grads[dW2] self.b2 - learning_rate * grads[db2] # 训练过程示例 def train_neural_network(): # 初始化网络 nn NeuralNetworkWithBackprop(2, 4, 1) # 模拟训练数据XOR问题 X np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) y np.array([[0], [1], [1], [0]]) # 训练循环 for epoch in range(1000): # 前向传播 output nn.forward(X) # 计算损失 loss mean_squared_error(y, output) # 反向传播 grads nn.backward(X, y, output) # 更新参数 nn.update_parameters(grads, learning_rate0.1) if epoch % 100 0: print(fEpoch {epoch}, Loss: {loss:.4f}) train_neural_network()3.3 优化算法进阶除了基本的梯度下降深度学习中还有多种优化算法动量法Momentum积累之前的梯度方向减少震荡class MomentumOptimizer: def __init__(self, learning_rate0.01, beta0.9): self.learning_rate learning_rate self.beta beta self.v {} # 动量项 def initialize(self, parameters): for key in parameters.keys(): self.v[key] np.zeros_like(parameters[key]) def update(self, parameters, grads): for key in parameters.keys(): # 更新动量项 self.v[key] self.beta * self.v[key] (1 - self.beta) * grads[key] # 更新参数 parameters[key] - self.learning_rate * self.v[key]Adam优化器结合动量法和RMSProp的优点class AdamOptimizer: def __init__(self, learning_rate0.001, beta10.9, beta20.999, epsilon1e-8): self.learning_rate learning_rate self.beta1 beta1 self.beta2 beta2 self.epsilon epsilon self.m {} # 一阶矩估计 self.v {} # 二阶矩估计 self.t 0 # 时间步 def initialize(self, parameters): for key in parameters.keys(): self.m[key] np.zeros_like(parameters[key]) self.v[key] np.zeros_like(parameters[key]) def update(self, parameters, grads): self.t 1 for key in parameters.keys(): # 更新一阶矩估计 self.m[key] self.beta1 * self.m[key] (1 - self.beta1) * grads[key] # 更新二阶矩估计 self.v[key] self.beta2 * self.v[key] (1 - self.beta2) * (grads[key] ** 2) # 偏差校正 m_hat self.m[key] / (1 - self.beta1 ** self.t) v_hat self.v[key] / (1 - self.beta2 ** self.t) # 更新参数 parameters[key] - self.learning_rate * m_hat / (np.sqrt(v_hat) self.epsilon)4. 卷积神经网络CNN工作原理4.1 卷积操作的核心思想卷积神经网络通过局部连接和权值共享大幅减少参数数量特别适合处理图像数据。import numpy as np def convolve2d(image, kernel): 二维卷积操作 # 输入图像尺寸 i_height, i_width image.shape # 卷积核尺寸 k_height, k_width kernel.shape # 输出图像尺寸 o_height i_height - k_height 1 o_width i_width - k_width 1 # 初始化输出 output np.zeros((o_height, o_width)) # 执行卷积 for i in range(o_height): for j in range(o_width): output[i, j] np.sum(image[i:ik_height, j:jk_width] * kernel) return output # 示例边缘检测卷积核 image np.random.randn(5, 5) # 5x5随机图像 sobel_kernel np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) # Sobel边缘检测核 edge_map convolve2d(image, sobel_kernel) print(原始图像:) print(image) print(\n边缘检测结果:) print(edge_map)4.2 池化层的作用池化层通过下采样减少特征图尺寸增强模型的平移不变性。def max_pooling(feature_map, pool_size2, stride2): 最大池化操作 # 输入特征图尺寸 f_height, f_width feature_map.shape # 输出特征图尺寸 o_height (f_height - pool_size) // stride 1 o_width (f_width - pool_size) // stride 1 # 初始化输出 output np.zeros((o_height, o_width)) # 执行最大池化 for i in range(o_height): for j in range(o_width): h_start i * stride h_end h_start pool_size w_start j * stride w_end w_start pool_size output[i, j] np.max(feature_map[h_start:h_end, w_start:w_end]) return output # 示例池化操作 feature_map np.random.randn(4, 4) * 10 pooled max_pooling(feature_map) print(原始特征图:) print(feature_map.astype(int)) print(\n池化后特征图:) print(pooled.astype(int))4.3 经典CNN架构解析以LeNet-5为例展示完整的CNN架构import torch import torch.nn as nn class LeNet5(nn.Module): def __init__(self, num_classes10): super(LeNet5, self).__init__() # 特征提取部分 self.features nn.Sequential( # 卷积层1: 输入1通道输出6通道5x5卷积核 nn.Conv2d(1, 6, kernel_size5), nn.ReLU(), nn.MaxPool2d(kernel_size2, stride2), # 2x2最大池化 # 卷积层2: 输入6通道输出16通道5x5卷积核 nn.Conv2d(6, 16, kernel_size5), nn.ReLU(), nn.MaxPool2d(kernel_size2, stride2) ) # 分类器部分 self.classifier nn.Sequential( nn.Linear(16 * 4 * 4, 120), # 全连接层1 nn.ReLU(), nn.Linear(120, 84), # 全连接层2 nn.ReLU(), nn.Linear(84, num_classes) # 输出层 ) def forward(self, x): x self.features(x) # 卷积特征提取 x torch.flatten(x, 1) # 展平 x self.classifier(x) # 分类 return x # 模型使用示例 model LeNet5() print(LeNet-5架构:) print(model) # 模拟输入数据 (batch_size1, channels1, height32, width32) dummy_input torch.randn(1, 1, 32, 32) output model(dummy_input) print(f\n输入形状: {dummy_input.shape}) print(f输出形状: {output.shape})5. 循环神经网络RNN与序列建模5.1 RNN的基本结构RNN通过循环连接处理序列数据能够捕捉时间依赖关系。class SimpleRNN: def __init__(self, input_size, hidden_size, output_size): # 权重参数 self.W_xh np.random.randn(input_size, hidden_size) * 0.01 self.W_hh np.random.randn(hidden_size, hidden_size) * 0.01 self.W_hy np.random.randn(hidden_size, output_size) * 0.01 # 偏置参数 self.b_h np.zeros((1, hidden_size)) self.b_y np.zeros((1, output_size)) # 隐藏状态 self.hidden_state np.zeros((1, hidden_size)) def forward_step(self, x): # 更新隐藏状态 self.hidden_state np.tanh(np.dot(x, self.W_xh) np.dot(self.hidden_state, self.W_hh) self.b_h) # 计算输出 output np.dot(self.hidden_state, self.W_hy) self.b_y return output, self.hidden_state def forward_sequence(self, X_sequence): 处理整个序列 outputs [] hidden_states [] # 重置隐藏状态 self.hidden_state np.zeros_like(self.hidden_state) for x_t in X_sequence: output, hidden_state self.forward_step(x_t.reshape(1, -1)) outputs.append(output) hidden_states.append(hidden_state) return np.array(outputs), np.array(hidden_states) # 示例简单序列预测 rnn SimpleRNN(input_size3, hidden_size5, output_size2) # 生成长度为4的序列 (batch_size1, sequence_length4, input_size3) sequence np.random.randn(4, 3) outputs, hidden_states rnn.forward_sequence(sequence) print(f输入序列形状: {sequence.shape}) print(f输出序列形状: {outputs.shape}) print(f隐藏状态序列形状: {hidden_states.shape})5.2 LSTM与GRU解决梯度消失问题传统RNN存在梯度消失问题LSTM和GRU通过门控机制解决这一问题。class LSTMCell: def __init__(self, input_size, hidden_size): # 输入门、遗忘门、输出门、候选细胞状态的参数 self.W_i np.random.randn(input_size hidden_size, hidden_size) * 0.01 self.W_f np.random.randn(input_size hidden_size, hidden_size) * 0.01 self.W_o np.random.randn(input_size hidden_size, hidden_size) * 0.01 self.W_c np.random.randn(input_size hidden_size, hidden_size) * 0.01 self.b_i np.zeros((1, hidden_size)) self.b_f np.zeros((1, hidden_size)) self.b_o np.zeros((1, hidden_size)) self.b_c np.zeros((1, hidden_size)) def forward(self, x, h_prev, c_prev): # 拼接输入和上一个隐藏状态 combined np.concatenate([x, h_prev], axis1) # 计算各个门 i sigmoid(np.dot(combined, self.W_i) self.b_i) # 输入门 f sigmoid(np.dot(combined, self.W_f) self.b_f) # 遗忘门 o sigmoid(np.dot(combined, self.W_o) self.b_o) # 输出门 # 候选细胞状态 c_candidate np.tanh(np.dot(combined, self.W_c) self.b_c) # 更新细胞状态 c_new f * c_prev i * c_candidate # 更新隐藏状态 h_new o * np.tanh(c_new) return h_new, c_new def sigmoid(x): return 1 / (1 np.exp(-x)) # LSTM使用示例 lstm_cell LSTMCell(input_size3, hidden_size5) x np.random.randn(1, 3) # 当前输入 h_prev np.zeros((1, 5)) # 上一个隐藏状态 c_prev np.zeros((1, 5)) # 上一个细胞状态 h_new, c_new lstm_cell.forward(x, h_prev, c_prev) print(f新的隐藏状态形状: {h_new.shape}) print(f新的细胞状态形状: {c_new.shape})6. Transformer架构深度解析6.1 自注意力机制原理自注意力机制是Transformer的核心它允许模型在处理每个位置时关注输入序列的所有位置。import math def scaled_dot_product_attention(Q, K, V, maskNone): 缩放点积注意力 d_k Q.shape[-1] # 键向量的维度 # 计算Q和K的点积并缩放 scores np.matmul(Q, K.transpose(0, 2, 1)) / math.sqrt(d_k) # 应用mask如果提供 if mask is not None: scores scores.masked_fill(mask 0, -1e9) # 计算softmax得到注意力权重 attention_weights softmax(scores, axis-1) # 应用注意力权重到V output np.matmul(attention_weights, V) return output, attention_weights def softmax(x, axisNone): 稳定的softmax实现 x x - np.max(x, axisaxis, keepdimsTrue) exp_x np.exp(x) return exp_x / np.sum(exp_x, axisaxis, keepdimsTrue) # 示例计算自注意力 batch_size, seq_len, d_model 2, 4, 8 Q np.random.randn(batch_size, seq_len, d_model) K np.random.randn(batch_size, seq_len, d_model) V np.random.randn(batch_size, seq_len, d_model) output, attention_weights scaled_dot_product_attention(Q, K, V) print(f查询Q形状: {Q.shape}) print(f注意力输出形状: {output.shape}) print(f注意力权重形状: {attention_weights.shape})6.2 多头注意力机制多头注意力将输入投影到多个子空间分别计算注意力后拼接结果。class MultiHeadAttention: def __init__(self, d_model, num_heads): self.d_model d_model self.num_heads num_heads self.d_k d_model // num_heads # 每个头的维度 # 线性变换矩阵 self.W_q np.random.randn(d_model, d_model) * 0.01 self.W_k np.random.randn(d_model, d_model) * 0.01 self.W_v np.random.randn(d_model, d_model) * 0.01 self.W_o np.random.randn(d_model, d_model) * 0.01 def split_heads(self, x, batch_size): 将输入分割成多个头 x x.reshape(batch_size, -1, self.num_heads, self.d_k) return x.transpose(0, 2, 1, 3) # (batch_size, num_heads, seq_len, d_k) def forward(self, Q, K, V, maskNone): batch_size Q.shape[0] # 线性变换 Q np.dot(Q, self.W_q) K np.dot(K, self.W_k) V np.dot(V, self.W_v) # 分割成多个头 Q self.split_heads(Q, batch_size) K self.split_heads(K, batch_size) V self.split_heads(V, batch_size) # 计算缩放点积注意力 attention_output, attention_weights scaled_dot_product_attention(Q, K, V, mask) # 拼接多个头 attention_output attention_output.transpose(0, 2, 1, 3) attention_output attention_output.reshape(batch_size, -1, self.d_model) # 输出线性变换 output np.dot(attention_output, self.W_o) return output, attention_weights # 多头注意力示例 mha MultiHeadAttention(d_model8, num_heads2) Q np.random.randn(2, 4, 8) # (batch_size, seq_len, d_model) output, weights mha.forward(Q, Q, Q) print(f多头注意力输出形状: {output.shape})6.3 Transformer编码器结构Transformer编码器由多头自注意力和前馈神经网络组成。class TransformerEncoderLayer: def __init__(self, d_model, num_heads, d_ff, dropout0.1): self.self_attention MultiHeadAttention(d_model, num_heads) self.feed_forward PositionwiseFeedForward(d_model, d_ff) self.norm1 LayerNorm(d_model) self.norm2 LayerNorm(d_model) self.dropout dropout def forward(self, x, maskNone): # 自注意力子层 attn_output, _ self.self_attention(x, x, x, mask) x self.norm1(x attn_output) # 残差连接和层归一化 # 前馈神经网络子层 ff_output self.feed_forward(x) x self.norm2(x ff_output) # 残差连接和层归一化 return x class PositionwiseFeedForward: 位置级前馈网络 def __init__(self, d_model, d_ff): self.w1 np.random.randn(d_model, d_ff) * 0.01 self.w2 np.random.randn(d_ff, d_model) * 0.01 self.b1 np.zeros(d_ff) self.b2 np.zeros(d_model) def forward(self, x): # 第一个线性变换 ReLU激活 return np.dot(np.maximum(0, np.dot(x, self.w1) self.b1), self.w2) self.b2 class LayerNorm: 层归一化 def __init__(self, features, eps1e-6): self.gamma np.ones(features) self.beta np.zeros(features) self.eps eps def forward(self, x): mean np.mean(x, axis-1, keepdimsTrue) std np.std(x, axis-1, keepdimsTrue) return self.gamma * (x - mean) / (std self.eps) self.beta # Transformer编码器示例 encoder_layer TransformerEncoderLayer(d_model8, num_heads2, d_ff16) input_sequence np.random.randn(2, 4, 8) # (batch_size, seq_len, d_model) output_sequence encoder_layer.forward(input_sequence) print(f编码器输入形状: {input_sequence.shape}) print(f编码器输出形状: {output_sequence.shape})7. 大模型训练关键技术7.1 预训练与微调大模型通常采用预训练微调的两阶段训练策略。class PretrainingStrategy: def __init__(self, model, vocab_size): self.model model self.vocab_size vocab_size def masked_language_modeling(self, input_ids, mask_ratio0.15): 掩码语言模型训练 batch_size, seq_len input_ids.shape # 创建掩码 mask np.random.rand(batch_size, seq_len) mask_ratio masked_input input_ids.copy() # 80%的时间用[MASK]替换10%用随机词替换10%保持不变 random_words np.random.randint(0, self.vocab_size, input_ids.shape) random_mask np.random.rand(batch_size, seq_len) 0.1 keep_mask np.random.rand(batch_size, seq_len) 0.1 masked_input[mask random_mask] random_words[mask random_mask] masked_input[mask keep_mask] input_ids[mask keep_mask] # 剩下的80%用[MASK]标记这里用0表示 masked_input[mask ~(random_mask | keep_mask)] 0 return masked_input, mask def compute_mlm_loss(self, predictions, targets, mask): 计算MLM损失 # 只计算被掩码位置的损失 masked_predictions predictions[mask] masked_targets targets[mask] # 交叉熵损失 loss -np.mean(np.log(softmax(masked_predictions)[range(len(masked_targets)), masked_targets])) return loss # 预训练示例 class SimpleTransformer: def __init__(self, vocab_size, d_model512): self.vocab_size vocab_size self.d_model d_model # 简化模型结构 self.embedding np.random.randn(vocab_size, d_model) * 0.01 def forward(self, input_ids): # 词嵌入 embeddings self.embedding[input_ids] # 简化处理平均池化 线性输出 pooled np.mean(embeddings, axis1) output np.dot(pooled, np.random.randn(self.d_model, self.vocab_size) * 0.01) return output # 模拟预训练过程 model SimpleTransformer(vocab_size10000) strategy PretrainingStrategy(model, vocab_size10000) # 模拟输入数据 input_ids np.random.randint(0, 10000, (32, 128)) # batch_size32, seq_len128 masked_input, mask strategy.masked_language_modeling(input_ids) predictions model.forward(masked_input) loss strategy.compute_mlm_loss(predictions, input_ids, mask) print(fMLM预训练损失: {loss:.4f})7.2 参数高效微调PEFT对于大模型全参数微调成本高昂参数高效微调技术应运而生。class LoRAAdapter: LoRA适配器通过低秩矩阵实现参数高效微调 def __init__(self, original_weight, rank4, alpha8): self.original_weight original_weight self.rank rank self.alpha alpha # 初始化低秩矩阵A和B in_features, out_features original_weight.shape self.A np.random.randn(in_features, rank) * 0.01 self.B np.zeros((rank, out_features)) def forward(self, x): # 原始权重 低秩适应 adapted_weight self.original_weight (self.alpha / self.rank) * np.dot(self.A, self.B) return np.dot(x, adapted_weight) def get_trainable_parameters(self): 返回可训练参数只有A和B return {A: self.A, B: self.B} # LoRA应用示例 class TransformerWithLoRA: def __init__(self, base_model, lora_rank4): self.base_model base_model self.lora_adapters {} # 为注意力层的Q、K、V、O矩阵添加LoRA适配器 attention_layers [q_proj, k_proj, v_proj, o_proj] for layer_name in attention_layers: original_weight getattr(base_model, layer_name) self.lora_adapters[layer_name] LoRAAdapter(original_weight, lora_rank) def forward(self, x): # 使用LoRA适配的权重进行前向传播 # 这里简化实现实际需要替换原始权重计算 return self.base_model.forward(x) def get_lora_parameters(self): 获取所有LoRA参数 params {} for name, adapter in self.lora_adapters.items(): params.update({f{name}.{k}: v for k, v in adapter.get_trainable_parameters().items()}) return params # LoRA参数统计 base_params 1000000 # 假设基础模型有100万个参数 lora_params 4 * (512 * 4 4 * 512) # 4个适配器每个适配器参数数量 print(f基础模型参数: {base_params}) print(fLoRA适配器参数: {lora_params}) print(f参数减少比例: {(1 - lora_params/base_params)*100:.2f}%)8. 大模型推理优化8.1 推理加速技术大模型推理时面临计算量和内存瓶颈需要优化技术。class KVCache: 键值缓存避免重复计算 def __init__(self): self.cache {} def update(self, layer_idx, new_k, new_v): if layer_idx not in self.cache: self.cache[layer_idx] (new_k, new_v) else: k_prev, v_prev self.cache[layer_idx] # 拼接新的键值对 k_new np.concatenate([k_prev, new_k], axis1) v_new np.concatenate([v_prev, new_v], axis1) self.cache[layer_idx] (k_new, v_new) def get(self, layer_idx): return self.cache.get(layer_idx, (None, None)) class OptimizedAttention: 优化后的注意力计算 def __init__(self, d_model,
