prefacio

He estado pensando durante mucho tiempo si publicar contenido de aprendizaje en profundidad. Después de todo, más de la mitad de los algoritmos en el contenido de aprendizaje automático en la columna de modelado matemático no se han actualizado. Lo he considerado durante mucho tiempo y decidí. Para crear una serie de artículos sobre redes neuronales. De lo contrario, si las redes neuronales se utilizan en competencias de modelado matemático u otros modelos más optimizados en el futuro (como el uso de LSTM para la predicción de modelos de series de tiempo), entonces será mejor explicar a todos Y explicó el principio. Sin embargo, el contenido del aprendizaje profundo no es tan fácil de dominar: contiene muchos conocimientos teóricos matemáticos y muchos principios de fórmulas de cálculo que requieren razonamiento. Y es difícil entender qué representa el código que escribimos en el marco informático de la red neuronal sin una operación real. Sin embargo, haré todo lo posible para simplificar el conocimiento y convertirlo en algo con lo que estemos más familiarizados. Haré todo lo posible para que todos comprendan y se familiaricen con el marco de la red neuronal, para garantizar una comprensión y una deducción fluidas. Trate de no utilizar demasiadas fórmulas matemáticas y conocimientos teóricos profesionales. Comprenda e implemente rápidamente el algoritmo en un artículo, domine este conocimiento de la manera más eficiente.

Aunque muchas competiciones no limitan el uso de marcos algorítmicos, cada vez más equipos galardonados utilizan algoritmos de aprendizaje profundo y los algoritmos tradicionales de aprendizaje automático están disminuyendo gradualmente. Por ejemplo, en la pregunta C de modelado matemático de estudiantes universitarios estadounidenses de 2022, el equipo de parámetros utilizó el equipo de la red de aprendizaje profundo y la proporción de victorias es muy alta. Ahora las competencias de inteligencia artificial y minería de datos están aumentando una tras otra, y la demanda de El conocimiento de las redes neuronales también está aumentando, por lo que es muy útil, es necesario dominar varios algoritmos de redes neuronales.

El blogger se ha centrado en el modelado durante cuatro años, ha participado en docenas de modelos matemáticos, grandes y pequeños, y comprende los principios de varios modelos, el proceso de modelado de cada modelo y varios métodos de análisis de temas. El propósito de esta columna es utilizar rápidamente varios modelos matemáticos, aprendizaje automático y aprendizaje profundo, y códigos con base cero. Cada artículo contiene proyectos prácticos y códigos ejecutables. Los blogueros se mantienen al día con todo tipo de competencias digitales y analógicas. Para cada competencia digital y analógica, los blogueros escribirán las últimas ideas y códigos en esta columna, así como ideas detalladas y códigos completos. Espero que los amigos necesitados no se pierdan la columna cuidadosamente creada por el autor.

propagación hacia adelante

Los dos últimos artículos describieron la arquitectura básica de la red neuronal y varias funciones de activación de uso común. Luego sabemos que en la red neuronal, cada neurona está conectada a cada neurona en las capas frontal y posterior, entonces, ¿cómo pasa la red neuronal? entrada ¿Cómo se calculan los datos en la capa de salida? Veamos cómo funciona ahora.

El proceso de transferencia de la red neuronal se puede describir en cuatro pasos clave:

desde la entrada a la capa oculta

La forma en que se calculan las redes neuronales desde la capa de entrada hasta la capa oculta implica una combinación lineal de pesos y sesgos y luego pasar el resultado a una función de activación.

Señal de entrada: la capa de entrada recibe datos de entrada externos, que pueden ser imágenes, texto, números, etc. Cada entrada corresponde a una neurona de entrada en la red. $norte^{(0)}$ Supongamos que hay una neurona en la capa de entrada , respectivamente $a_1^{(0)}, a_2^{(0)}, ..., a_{n^{(0)}}^{(0)}$ , representan respectivamente la salida de la primera a la primera $norte^{(0)}$ neurona de entrada.
Pesos y sesgos: la capa oculta contiene múltiples neuronas, cada neurona tiene una conexión con cada neurona en la capa de entrada y hay un peso en la conexión $w_ {ji}^{(1)}$ . Entre ellos, $j$ representa el índice de neuronas en la capa oculta y $i$ representa el índice de neuronas en la capa de entrada. Cada neurona de capa oculta también tiene un sesgo $b_j^{(1)}$ .
Combinación lineal: $j$ para la primera neurona en la capa oculta , su señal de entrada se multiplicará por el peso y se polarizará para obtener el valor de la combinación lineal $z_j^{(1)}$ :
Función de activación: para el valor de la combinación lineal $z_j^{(1)}$ , introdúzcalo en la función de activación $f$ para obtener la salida de las neuronas de la capa oculta $a_j^{(1)}$ : las funciones de activación comunes incluyen sigmoide, ReLU, tanh, etc., que introducen propiedades no lineales, por lo que que la red neuronal puede aprender funciones más complejas.
Pase capa por capa: los pasos anteriores se repiten para cada neurona en cada capa oculta. La salida de cada neurona en la capa oculta se convierte en la entrada a la neurona de la siguiente capa.

