[Aprendizaje automático] P15 Comprensión lógica de la red neuronal Tensorflow, establecimiento de un esquema de marco lógico

Revisar el flujo lógico de entrenamiento de una red neuronal

.1 Crear neuronas

Para cada neurona:
$$F_{\vec{w},}\left(\vec{X}\right)=\vec{w}\cdot \vec{X}+b$$

Por ejemplo, la primera neurona en la capa 1:
$${\vec{a}}_1^{[1}=g\left(f_{{\vec{w}}_1^{[1},{segundo}_1^{[1}}\right(\vec{X}))$$

Enlaces de publicaciones de blog relacionadas:

[Aprendizaje automático] P11 Red neuronal
[Aprendizaje automático] P12 Propergación directa
[Aprendizaje automático] P14 Guía de usuario de Tensorflow Implementación de Tensorflow secuencial denso

---

.2 Cálculo del valor de la pérdida

En una red neuronal, el valor de pérdida se refiere a la diferencia entre el valor predicho y el valor real de la capa de salida de cada muestra de entrenamiento:
$$pérdida\_=-ylogramo(f\_{}_{\vec{w},}(\vec{X}))-(1-y)logaritmo(1\_\_-F_{\vec{w},}(\vec{X}))$$

La suma de los valores de pérdida de todas las muestras de entrenamiento es:
$$J(\vec{w},segundo)=\frac{}{metro}\sum _{yo=1}pérdida\_$$

Enlaces de publicaciones de blog relacionadas:

[Aprendizaje automático] P6 Función de pérdida de regresión logística y descenso de gradiente

---

.3 Modelo de entrenamiento de descenso de gradiente

A través del método de descenso de gradiente, optimizar continuamente los parámetros del modelo de entrenamiento ( $\vec{w},b$ ), de modo que el valor de pérdida$J(\vec{w},b)$ Mínima, es decir, la predicción es lo más precisa posible:

Actualizar $\vec{w}$
$$w_{}=w_{}-a\frac{\partial J(\vec{w},segundo}{\partial w_{}}$$

actualizar $segundo$
$$b=b-a\frac{\partial J(\vec{w},segundo}{\partial segundo}$$

其中：
$$\begin{gathered} \frac{\partial J(\vec{w},segundo}{\partial w_{}}=\frac{}{metro}\sum _{yo=0}^{metro-}\left(f_{\vec{w},}\right({\vec{X}}^{\left[yo\right]})-y^{\left[yo\right]})x_j^{[yo} \\ \frac{\partial J(\vec{w},segundo}{\partial segundo}=\frac{}{metro}\sum _{yo=0}^{metro-}\left(f_{\vec{w},}\right({\vec{X}}^{\left[yo\right]})-y^{\left[yo\right]}) \end{gathered}$$

El método específico de actualización de la red neuronal se llama backpropagation, que se describirá en detalle en publicaciones de blog posteriores. El enlace es el siguiente:
xxxxxxxx

---

implementación de Python

Publicaciones de blog relacionadas: [Aprendizaje automático] P9 implementa un caso de regresión logística de principio a fin

.1 Crear neuronas

def sigmoid(z):
	f_x = 1/(1 + np.exp(-z))
	return f_x

z = np.dot(w,x) + b
f_x = sigmoid(z)

.2 Cálculo del valor de la pérdida

def compute_cost(X,y,w,b):
	m = X.shape[0]
	cost = 0.
	for i in range(m):
		f_x_i = sigmoid(np.dot(w,X[i]) + b)
		loss = -y * np.log(f_x_i) - (1 - y) * np.log(1 - f_x_i)
		cost += loss
	cost = cost / m
	
	return cost

.3 Modelo de entrenamiento de descenso de gradiente

def compute_gradient(X,y,w,b):
	m = X.shape[0]
	dj_dw = np.zeros(w.shape)
	dj_db = 0.

	for i in range(m):
		f_wb = sigmoid(np.dot(w, X[i]) + b)
		cost = f_wb - y[i]

		dj_db += cost
		dj_dw += cost * X[i]

	dj_dw = dj_dw / m
	dj_db = dj_db / m

	return dj_dw, dj_db

def gradient_descent(X,y,w_in,b_in,cost_function,gradient_function,alpha,num_iters):

    m = len(X)
  
    J_history = []		
    w_history = []		
    
    for i in range(num_iters):
        dj_db, dj_dw = gradient_function(X, y, w_in, b_in)   

        w_in = w_in - alpha * dj_dw     # alpha 为学习率          
        b_in = b_in - alpha * dj_db              
       
        if i<100000:
            cost =  cost_function(X, y, w_in, b_in)
            J_history.append(cost)

        if i% math.ceil(num_iters/10) == 0 or i == (num_iters-1):
            w_history.append(w_in)
            print(f"Iteration {
      
      i:4}: Cost {
      
      float(J_history[-1]):8.2f}   ")
        
    return w_in, b_in, J_history, w_history	

---

Implementación de tensorflow

.1 Crear neuronas

model = Sequential([
	Dense(units = 25, activation="sigmoid"),
	Dense(units = 15, activation="sigmoid"),
	Dense(units = 1, activation="sigmoid")
])

.2 Cálculo del valor de la pérdida

model.compile(
	loss = BinaryCrossentropy()
)

.3 Modelo de entrenamiento de descenso de gradiente

model.fit(X,y,epochs=100)

---