C#构建一个简单的循环神经网络，模拟对话

循环神经网络（Recurrent Neural Network, RNN）是一种用于处理序列数据的神经网络模型。与传统的前馈神经网络不同，RNN具有内部记忆能力，可以捕捉到序列中元素之间的依赖关系。这种特性使得RNN在自然语言处理、语音识别、时间序列预测等需要考虑上下文信息的任务中表现出色。

RNN的基本结构

RNN的基本结构包括输入层、隐藏层和输出层。在处理序列数据时，RNN会按照序列的时间顺序逐个处理每个元素。对于序列中的每一个时间步，RNN不仅会接收该时间步的输入，还会接收上一个时间步的隐藏状态作为输入。这样，通过将之前的信息传递给后续的处理步骤，RNN能够利用历史信息来影响当前的输出。

方法

• InitializeWeightsAndBiases()：使用随机值初始化权重矩阵和偏置向量。
• Sigmoid()：激活函数，用于隐藏层的非线性变换。
• RandomMatrix()：生成指定大小的随机矩阵，用于权重的初始化。
• Softmax()：通常用于多分类问题中的输出层，将输出转换为概率分布。
• Forward()：前向传播方法，根据输入数据计算每个时间步的输出。它会更新隐藏状态，并最终返回所有时间步的输出列表。
• Backward()：反向传播方法，用于根据预测输出与目标输出之间的差异调整模型参数。它计算梯度并更新权重和偏置。
• UpdateWeights()：根据计算出的梯度更新模型的权重和偏置。
• Train()：训练模型的方法，通过多次迭代（epoch）对输入数据进行前向传播和反向传播，以优化模型参数。
• Predict()：预测方法，根据输入数据返回每个时间步的预测结果索引，即输出概率最高的类别。

说明

这只是一个基础的 RNN 模型实现，实际应用中可能需要考虑更多的优化技术，比如使用长短期记忆网络（LSTM）、门控循环单元（GRU）等更复杂的架构来改善性能。

