当前位置：首页 > news >正文

Go语言深度学习：神经网络实现与优化

news 2026/5/30 5:38:44

Go语言深度学习：神经网络实现与优化

引言

深度学习是人工智能的前沿领域，它通过多层神经网络从数据中学习复杂的模式。Go语言以其高性能和并发能力，成为实现深度学习模型的理想选择。本文将介绍如何使用Go语言实现深度学习神经网络。

一、神经网络基础

1.1 神经网络结构

// 神经网络由输入层、隐藏层和输出层组成 // 每层由多个神经元组成 // 神经元之间通过权重连接

1.2 激活函数

package main import ( "fmt" "math" ) // Sigmoid激活函数 func sigmoid(x float64) float64 { return 1.0 / (1.0 + math.Exp(-x)) } // Sigmoid导数 func sigmoidDerivative(x float64) float64 { return x * (1.0 - x) } // ReLU激活函数 func relu(x float64) float64 { if x > 0 { return x } return 0 } // ReLU导数 func reluDerivative(x float64) float64 { if x > 0 { return 1 } return 0 } // Tanh激活函数 func tanh(x float64) float64 { return math.Tanh(x) } // Tanh导数 func tanhDerivative(x float64) float64 { return 1 - math.Pow(tanh(x), 2) } func main() { fmt.Printf("Sigmoid(0.5) = %.4f\n", sigmoid(0.5)) fmt.Printf("ReLU(0.5) = %.4f\n", relu(0.5)) fmt.Printf("Tanh(0.5) = %.4f\n", tanh(0.5)) }

二、前向传播

2.1 实现前向传播

