神经网络基础教程

1. 神经网络简介

神经网络（Neural Network, NN）是一种受生物神经系统启发的计算模型，能够通过训练学习复杂的映射关系。神经网络广泛应用于图像识别、自然语言处理（NLP）、语音识别等多个领域。

2. 神经网络的基本组件

2.1 神经元

神经网络的基本单元是神经元（Neuron），每个神经元接收多个输入，经过加权求和并通过激活函数处理后，产生输出。

数学表达式如下：

$$y=f(\sum _{i=1}^n{w}_i{x}_i+b)$$

其中：

• (x_i) 是输入特征
• (w_i) 是权重
• (b) 是偏置项
• (f) 是激活函数

2.2 层次结构

神经网络通常由多个层级组成：

• 输入层（Input Layer）：接收数据的原始输入
• 隐藏层（Hidden Layer）：对数据进行特征提取和变换
• 输出层（Output Layer）：生成最终的预测结果

3. 激活函数

激活函数决定了神经元的输出形式，常见的激活函数包括：

3.1 Sigmoid

$$f(x)=\frac{1}{1+e^{-x}}$$

特点：

• 适用于二分类问题
• 存在梯度消失问题

3.2 ReLU（Rectified Linear Unit）

$$f(x)=\max (0,x)$$

特点：

• 计算简单，收敛快
• 存在“死亡神经元”问题（某些神经元可能永远不会激活）

3.3 Tanh

$$f(x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}$$

特点：

• 输出范围在 (-1,1)，相比 Sigmoid 收敛速度更快

4. 反向传播（Backpropagation）

反向传播是一种用于训练神经网络的算法，它通过计算梯度来调整网络的权重和偏置。

4.1 计算损失

常见的损失函数包括：

• 均方误差（MSE）：用于回归任务

$$L=\frac{1}{n}\sum (y_{true}-y_{pred}{)}^2$$

• 交叉熵损失（Cross-Entropy）：用于分类任务

$$L=-\sum y_{true}\log (y_{pred})$$

4.2 计算梯度

使用链式法则计算损失函数对各层参数的偏导数，以调整权重：

$$w_{new}=w_{old}-\alpha \cdot \frac{\partial L}{\partial w}$$

其中 (\alpha) 为学习率。

5. 优化算法

优化算法用于调整网络权重以减少损失函数的值。

5.1 随机梯度下降（SGD）

$$w_{new}=w-\alpha \frac{\partial L}{\partial w}$$

优点：计算简单，适用于大规模数据集

缺点：收敛速度慢，容易陷入局部最优

5.2 Adam（Adaptive Moment Estimation）

Adam 结合了动量和自适应学习率，计算公式如下：

$$m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1)g_t$$

$$v_t={\beta }_2{v}_{t-1}+(1-{\beta }_2)g_t^2$$

优点：适用于大多数深度学习任务，收敛快

缺点：计算复杂，参数较多

6. Java 实现简单神经网络

以下代码演示了一个简单的神经网络实现（单层感知机），用于二分类任务。

import java.util.Random;

public class SimpleNeuralNetwork {
    private double[] weights;
    private double bias;
    private double learningRate = 0.1;
    
    public SimpleNeuralNetwork(int inputSize) {
        Random random = new Random();
        weights = new double[inputSize];
        for (int i = 0; i < inputSize; i++) {
            weights[i] = random.nextDouble() - 0.5;
        }
        bias = random.nextDouble() - 0.5;
    }
    
    private double sigmoid(double x) {
        return 1 / (1 + Math.exp(-x));
    }
    
    private double sigmoidDerivative(double x) {
        return x * (1 - x);
    }
    
    public double predict(double[] inputs) {
        double sum = bias;
        for (int i = 0; i < inputs.length; i++) {
            sum += inputs[i] * weights[i];
        }
        return sigmoid(sum);
    }
    
    public void train(double[][] inputs, double[] targets, int epochs) {
        for (int epoch = 0; epoch < epochs; epoch++) {
            for (int i = 0; i < inputs.length; i++) {
                double output = predict(inputs[i]);
                double error = targets[i] - output;
                for (int j = 0; j < weights.length; j++) {
                    weights[j] += learningRate * error * sigmoidDerivative(output) * inputs[i][j];
                }
                bias += learningRate * error * sigmoidDerivative(output);
            }
        }
    }
    
    public static void main(String[] args) {
        double[][] trainingInputs = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
        double[] trainingOutputs = {0, 1, 1, 0}; // XOR 问题
        SimpleNeuralNetwork nn = new SimpleNeuralNetwork(2);
        nn.train(trainingInputs, trainingOutputs, 10000);
        
        System.out.println("预测 (0,0): " + nn.predict(new double[]{0, 0}));
        System.out.println("预测 (0,1): " + nn.predict(new double[]{0, 1}));
        System.out.println("预测 (1,0): " + nn.predict(new double[]{1, 0}));
        System.out.println("预测 (1,1): " + nn.predict(new double[]{1, 1}));
    }
}

7. 结论

神经网络在众多领域有广泛应用，尽管其训练较慢且计算成本较高，但在大规模数据集和高复杂度任务上表现卓越。了解神经网络的基础知识，并结合 Java 实现，可以帮助开发者更好地理解和应用深度学习技术。