using System;
using System.Linq;
using System.Collections.Generic;namespace Project.NeuralNetwork
{/// <summary>/// 构建神经网络/// </summary>public class RnnModel{/// <summary>/// 输入层大小/// </summary>private readonly int _inputSize;/// <summary>/// 隐藏层大小/// </summary>private readonly int _hiddenSize;/// <summary>/// 输出层大小/// </summary>private readonly int _outputSize;/// <summary>/// 输入到隐藏层的权重/// </summary>private double[,] _weightsInputHidden;/// <summary>/// 隐藏层到隐藏层的权重/// </summary>private double[,] _weightsHiddenHidden;/// <summary>/// 隐藏层到输出层的权重/// </summary>private double[,] _weightsHiddenOutput;/// <summary>/// 隐藏层偏置/// </summary>private double[] _biasHidden;/// <summary>/// 输出层偏置/// </summary>private double[] _biasOutput;/// <summary>/// 隐藏层状态/// </summary>private double[] _hiddenState;/// <summary>/// 初始化模型的构造函数/// </summary>/// <param name="inputSize"></param>/// <param name="hiddenSize"></param>/// <param name="outputSize"></param>public RnnModel(int inputSize, int hiddenSize, int outputSize){_inputSize = inputSize;_hiddenSize = hiddenSize;_outputSize = outputSize;InitializeWeightsAndBiases();}/// <summary>/// 初始化权重和偏置/// </summary>private void InitializeWeightsAndBiases(){_weightsInputHidden = RandomMatrix(_inputSize, _hiddenSize);_weightsHiddenHidden = RandomMatrix(_hiddenSize, _hiddenSize);_weightsHiddenOutput = RandomMatrix(_hiddenSize, _outputSize);_biasHidden = new double[_hiddenSize];_biasOutput = new double[_outputSize];}/// <summary>/// 激活函数/// </summary>/// <param name="x"></param>/// <returns></returns>private double Sigmoid(double x){return 1 / (1 + Math.Exp(-x));}/// <summary>/// 生成随机矩阵/// </summary>/// <param name="rows"></param>/// <param name="cols"></param>/// <returns></returns>private double[,] RandomMatrix(int rows, int cols){var matrix = new double[rows, cols];var random = new Random();for (int i = 0; i < rows; i++){for (int j = 0; j < cols; j++){matrix[i, j] = random.NextDouble() * 2 - 1; // [-1, 1]}}return matrix;}/// <summary>/// 前向传播/// </summary>/// <param name="inputs"></param>/// <returns></returns>public List<double[]> Forward(List<double[]> inputs){_hiddenState = new double[_hiddenSize];var outputs = new List<double[]>();foreach (var input in inputs){var hidden = new double[_hiddenSize];for (int h = 0; h < _hiddenSize; h++){hidden[h] = _biasHidden[h];for (int i = 0; i < _inputSize; i++){hidden[h] += _weightsInputHidden[i, h] * input[i];}for (int hh = 0; hh < _hiddenSize; hh++){hidden[h] += _weightsHiddenHidden[hh, h] * _hiddenState[hh];}hidden[h] = Sigmoid(hidden[h]);}_hiddenState = hidden;var output = Output(hidden);outputs.Add(output);}return outputs;}/// <summary>/// 输出层/// </summary>/// <param name="h"></param>/// <returns></returns>private double[] Output(double[] h){double[] y = new double[_outputSize];for (int i = 0; i < _outputSize; i++){double sum = _biasOutput[i];for (int j = 0; j < _hiddenSize; j++){sum += h[j] * _weightsHiddenOutput[j, i];}y[i] = sum;}return Softmax(y);}/// <summary>/// 输出层的激活函数/// </summary>/// <param name="x"></param>/// <returns></returns>private double[] Softmax(double[] x){double max = x.Max();double expSum = x.Select(xi => Math.Exp(xi - max)).Sum();return x.Select(xi => Math.Exp(xi - max) / expSum).ToArray();}/// <summary>/// 反向传播/// </summary>/// <param name="inputs"></param>/// <param name="targets"></param>/// <param name="outputs"></param>/// <param name="learningRate"></param>private void Backward(List<double[]> inputs, List<double[]> targets, List<double[]> outputs, double learningRate){//输入到隐藏层的梯度double[,] dWeightsInputHidden = new double[_inputSize, _hiddenSize];//隐藏层到隐藏层的梯度double[,] dWeightsHiddenHidden = new double[_hiddenSize, _hiddenSize];//隐藏层到输出层的梯度double[,] dWeightsHiddenOutput = new double[_hiddenSize, _outputSize];//隐藏层的偏置double[] dBiasHidden = new double[_hiddenSize];//输出层的偏置double[] dBiasOutput = new double[_outputSize];for (int t = inputs.Count - 1; t >= 0; t--){double[] targetVector = new double[_outputSize];Array.Copy(targets[t], targetVector, _outputSize);// 计算输出层的误差for (int o = 0; o < _outputSize; o++){dBiasOutput[o] = outputs[t][o] - targetVector[o];}// 计算隐藏层到输出层的梯度for (int o = 0; o < _outputSize; o++){for (int h = 0; h < _hiddenSize; h++){dWeightsHiddenOutput[h, o] += dBiasOutput[o] * _hiddenState[h];}}// 计算隐藏层的偏置double[] dh = new double[_hiddenSize];for (int h = 0; h < _hiddenSize; h++){double error = 0;for (int o = 0; o < _outputSize; o++){error += dBiasOutput[o] * _weightsHiddenOutput[h, o];}dh[h] = error * (_hiddenState[h] * (1 - _hiddenState[h]));}for (int h = 0; h < _hiddenSize; h++){dBiasHidden[h] += dh[h];}//计算输入到隐藏层的梯度for (int h = 0; h < _hiddenSize; h++){for (int i = 0; i < _inputSize; i++){dWeightsInputHidden[i, h] += dh[h] * inputs[t][i];}}// 计算输入到隐藏层的梯度if (t > 0){for (int h = 0; h < _hiddenSize; h++){for (int hh = 0; hh < _hiddenSize; hh++){dWeightsHiddenHidden[hh, h] += dh[h] * _hiddenState[hh];}}}}// 更新权重和偏置UpdateWeights(dWeightsInputHidden, dWeightsHiddenHidden, dWeightsHiddenOutput, dBiasHidden, dBiasOutput, learningRate);}/// <summary>/// 更新权重/// </summary>/// <param name="dWxh"></param>/// <param name="dWhh"></param>/// <param name="dWhy"></param>/// <param name="dbh"></param>/// <param name="dby"></param>/// <param name="learningRate"></param>private void UpdateWeights(double[,] dWeightsInputHidden, double[,] dWeightsHiddenHidden, double[,] dWeightsHiddenOutput, double[] dBiasHidden, double[] dBiasOutput, double learningRate){// 更新输入到隐藏层的权重for (int i = 0; i < _inputSize; i++){for (int h = 0; h < _hiddenSize; h++){_weightsInputHidden[i, h] -= learningRate * dWeightsInputHidden[i, h];}}//更新隐藏层到隐藏层的权重for (int h = 0; h < _hiddenSize; h++){for (int hh = 0; hh < _hiddenSize; hh++){_weightsHiddenHidden[h, hh] -= learningRate * dWeightsHiddenHidden[h, hh];}}//更新隐藏层到输出层的权重for (int h = 0; h < _hiddenSize; h++){for (int o = 0; o < _outputSize; o++){_weightsHiddenOutput[h, o] -= learningRate * dWeightsHiddenOutput[h, o];}}//更新隐藏层的偏置for (int h = 0; h < _hiddenSize; h++){_biasHidden[h] -= learningRate * dBiasHidden[h];}//更新输出层的偏置for (int o = 0; o < _outputSize; o++){_biasOutput[o] -= learningRate * dBiasOutput[o];}}/// <summary>/// 训练/// </summary>/// <param name="inputs"></param>/// <param name="targets"></param>/// <param name="epochs"></param>/// <param name="learningRate"></param>public void Train(List<List<double[]>> inputs, List<List<double[]>> targets, double learningRate, int epochs){for (int epoch = 0; epoch < epochs; epoch++){for (int i = 0; i < inputs.Count; i++){List<double[]> input = inputs[i];List<double[]> target = targets[i];List<double[]> outputs = Forward(input);Backward(input, target, outputs, learningRate);}}}/// <summary>/// 预测/// </summary>/// <param name="inputs"></param>/// <returns></returns>public int[] Predict(List<double[]> inputs){var output = Forward(inputs);var predictedIndices = output.Select(o => Array.IndexOf(o, o.Max())).ToArray();return predictedIndices;}}
}

