Compartir tecnología

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Hola a todos, soy Wei Xue AI. Hoy les presentaré la explicación detallada de la base y el código de la red neuronal del curso 8-Red neuronal PyTorch de ingeniero de algoritmos de inteligencia artificial (intermedio). La red neuronal es un modelo informático que imita la conexión de neuronas en el cerebro humano y se usa ampliamente en el reconocimiento de imágenes, el procesamiento del lenguaje natural y otros campos. Este artículo presentará el concepto, la estructura, los ejemplos, el entrenamiento y la evaluación de las redes neuronales, junto con el código ejecutable completo.

Explicación detallada de los conceptos básicos y el código de las redes neuronales.

1. Concepto de red neuronal

Una red neuronal consta de una gran cantidad de nodos (o neuronas) y los bordes que conectan estos nodos. Cada nodo representa una neurona y cada borde representa una conexión entre neuronas. La función principal de la red neuronal es extraer información útil de los datos mediante suma ponderada y transformación no lineal de los datos de entrada.

2. Estructura de la red neuronal.

Las redes neuronales suelen dividirse en capa de entrada, capa oculta y capa de salida. La capa de entrada recibe datos externos, la capa oculta procesa los datos y la capa de salida genera el resultado final. Los nodos de cada capa están conectados a los nodos de la siguiente capa y cada conexión tiene un peso correspondiente.

2.1 Fórmula de cálculo de la red neuronal

La salida de la red neuronal se puede calcular mediante la siguiente fórmula:
$$a^{(yo)}=F({el}^{(yo)})$$
$${el}^{(yo)}={el}^{(yo)}{a}^{(yo-1)}+b^{(yo)}$$
en,$a^{(yo)}$ Indica la primera$yo$ La salida de la capa,${el}^{(yo)}$ Indica la primera$yo$ El resultado de la suma ponderada de las capas,${el}^{(yo)}$ y$b^{(yo)}$ Representan respectivamente el$yo$ pesos y sesgos de capa,$F(\cdot )$ representa la función de activación.

2.2 Código ejecutable

A continuación se muestra un ejemplo de una estructura de red neuronal simple:

import numpy as np
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
def feedforward(X, weights, biases):
    a = X
    for w, b in zip(weights, biases):
        z = np.dot(a, w) + b
        a = sigmoid(z)
    return a
# 定义输入数据
X = np.array([[1, 2], [3, 4]])
# 定义权重和偏置
weights = [np.array([[0.1, 0.2], [0.3, 0.4]]), np.array([[0.5], [0.6]])]
biases = [np.array([0.1, 0.2]), np.array([0.3])]
# 计算输出
output = feedforward(X, weights, biases)
print(output)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3. Muestra de red neuronal

Una muestra de una red neuronal incluye datos de entrada y etiquetas correspondientes. Durante el proceso de entrenamiento, la red neuronal ajusta continuamente los pesos y sesgos para que la salida sea lo más cercana posible a la etiqueta.

3.1 Función de pérdida

El objetivo del entrenamiento de las redes neuronales es minimizar la función de pérdida. Las funciones de pérdida utilizadas comúnmente incluyen el error cuadrático medio (MSE) y la pérdida de entropía cruzada. La fórmula para el error cuadrático medio es la siguiente:
$$Yo(el,b)=\frac{1}{2metroetroetro}\sum _{i=1}^{metroetroetro}(y^{(i)}-a^{(i)}{)}^2$$
en,$metroetroetro$ representa el número de muestras,$y^{(i)}$ y$a^{(i)}$ Representan respectivamente el$i$ etiquetas y valores previstos de muestras.

3.2 Código ejecutable

A continuación se muestra un ejemplo sencillo de generación de muestras y cálculo de pérdidas:

import numpy as np
def mse_loss(y_true, y_pred):
    return np.mean((y_true - y_pred) ** 2)
# 定义标签
y_true = np.array([[1], [0]])
# 计算损失
loss = mse_loss(y_true, output)
print(loss)
1
2
3
4
5
6
7
8

4. Entrenamiento de redes neuronales.