package main import ( "fmt" "math" ) type NeuralNetwork struct { weights [][][]float64 // [层][神经元][权重] biases [][]float64 // [层][神经元] } func NewNeuralNetwork(layerSizes []int) *NeuralNetwork { nn := &NeuralNetwork{ weights: make([][][]float64, len(layerSizes)-1), biases: make([][]float64, len(layerSizes)-1), } // 初始化权重和偏置 for i := 0; i < len(layerSizes)-1; i++ { nn.weights[i] = make([][]float64, layerSizes[i+1]) nn.biases[i] = make([]float64, layerSizes[i+1]) for j := 0; j < layerSizes[i+1]; j++ { nn.weights[i][j] = make([]float64, layerSizes[i]) for k := 0; k < layerSizes[i]; k++ { // 随机初始化权重 (-1到1) nn.weights[i][j][k] = (math.Random() * 2) - 1 } nn.biases[i][j] = (math.Random() * 2) - 1 } } return nn } func (nn *NeuralNetwork) Forward(input []float64) []float64 { activations := input for layer := 0; layer < len(nn.weights); layer++ { nextActivations := make([]float64, len(nn.weights[layer])) for neuron := 0; neuron < len(nn.weights[layer]); neuron++ { sum := nn.biases[layer][neuron] for inputNeuron := 0; inputNeuron < len(activations); inputNeuron++ { sum += activations[inputNeuron] * nn.weights[layer][neuron][inputNeuron] } nextActivations[neuron] = sigmoid(sum) } activations = nextActivations } return activations } func main() { // 创建神经网络: 2输入, 3隐藏, 1输出 nn := NewNeuralNetwork([]int{2, 3, 1}) input := []float64{0.5, 0.8} output := nn.Forward(input) fmt.Printf("输入: %v\n", input) fmt.Printf("输出: %v\n", output) }

三、反向传播

3.1 实现反向传播

package main import ( "fmt" "math" ) func (nn *NeuralNetwork) Train(inputs, targets []float64, learningRate float64) { // 前向传播，保存各层激活值 activation := inputs activations := [][]float64{inputs} for layer := 0; layer < len(nn.weights); layer++ { nextActivation := make([]float64, len(nn.weights[layer])) for neuron := 0; neuron < len(nn.weights[layer]); neuron++ { sum := nn.biases[layer][neuron] for inputNeuron := 0; inputNeuron < len(activation); inputNeuron++ { sum += activation[inputNeuron] * nn.weights[layer][neuron][inputNeuron] } nextActivation[neuron] = sigmoid(sum) } activation = nextActivation activations = append(activations, activation) } // 反向传播 // 计算输出层误差 outputLayer := len(nn.weights) - 1 errors := make([]float64, len(activations[outputLayer+1])) for i := range errors { errors[i] = (activations[outputLayer+1][i] - targets[i]) * sigmoidDerivative(activations[outputLayer+1][i]) } // 反向传播误差并更新权重 for layer := outputLayer; layer >= 0; layer-- { nextErrors := make([]float64, len(activations[layer])) // 更新权重 for neuron := 0; neuron < len(nn.weights[layer]); neuron++ { for inputNeuron := 0; inputNeuron < len(activations[layer]); inputNeuron++ { nn.weights[layer][neuron][inputNeuron] -= learningRate * errors[neuron] * activations[layer][inputNeuron] } nn.biases[layer][neuron] -= learningRate * errors[neuron] // 计算下一层误差 for inputNeuron := 0; inputNeuron < len(activations[layer]); inputNeuron++ { nextErrors[inputNeuron] += nn.weights[layer][neuron][inputNeuron] * errors[neuron] * sigmoidDerivative(activations[layer][inputNeuron]) } } errors = nextErrors } } func main() { nn := NewNeuralNetwork([]int{2, 4, 1}) // XOR训练数据 inputs := [][]float64{ {0, 0}, {0, 1}, {1, 0}, {1, 1}, } targets := [][]float64{ {0}, {1}, {1}, {0}, } // 训练 for epoch := 0; epoch < 10000; epoch++ { for i := range inputs { nn.Train(inputs[i], targets[i], 0.1) } if epoch % 1000 == 0 { fmt.Printf("Epoch %d\n", epoch) } } // 测试 for i := range inputs { output := nn.Forward(inputs[i]) fmt.Printf("Input: %v -> Output: %.4f (Target: %v)\n", inputs[i], output[0], targets[i][0]) } }

四、卷积神经网络

4.1 卷积运算

package main import ( "fmt" ) func convolve(input [][]float64, kernel [][]float64) [][]float64 { inputHeight := len(input) inputWidth := len(input[0]) kernelSize := len(kernel) outputHeight := inputHeight - kernelSize + 1 outputWidth := inputWidth - kernelSize + 1 output := make([][]float64, outputHeight) for i := range output { output[i] = make([]float64, outputWidth) } for i := 0; i < outputHeight; i++ { for j := 0; j < outputWidth; j++ { var sum float64 for ki := 0; ki < kernelSize; ki++ { for kj := 0; kj < kernelSize; kj++ { sum += input[i+ki][j+kj] * kernel[ki][kj] } } output[i][j] = sum } } return output } func main() { // 3x3输入图像 input := [][]float64{ {1, 2, 3}, {4, 5, 6}, {7, 8, 9}, } // 3x3卷积核（边缘检测） kernel := [][]float64{ {-1, -1, -1}, {-1, 8, -1}, {-1, -1, -1}, } result := convolve(input, kernel) fmt.Println("输入:") for _, row := range input { fmt.Println(row) } fmt.Println("\n输出:") for _, row := range result { fmt.Println(row) } }

4.2 池化操作

package main import ( "fmt" "math" ) func maxPool(input [][]float64, poolSize int) [][]float64 { inputHeight := len(input) inputWidth := len(input[0]) outputHeight := inputHeight / poolSize outputWidth := inputWidth / poolSize output := make([][]float64, outputHeight) for i := range output { output[i] = make([]float64, outputWidth) } for i := 0; i < outputHeight; i++ { for j := 0; j < outputWidth; j++ { maxVal := math.Inf(-1) for pi := 0; pi < poolSize; pi++ { for pj := 0; pj < poolSize; pj++ { val := input[i*poolSize+pi][j*poolSize+pj] if val > maxVal { maxVal = val } } } output[i][j] = maxVal } } return output } func averagePool(input [][]float64, poolSize int) [][]float64 { inputHeight := len(input) inputWidth := len(input[0]) outputHeight := inputHeight / poolSize outputWidth := inputWidth / poolSize output := make([][]float64, outputHeight) for i := range output { output[i] = make([]float64, outputWidth) } for i := 0; i < outputHeight; i++ { for j := 0; j < outputWidth; j++ { var sum float64 for pi := 0; pi < poolSize; pi++ { for pj := 0; pj < poolSize; pj++ { sum += input[i*poolSize+pi][j*poolSize+pj] } } output[i][j] = sum / float64(poolSize*poolSize) } } return output } func main() { input := [][]float64{ {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}, } maxPoolResult := maxPool(input, 2) avgPoolResult := averagePool(input, 2) fmt.Println("输入:") for _, row := range input { fmt.Println(row) } fmt.Println("\n最大池化结果:") for _, row := range maxPoolResult { fmt.Println(row) } fmt.Println("\n平均池化结果:") for _, row := range avgPoolResult { fmt.Println(row) } }

五、循环神经网络

5.1 RNN实现

package main import ( "fmt" "math" ) type RNN struct { inputSize int hiddenSize int outputSize int // 权重 Wxh [][]float64 // 输入到隐藏 Whh [][]float64 // 隐藏到隐藏 Why [][]float64 // 隐藏到输出 // 偏置 bh []float64 by []float64 } func NewRNN(inputSize, hiddenSize, outputSize int) *RNN { rnn := &RNN{ inputSize: inputSize, hiddenSize: hiddenSize, outputSize: outputSize, } // 初始化权重 rnn.Wxh = make([][]float64, hiddenSize) for i := range rnn.Wxh { rnn.Wxh[i] = make([]float64, inputSize) for j := range rnn.Wxh[i] { rnn.Wxh[i][j] = (math.Random() * 2) - 1 } } rnn.Whh = make([][]float64, hiddenSize) for i := range rnn.Whh { rnn.Whh[i] = make([]float64, hiddenSize) for j := range rnn.Whh[i] { rnn.Whh[i][j] = (math.Random() * 2) - 1 } } rnn.Why = make([][]float64, outputSize) for i := range rnn.Why { rnn.Why[i] = make([]float64, hiddenSize) for j := range rnn.Why[i] { rnn.Why[i][j] = (math.Random() * 2) - 1 } } rnn.bh = make([]float64, hiddenSize) rnn.by = make([]float64, outputSize) return rnn } func (rnn *RNN) Forward(inputs [][]float64) ([][]float64, [][]float64) { hidden := make([]float64, rnn.hiddenSize) outputs := make([][]float64, len(inputs)) hiddens := make([][]float64, len(inputs)) for t, input := range inputs { // 计算隐藏状态 newHidden := make([]float64, rnn.hiddenSize) for i := range newHidden { sum := rnn.bh[i] for j := range input { sum += input[j] * rnn.Wxh[i][j] } for j := range hidden { sum += hidden[j] * rnn.Whh[i][j] } newHidden[i] = tanh(sum) } // 计算输出 output := make([]float64, rnn.outputSize) for i := range output { sum := rnn.by[i] for j := range newHidden { sum += newHidden[j] * rnn.Why[i][j] } output[i] = sigmoid(sum) } hidden = newHidden outputs[t] = output hiddens[t] = hidden } return outputs, hiddens } func main() { rnn := NewRNN(3, 4, 2) // 序列输入 inputs := [][]float64{ {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, } outputs, _ := rnn.Forward(inputs) for t, output := range outputs { fmt.Printf("时间步 %d: %v\n", t, output) } }

六、优化算法

6.1 梯度下降变体

package main import ( "fmt" "math" ) // 动量优化 func momentumUpdate(weights [][]float64, gradients [][]float64, velocity [][]float64, lr, momentum float64) { for i := range weights { for j := range weights[i] { velocity[i][j] = momentum*velocity[i][j] + lr*gradients[i][j] weights[i][j] -= velocity[i][j] } } } // RMSprop func rmsPropUpdate(weights [][]float64, gradients [][]float64, cache [][]float64, lr, decay, eps float64) { for i := range weights { for j := range weights[i] { cache[i][j] = decay*cache[i][j] + (1-decay)*gradients[i][j]*gradients[i][j] weights[i][j] -= lr * gradients[i][j] / (math.Sqrt(cache[i][j]) + eps) } } } // Adam优化 func adamUpdate(weights [][]float64, gradients [][]float64, m, v [][]float64, t int, lr, beta1, beta2, eps float64) { for i := range weights { for j := range weights[i] { m[i][j] = beta1*m[i][j] + (1-beta1)*gradients[i][j] v[i][j] = beta2*v[i][j] + (1-beta2)*gradients[i][j]*gradients[i][j] mHat := m[i][j] / (1 - math.Pow(beta1, float64(t))) vHat := v[i][j] / (1 - math.Pow(beta2, float64(t))) weights[i][j] -= lr * mHat / (math.Sqrt(vHat) + eps) } } } func main() { weights := [][]float64{ {0.5, 0.3}, {0.2, 0.7}, } gradients := [][]float64{ {0.1, 0.05}, {0.08, 0.12}, } fmt.Printf("更新前权重:\n") for _, row := range weights { fmt.Println(row) } // 动量优化示例 velocity := make([][]float64, len(weights)) for i := range velocity { velocity[i] = make([]float64, len(weights[i])) } momentumUpdate(weights, gradients, velocity, 0.1, 0.9) fmt.Printf("\n动量优化后权重:\n") for _, row := range weights { fmt.Println(row) } }

七、实战：MNIST手写数字识别

package main import ( "fmt" "math" ) type CNN struct { // 卷积层 convKernel [][]float64 convBias float64 // 全连接层 fcWeights [][]float64 fcBias []float64 } func NewCNN() *CNN { cnn := &CNN{ convKernel: make([][]float64, 3), fcWeights: make([][]float64, 10), fcBias: make([]float64, 10), } // 初始化卷积核 for i := range cnn.convKernel { cnn.convKernel[i] = make([]float64, 3) for j := range cnn.convKernel[i] { cnn.convKernel[i][j] = (math.Random() * 2) - 1 } } // 初始化全连接层 for i := range cnn.fcWeights { cnn.fcWeights[i] = make([]float64, 24*24) // 28-3+1=26, 池化后13x13 for j := range cnn.fcWeights[i] { cnn.fcWeights[i][j] = (math.Random() * 2) - 1 } } return cnn } func (cnn *CNN) Forward(image [][]float64) []float64 { // 卷积层 convOutput := convolve(image, cnn.convKernel) // ReLU激活 for i := range convOutput { for j := range convOutput[i] { convOutput[i][j] = relu(convOutput[i][j]) } } // 展平 flattened := make([]float64, 0) for _, row := range convOutput { flattened = append(flattened, row...) } // 全连接层 output := make([]float64, 10) for i := range output { sum := cnn.fcBias[i] for j := range flattened { sum += flattened[j] * cnn.fcWeights[i][j] } output[i] = softmax(sum) } return output } func softmax(x float64) float64 { // 简化版softmax return math.Exp(x) } func main() { cnn := NewCNN() // 模拟28x28图像 image := make([][]float64, 28) for i := range image { image[i] = make([]float64, 28) for j := range image[i] { image[i][j] = math.Random() } } output := cnn.Forward(image) // 找到预测的数字 maxIdx := 0 maxVal := output[0] for i, val := range output { if val > maxVal { maxVal = val maxIdx = i } } fmt.Printf("预测数字: %d\n", maxIdx) }