C# Transformer 实现原理与实战：从自然语言处理到代码生成

1次阅读

没有评论

共计 4172 个字符，预计需要花费 11 分钟才能阅读完成。

在自然语言处理（NLP）领域，传统序列模型如循环神经网络（RNN）和长短期记忆网络（LSTM）在处理长文本时面临诸多挑战。这些模型通常依赖顺序处理，导致以下问题：

梯度消失 / 爆炸 ：随着序列长度的增加，RNN 在反向传播时容易出现梯度消失或爆炸，难以有效学习长期依赖关系。
并行化困难 ：RNN 的时序依赖性限制了训练时的并行计算能力，导致训练速度缓慢。
信息瓶颈 ：LSTM 虽然缓解了梯度问题，但在处理超长序列时仍可能丢失关键信息。

这些局限性促使了 Transformer 模型的诞生，它通过自注意力机制彻底改变了序列建模的方式。

RNN
优点：结构简单，适合短序列建模。
缺点：难以捕捉长期依赖，训练效率低。
LSTM
优点：通过门控机制缓解梯度问题，适合中等长度序列。
缺点：计算复杂度高，仍存在信息丢失风险。
Transformer
优点：完全基于注意力机制，支持并行计算，擅长捕捉长距离依赖。
缺点：内存消耗较大，需要更多数据训练。

自注意力机制是 Transformer 的核心，其数学表示为：

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

在 C# 中，可以通过以下步骤实现：

定义查询（Q）、键（K）和值（V）矩阵
计算注意力分数
应用 softmax 归一化
加权求和得到输出

public Tensor SelfAttention(Tensor query, Tensor key, Tensor value)
{var scores = query.MatMul(key.Transpose()) / Math.Sqrt(query.Shape[-1]);
    var weights = Softmax(scores);
    return weights.MatMul(value);
}

由于 Transformer 不包含递归结构，需要显式注入位置信息：

public Tensor PositionalEncoding(int seqLength, int dModel)
{var positions = Enumerable.Range(0, seqLength).Select(p => (float)p).ToArray();
    var dimensions = Enumerable.Range(0, dModel).Select(d => (float)d).ToArray();

    var pe = new float[seqLength, dModel];
    for (int i = 0; i < seqLength; i++)
    {for (int j = 0; j < dModel; j += 2)
        {pe[i, j] = (float)Math.Sin(positions[i] / Math.Pow(10000, 2 * j / dModel));
            pe[i, j + 1] = (float)Math.Cos(positions[i] / Math.Pow(10000, 2 * j / dModel));
        }
    }

    return Tensor.FromArray(pe);
}

将注意力机制扩展到多个头可以捕获不同子空间的信息：

线性投影分割多头
并行计算注意力
合并输出结果

public Tensor MultiHeadAttention(Tensor query, Tensor key, Tensor value, int numHeads)
{var batchSize = query.Shape[0];
    var dModel = query.Shape[1];
    var depth = dModel / numHeads;

    // 分割多头
    var q = query.Reshape(batchSize, -1, numHeads, depth).Transpose(1, 2);
    var k = key.Reshape(batchSize, -1, numHeads, depth).Transpose(1, 2);
    var v = value.Reshape(batchSize, -1, numHeads, depth).Transpose(1, 2);

    // 计算注意力
    var attention = SelfAttention(q, k, v);

    // 合并多头
    return attention.Transpose(1, 2).Reshape(batchSize, -1, dModel);
}

public class TransformerBlock
{public MultiHeadAttention Attention { get;} 
    public FeedForwardNetwork Ffn {get;}
    public LayerNorm LayerNorm1 {get;}
    public LayerNorm LayerNorm2 {get;}

    public TransformerBlock(int dModel, int numHeads, int dFf)
    {Attention = new MultiHeadAttention(dModel, numHeads);
        Ffn = new FeedForwardNetwork(dModel, dFf);
        LayerNorm1 = new LayerNorm(dModel);
        LayerNorm2 = new LayerNorm(dModel);
    }

    public Tensor Forward(Tensor x, Tensor mask = null)
    {
        // 残差连接和层归一化
        var attnOutput = Attention.Forward(LayerNorm1.Forward(x), mask);
        x = x + attnOutput;

        var ffnOutput = Ffn.Forward(LayerNorm2.Forward(x));
        return x + ffnOutput;
    }
}

public void Train(Transformer model, Dataset dataset, int epochs)
{var optimizer = new AdamOptimizer(learningRate: 0.001);
    var lossFn = new CrossEntropyLoss();

    for (int epoch = 0; epoch < epochs; epoch++)
    {foreach (var (inputs, targets) in dataset)
        {
            // 前向传播
            var predictions = model.Forward(inputs);

            // 计算损失
            var loss = lossFn.Forward(predictions, targets);

            // 反向传播
            var gradients = lossFn.Backward();
            model.Backward(gradients);

            // 参数更新
            optimizer.Step(model.Parameters());
        }
    }
}

将浮点参数转换为低精度表示（如 INT8）可以显著减少内存占用：

public QuantizedTensor Quantize(Tensor floatTensor)
{var scale = floatTensor.Max() / 127.0f;
    var quantized = floatTensor / scale;
    return new QuantizedTensor(quantized.Round().Cast<byte>(), scale);
}

使用对象池重用张量
及时释放中间计算结果
采用分块处理超长序列

using (var workspace = new TensorWorkspace())
{var temp = workspace.AllocateTensor(shape);
    // 计算操作...
} // 自动释放内存

利用 C# 的并行库加速矩阵运算：

public Tensor ParallelMatMul(Tensor a, Tensor b)
{var result = new Tensor(a.Shape[0], b.Shape[1]);

    Parallel.For(0, a.Shape[0], i => 
    {for (int j = 0; j < b.Shape[1]; j++)
        {
            float sum = 0;
            for (int k = 0; k < a.Shape[1]; k++)
            {sum += a[i, k] * b[k, j];
            }
            result[i, j] = sum;
        }
    });

    return result;
}

ONNX 导出 ：将训练好的模型转换为标准格式
服务封装 ：创建 REST API 或 gRPC 服务
容器化 ：使用 Docker 打包运行时环境

// 导出为 ONNX
var session = new InferenceSession(modelPath);
var inputs = new List<NamedOnnxValue> {NamedOnnxValue.CreateFromTensor("input", inputTensor) };
var results = session.Run(inputs);

请求延迟
内存使用率
GPU 利用率
预测准确率

public class MonitoringMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;

    public async Task Invoke(HttpContext context)
    {var stopwatch = Stopwatch.StartNew();

        await _next(context);

        _logger.LogInformation($"Request took {stopwatch.ElapsedMilliseconds}ms");
        Metrics.RecordLatency(stopwatch.Elapsed);
    }
}