El proceso de entrenamiento de una red neuronal incluye propagación hacia adelante y hacia atrás. La propagación hacia adelante calcula la salida de la red neuronal y la propagación hacia atrás calcula el gradiente de la función de pérdida con respecto a los pesos y sesgos, y actualiza los pesos y sesgos.

4.1 Propagación hacia atrás

El algoritmo de retropropagación calcula los gradientes mediante la regla de la cadena.Por el primero$yo$ peso de la capa${el}^{(yo)}$, su gradiente se puede expresar como:
$$\frac{\partial Yo}{\partial {el}^{(yo)}}=a^{(yo-1)}\cdot (F^{\prime }({el}^{(yo)})\cdot {\delta }^{(yo)})$$
en,${\delta }^{(yo)}$ Indica la primera$yo$ error de capa,$F^{\prime }(\cdot )$ representa la derivada de la función de activación.

4.2 Código para entrenamiento de redes neuronales

Aquí hay un ejemplo simple de entrenamiento de redes neuronales:

import numpy as np
def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(x))
def backpropagation(X, y_true, weights, biases):
    gradients_w = [np.zeros(w.shape) for w in weights]
    gradients_b = [np.zeros(b.shape) for b in biases]
    # 前向传播
    a = X
    activations = [a]
    zs = []
    for w, b in zip(weights, biases):
        z = np.dot(a, w) + b
        zs.append(z)
        a = sigmoid(z)
        activations.append(a)
    # 计算输出层误差
    delta = activations[-1] - y_true
    gradients_b[-1] = delta
    gradients_w[-1] = np.dot(activations[-2].T, delta)
    # 反向传播
    for l in range(2, len(weights) + 1):
        z = zs[-l]
        sp = sigmoid_derivative(z)
        delta = np.dot(delta, weights[-l + 1].T) * sp
        gradients_b[-l] = delta
        gradients_w[-l] = np.dot(activations[-l - 1].T, delta)
    return gradients_w, gradients_b
# 定义学习率
learning_rate = 0.1
# 进行一次梯度下降
gradients_w, gradients_b = backpropagation(X, y_true, weights, biases)
# 更新权重和偏置
for w, grad_w in zip(weights, gradients_w):
    w -= learning_rate * grad_w
for b, grad_b in zip(biases, gradients_b):
    b -= learning_rate * grad_b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

5. Evaluación de redes neuronales

La evaluación de las redes neuronales generalmente se realiza calculando el valor de la función de precisión o pérdida en el conjunto de prueba. La precisión se refiere a la relación entre el número de muestras predichas correctamente por el modelo y el número total de muestras.

5.1 Precisión

La fórmula de cálculo para la precisión es la siguiente:
$$\text{Exactitud}=\frac{\text{Número de predicciones correctas}}{\text{Número total de predicciones}}$$

5.2 Implementación del código

A continuación se muestra un ejemplo simple de evaluación de una red neuronal:

def predict(X, weights, biases):
    a = X
    for w, b in zip(weights, biases):
        z = np.dot(a, w) + b
        a = sigmoid(z)
    return np.round(a)
# 定义测试数据
X_test = np.array([[2, 3], [4, 5]])
# 进行预测
predictions = predict(X_test, weights, biases)
print(predictions)
# 计算准确率
y_test = np.array([[1], [0]])
accuracy = np.mean(predictions == y_test)
print("Accuracy:", accuracy)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Resumir

En este artículo, implementamos una red neuronal simple, que incluye propagación hacia adelante, propagación hacia atrás, descenso de gradiente y proceso de evaluación. Aunque esta red es simple, demuestra los principios básicos y los métodos de implementación de las redes neuronales. En aplicaciones prácticas, la estructura de las redes neuronales será más compleja e involucrará más capas y nodos, así como algoritmos de optimización y técnicas de regularización más avanzados. Además, los marcos modernos de aprendizaje profundo (como TensorFlow y PyTorch) proporcionan funciones de implementación y diferenciación automática más eficientes, lo que hace que la construcción y el entrenamiento de redes neuronales sean más convenientes.