以下是用Go语言实现深度学习正向传播和反向传播的核心方法，包含矩阵运算、激活函数和梯度计算的关键实现：

正向传播实现

type Layer struct {
    Weights [][]float64
    Biases  []float64
    Output  []float64
}

func (l *Layer) Forward(input []float64) []float64 {
    output := make([]float64, len(l.Biases))
    for i := range l.Weights {
        sum := 0.0
        for j, w := range l.Weights[i] {
            sum += w * input[j]
        }
        output[i] = sigmoid(sum + l.Biases[i])
    }
    l.Output = output
    return output
}

func sigmoid(x float64) float64 {
    return 1.0 / (1.0 + math.Exp(-x))
}

反向传播实现

func (l *Layer) Backward(input, gradOutput []float64) ([]float64, [][]float64, []float64) {
    gradInput := make([]float64, len(input))
    gradWeights := make([][]float64, len(l.Weights))
    gradBiases := make([]float64, len(l.Biases))

    for i := range l.Weights {
        gradBiases[i] = gradOutput[i] * sigmoidDerivative(l.Output[i])
        gradWeights[i] = make([]float64, len(l.Weights[i]))
        for j := range l.Weights[i] {
            gradWeights[i][j] = gradBiases[i] * input[j]
            gradInput[j] += l.Weights[i][j] * gradBiases[i]
        }
    }

    return gradInput, gradWeights, gradBiases
}

func sigmoidDerivative(x float64) float64 {
    return x * (1 - x)
}

损失函数计算

func MeanSquaredError(predictions, targets []float64) float64 {
    sum := 0.0
    for i := range predictions {
        diff := predictions[i] - targets[i]
        sum += diff * diff
    }
    return sum / float64(len(predictions))
}

func MSEGradient(predictions, targets []float64) []float64 {
    grad := make([]float64, len(predictions))
    for i := range predictions {
        grad[i] = 2 * (predictions[i] - targets[i]) / float64(len(predictions))
    }
    return grad
}

参数更新方法

func (l *Layer) UpdateParams(gradWeights [][]float64, gradBiases []float64, learningRate float64) {
    for i := range l.Weights {
        l.Biases[i] -= learningRate * gradBiases[i]
        for j := range l.Weights[i] {
            l.Weights[i][j] -= learningRate * gradWeights[i][j]
        }
    }
}

网络训练流程示例

func TrainNetwork(layers []*Layer, input, target []float64, epochs int, lr float64) {
    for epoch := 0; epoch < epochs; epoch++ {
        // 正向传播
        output := input
        for _, layer := range layers {
            output = layer.Forward(output)
        }

        // 计算损失
        loss := MeanSquaredError(output, target)
        fmt.Printf("Epoch %d, Loss: %.4f\n", epoch, loss)

        // 反向传播
        grad := MSEGradient(output, target)
        for i := len(layers) - 1; i >= 0; i-- {
            var inputForLayer []float64
            if i > 0 {
                inputForLayer = layers[i-1].Output
            } else {
                inputForLayer = input
            }
            grad, gradW, gradB := layers[i].Backward(inputForLayer, grad)
            layers[i].UpdateParams(gradW, gradB, lr)
        }
    }
}

该实现包含神经网络的核心组件：

• 使用sigmoid作为激活函数
• 实现均方误差损失函数
• 完整的正向/反向传播流程
• 参数更新机制

实际使用时需要根据具体任务调整网络结构、激活函数和优化器参数。对于更复杂的网络，建议使用成熟的深度学习框架如Gorgonia或GoML。