训练图片:mnist160
测试结果:1000次训练学习率为0.1时,准确率在60%以上
学习的图片越多，训练的时候越长(比如把 epochs*10 = 10000或更高时)效果越好
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
namespace LLM
{
// 定义权重类
class Weight
{
private static Random random = new Random();
public double Value { get; set; }
public Weight()
{
Value = random.NextDouble() - 0.5;
}
}
// 定义神经元连接类
class NeuronLink
{
public Weight Weight { get; set; }
public Neuron FromNeuron { get; set; }
public Neuron ToNeuron { get; set; }
public NeuronLink(Neuron fromNeuron, Neuron toNeuron)
{
FromNeuron = fromNeuron;
ToNeuron = toNeuron;
Weight = new Weight();
}
}
// 定义神经元类
class Neuron
{
private static Random random = new Random();
public double Bias { get; set; }
public double Output { get; set; }
public double Error { get; set; }
public NeuronLink[] InputLinks { get; set; }
public Neuron(int inputCount, Neuron[] previousLayerNeurons)
{
Bias = random.NextDouble() - 0.5;
InputLinks = new NeuronLink[inputCount];
for (int i = 0; i < inputCount; i++)
{
InputLinks[i] = new NeuronLink(previousLayerNeurons[i], this);
}
}
// 激活函数（Sigmoid）
private double Sigmoid(double x)
{
return 1.0 / (1.0 + Math.Exp(-x));
}
// 计算神经元的输出
public double CalculateOutput()
{
double sum = Bias;
foreach (var link in InputLinks)
{
sum += link.FromNeuron.Output * link.Weight.Value;
}
Output = Sigmoid(sum);
return Output;
}
// 激活函数的导数
public double SigmoidDerivative()
{
return Output * (1 - Output);
}
}
// 定义层类
class Layer
{
public Neuron[] Neurons { get; set; }
public Layer(int neuronCount, Layer previousLayer)
{
Neurons = new Neuron[neuronCount];
if (previousLayer == null)
{
for (int i = 0; i < neuronCount; i++)
{
// 输入层神经元没有输入连接
Neurons[i] = new Neuron(0, new Neuron[0]);
}
}
else
{
for (int i = 0; i < neuronCount; i++)
{
Neurons[i] = new Neuron(previousLayer.Neurons.Length, previousLayer.Neurons);
}
}
}
}
// 定义神经网络类
class NeuralNetwork
{
private Layer inputLayer;
private Layer hiddenLayer;
private Layer outputLayer;
public NeuralNetwork(int inputSize, int hiddenSize, int outputSize)
{
inputLayer = new Layer(inputSize, null);
hiddenLayer = new Layer(hiddenSize, inputLayer);
outputLayer = new Layer(outputSize, hiddenLayer);
}
// 前向传播
public double[] FeedForward(double[] input)
{
// 设置输入层神经元的输出
for (int i = 0; i < inputLayer.Neurons.Length; i++)
{
inputLayer.Neurons[i].Output = input[i];
}
// 计算隐藏层神经元的输出
foreach (var neuron in hiddenLayer.Neurons)
{
neuron.CalculateOutput();
}
// 计算输出层神经元的输出
double[] outputs = new double[outputLayer.Neurons.Length];
for (int i = 0; i < outputLayer.Neurons.Length; i++)
{
outputs[i] = outputLayer.Neurons[i].CalculateOutput();
}
return outputs;
}
// 训练网络
public void Train(double[] input, double[] target, double learningRate)
{
// 前向传播
double[] output = FeedForward(input);
// 计算输出层的误差
for (int i = 0; i < outputLayer.Neurons.Length; i++)
{
outputLayer.Neurons[i].Error = (target[i] - output[i]) * outputLayer.Neurons[i].SigmoidDerivative();
}
// 反向传播到隐藏层
for (int j = 0; j < hiddenLayer.Neurons.Length; j++)
{
double errorSum = 0;
foreach (var link in hiddenLayer.Neurons[j].InputLinks)
{
errorSum += link.ToNeuron.Error * link.Weight.Value;
}
hiddenLayer.Neurons[j].Error = errorSum * hiddenLayer.Neurons[j].SigmoidDerivative();
}
// 更新输出层的权重和偏置
foreach (var neuron in outputLayer.Neurons)
{
neuron.Bias += learningRate * neuron.Error;
foreach (var link in neuron.InputLinks)
{
link.Weight.Value += learningRate * neuron.Error * link.FromNeuron.Output;
}
}
// 更新隐藏层的权重和偏置
foreach (var neuron in hiddenLayer.Neurons)
{
neuron.Bias += learningRate * neuron.Error;
foreach (var link in neuron.InputLinks)
{
link.Weight.Value += learningRate * neuron.Error * link.FromNeuron.Output;
}
}
}
}
// 定义训练数据对象类
class TrainingData
{
public double[] Input { get; set; }
public double[] Target { get; set; }
public TrainingData(double[] input, double[] target)
{
Input = input;
Target = target;
}
}
public class Program
{
//测试
public static void Main()
{
// 假设图片是 28x28 的黑白图片，输入层大小为 28x28
int inputSize = 28 * 28;
int hiddenSize = 30;
int outputSize = 10; // 识别 0 - 9 数字
NeuralNetwork neuralNetwork = new NeuralNetwork(inputSize, hiddenSize, outputSize);
// 创建训练数据对象数组
string dire = Application.StartupPath + "\\mnist160\\train\\";
string[] directories = System.IO.Directory.GetDirectories(dire);
List<TrainingData> allTrainingData = new List<TrainingData>();
string[] files = null;
foreach (string directory in directories)
{
files = System.IO.Directory.GetFiles(directory);
for (int i = 0; i < files.Length; i++)
{
// 读取图片
string imagePath = files[i];
double[] input = ReadImageAsInput(imagePath);
double[] target = new double[outputSize];
string dirname = new DirectoryInfo(directory).Name;
target[int.Parse(dirname)] = 1;
allTrainingData.Add(new TrainingData(input, target));
}
}
TrainingData[] trainingData = allTrainingData.ToArray();
// 训练网络
double learningRate = 0.1;
int epochs = 1000;
for (int epoch = 0; epoch < epochs; epoch++)
{
foreach (TrainingData data in trainingData)
{
neuralNetwork.Train(data.Input, data.Target, learningRate);
}
}
dire = Application.StartupPath + "\\mnist160\\test\\";
directories = System.IO.Directory.GetDirectories(dire);
foreach (string directory in directories)
{
files = System.IO.Directory.GetFiles(directory);
// 测试网络
foreach (var item in files)
{
string testImagePath = item;
try
{
double[] testInput = ReadImageAsInput(testImagePath);
double[] output = neuralNetwork.FeedForward(testInput);
double maxVal = output[0];
for (int i = 1; i < output.Length; i++)
{
if (output[i] > maxVal)
{
maxVal = output[i];
}
}
int predictedDigit = Array.IndexOf(output, maxVal);
//输出结果
Console.WriteLine($"Predicted digit: {testImagePath}==={predictedDigit}");
}
catch (FileNotFoundException ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
static double[] ReadImageAsInput(string imagePath)
{
if (!File.Exists(imagePath))
{
throw new FileNotFoundException($"Image file {imagePath} not found.");
}
using (Bitmap image = new Bitmap(imagePath))
{
double[] input = new double[28 * 28];
int index = 0;
for (int y = 0; y < 28; y++)
{
for (int x = 0; x < 28; x++)
{
Color pixelColor = image.GetPixel(x, y);
// 将像素值转换为 0 到 1 之间的双精度值
input[index] = (pixelColor.R + pixelColor.G + pixelColor.B) / (3.0 * 255);
index++;
}
}
return input;
}
}
}
}