• 准备训练数据
• 训练网络
• 测试并输出结果

public static void Rnn_Predict()
{// 定义数据集var data = new List<Tuple<string[], string[]>>{Tuple.Create(new string[] { "早安" }, new string[] { "早上好" }),Tuple.Create(new string[] { "午安" }, new string[] { "中午好" }),Tuple.Create(new string[] { "晚安" }, new string[] { "晚上好" }),Tuple.Create(new string[] { "你好吗？" }, new string[] { "我很好，谢谢。" })};// 创建词汇表var allWords = data.SelectMany(t => t.Item1.Concat(t.Item2)).Distinct().ToList();var wordToIndex = allWords.ToDictionary(word => word, word => allWords.IndexOf(word));// 将字符串转换为one-hot编码List<List<double[]>> inputsData = new List<List<double[]>>();List<List<double[]>> targetsData = new List<List<double[]>>();foreach (var item in data){var inputSequence = item.Item1.Select(word => OneHotEncode(word, wordToIndex)).ToList();var targetSequence = item.Item2.Select(word => OneHotEncode(word, wordToIndex)).ToList();inputsData.Add(inputSequence);targetsData.Add(targetSequence);}double[] OneHotEncode(string word, Dictionary<string, int> wordToIndex){var encoding = new double[wordToIndex.Count];encoding[wordToIndex[word]] = 1;return encoding;}//开始训练int inputSize = allWords.Count;int hiddenSize = allWords.Count;int outputSize = allWords.Count;RnnModel model = new RnnModel(inputSize, hiddenSize, outputSize);int epochs = 10000;double learningRate = 0.1;model.Train(inputsData, targetsData, learningRate, epochs);//预测while (true){Console.Write("你: ");string userInput = Console.ReadLine();if (userInput.ToLower() == "exit"){break;}if (!allWords.Contains(userInput)){Console.WriteLine("对不起，我不认识这些词。");continue;}var testInput = new List<double[]> { OneHotEncode(userInput, wordToIndex) };var prediction = model.Predict(testInput);var predictedWords = prediction.Select(index => allWords[index]).ToArray();Console.WriteLine($"机器人: {string.Join(", ", predictedWords)}");}
}