Este proceso de cálculo se repetirá en cada neurona de cada capa hasta obtener la salida de la capa oculta. La salida de estas capas ocultas se convierte en la entrada de la siguiente capa, y así sucesivamente, hasta llegar a la capa de salida. A través de este cálculo capa por capa, la red neuronal puede extraer y representar características de nivel superior a partir de los datos de entrada.

Si comprender la descripción del texto anterior parece abstracto y difícil, podemos usar un pequeño ejemplo para comprender específicamente el proceso de transferencia directa de la red neuronal:

$X_ {1} = 0,4, X_ {2} = -0,6$ Como se muestra en la figura anterior , muestra la estructura básica de una red neuronal. Establecemos dos nodos de entrada $Y$ como el valor verdadero real $Y=0,1$ , luego establecemos el peso: $W_{1}=0.3,W_{2}=-0.6,W_{3}=0.9,W_{4}=-0.4,W_{5}=0.4,W_{6}=0.7$

Se realiza la suma ponderada de los nodos desde la capa de entrada a la capa oculta y los resultados son los siguientes:

El valor del nodo 1 es: $X_{1}*W_{1}+X_{2}*W_{3}=0,4*0,3+-0,6*0,9=-0,42$

El valor del nodo 2 es: $X_{1}*W_{2}+X_{2}*W_{4}=0,4*-0,6+-0,6*-0,4=0$

Luego realice la activación sigmoidea en el valor del nodo en la capa oculta. La función sigmoidea se describe en detalle en mi último artículo y puede calcularla directamente:

$\frac{1}{1+e^{-0.42}}=0.4,\frac{1}{1+e^{0}}=0.5$

Luego, la salida de la capa oculta se pondera y se suma al nodo de salida:

$-0,42*0,4+0,5*0,7=0,18$

Finalmente, encontramos que todavía hay una brecha entre 0.18 y el valor real de 0.1. Si la configuración de peso no es apropiada, conducirá a peores resultados. En este momento, debemos usar la propagación hacia atrás para acercar el valor predicho. al valor real. Por supuesto, si hay muchas capas de entrada y la capa oculta es más complicada, generalmente usamos una matriz para hacerlo, por ejemplo:

Podemos usar operaciones matriciales para expresar:

$\begin{pmatrix} w11&w21 \\ w12&w22 \end{pmatrix}*\begin{pmatrix} x1\\x2 \end{pmatrix}=\begin{pmatrix} w11*x1+w21*x2\\ w12*x1+w22* x2 \end{pmatriz}$

Ahora suponiendo que la fuente de datos de entrada es $[0.9,0.1,0.8]$ , hacemos otro cálculo:

import numpy as np
def _sigmoid(in_data):
    return 1/(1+np.exp(-in_data))
#输入层
x = np.array([0.9,0.1,0.8])
#隐藏层：需要计算输入层到中间隐藏层每个节点的组合，中间隐藏层的每个节点都与输入层相连，所以w1是一个3*3的矩阵
#因此每个节点都会得到输入信号的部分信息
#第一个输入节点与中间隐藏层第一个节点之间的权重w11=0.9，输入的第二个节点与隐藏层之间的连接的权重为w22=0.8
w1 = np.array([[0.9,0.3,0.4],
              [0.2,0.8,0.2],
              [0.1,0.5,0.6]]
             )
#因为输出层包含了3个节点，所以w2也是一个3x3的矩阵
w2 = np.array([
    [0.3,0.7,0.5],
    [0.6,0.5,0.2],
    [0.8,0.1,0.9]
])

Xhidden = _sigmoid(w1.dot(x))
print(Xhidden)
Xoutput = w2.dot(Xhidden)
print(Xoutput)  #最终输出结果

Veamos un ejemplo más complejo:

En este caso, agreguemos una capa oculta y veamos cómo funciona:

def _sigmoid(in_data):
    return 1/(1+np.exp(-in_data))

def init_network():
    network={}
    network['w1']=np.array([[0.1,0.3,0.5],[0.2,0.4,0.6]])
    network['b1']=np.array([0.1,0.2,0.3])
    network['w2']=np.array([[0.1,0.4],[0.2,0.5],[0.3,0.6]])
    network['b2']=np.array([0.1,0.2])
    network['w3']=np.array([[0.1,0.3],[0.2,0.4]])
    network['b3']=np.array([0.1,0.2])
    
    return network
    
def forward(network,x):
    w1,w2,w3 = network['w1'],network['w2'],network['w3']
    b1,b2,b3 = network['b1'],network['b2'],network['b3']
    a1 = x.dot(w1) + b1
    z1 = _sigmoid(a1)
    a2 = z1.dot(w2) + b2
    z2 = _sigmoid(a2)
    a3 = z2.dot(w3)+b3
    y=a3
    return y

network = init_network()
x = np.array([1.0,0.5])
y = forward(network,x)
print(y)

Entonces la propagación hacia adelante está completa aquí. No hay contenido complicado, solo cálculo lineal. En el próximo capítulo, nos centraremos en el cálculo y la función de la capa de salida.

Aprendizaje rápido en un artículo: deje que las redes neuronales ya no sean misteriosas, aprenda los conceptos básicos de las redes neuronales en un día: propagación hacia adelante (3)

prefacio

propagación hacia adelante

desde la entrada a la capa oculta

Supongo que te gusta