Neural network from Scratch: Forward (Parte 4)

En este articulo nos centraremos en el proceso de forward de la red. Este es esencial para una red tanto para calcular el error, corregir los pesos, guardar resultados parciales que usará el backward como para una vez aprendida poder usarla.
Forward es un algoritmo similar al computeSizes, pero en este caso se devuelve el resultado y este se pasa al siguiente nodo.
El proceso empieza en la clase Network por los nodos que solo tienen salidas, estos pueden ser Inputs o Targets de la red.

def forward(self):
    # Recorremos los nodos que SOLO tienen salidas, es decir: Son la entrada de datos a la red.
    for n in self.nodes_with_only_outputs.values():
        # Solo se realiza el forward para elementos que participan en la preciccion.
        # Los tagets por ejemplo no se calculan.
        if not self.predict_flag or n.compute_forward_in_prediction:
            n.forward()
    # indicamos que hemos realizado ya el forward
    self.status = Network.STATUS.FORWARDED

def forward(self):

# Recorremos los nodos que SOLO tienen salidas, es decir: Son la entrada de datos a la red.

for n in self.nodes_with_only_outputs.values():

# Solo se realiza el forward para elementos que participan en la preciccion.

# Los tagets por ejemplo no se calculan.

if not self.predict_flag or n.compute_forward_in_prediction:

n.forward()

# indicamos que hemos realizado ya el forward

self.status = Network.STATUS.FORWARDED

Se verifica si estamos en modo predicción, existen nodos que en el modo predicción que no tienen utilidad porque solo participan en el aprendizaje, por ejemplo: los targets que básicamente se usan para determinar el error en una loss, las losses o las metricas.
Así que si la red está en modo predicción activado se mira si ese nodo debe calcularse.
Este proceso se inicia en los nodos que solo tienen salidas y se propaga hasta los nodos que solo tienen entradas (algunos son la salida de datos de la red). En la clase del nodo encontramos estos métodos:

def clearForwardDependences(self):
    self.temp_forward_dependences = 0
def incrementForwardDependences(self):
    self.temp_forward_dependences += 1
def checkForwardDependences(self):
    return self.temp_forward_dependences == len(self.prevs)
def clearForwardResults(self):
    self.temp_forward_result = None
def computeForward(self):
    inputs = [n.temp_forward_result for n in self.prevs]
    return self.layer.forward(inputs)
def forward(self):
    if self.network.predict_flag and not self.compute_forward_in_prediction:
        return
    # Si esta en modo no prediccion el forward se para en la Loss
    result = self.computeForward()
    self.temp_forward_result = result
    for n in self.nexts:
        if self.network.predict_flag and not n.compute_forward_in_prediction:
            continue
        n.incrementForwardDependences()
        # Solo se podra ejecutar si todas las dependencias han terminado de calcularse.
        if n.checkForwardDependences():
            n.forward()
            n.clearForwardDependences()
    return result

def clearForwardDependences(self):

self.temp_forward_dependences = 0

def incrementForwardDependences(self):

self.temp_forward_dependences += 1

def checkForwardDependences(self):

return self.temp_forward_dependences == len(self.prevs)

def clearForwardResults(self):

self.temp_forward_result = None

def computeForward(self):

inputs = [n.temp_forward_result for n in self.prevs]

return self.layer.forward(inputs)

def forward(self):

if self.network.predict_flag and not self.compute_forward_in_prediction:

return

# Si esta en modo no prediccion el forward se para en la Loss

result = self.computeForward()

self.temp_forward_result = result

for n in self.nexts:

if self.network.predict_flag and not n.compute_forward_in_prediction:

continue

n.incrementForwardDependences()

# Solo se podra ejecutar si todas las dependencias han terminado de calcularse.

if n.checkForwardDependences():

n.forward()

n.clearForwardDependences()

return result

Cada nodo dispone del método forward. Este se encarga de verificar primero si el nodo participa en un forward en modo predicción (esto excluye las losses, las métricas, etc).
Después calcula el computeForward (realiza la operación de la capa que contiene el nodo) y guarda el resultado en la estructura del nodo actual para que los nodos que dependen de él puedan obtenerlo.
Como los nodos dependen de los nodos anteriores, se incrementará un contador de dependencias en el siguiente nodo que indicará que una de sus dependencias ya ha sido calculada. Esté contador es el encargado de saber cuando se han calculado todos los forwards previos a un nodo (algoritmo que explicamos en la parte 1).
Además bloqueará el proceso cuando un nodo está esperando a que se realicen los cálculos previos (nodos anteriores). Y una vez se han calculado todas las dependencias de un nodo se desbloquea el acceso y se empezará a ejecutar su correspondiente forward (el contador será igual al número de nodos anteriores).
En la siguiente figura podremos ver mejor este proceso:

Representación del proceso de forward en el nodo C.

Si en vez de usar un contador de dependencias computadas, nos basásemos en ver si el resultado a sido llenado, siempre veríamos que esta lleno y no esperariamos al calculo de esta iteración.

Antes comentamos que el método computeForward se encarga de calcular el forward de un nodo en particular, concretamente lo que hace es pasar todas las entradas a la capa para que pueda realizar el calculo.

Calculo desde el punto de vista de un nodo y su respectiva capa.

Al final a la clase Layer solamente recibe una lista de inputs que corresponden al resultado del forward de cada nodo anterior.
En el próximo articulo veremos como propagar las derivadas hacia atrás.