Una red neuronal artificial (o red neuronal para abreviar) es un modelo predictivo motivado por la forma en que funciona el cerebro. Pensemos en el cerebro como una colección de neuronas conectadas entre sí. Cada neurona mira las salidas de las otras neuronas que la alimentan, hace un cálculo, y luego se dispara (si el cálculo excede algún umbral) o no (si no lo hace).
En consecuencia, las redes neuronales artificiales constan de neuronas artificiales, que funcionan de esta manera. Las redes neuronales pueden resolver una amplia variedad de problemas como reconocimiento de escritura a mano y detección de rostros, y se utilizan mucho en el aprendizaje profundo, uno de los subcampos más de moda de la ciencia de datos. Sin embargo, la mayoría de las redes neuronales son "cajas negras"- inspeccionar sus detalles no nos dará mucha comprensión de cómo están resueltos los problemas. Y las grandes redes neuronales pueden ser difíciles de entrenar.
Perceptrones
El equivalente electrónico de una neurona es el perceptrón, con n entradas binarias. Calcula una suma ponderada de sus entradas y "dispara" si esa suma ponderada es cero o mayor:
def funcion_escalon(x):
return 1 if x >= 0 else 0
def psalida_perceptron(pesos, sesgo, x):
"""devuelve 1 si
el perceptrón se 'activa' y 0 si no lo hace"""
calcula = punto(pesos, x) + sesgo
return funcion_escalon(calcula)
El perceptrón simplemente distingue entre los medios espacios separados por el hiperplano de puntos x para el cual:
punto(pesos,x) + sesgo == 0
Con pesos elegidos correctamente, los perceptrones pueden resolver una serie de problemas simples ver figura.
Por ejemplo, podemos crear una puerta AND (que devuelve 1 si ambas entradas son 1 pero devuelve 0 si una de sus entradas es 0) con:
#Definición de puerta AND
pesos = [2, 2]
sesgo = -3
Si ambas entradas son 1, el cálculo es igual a 2 + 2 - 3 = 1 y la salida es 1. Si solo una de las entradas es 1, el cálculo es igual a 2 + 0 - 3 = -1, y la salida es 0. Y si ambas las entradas son 0, el cálculo es igual a -3 y la salida es 0. Del mismo modo, podríamos construir una puerta OR con:
#Definición puerta OR
pesos = [2, 2]
sesgo = -1
Y podríamos construir una puerta NOT (que tiene una entrada y convierte 1 a 0 y 0 a 1) con:
#Definición de puerta NOT
pesos = [-2]
bias = 1
Sin embargo, hay algunos problemas que simplemente no pueden resolverse con un solo perceptrón. Por ejemplo, no importa cuánto lo intentemos, no podemos utilizar un perceptrón para construir una puerta XOR que genera 1 si exactamente una de sus entradas es 1 y 0 en caso contrario. Aquí es donde empezamos necesitando redes neuronales más complejas.
Por supuesto, no es necesario utilizar una neurona (perceptrón) para construir una puerta lógica lo podemos hacer fácilmente por programación tradicional.
puerta_and = min
puerta_or = max
puerta_xor = lambda x, y: 0 if x == y else 1
Al igual que las neuronas reales, las neuronas artificiales comienzan a volverse más interesantes cuando comenzamos a conectar muchas.
Redes neuronales de realimentación positiva (avance)
La topología del cerebro es enormemente complicada, por lo que es común aproximarla con una red neuronal de realimentación idealizada que consta de capas discretas de neuronas, cada uno conectado al siguiente. Esto normalmente implica una capa de entrada (que recibe entradas y las alimenta sin cambios), una o más "capas ocultas" (cada una de las cuales consta de neuronas que toman las salidas de la capa anterior, realizan algunos cálculos y pasan el resultado a la siguiente capa) y una capa de salida (que produce las salidas finales).
Al igual que el perceptrón, cada neurona (no las de entrada) tiene un peso correspondiente a cada una de sus entradas y un sesgo. Para simplificar nuestra representación, agregaremos el sesgo al final de nuestro vector ponderado y daremos a cada neurona una entrada de sesgo que siempre es igual a 1.
Al igual que con el perceptrón, para cada neurona resumiremos los productos de sus entradas y sus pesos. Pero aquí, en lugar de generar una función escalón, generaremos una aproximación suave de la función de paso. En particular, utilizaremos el sigmoide :
#Función sigmoide
def sigmoide(t):
return 1 / (1 + math.exp(-t))
¿Por qué utilizar un sigmoide en lugar de una función de escalón más simple? Para entrenar una red neuronal, necesitaremos utilizar cálculo diferencial, y para esto, necesitamos funciones derivables. La función de paso ni siquiera es continua y por tanto no es derivable, la función sigmoide es una buena aproximación derivable de la misma.
La función sigmoide, también se llama función logística. Técnicamente "sigmoide" se refiere a la forma de la función, "logística" a esta función en particular.
Luego calculamos la salida como:
def salida_neurona(pesos, entradas):
return sigmoide(punto(pesos, entradas))
Dada esta función, podemos representar una neurona simplemente como una lista de pesos cuya longitud es uno más que el número de entradas a esa neurona (debido al peso del sesgo). Entonces nosotros podemos representar una red neuronal como una lista de capas (sin entrada), donde cada capa es el número de neuronas en esa capa. Es decir, representaremos una red neuronal como una lista (capas) de listas (neuronas) de listas (pesos).
Dada tal representación, utilizaremos una red neuronal es bastante simple:
def red_secuencial(red_neuronal, vector_entrada):
"""toma una red neuronal
(representada como una lista
de listas de listas de pesos)
y devuelve la salida desde la
entrada propagada hacia adelante"""
salidas = []
# procesa una capa cada vez
for capa in red_neuronal:
entrada_con_sesgo
=
vector_entrada + [1] # añade el sesgo de entrada
salida = [salida_neurona(neurona,
entrada_con_sesgo) # calcula la salida
for neurona in capa] # para cada neurona en la capa
salidas.append(salida) # la recuerda
# entonces, la entrada a la siguiente capa es la salida de
cada una
vector_entrada = salida
return salidas
Ahora es fácil construir la puerta XOR que no podríamos construir con un solo perceptrón. Nosotros solo necesitamos escalar los pesos para que las salidas de cada neurona estén realmente cerca de 0 o muy cerca de 1:
red_xor = [# capa oculta
[[20, 20, -30], # neurona'and'
[20, 20, -10]], # neurona 'or'
# capa de salida
[[-60, 60, -30]]] # ' segunda entrada pero no primera entrada en una neurona
for x in [0, 1]:
for y in [0, 1]:
# red_secuencial produce las salidas de
cada neurona
# red_secuencial[-1] son las salidas de
las neuronas de las capas de salida
# print (x, y, red_secuencial(red_xor,[x,
y])[-1]) Esta línea no funciona, si alguien nos puede ayudar...
print (x, y)
# 0 0 [9.38314668300676e-14]
# 0 1 [0.9999999999999059]
# 1 0 [0.9999999999999059]
# 1 1 [9.383146683006828e-14]
El print nos da error, así que lo hemos dejado en un print más sencillo, si alguien sabe como evitar dicho error, que lo indique.
Al utilizar una segunda capa (capa oculta), podemos alimentar la entrada de una neurona "y" y la entrada de una neurona "o" con la salida de la neurona “y” lo que la convierte en en una neurona de "segunda capa o capa oculta”. El resultado es una red que realiza "o, pero no y", que es precisamente XOR
Por lo general, no construimos redes neuronales a mano. Esto se debe en parte a que las utilizamos para resolver problemas mucho mayores: un problema de reconocimiento de imágenes puede involucrar cientos o miles de neuronas. Y es en parte porque normalmente no podemos "razonar" lo que deberían hacer todas y cada una de estas neuronas. En vez de eso, “entrenamos” la red con datos. Un enfoque popular es un algoritmo llamado retropropagación que tiene similitudes con el algoritmo de descenso de gradiente.
Supongamos que tenemos un conjunto de entrenamiento que consta de vectores de entrada y el resultado correspondiente de vectores de salida. Por ejemplo, en nuestro ejemplo anterior, la red XOR, el vector de entrada [1, 0] correspondía a la salida de destino [1]. Imaginemos que nuestra red tiene un conjunto de pesos. Luego ajustamos los pesos usando el siguiente algoritmo:
Ejecutamos el algoritmo de realimentación positiva feed_forward en un vector de entrada para producir las salidas de todas las neuronas en la red.
Esto da como resultado un error para cada neurona de salida: la diferencia entre su salida y su objetivo.
Calculamos el gradiente de este error en función de los pesos de las neuronas y ajustamos sus pesos en la dirección que más disminuye el error.
"Propagamos" estos errores de salida hacia atrás para inferir errores para la capa oculta.
Calculamos los gradientes de estos errores y ajustamos los pesos de la capa oculta de la misma manera.
Por lo general, ejecutamos este algoritmo muchas veces para todo nuestro conjunto de entrenamiento hasta que la red converge:
def retropropagacion(red, vector_entrada, objetivos):
salidas_ocultas, salidas = red_secuencial(red, vector_entrada)
# la salida * (1 - salida) es de la derivada o sigmoide
salidas_incrementales = [salida * (1 - salida) * (salida - objetivo)
for salida, objetivo in zip(salidas, objetivos)]
# ajustamos los pesos para la capa de salida, una neurona cada vez
for i,
neurona_de_salida in enumerate(red[-1]):
# nos centramos en la i ésima salida de la capa neuronal
for j, salida_oculta in enumerate(salidas_ocultas + [1]):
# ajustamos el j ésimo peso basado en ambas:
# el incremental de la neurona y su j ésima entrada
neurona_de_salida[j] -=
salidas_incrementale[i] * salida_oculta
# propagamos hacia atrás los errores de la capa oculta
incrementales_ocultas = [salida_oculta * (1 - salida_oculta) *
dot(salidas_incrementales
, [n[i] for n in capa_de_salida])
for i, salida_oculta in enumerate(salidas_ocultas)]
# ajustamos los pesos de la capa oculta, una neurona cada vez
for i, neurona_oculta in enumerate(red[0]):
for j, input in enumerate(vector_entrada + [1]):
neurona_oculta[j] -=
incrementales_ocultas[i] * input
Esto es prácticamente lo mismo que si escribiéramos explícitamente el error al cuadrado como una función de los pesos y usáremos la función minimo_estocastico.
En este caso, escribir explícitamente la función de gradiente resulta ser una molestia. Si conocemos el cálculo y la regla de la cadena, los detalles matemáticos son relativamente sencillos, pero manteniendo la notación correcta ("la derivada parcial de la función de error con respecto al peso que la neurona i asigna a la entrada procedente de la neurona j ”).
