Modelo de red neuronal
- La cantidad de datos es cada vez mayor, la dimensión de datos es cada vez mayor (texto, imágenes), los datos de múltiples fuentes son cada vez más
- Es difícil para otros modelos manejar estos datos multidimensionales y de alta dimensión. La mayoría de los productos actuales de inteligencia artificial utilizan modelos de redes neuronales
Principios de las redes neuronales.
- Capa de entrada: variable independiente
- Capa oculta : estado intermedio (extracción de características)
- Capa de salida: variable dependiente
Extracción de características de capas ocultas en redes neuronales convolucionales
Cómo producen salida las redes neuronales
Método de cálculo lineal
Problemas con modelos lineales
Introducir no linealidad
Función de activación sigmoidea 
- La salida de la función sigmoidea está entre 0 y 1
- Se puede entender que pone (−∞, + ∞)
- El número en el rango está comprimido a (0, 1) .
Cómo la red neuronal logra la autocorrección
Función de error
Error cuadrado medio:
Derivación de MSE:
Función de pérdida
En realidad es una función multivariante con múltiples pesos y compensaciones.
Autoajuste de la red neuronal:
Cómo el error MSE se vuelve más pequeño: ajuste los parámetros,
¿Cómo ajustar los parámetros?
¿Cómo ajustar los parámetros?
Cómo encontrar el valor mínimo de esta función
w está a la derecha: w debería disminuir, la base para el juicio: la derivada parcial es positiva
w a la izquierda: w debería aumentar, la base para el juicio: la derivada parcial es negativa
Método: derivada parcial ∂ L / ∂ w
Encuentre derivadas parciales de parámetros para minimizar MSE
Más compleja la función es: no podemos determinar el mínimo global sólo puede encontrar mínimo local
Todo el proceso de optimización de parámetros.
Cómo encontrar el gradiente del valor de propiedad
De acuerdo con la regla de derivación de la cadena
Luego encuentra ∂h1 / ∂w1
Derivada de la función sigmoidea (función de activación):
Proceso de derivación de la cadena
Estrategia de actualización de parámetros
Descenso de gradiente estocástico (SGD)
η es una constante, llamada tasa de aprendizaje , que determina la velocidad de la red de entrenamiento .
El W1 menos [eta] · ∂L / ∂w1 , sólo tiene que esperar hasta que el nuevo peso W1 .
Cuando ∂ L / ∂w1 es positivo, w1 se hará más pequeño; cuando ∂ L / ∂w1 es negativo, w1 se hará más grande.
Proceso de entrenamiento modelo
- Seleccione una muestra del conjunto de datos;
- Calcule la derivada parcial de la función de pérdida de peso y sesgo;
- Use la fórmula de actualización para actualizar cada peso y desplazamiento;
- Regresar al paso 1
Todas las fórmulas
Conducción hacia adelante
Conducción hacia atrás
Actualización de parámetros
Implementación del programa de red neuronal
- Seleccione una muestra del conjunto de datos;
- Calcule la derivada parcial de la función de pérdida de peso y sesgo;
- Use la fórmula de actualización para actualizar cada peso y desplazamiento;
- Regresar al paso 1
El código es el siguiente:
import numpy as np
def sigmoid(x):
# Sigmoid 激活函数: f(x) = 1 / (1 + e^(-x))
return 1 / (1 + np.exp(-x))
def deriv_sigmoid(x):
# sigmoid的倒数: f'(x) = f(x) * (1 - f(x))
fx = sigmoid(x)
return fx * (1 - fx)
def mse_loss(y_true, y_pred):
# MSE损失函数
return ((y_true - y_pred) ** 2).mean()
class OurNeuralNetwork:
def __init__(self):
# 权值矩阵
self.w1 = np.random.normal()
self.w2 = np.random.normal()
self.w3 = np.random.normal()
self.w4 = np.random.normal()
self.w5 = np.random.normal()
self.w6 = np.random.normal()
# 偏置
self.b1 = np.random.normal()
self.b2 = np.random.normal()
self.b3 = np.random.normal()
def feedforward(self, x):
# sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
# h1 = sigmoid(sum_h1)
#
# sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
# h2 = sigmoid(sum_h2)
#
# sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3
# o1 = sigmoid(sum_o1)
# y_pred = o1
# return y_pred
h1 = sigmoid(self.w1 * x[0] + self.w2 * x[1] + self.b1)
h2 = sigmoid(self.w3 * x[0] + self.w4 * x[1] + self.b2)
o1 = sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
return o1
# x是输入数据，这里输入只有两个属性.
def train(self, data, all_y_trues):
learn_rate = 0.1
epochs = 1000 # 迭代次数
for epoch in range(epochs):
for x, y_true in zip(data, all_y_trues):
# feed forward
sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
h1 = sigmoid(sum_h1)
sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
h2 = sigmoid(sum_h2)
sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3
o1 = sigmoid(sum_o1)
y_pred = o1
# 计算偏导数.
# 对目标函数求导
d_L_d_ypred = -2*(y_true - y_pred)
# # Neuron o1
# d_ypred_d_w5 = h1 * deriv_sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
# d_ypred_d_w6 = h2 * deriv_sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
# d_ypred_d_b3 = deriv_sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
#
# d_ypred_d_h1 = self.w5 * deriv_sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
# d_ypred_d_h2 = self.w6 * deriv_sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
#
# # Neuron h1
# d_h1_d_w1 = x[0]*deriv_sigmoid(self.w1*x[0] + self.w2*x[1] + self.b1)
# d_h1_d_w2 = x[1]*deriv_sigmoid(self.w1*x[0] + self.w2*x[1] + self.b1)
# d_h1_d_b1 = deriv_sigmoid(self.w1*x[0] + self.w2*x[1] + self.b1)
#
# # Neuron h2
# d_h2_d_w3 = x[0]*deriv_sigmoid(self.w3*x[0] + self.w4*x[1] + self.b2)
# d_h2_d_w4 = x[1]*deriv_sigmoid(self.w3*x[0] + self.w4*x[1] + self.b2)
# d_h2_d_b2 = deriv_sigmoid(self.w3*x[0] + self.w4*x[1] + self.b2)
# Neuron o1
d_ypred_d_w5 = h1 * deriv_sigmoid(sum_o1)
d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1)
d_ypred_d_b3 = deriv_sigmoid(sum_o1)
d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1)
d_ypred_d_h2 = self.w6 * deriv_sigmoid(sum_o1)
# Neuron h1
d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1)
d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1)
d_h1_d_b1 = deriv_sigmoid(sum_h1)
# Neuron h2
d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2)
d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2)
d_h2_d_b2 = deriv_sigmoid(sum_h2)
# 更新权值和偏置
# Neuron h1
self.w1 -= learn_rate*d_L_d_ypred*d_ypred_d_h1*d_h1_d_w1
self.w2 -= learn_rate*d_L_d_ypred*d_ypred_d_h1*d_h1_d_w2
self.b1 -= learn_rate*d_L_d_ypred*d_ypred_d_h1*d_h1_d_b1
# Neuron h2
self.w3 -= learn_rate*d_L_d_ypred*d_ypred_d_h2*d_h2_d_w3
self.w4 -= learn_rate*d_L_d_ypred*d_ypred_d_h2*d_h2_d_w4
self.b2 -= learn_rate*d_L_d_ypred*d_ypred_d_h2*d_h2_d_b2
# Neuron o1
self.w5 -= learn_rate*d_L_d_ypred*d_ypred_d_w5
self.w6 -= learn_rate*d_L_d_ypred*d_ypred_d_w6
self.b3 -= learn_rate*d_L_d_ypred*d_ypred_d_b3
# 计算误差
if epoch % 10 == 0:
y_preds = np.apply_along_axis(self.feedforward, 1, data)
loss = mse_loss(all_y_trues, y_preds)
print("Epoch %d loss: %.3f" % (epoch, loss))
# 数据集定义
data = np.array([
[-2, -1], # Alice
[25, 6], # Bob
[17, 4], # Charlie
[-15, -6], # Diana
])
all_y_trues = np.array([
1, # Alice
0, # Bob
0, # Charlie
1, # Diana
])
# 模型训练
network = OurNeuralNetwork()
network.train(data, all_y_trues)
Pérdida de la época 0: 0.383 Pérdida de la época 10 : 0.213 Pérdida de la época 20: 0.125 Pérdida de la época 30: 0.095 Pérdida de la época 40: 0.077 Pérdida de la época 50: 0.064 Pérdida de la época 60: 0.054 Pérdida de la época 70: 0.046 Pérdida de la época 80: 0.041 Pérdida de la época 90: 0.036 Epoch 100 loss: 0.032 Epoch 110 loss: 0.029 Epoch 120 loss: 0.026 Epoch 130 loss: 0.024 Epoch 140 loss: 0.022 Epoch 150 loss: 0.020 Epoch 160 loss: 0.019 Epoch 170 loss: 0.017 Epoch 180 loss: 0.016 Epoch 190 loss: 0.015 Pérdida de la época 200: 0.014 Pérdida de la época 210: 0.014 Pérdida de la época 220: 0.013 Pérdida de la época 230: 0.012 Epoch 240 loss: 0.012 Epoch 250 loss: 0.011 Epoch 260 loss: 0.011 Epoch 270 loss: 0.010 Epoch 280 loss: 0.010 Epoch 290 loss: 0.009 Epoch 300 loss: 0.009 Epoch 310 loss: 0.009 Epoch 320 loss: 0.008 Epoch 330 loss: 0.008 Epoch 340 loss: 0.008 Epoch 350 loss: 0.008 Epoch 360 loss: 0.007 Epoch 370 loss: 0.007 Epoch 380 loss: 0.007 Epoch 390 loss: 0.007 Epoch 400 loss: 0.006 Epoch 410 loss: 0.006 Epoch 420 loss: 0.006 Epoch 430 loss: 0.006 Epoch 440 pérdida: 0.006 Epoch 450 pérdida: 0.006 Epoch 460 pérdida: 0.006 Epoch 470 pérdida: 0.005 Pérdida de la época 480: 0.005 Pérdida de la época 490: 0.005 Epoch 500: 0.005 Pérdida de Epoch 510: 0.005 Pérdida de Epoch 520: 0.005 Pérdida de Epoch 530: 0.005 Pérdida de Epoch 540: 0.005 Epoch 550 loss: 0.005 Epoch 560 loss: 0.004 Epoch 570 loss: 0.004 Epoch 580 loss: 0.004 Epoch 590 loss: 0.004 Epoch 600 loss: 0.004 Epoch 610 loss: 0.004 Epoch 620 loss: 0.004 Epoch 630 loss: 0.004 Epoch 640 loss: 0.004 Epoch 650 loss: 0.004 Epoch 660 loss: 0.004 Epoch 670 loss: 0.004 Epoch 680 loss: 0.004 Epoca 690 pérdida: 0.003 Epoca 700 pérdida: 0.003 Epoca 710 pérdida: 0.003 Epoca 720 pérdida: 0.003 Epoca 730 pérdida: 0.003 Pérdida de la época 970: 0.002 Epoca 740 pérdida: 0.003 Epoch 750 loss: 0.003 Epoch 760 loss: 0.003 Epoch 770 loss: 0.003 Epoch 780 loss: 0.003 Epoch 790 loss: 0.003 Epoch 800 loss: 0.003 Epoch 810 loss: 0.003 Epoch 820 loss: 0.003 Epoch 830 loss: 0.003 Epoch 840 loss: 0.003 Epoch 850 loss: 0.003 Epoch 860 loss: 0.003 Epoch 870 loss: 0.003 Epoch 880 loss: 0.003 Epoch 890 loss: 0.003 Epoch 900 loss: 0.003 Epoch 910 loss: 0.003 Epoch 920 loss: 0.003 Epoch 930 loss: 0.003 Epoch 940 loss: 0.002 Pérdida de Epoch 950: 0.002 Pérdida de Epoch 960: 0.002 Pérdida de la época 980: 0.002 Pérdida de la época 990: 0.002
network.feedforward([-25,-6])0.9660953631431157
