Redes Neuronales

Universidad de Sevilla Dpto.
de Ciencias de la Computación e Inteligencia Artificial
Redes neuronales
Una red neuronal con alimentación hacia adelante (feedforward neural network, en
inglés), es un modelo de regresión para aprendizaje supervisado a partir de atributos
numéricos. Como tal implementa una función 𝑓: ℝ𝑚 → ℝ𝑛 , cuyos argumentos 𝑥1 , … , 𝑥𝑚
son atributos numéricos.
Ejemplo del dominio:

Dominio de (𝑥1 , … , 𝑥𝑚 ) ∈ ℝ𝑚 Red Salida de la red:
la tarea neuronal 𝑓(𝑥1 , … , 𝑥𝑚 ) ∈ ℝ𝑛
Las redes neuronales se inspiran en la estructura y funcionamiento del cerebro, aun-

que no son un modelo de este. Un cerebro humano se compone de un enorme número
de neuronas (se estima que contiene unos ochenta mil millones, 8 × 1010 , de neuronas),
aunque aún más importante que la cantidad es el hecho de que estas neuronas se inter-
conectan entre sí. De esta forma, a través de estas interconexiones una neurona puede
enviar información (en forma de señales eléctricas) a otras neuronas a las que esté co-
nectada. Estas neuronas, a su vez, propagarán esa información a otras neuronas, y así
sucesivamente.
De manera análoga, las redes neuronales se construyen a partir de unas unidades
básicas, que llamaremos neuronas artificiales, organizadas en capas. De esta forma, la
red neuronal calcula la función 𝑓 como la composición de las funciones 𝑓 𝑖 : ℝ𝑛𝑖−1 → ℝ𝑛𝑖
calculadas en cada capa:
ℝ𝑚 ℝ𝑛1 ℝ𝑛2 ℝ𝑛𝑘−1 ℝ𝑛

𝑓1 𝑓2 𝑓𝑘
𝑓(𝑥1 , … , 𝑥𝑚 ) = 𝑓𝑘 (… 𝑓2 (𝑓1 (𝑥1 , … , 𝑥𝑚 )))
Es habitual representar las redes neuronales como un grafo acíclico en el que los
nodos son las neuronas artificiales y las aristas conectan todas las neuronas de cada capa
con cada una de las neuronas de la capa siguiente. Suele incluirse una primera capa, de
entrada, que no calcula nada, sino que simplemente proporciona a la siguiente capa los
argumentos de la función. La última capa, de salida, es la que proporciona el resultado
de la función. El resto de capas, entre la capa de entrada y la de salida, se llaman capas
ocultas, ya que los resultados proporcionados por esas capas no son observables por un
observador externo.
1 de 22
Dpto. de Ciencias de la Computación e Inteligencia Artificial Universidad de Sevilla
Ejemplo: Representación gráfica de una red neuronal
Capa de Capa Capa Capa de

entrada oculta oculta salida
𝑥1
𝑥2
𝑥3
Esta red neuronal tiene una capa de entrada con tres neuronas, dos capas ocul-
tas con cuatro y tres neuronas, respectivamente, y una capa de salida con dos neu-
ronas:
La primera capa oculta define una función 𝑓1 : ℝ3 → ℝ4 dada por
𝑓1 (𝑥1 , 𝑥2 , 𝑥3 ) = (𝑎11 , 𝑎12 , 𝑎13 , 𝑎14 )
donde cada 𝑎1𝑖 es la salida de la neurona 𝑖-ésima de la capa, calculada a partir

de los argumentos 𝑥1 , 𝑥2 , 𝑥3 .
La segunda capa oculta define una función 𝑓2 : ℝ4 → ℝ3 dada por
𝑓2 (𝑎11 , 𝑎12 , 𝑎13 , 𝑎14 ) = (𝑎21 , 𝑎22 , 𝑎23 )

de los argumentos 𝑎11 , 𝑎12 , 𝑎13 , 𝑎14 .
La capa de salida define una función 𝑓3 : ℝ3 → ℝ2 dada por
𝑓3 (𝑎21 , 𝑎22 , 𝑎23 ) = (𝑎31 , 𝑎32 )

de los argumentos 𝑎21 , 𝑎22 , 𝑎23 .
La red neuronal define, por tanto, una función 𝑓: ℝ3 → ℝ2 dada por
𝑓(𝑥1 , 𝑥2 , 𝑥3 ) = 𝑓3 (𝑓2 (𝑓1 (𝑥1 , 𝑥2 , 𝑥3 )))
Un perceptrón es un tipo de neurona artificial que para cada entrada proporciona

como salida 0 o 1. Es posible, por tanto, usarlo como modelo para tareas de clasificación
binaria, identificando por ejemplo la salida 1 con la clase positiva y la salida 0 con la clase
negativa.
2 de 22
Universidad de Sevilla Dpto. de Ciencias de la Computación e Inteligencia Artificial
Dados los argumentos 𝑥1 , … , 𝑥𝑚 , la salida del perceptrón se calcula como sigue:
𝑚
1 si ∑𝑖=1 𝑤𝑖 ⁢𝑥𝑖 + 𝑏 > 0,
𝑎={ 𝑚
0 si ∑𝑖=1 𝑤𝑖 ⁢𝑥𝑖 + 𝑏 ≤ 0.
1 si 𝒘 T ⁢𝒙 + 𝑏 > 0,
={
0 si 𝒘 T ⁢𝒙 + 𝑏 ≤ 0.
= umbral(𝑧)
donde 𝒙 es el vector de los argumentos, 𝒘 es el vector de pesos asociados a los argu-

mentos, 𝑏 es el sesgo de activación, 𝑧 = 𝒘⁢𝒙 + 𝑏 es la entrada del perceptrón y umbral es
la función de activación, definida como
1 si 𝑧 > 0,
umbral(𝑧) ≝ {
0 si 𝑧 ≤ 0.
En el campo del álgebra matricial, los vectores se consideran como matrices co-
lumna. Por economía de espacio, en el documento escribimos los vectores como
T 𝑣1
𝒗 = (𝑣1 … 𝑣𝑚 ) en lugar de 𝒗 = ( 𝑣⋮ ) , donde T denota la operación de trasposición.
𝑚
De esta forma,
𝑥1 𝑚
T T T
𝒙 = (𝑥1 … 𝑥𝑚 ) 𝒘 = (𝑤1 … 𝑤𝑚 ) ⁢ = (𝑤1 … 𝑤𝑚 ) ⁢ ( ⋮ ) = ∑ 𝑤𝑖 ⁢𝑥𝑖
𝒘 𝒙
𝑥𝑚 𝑖=1
También es posible usar como función de activación la función signo:
1 si 𝑧 > 0,
signo(𝑧) ≝ {
−1 si 𝑧 ≤ 0.
en cuyo caso el perceptrón para cada entrada proporcionará como salida −1 o 1.
Ejemplo: Cálculo de la función lógica NOT mediante un perceptrón
El perceptrón con argumento 𝑥1 , peso asociado al argumento 𝑤1 = −1 y sesgo 𝑏 = 1

calcula la función lógica NOT.
En efecto:
Para 𝑥1 = 0 se tiene que 𝑧 = 𝑤1 ⁢𝑥1 + 𝑏 = 1, por lo que la salida del perceptrón

es 𝑎 = umbral(𝑧) = 1.
Para 𝑥1 = 1 se tiene que 𝑧 = 𝑤1 ⁢𝑥1 + 𝑏 = 0, por lo que la salida del perceptrón

es 𝑎 = umbral(𝑧) = 0.
3 de 22
Ejemplo: Cálculo de la función lógica AND mediante un perceptrón
El perceptrón con argumentos 𝑥1 , 𝑥2 , pesos asociados a los argumentos 𝑤1 = 𝑤2 = 1

y sesgo 𝑏 = −1 calcula la función lógica AND.
En efecto:
Para 𝑥1 = 0 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 + 𝑏 = −1, por lo que la salida

del perceptrón es 𝑎 = umbral(𝑧) = 0.
Para 𝑥1 = 0 y 𝑥2 = 1 se tiene que 𝑧 = 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 + 𝑏 = 0, por lo que la salida



El sesgo 𝑏 establece con qué facilidad se activa el perceptrón. A mayor valor de 𝑏,

mayor valor de 𝑧 y, en consecuencia, más fácil es obtener 𝑎 = 1 como salida. Por el
contrario, a menor valor de 𝑏, menor valor de 𝑧 y, en consecuencia, más difícil es obtener
𝑎 = 1 como salida.
La inclusión del sesgo facilita el entrenamiento del perceptrón. En efecto, puesto que
para clasificar un ejemplo (𝑥1 , … , 𝑥𝑛 ) calcula una combinación lineal de esos argumentos,
el resultado final es que el perceptrón establece el hiperplano definido por la ecuación
𝑚
∑𝑖=1 𝑤𝑖 ⁢𝑥𝑖 + 𝑏 = 0 como frontera entre los ejemplos positivos y los negativos. Si no se
incluyera el sesgo, esa frontera siempre incluiría el punto (0, … , 0) y se dificultaría la tarea
de clasificación correspondiente.
Para simplificar la notación, es habitual considerar un argumento virtual 𝑥0 = 1 con
𝑚
peso asociado 𝑤0 = 𝑏. De esta forma, podemos escribir 𝑧 = ∑𝑖=0 𝑤𝑖 ⁢𝑥𝑖 . La función definida
por el perceptrón es, entonces, 𝑓 = 𝑓(𝒙; 𝒘), donde los pesos 𝑤0 , … , 𝑤𝑚 son los parámetros
que debe aprender el modelo.
Un perceptrón se entrena mediante aprendizaje supervisado. Dado un conjunto de
ejemplos de entrenamiento, para cada uno de ellos se compara la salida correcta con la
salida proporcionada por el perceptrón, actualizando el valor de los pesos en el sentido
que disminuya el error cometido.
1 Inicializar los pesos aleatoriamente

2 Repetir hasta que se cumpla la condición de terminación
3 Para cada ejemplo de entrenamiento
4 Si la salida del perceptrón es incorrecta entonces
5 Actualizar los pesos
6 Devolver los pesos
Si (𝑥1 , … , 𝑥𝑚 , 𝑦) es un ejemplo de entrenamiento con salida 𝑎 incorrecta, entonces los

pesos se actualizan así:
𝑤𝑖 ← 𝑤𝑖 + η⁢(𝑦 − 𝑎)⁢𝑥𝑖 , para cada 𝑖 = 0, … , 𝑚
4 de 22
donde el hiperparámetro η > 0 es el factor de aprendizaje.

Un perceptrón solo es capaz de clasificar correctamente un conjunto de ejemplos si
este es linealmente separable (es decir, los ejemplos positivos estén separados de los
negativos por un hiperplano). Por un lado, la condición es necesaria, ya que el percep-
trón establece un hiperplano como frontera de clasificación. Por otro lado, el siguiente
resultado establece que la condición es suficiente.
Teorema (Minsky y Papert, 1969)

Si 𝒟 es un conjunto de ejemplos linealmente separable y η es un factor de aprendizaje
suficientemente pequeño, entonces el algoritmo de entrenamiento del perceptrón conver-
ge en un número finito de pasos a un vector de pesos tal que todos los ejemplos de 𝒟 se
clasifican correctamente.
Por lo tanto, si se cumplen las condiciones del teorema se puede establecer como
condición de terminación del algoritmo de entrenamiento del perceptrón el que todos
los ejemplos se clasifiquen correctamente.
Ejemplo: Entrenamiento de un perceptrón para que calcule la función lógica OR
El conjunto de entrenamiento es linealmente separable ( representa un ejemplo

con 𝑦 = 0 y representa un ejemplo con 𝑦 = 1):
𝑥2
𝑥1 𝑥2 𝑦 1
0 0 0
0 1 1
1 0 1
1 1 1
0 1 𝑥1
Supongamos 𝑤0 = 0.1, 𝑤1 = −0.1 y 𝑤2 = 0.1 como pesos iniciales y η = 0.1 como

factor de aprendizaje.
Para 𝑥1 = 0 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.1, por lo que la
salida del perceptrón es 𝑎 = umbral(𝑧) = 1, que es incorrecta.
Los pesos se actualizan como sigue:
𝑤0 ← 𝑤0 + η⁢(0 − 1)⁢1 = 0.1 − 0.1 = 0
𝑤1 ← 𝑤1 + η⁢(0 − 1)⁢𝑥1 = −0.1 − 0 = −0.1
𝑤2 ← 𝑤2 + η⁢(0 − 1)⁢𝑥2 = 0.1 − 0 = 0.1

salida del perceptrón es 𝑎 = umbral(𝑧) = 1, que es correcta.
Para 𝑥1 = 1 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = −0.1, por lo que la
5 de 22
𝑤0 ← 𝑤0 + η⁢(1 − 0)⁢1 = 0 + 0.1 = 0.1

𝑤1 ← 𝑤1 + η⁢(1 − 0)⁢𝑥1 = −0.1 + 0.1 = 0
𝑤2 ← 𝑤2 + η⁢(1 − 0)⁢𝑥2 = 0.1 + 0 = 0.1


𝑤0 ← 𝑤0 + η⁢(0 − 1)⁢1 = 0.1 − 0.1 = 0

𝑤1 ← 𝑤1 + η⁢(0 − 1)⁢𝑥1 = 0 − 0 = 0
𝑤2 ← 𝑤2 + η⁢(0 − 1)⁢𝑥2 = 0.1 − 0 = 0.1

Para 𝑥1 = 1 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0, por lo que la

𝑤0 ← 𝑤0 + η⁢(1 − 0)⁢1 = 0 + 0.1 = 0.1

𝑤1 ← 𝑤1 + η⁢(1 − 0)⁢𝑥1 = 0 + 0.1 = 0.1
𝑤2 ← 𝑤2 + η⁢(1 − 0)⁢𝑥2 = 0.1 + 0 = 0.1


𝑤0 ← 𝑤0 + η⁢(0 − 1)⁢1 = 0.1 − 0.1 = 0

𝑤1 ← 𝑤1 + η⁢(0 − 1)⁢𝑥1 = 0.1 − 0 = 0.1
𝑤2 ← 𝑤2 + η⁢(0 − 1)⁢𝑥2 = 0.1 − 0 = 0.1


6 de 22


Por lo tanto, el algoritmo proporciona un perceptrón con pesos 𝑤0 = 0, 𝑤1 = 0.1

y 𝑤2 = 0.1 que clasifica correctamente todos los ejemplos del conjunto de entrena-
miento.
Un ejemplo clásico de conjunto de ejemplos no linealmente separable es el que se

tiene para la función lógica XOR (disyunción exclusiva). Un perceptrón no puede, en con-
secuencia, aprender correctamente este conjunto de ejemplos en su totalidad.
Ejemplo: No separabilidad lineal de la función XOR
El conjunto de entrenamiento no es linealmente separable ( representa un ejemplo

con 𝑦 = 0 y representa un ejemplo con 𝑦 = 1):
𝑥2
𝑥1 𝑥2 𝑦 1
0 0 0
0 1 1
1 0 1
1 1 0
0 1 𝑥1
Queda patente, pues, que los perceptrones tienen una capacidad expresiva limitada,
lo que lleva a la necesidad de construir redes multicapas de perceptrones que, mediante
la combinación de más de una de esas unidades, proporcionen mayor capacidad expre-
siva.
Ejemplo: Cálculo de la función lógica XOR mediante una red multicapa de percep-
trones
Capa de Capa Capa de

entrada oculta salida
1 1
0 0
−1
𝑥1 1 1
1 −1
1
𝑥2 1
7 de 22
La entrada del primer perceptrón de la capa oculta es 𝑧 = 𝑥1 + 𝑥2 , luego solo

se activa cuando alguno de los dos argumentos, o ambos, tiene el valor 1. La
salida de este perceptrón es 𝑎11 = 1 en ese caso y 𝑎11 = 0 en caso contrario.
La entrada del segundo perceptrón de la capa oculta es 𝑧 = 𝑥1 + 𝑥2 − 1, luego

solo se activa cuando ambos argumentos tienen el valor 1. La salida de este
perceptrón es 𝑎12 = 1 en ese caso y 𝑎12 = 0 en caso contrario.
La entrada del perceptrón de la capa de salida es 𝑧 = 𝑎11 − 𝑎12 , luego solo se

activa cuando se ha activado el primer perceptrón de la capa oculta, pero no
el segundo. Es decir, cuando alguno de los dos argumentos, pero no ambos,
tiene el valor 1.
Para poder concebir un algoritmo de entrenamiento para las redes neuronales, nos
interesa que un cambio pequeño en los pesos produzca un cambio pequeño en la salida
de la función implementada por la red. Esto no ocurre si la red está formada por percep-
trones. Una manera de superar este problema es cambiar la función de activación por una
función que pase del valor 0 al valor 1 de una forma más suave que la función umbral (y,
como veremos más adelante, también interesa que sea diferenciable). Se tiene entonces
lo que conocemos propiamente como neurona artificial.
Una opción habitual es usar como función de activación la función sigmoide
1
σ(𝑧) ≝
1 + e−𝑧
cuya gráfica podemos comparar con la de la función umbral:
umbral sigmoide
1 1
0.8 0.8
0.6 0.6
0.4 0.4
0.2 0.2
0 0
−4 −2 0 2 4 −4 −2 0 2 4
Esta función tiene la propiedad de que σ′ (𝑧) = σ(𝑧)⁢(1 − σ(𝑧)).

Otras funciones de activación que también se suelen utilizar son la función tangente
hiperbólica o la función rectificador (una neurona artificial que use esta última como
8 de 22
función de activación se conoce como unidad lineal rectificada, ReLU):
e𝑧 − e−𝑧 ′
tanh(𝑧) ≝ tanh (𝑧) = 1 − tanh(𝑧)2
e𝑧 + e−𝑧
′ 0 si 𝑧 ≤ 0,
́
rectificador(𝑧) ≝ max(0, 𝑧) rectificador (𝑧) = {
1 si 𝑧 > 0.
tangente hiperbólica rectificador
1 4
0.5 3
0 2
−0.5 1
−1 0
−4 −2 0 2 4 −4 −2 0 2 4
En realidad, la función rectificador no es derivable en 𝑧 = 0, pero en una imple-

mentación práctica nunca se va a necesitar para ese valor, por lo que la derivada
se puede definir con un valor arbitrario, en este caso el 0.
De hecho, aunque las primeras funciones de activación que se estudiaron fueron la

sigmoide y la tangente hiperbólica, en la actualidad se recomienda utilizar ReLUs en las
capas ocultas de las redes neuronales.
Una neurona artificial usando como función de activación cualquiera de estas fun-
ciones se convierte en un modelo de regresión, ya que la salida se transforma en una
variable continua con valores en un cierto intervalo ([0, 1] para la sigmoide, [−1, 1] para
la tangente hiperbólica y [0, +∞] para la función rectificador). Para volver a convertir a la
neurona artificial en un modelo de clasificación binaria basta discretizar la salida fijando
un determinado umbral 𝑢: los ejemplos para los que la salida es mayor que 𝑢 se clasifican
como positivos y los ejemplos para los que la salida es menor o igual que 𝑢 como nega-
tivos. No obstante, la neurona artificial seguiría separando los ejemplos positivos de los
negativos mediante un hiperplano. Por ejemplo, para la función de activación sigmoide,
σ(𝒘 T ⁢𝒙) > 𝑢 ⇔ 𝒘 T ⁢𝒙 > σ−1 (𝑢)
El entrenamiento de una neurona artificial, como modelo de regresión, se realiza mi-

nimizando una función de pérdida o coste (loss o cost function, en inglés) mediante el
método del descenso por el gradiente, que en su forma genérica consiste en lo siguiente:
Supongamos una función de coste 𝐶(𝑣1 , … , 𝑣𝑛 ).
9 de 22
Si los argumentos cambian en una pequeña cantidad, ∆𝑣1 , … , ∆𝑣𝑛 , entonces la teo-
ría del cálculo infinitesimal nos dice que el valor de 𝐶 cambia aproximadamente
como
∆𝐶 = 𝐶(𝑣1 + ∆𝑣1 , … , 𝑣𝑛 + ∆𝑣𝑛 ) − 𝐶(𝑣1 , … , 𝑣𝑛 )

∂𝐶 ∂𝐶
≅ (𝑣1 , … , 𝑣𝑛 )⁢∆𝑣1 + ⋯ + (𝑣 , … , 𝑣𝑛 )⁢∆𝑣𝑛 (*)
∂𝑣1 ∂𝑣𝑛 1
= 𝛁𝐶 T ⁢𝚫𝒗
T
∂𝐶 ∂𝐶
donde 𝛁𝐶 = ( (𝑣1 , … , 𝑣𝑛 ), … , (𝑣1 , … , 𝑣𝑛 )) es el gradiente de 𝐶 en (𝑣1 , … , 𝑣𝑛 ) y
∂𝑣1 ∂𝑣𝑛
T
𝚫𝒗 = (∆𝑣1 , … , ∆𝑣𝑛 ) .
Una condición suficiente para conseguir que ∆𝐶 ≤ 0, es decir, que el valor de 𝐶
disminuya (o, al menos, que no aumente) es elegir
𝚫𝒗 = −η⁢𝛁𝐶
donde η > 0 es el factor de aprendizaje.

En efecto, en ese caso se tiene
2 2
∂𝐶 ∂𝐶
∆𝐶 ≅ 𝛁𝐶 T ⁢𝚫𝒗 = −η⁢𝛁𝐶 T ⁢𝛁𝐶 = −η⁢(( (𝑣1 , … , 𝑣𝑛 )) + ⋯ + ( (𝑣 , … , 𝑣𝑛 )) )
∂𝑣1 ∂𝑣𝑛 1
De hecho, se puede demostrar que −𝛁𝐶 proporciona la dirección en la que se ob-

tiene el mayor decremento de 𝐶.
El método del descenso por el gradiente para un modelo de regresión realiza dos
asunciones acerca de la función de coste:
El coste 𝐶(𝒙,𝑦) para cada ejemplo únicamente depende de la salida del modelo para
ese ejemplo y, por tanto, se puede entender como una función de los parámetros
del modelo.
El coste total se calcula como el promedio de los costes para cada ejemplo del
1
conjunto de entrenamiento: 𝐶 = ⁢ ∑(𝒙,𝑦)∈𝒟 𝐶(𝒙,𝑦) .
|𝒟|
El algoritmo para entrenar una neurona artificial mediante descenso por el gradiente
es, entonces, el siguiente:

3 Actualizar los pesos en la dirección −𝛁𝐶
donde cada peso 𝑤𝑖 se actualiza así:

∂𝐶
𝑤𝑖 ← 𝑤𝑖 − η⁢
𝑤𝑖
10 de 22
Es decir,
η ∂𝐶(𝒙,𝑦)
𝑤𝑖 ← 𝑤𝑖 − ⁢ ∑
|𝒟| (𝒙,𝑦)∈𝒟 𝑤𝑖
Por ejemplo, en el caso de que la función de coste considerada fuera el error cuadrá-
tico medio
1 2
MSE = ⁢ ∑ (𝑦 − 𝑎𝒙 )
|𝒟| (𝒙,𝑦)∈𝒟
donde 𝒘 son los pesos, 𝑔 la función de activación y 𝑎𝒙 = 𝑔(𝒘 T ⁢𝒙) la salida de la neurona
para 𝒙, entonces
2⁢η
𝑤𝑖 ← 𝑤𝑖 − ⁢ ∑ (𝑦 − 𝑎𝒙 )⁢(−𝑔′ (𝒘 T ⁢𝒙))⁢𝑥𝑖
|𝒟| (𝒙,𝑦)∈𝒟
A la hora de aplicar el algoritmo para entrenar una neurona artificial debe tenerse en
cuenta lo siguiente:
La función de activación de la neurona artificial debe ser diferenciable.
El factor de aprendizaje debe ser lo suficientemente pequeño para que se cumpla

la aproximación (*), pero suficientemente grande para que el algoritmo no minimice
la función de coste con demasiada lentitud.
Ejemplo: Entrenamiento de una neurona artificial
𝑥1 𝑥2 𝑦
0 0 0
0 1 1
1 0 1
1 1 1
Supongamos la función sigmoide σ como función de activación y MSE como

función de coste. En este caso, la salida de la neurona para un vector de argu-
mentos 𝒙 es 𝑎𝒙 = σ(𝒘 T ⁢𝒙) y, por las propiedades de σ, se tiene que σ′ (𝒘 T ⁢𝒙) =
σ(𝒘 T ⁢𝒙)⁢(1 − σ(𝒘 T ⁢𝒙)) = 𝑎𝒙 ⁢(1 − 𝑎𝒙 ). Por lo tanto, la actualización de los pesos es
2⁢η
𝑤𝑖 ← 𝑤𝑖 − ⁢ ∑ (𝑎 − 𝑦)⁢𝑎𝒙 ⁢(1 − 𝑎𝒙 )⁢𝑥𝑖
|𝒟| (𝒙,𝑦)∈𝒟 𝒙
Tomando 𝑤0 = 0.1, 𝑤1 = −0.1 y 𝑤2 = 0.1 como pesos iniciales y η = 0.1 como

factor de aprendizaje, la primera actualización de los pesos sería:

salida del perceptrón es 𝑎(0,0) = σ(𝑧) ≅ 0.525.

11 de 22

salida del perceptrón es 𝑎(1,0) = σ(𝑧) = 0.5.

El peso 𝑤0 se actualiza como sigue:

0.2
𝑤0 ← 0.1 − ⁢((0.525 − 0)⁢0.525⁢(1 − 0.525)⁢1+
4
(0.55 − 1)⁢0.55⁢(1 − 0.55)⁢1+
(0.5 − 1)⁢0.5⁢(1 − 0.5)⁢1+
(0.525 − 1)⁢0.525⁢(1 − 0.525)⁢1)
≅ 0.111

0.2
𝑤1 ← −0.1 − ⁢((0.525 − 0)⁢0.525⁢(1 − 0.525)⁢0+
4
(0.55 − 1)⁢0.55⁢(1 − 0.55)⁢0+
(0.5 − 1)⁢0.5⁢(1 − 0.5)⁢1+
(0.525 − 1)⁢0.525⁢(1 − 0.525)⁢1)
≅ −0.088

0.2
𝑤2 ← 0.1 − ⁢((0.525 − 0)⁢0.525⁢(1 − 0.525)⁢0+
4
(0.55 − 1)⁢0.55⁢(1 − 0.55)⁢1+
(0.5 − 1)⁢0.5⁢(1 − 0.5)⁢0+
(0.525 − 1)⁢0.525⁢(1 − 0.525)⁢1)
≅ 0.111
El algoritmo continuaría actualizando los pesos de la misma manera, hasta que se

cumpla la condición de terminación como pueden ser, por ejemplo, que se haya
realizado un cierto número de actualizaciones de los pesos o que el valor de la
función de coste se halle por debajo de un cierto umbral.
Nótese como, en nuestro ejemplo, el error cuadrático medio cometido por la
neurona artificial se ha reducido.
Con los valores iniciales de los pesos, el error es

1
MSE ≅ (⁢ (0 − 0.525)2 + (1 − 0.55)2 + (1 − 0.5)2 + (1 − 0.525)2 ) ≅ 0.238
4
Tras la primera actualización de los pesos,
12 de 22
• Para 𝑥1 = 0 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.111, por lo

que la salida del perceptrón es 𝑎(0,0) = σ(𝑧) ≅ 0.528.
que la salida del perceptrón es 𝑎(1,0) = σ(𝑧) = 0.506.
• El error es
1
MSE ≅ (⁢ (0 − 0.528)2 + (1 − 0.555)2 + (1 − 0.506)2 + (1 − 0.533)2 ) ≅ 0.235
4
El algoritmo de descenso por el gradiente se usa también para entrenar las redes
neuronales genéricas. En este caso, una aplicación directa de la regla de la cadena para
calcular las derivadas parciales de la función de coste respecto a los pesos sería compu-
tacionalmente ineficiente. El algoritmo de retropropagación (backpropagation, en inglés)
calcula estas derivadas de manera eficiente, evitando repetir cálculos.
Para una mejor descripción de este algoritmo, se introducen las siguientes notaciones:
𝐿 es la cantidad de capas de la red neuronal, a las cuales numeramos de 1 a 𝐿.
𝑛𝑙 es la cantidad de neuronas en la capa 𝑙, a las cuales numeramos de 1 a 𝑛𝑙 .
𝑙
𝑤𝑗←𝑘 es el peso de la conexión entre la neurona 𝑘 en la capa 𝑙 − 1 y la neurona 𝑗 en
la capa 𝑙.
𝑧𝑗𝑙 y 𝑎𝑗𝑙 son la entrada y la salida, respectivamente, de la neurona 𝑗 en la capa 𝑙.
Consideramos que cada capa tiene una neurona 0 con 𝑎𝑙0 = 1. Entonces 𝑤j←0
𝑙
es el
sesgo de la neurona 𝑗 en la capa 𝑙.
T T
Dados dos vectores de la misma dimensión, 𝒗1 = (𝑣11 , … , 𝑣𝑛1 ) y 𝒗2 = (𝑣12 , … , 𝑣𝑛2 ) , el
T
producto de Hadamard es 𝒗1 ⊙ 𝒗2 = (𝑣11 ⁢𝑣12 , … , 𝑣𝑛1 ⁢𝑣𝑛2 ) .
Si 𝑔𝑗𝑙 es la función de activación de la neurona 𝑗 en la capa 𝑙, entonces
𝑛𝑙−1
𝑧𝑗𝑙 𝑙
= ∑ 𝑤𝑗←𝑘 ⁢𝑎𝑙−1 𝑙
𝑘 + 𝑤𝑗←0 y 𝑎𝑗𝑙 = 𝑔𝑗𝑙 (𝑧𝑗𝑙 )
𝑘=1
Es habitual que todas las neuronas en una misma capa usen la misma función de ac-
tivación 𝑔𝑙 . Podemos entonces calcular las salidas de las neuronas mediante operaciones
matriciales:
𝒛𝑙 = 𝑾 𝑙 ⁢𝒂𝑙−1 + 𝒘0𝑙 y 𝒂𝑙 = 𝑔𝑙 (𝒛𝑙 )
𝑙
𝑤1←1 … 𝑤𝑙
T 𝑙−1
donde 𝒛𝑙 = (𝑧1𝑙 , … , 𝑧𝑛𝑙 𝑙 ) es el vector de entradas de la capa 𝑙, 𝑾 𝑙 = ( … …
𝑙 𝑙
1←𝑛
… ) la
𝑤 𝑙 … 𝑤 𝑙 𝑙−1
𝑛 ←1 𝑛 ←𝑛
T T
matriz de pesos, 𝒂𝑙 = (𝑎𝑙1 , … , 𝑎𝑙𝑛𝑙 ) el vector de salidas, 𝒘0𝑙 = 𝑙
(𝑤1←0 , … , 𝑤𝑛𝑙 𝑙←0 ) el vector
13 de 22
de sesgos y 𝑔𝑙 la consideramos una función vectorizada (es decir, que aplicada a un vector
se aplica elemento a elemento de ese vector).
∂𝐶
El error Δ𝑗𝑙 de la neurona 𝑗 en la capa 𝑙 es Δ𝑗𝑙 ≝ 𝑙 . Aplicando convenientemente la
∂𝑧𝑗
regla de la cadena se llega a
′
𝚫𝐿 = 𝛁𝒂𝐿 𝐶 ⊙ (𝑔𝐿 ) (𝒛𝐿 )
T ′
𝚫𝑙 = ((𝑾 𝑙+1 ) ⁢𝚫𝑙+1 ) ⊙ (𝑔𝑙 ) (𝒛𝑙 ), para 𝑙 = 2, … , 𝐿 − 1
T T
∂𝐶 ∂𝐶 ∂𝐶 ∂𝐶
donde 𝚫 = (
𝑙
,…, ) y 𝛁𝒂𝐿 𝐶 = ( ,…, ) .
∂𝑧1𝑙 ∂𝑧𝑙 𝑙 ∂𝑎𝐿
1 ∂𝑎𝐿𝐿
𝑛 𝑛
∂𝐶
De nuevo aplicando la regla de la cadena se llega a 𝑙 𝑘 ⁢Δ𝑗 . Es decir, la compo-
= 𝑎𝑙−1 𝑙
∂𝑤𝑗←𝑘
nente de 𝛁𝐶 correspondiente al peso de una conexión entre dos neuronas es el producto
de la salida de la neurona de partida por el error de la neurona de llegada, lo que gráfi-
camente se puede representar como
∂𝐶
=
∂𝑤
𝑎desde × Δhasta
Estamos ya en condiciones de plantear el algoritmo de retropropagación (backpropa-

gation, en inglés).

3 Para cada ejemplo (𝒙, 𝒚) ∈ 𝒟 hacer
4 𝒂1 ← 𝒙
5 (Propagar salidas hacia delante) Para cada 𝑙 = 2, … , 𝐿 hacer
6 𝒛𝑙 ← 𝑾 𝑙 ⁢𝒂𝑙−1 + 𝒘0𝑙 y 𝒂𝑙 ← 𝑔𝑙 (𝒛𝑙 )
′
7 𝚫𝐿 ← 𝛁𝑎𝐿 𝐶 ⊙ (𝑔𝐿 ) (𝒛𝐿 )
8 (Propagar errores hacia atrás) Para cada 𝑙 = 𝐿 − 1, … , 2 hacer
T ′
9 𝚫𝑙 ← ((𝑾 𝑙+1 ) ⁢𝚫𝑙+1 ) ⊙ (𝑔𝑙 ) (𝒛𝑙 )
10 Para cada peso 𝑤𝑗←𝑘 𝑙
hacer
∂𝐶(𝒙,𝒚)
11 𝑙
← 𝑎𝑙−1 𝑙
𝑘 ⁢Δ𝑗
∂𝑤𝑗←𝑘
12 Para cada peso 𝑤𝑗←𝑘
𝑙
hacer
η ∂𝐶(𝒙,𝒚)
13 𝑙
𝑤𝑗←𝑘 𝑙
← 𝑤𝑗←𝑘 − ⁢ ∑(𝒙,𝒚)∈𝒟 𝑙
|𝒟| 𝑤𝑗←𝑘
Actualizar los pesos promediando el gradiente de 𝐶 sobre todos los ejemplos de en-
trenamiento es costoso. El método del descenso estocástico por el gradiente (stochastic
gradient descent, en inglés) aproxima el promedio a partir de un pequeño minilote (mi-
nibatch, en inglés) de ejemplos de entrenamiento elegidos aleatoriamente (es decir, un
14 de 22
suconjunto aleatorio del lote completo de ejemplos de entrenamiento). Cuando en el bu-

cle del algoritmo se han considerado todos los ejemplos se dice que ha transcurrido una
época (epoch, en inglés).
La elección de la capa de salida, de la función de activación en esa capa y de la función
de coste a minimizar para entrenar la red neuronal, es dependiente del problema que se
pretenda resolver. Habitualmente se suele realizar lo siguiente:
Para una tarea de regresión multisalida, es decir, en la que hay que predecir el valor
de 𝑛 atributos continuos, con 𝑛 ≥ 1:
• Se considera una capa de salida con 𝑛𝐿 = 𝑛 neuronas artificiales.
• Se establece como función de activación 𝑔𝐿 para la capa de salida la función
identidad. La salida de la red es, por lo tanto, 𝒂𝐿 = 𝑔𝐿 (𝒛𝐿 ) = 𝑾 𝐿 𝒂𝐿−1 + 𝒘0𝐿 y la
tarea se resuelve simplemente proporcionando esa tupla de valores.
• Se considera como función de coste el error cuadrático medio:
𝑛
1 2
⁢ ∑ (𝑦𝑘 − 𝑎𝐿𝑘 )
𝑛 𝑘=1
Nótese que, puesto que se compara la salida de la red con la respuesta correcta
y ambas son una tupla de 𝑛 valores, deben agregarse los errores cometidos
por cada neurona de salida. En este caso se ha elegido realizar esa agregación
mediante una media aritmética, aunque otra opción que se suele utilizar es
sumar esos errores individuales.
• El gradiente de la función de coste respecto de la salida de la red y el vector
de errores en la capa de salida son, entonces,
2 𝐿
𝛁𝒂𝐿 𝐶 = ⁢(𝒂 − 𝒚)
𝑛
2 𝐿
𝚫𝐿 = 𝛁𝒂𝐿 𝐶 ⊙ 𝟏 = ⁢(𝒂 − 𝒚)
𝑛
Para una tarea de clasificación binaria:
• Las dos posibles clases se codifican con 0 y 1.
• Se considera una capa de salida con 𝑛𝐿 = 1 neurona artificial.
sigmoide. La salida de la red es, por lo tanto, 𝑎𝐿 = 𝑔𝐿 (𝑧 𝐿 ) = σ(𝑾 𝐿 𝒂𝐿−1 + 𝑤0𝐿 ) y
la tarea se resuelve prefijando un umbral 𝑢 y proporcionando la clase 1 si 𝑎𝐿
supera ese umbral y 0 en caso contrario.
• Se considera como función de coste la entropía cruzada binaria:
−𝑦⁢ loge (𝑎𝐿 ) − (1 − 𝑦)⁢ loge (1 − 𝑎𝐿 )
• El gradiente de la función de coste respecto de la salida de la red y el error en
la capa de salida son, entonces,
𝑦 1−𝑦 𝑎𝐿 − 𝑦
∇𝑎𝐿 𝐶 = − + =
𝑎𝐿 1 − 𝑎𝐿 𝑎𝐿 ⁢(1 − 𝑎𝐿 )
Δ𝐿 = ∇𝑎𝐿 𝐶 × 𝑎𝐿 × (1 − 𝑎𝐿 ) = 𝑎𝐿 − 𝑦
15 de 22
Para una tarea de clasificación multiclase:

• Se realiza una codificación one-hot de las 𝑛 posibles clases.
• Se considera una capa de salida con 𝑛𝐿 = 𝑛 neuronas artificiales.
softmax
e𝑧1 e𝑧𝑛
softmax(𝑧1 , … , 𝑧𝑛 ) = ( 𝑛 ,…, 𝑛 )
∑𝑖=1 e𝑧𝑖 ∑𝑖=1 e𝑧𝑖
La salida de la red es, por lo tanto, 𝒂𝐿 = 𝑔𝐿 (𝒛𝐿 ) = softmax(𝑾 𝐿 𝒂𝐿−1 + 𝒘0𝐿 ) y la
tarea se resuelve proporcionando la clase arg max́ 𝑘=1,…,𝑛 (𝑎𝐿𝑘 ).
• Se considera como función de coste la entropía cruzada categórica:
𝑛
− ∑ 𝑦𝑘 ⁢ loge (𝑎𝐿𝑘 )
𝑘=1
• El gradiente de la función de coste respecto de la salida de la red y el vector

de errores en la capa de salida son, entonces,
𝒚
𝛁𝒂𝐿 𝐶 = −
𝒂𝐿
𝑎𝐿1 ⁢(1 − 𝑎𝐿1 ) −𝑎𝐿1 ⁢𝑎𝐿2 … −𝑎𝐿1 ⁢𝑎𝐿𝑛
𝚫𝐿 = 𝛁𝒂𝐿 𝐶 × ( .................. ) = 𝒂𝐿 − 𝒚
−𝑎𝐿𝑛 ⁢𝑎𝐿1 −𝑎𝐿𝑛 ⁢𝑎𝐿2 … 𝑎𝐿𝑛 ⁢(1 − 𝑎𝐿𝑛 )
La regla de la cadena establece, de forma general, que

𝑛
∂𝐶 ∂𝐶 ∂𝑎𝐿𝑘
Δ𝑗𝐿 = = ∑ ⁢
∂𝑧𝑗𝐿 𝑘=1 ∂𝑎𝐿𝑘 ∂𝑧𝑗𝐿
Es decir,
1 ∂𝑎𝐿 1∂𝑎𝐿
⎛ ∂𝑧𝐿 … ∂𝑧𝑛𝐿 ⎞
1
𝚫𝐿 = 𝛁𝒂𝐿 𝐶 × ⎜⎜ . . . . . . ⎟⎟
⎜ ∂𝑎𝐿𝑛 ∂𝑎𝐿
𝑛⎟
…
⎝ ∂𝑧1𝐿 𝐿
∂𝑧𝑛 ⎠
En los dos primeros casos, en los que la función de activación 𝑔 es, respectiva-
mente, la función de identidad y la función sigmoide, la salida de cada neurona de
la capa de salida solo depende de su propia entrada: 𝑎𝐿1 = 𝑔(𝑧1𝐿 ), … , 𝑎𝐿𝑛 = 𝑔(𝑧𝑛𝐿 ). Por
lo tanto,
∂𝑔(𝑧1𝐿 )
⎛ 0 … 0 ⎞
∂𝑧1𝐿
⎜ ⎟
𝚫𝐿 = 𝛁𝒂𝐿 𝐶 × ⎜ ........... ′ 𝐿
⎟ = 𝛁𝒂𝐿 𝐶 ⊙ 𝑔 (𝒛 )
⎜ ∂𝑔(𝑧𝑛𝐿
)⎟
0 … 0
⎝ ∂𝑧𝑛 ⎠
𝐿
Sin embargo, en el tercer caso en el que la función de activación 𝑔 es la función

softmax, la salida de cada neurona de la capa de salida depende de las entradas
16 de 22
de todas las neuronas de esa capa: 𝑎𝐿1 = 𝑔(𝑧1𝐿 , … , 𝑧𝑛𝐿 )1 , … , 𝑎𝐿𝑛 = 𝑔(𝑧1𝐿 , … , 𝑧𝑛𝐿 )𝑛 . La
expresión, por tanto, no se puede simplificar.
Las funciones de coste anteriores se derivan a partir de asumir que la salida de la

red modeliza una distribución de probabilidad sobre los atributos objetivos (una
distribución normal multidimensional N(𝒂𝐿 , 𝟏) en el primer caso; una distribución
de Bernoulli con probabilidad de éxito 𝑎𝐿 en el segundo caso; una distribución ca-
tegórica con vector 𝒂𝐿 de probabilidades en el tercer caso) y considerar una esti-
mación de máxima verosimilitud del conjunto de entrenamiento, realizada de una
forma numéricamente estable.
Ejemplo: Aplicación del descenso estocástico por el gradiente durante una época
Consideremos, para una tarea de clasificación binaria, el conjunto de entrenamien-

to 𝒟
Entrada: 𝒙 = (𝑥1 , 𝑥2 ) T Objetivo: 𝑦
𝐸1 (0.78, −0.67) T 0
𝐸2 (−0.73, −1.38) T 0
𝐸3 (−0.64, 0.88) T 1
𝐸4 (−0.80, 0.48) T 1
y la red neuronal
Capa 1 Capa 2 Capa 3 Capa 4

𝑛1 = 2 𝑛2 = 2 𝑛3 = 2 𝑛4 = 1
1 1 1
𝑥1
𝑥2
La función de activación de las neuronas artificiales es la función rectificador en las

capas ocultas y la función sigmoide en la capa de salida. Los pesos iniciales son
−0.67 −0.74 0.68

𝑾2 = ( ) 𝒘02 = ( )
−0.10 0.23 1.11
0.73 −1.78 0.17
𝑾3 = ( ) 𝒘03 = ( )
0.09 0.56 −0.29
𝑾 4 = (0.91 −0.89) 𝒘04 = (0.65)
Veamos cómo se entrenaría la red neuronal durante una época mediante el mé-
todo del descenso estocástico por el gradiente asumiendo que los ejemplos del
17 de 22
conjunto de entrenamiento se han distribuido aleatoriamente en los siguientes dos

minilotes:
𝐵1 = {𝐸2 , 𝐸3 } 𝐵2 = {𝐸1 , 𝐸4 }
Consideramos η = 0.1 como factor de aprendizaje y la entropía cruzada binaria
como función de coste a minimizar.
Nota: en los cálculos siguientes se han redondeado los resultados a cuatro de-
cimales.
Minilote 𝐵1 :
−0.73
• Ejemplo 𝐸2 : 𝒙 = ( ),𝑦 = 0
−1.38
−0.73
𝒂1 = 𝒙 = ( )
−1.38
2.1903 2.1903
𝒛2 = 𝑾 2 ⁢𝒂1 + 𝒘02 ≅ ( ) 𝒂2 = rectificador(𝒛2 ) ≅ ( )
0.8656 0.8656
0.2282 0.2282
0.3919 0.3919
𝒛4 = 𝑾 4 ⁢𝒂3 + 𝒘04 ≅ (0.5089) 𝒂4 = σ(𝒛4 ) ≅ (0.6245)
𝚫4 = 𝒂4 − 𝑦 = (0.6245)
T ′ 0.5683
𝚫3 = ((𝑾 4 ) ⁢Δ4 ) ⊙ rectificador (𝒛3 ) ≅ ( )
−0.5558
T ′ 0.3648
𝚫2 = ((𝑾 3 ) ⁢𝚫3 ) ⊙ rectificador (𝒛2 ) ≅ ( )
−1.3228
∂𝐶𝐸2 ∂𝐶𝐸2 ∂𝐶𝐸2

2
= 1⁢Δ21 ≅ 0.3648 2
= 𝑎11 ⁢Δ21 ≅ −0.2663 2
= 𝑎12 ⁢Δ21 ≅ −0.5034
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
2
= 1⁢Δ22 ≅ −1.3228 2
= 𝑎11 ⁢Δ22 ≅ 0.9656 2
= 𝑎12 ⁢Δ22 ≅ 1.8255
∂𝑤2←0 ∂𝑤2←1 ∂𝑤2←2
3
= 1⁢Δ31 ≅ 0.5683 3
= 𝑎21 ⁢Δ31 ≅ 1.2447 3
= 𝑎22 ⁢Δ31 ≅ 0.4919
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
3
= 1⁢Δ32 ≅ −0.5558 3
= 𝑎21 ⁢Δ32 ≅ −1.2174 3
= 𝑎22 ⁢Δ32 ≅ −0.4811
∂𝑤2←0 ∂𝑤2←1 ∂𝑤2←2
4
= 1⁢Δ41 ≅ 0.6245 4
= 𝑎31 ⁢Δ41 ≅ 0.1425 4
= 𝑎32 ⁢Δ41 ≅ 0.2447
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
18 de 22
−0.64
• Ejemplo 𝐸3 : 𝒙 = ( ),𝑦 = 1
0.88
−0.64
𝒂1 = 𝒙 = ( )
0.88
0.4576 0.4576
1.3764 1.3764
−1.9459 0
0.5520 0.5520
𝒛4 = 𝑾 4 ⁢𝒂3 + 𝒘04 ≅ (0.1854) 𝒂4 = σ(𝒛4 ) ≅ (0.5462)
𝚫4 = 𝒂4 − 𝑦 = (−0.4538)
T ′ 0
0.4039
T ′ 0.0364
0.2262

2
= 1⁢Δ21 ≅ 0.0364 2
= 𝑎11 ⁢Δ21 ≅ −0.0233 2
= 𝑎12 ⁢Δ21 ≅ 0.0320
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
2
= 1⁢Δ22 ≅ 0.2262 2
= 𝑎11 ⁢Δ22 ≅ −0.1448 2
= 𝑎12 ⁢Δ22 ≅ 0.1991
∂𝑤2←0 ∂𝑤2←1 ∂𝑤2←2
3
= 1⁢Δ31 ≅ 0 3
= 𝑎21 ⁢Δ31 ≅ 0 3
= 𝑎22 ⁢Δ31 ≅ 0
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
3
= 1⁢Δ32 ≅ 0.4039 3
= 𝑎21 ⁢Δ32 ≅ 0.1848 3
= 𝑎22 ⁢Δ32 ≅ 0.5559
∂𝑤2←0 ∂𝑤2←1 ∂𝑤2←2
4
= 1⁢Δ41 ≅ −0.4538 4
= 𝑎31 ⁢Δ41 ≅ 0 4
= 𝑎32 ⁢Δ41 ≅ −0.2369
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
19 de 22
• Actualización de los pesos:

∂𝐶𝐸2 ∂𝐶𝐸2 ∂𝐶𝐸3 ∂𝐶𝐸3
η 2 2 2 2 −0.6555 −0.7164
𝑾 2 = 𝑾 2 − ⁢(( ∂𝑤 1←1
∂𝐶𝐸2
∂𝑤1←2
∂𝐶𝐸2 ) + ( ∂𝑤 1←1
∂𝐶𝐸3
∂𝑤1←2
∂𝐶𝐸3 )) ≅( )
2 −0.1410 0.1288
2
∂𝑤2←1 2
∂𝑤2←2 2
∂𝑤2←1 2
∂𝑤2←2
∂𝐶𝐸2 ∂𝐶𝐸3
η 2 2 0.6599
𝒘02 = 𝒘02 − ⁢(( ∂𝑤 ∂𝑤1←0
∂𝐶𝐸2 ) + ( ∂𝐶𝐸3 )) ≅ (1.1648)
1←0
2
2
∂𝑤2←0 2
∂𝑤2←0
η 3 3 3 3 0.6678 −1.8046
𝑾 3 = 𝑾 3 − ⁢(( ∂𝑤 1←1
∂𝐶𝐸2
∂𝑤1←2
∂𝐶𝐸2 )+( ∂𝑤1←1
∂𝐶𝐸3
∂𝑤1←2
∂𝐶𝐸3 )) ≅( )
2 0.1416 0.5563
3
∂𝑤2←1 3
∂𝑤2←2 3 3
∂𝑤2←1 ∂𝑤2←2
η 3 3 0.1416
𝒘03 = 𝒘03 − ⁢(( ∂𝑤 ∂𝑤1←0
∂𝐶𝐸2 ) + ( ∂𝐶𝐸3 )) ≅ (−0.2824)
1←0
2
3
∂𝑤2←0 3
∂𝑤2←0
η ∂𝐶𝐸 ∂𝐶𝐸2 ∂𝐶𝐸 ∂𝐶𝐸3
𝑾 4 = 𝑾 4 − (⁢ ( 4 2 4 )+( 43 4 )) ≅ (0.9029 −0.8904)
2 ∂𝑤1←1 ∂𝑤1←2 ∂𝑤1←1 ∂𝑤1←2
η ∂𝐶𝐸 ∂𝐶𝐸
𝒘04 = 𝒘04 − ⁢(( 4 2 ) + ( 4 3 )) ≅ (0.6415)
2 ∂𝑤1←0 ∂𝑤1←0
Minilote 𝐵2 :
0.78
• Ejemplo 𝐸1 : 𝒙 = ( ),𝑦 = 0
−0.67
0.78
𝒂1 = 𝒙 = ( )
−0.67
0.6286 0.6286
0.9685 0.9685
−1.1864 0
0.3454 0.3454
𝒛4 = 𝑾 4 ⁢𝒂3 + 𝒘04 ≅ (0.3340) 𝒂4 = σ(𝒛4 ) ≅ (0.5827)
𝚫4 = 𝒂4 − 𝑦 = (0.5827)
T ′ 0
−0.5188
T ′ −0.0735
−0.2886
20 de 22

2
= 1⁢Δ21 ≅ −0.0735 2
= 𝑎11 ⁢Δ21 ≅ −0.0573 2
= 𝑎12 ⁢Δ21 ≅ 0.0492
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
2
= 1⁢Δ22 ≅ −0.2886 2
= 𝑎11 ⁢Δ22 ≅ −0.2251 2
= 𝑎12 ⁢Δ22 ≅ 0.1934
∂𝑤2←0 ∂𝑤2←1 ∂𝑤2←2
3
= 1⁢Δ31 ≅ 0 3
= 𝑎21 ⁢Δ31 ≅ 0 3
= 𝑎22 ⁢Δ31 ≅ 0
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
3
= 1⁢Δ32 ≅ −0.5188 3
= 𝑎21 ⁢Δ32 ≅ −0.3261 3
= 𝑎22 ⁢Δ32 ≅ −0.5025
∂𝑤2←0 ∂𝑤2←1 ∂𝑤2←2
4
= 1⁢Δ41 ≅ 0.5827 4
= 𝑎31 ⁢Δ41 ≅ 0 4
= 𝑎32 ⁢Δ41 ≅ 0.2013
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
−0.80
• Ejemplo 𝐸4 : 𝒙 = ( ),𝑦 = 1
0.48
−0.80
𝒂1 = 𝒙 = ( )
0.48
0.8404 0.8404
1.3394 1.3394
−1.7143 0
0.5817 0.5817
𝒛4 = 𝑾 4 ⁢𝒂3 + 𝒘04 ≅ (0.1236) 𝒂4 = σ(𝒛4 ) ≅ (0.5309)
𝚫4 = 𝒂4 − 𝑦 = (−0.4691)
T ′ 0
0.4177
T ′ 0.0591
0.2324

2
= 1⁢Δ21 ≅ 0.0591 2
= 𝑎11 ⁢Δ21 ≅ −0.0473 2
= 𝑎12 ⁢Δ21 ≅ 0.0284
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
2
= 1⁢Δ22 ≅ 0.2324 2
= 𝑎11 ⁢Δ22 ≅ −0.1859 2
= 𝑎12 ⁢Δ22 ≅ 0.1116
∂𝑤2←0 ∂𝑤2←1 ∂𝑤2←2
3
= 1⁢Δ31 ≅ 0 3
= 𝑎21 ⁢Δ31 ≅ 0 3
= 𝑎22 ⁢Δ31 ≅ 0
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
3
= 1⁢Δ32 ≅ 0.4177 3
= 𝑎21 ⁢Δ32 ≅ 0.3510 3
= 𝑎22 ⁢Δ32 ≅ 0.5595
∂𝑤2←0 ∂𝑤2←1 ∂𝑤2←2
4
= 1⁢Δ41 ≅ −0.4691 4
= 𝑎31 ⁢Δ41 ≅ 0 4
= 𝑎32 ⁢Δ41 ≅ −0.2729
∂𝑤1←0 ∂𝑤1←1 ∂𝑤1←2
21 de 22
• Actualización de los pesos:

η 2 2 2 2 −0.6520 −0.7194
𝑾 2 = 𝑾 2 − ⁢(( ∂𝑤 1←1
∂𝐶𝐸1
∂𝑤1←2
∂𝐶𝐸1 ) + ( ∂𝑤 1←1
∂𝐶𝐸4
∂𝑤1←2
∂𝐶𝐸4 )) ≅( )
2 −0.1245 0.1133
2
∂𝑤2←1 2
∂𝑤2←2 2
∂𝑤2←1 2
∂𝑤2←2
η 2 2 0.6551
𝒘02 = 𝒘02 − ⁢(( ∂𝑤 ∂𝑤1←0
∂𝐶𝐸1 ) + ( ∂𝐶𝐸4 )) ≅ (1.1419)
1←0
2
2
∂𝑤2←0 2
∂𝑤2←0
η 3 3 3 3 0.6678 −1.8046
𝑾 3 = 𝑾 3 − ⁢(( ∂𝑤 1←1
∂𝐶𝐸1
∂𝑤1←2
∂𝐶𝐸1 ) + ( ∂𝑤 1←1
∂𝐶𝐸4
∂𝑤1←2
∂𝐶𝐸4 )) ≅( )
2 0.1148 0.5005
3
∂𝑤2←1 3
∂𝑤2←2 3
∂𝑤2←1 3
∂𝑤2←2
η 3 3 0.1416
𝒘03 = 𝒘03 − ⁢(( ∂𝑤 ∂𝑤1←0
∂𝐶𝐸1 ) + ( ∂𝐶𝐸4 )) ≅ (−0.3235)
1←0
2
3
∂𝑤2←0 3
∂𝑤2←0
η ∂𝐶𝐸 ∂𝐶𝐸1 ∂𝐶𝐸 ∂𝐶𝐸4
𝑾 4 = 𝑾 4 − (⁢ ( 4 1 4 )+( 44 4 )) ≅ (0.9029 −0.8649)
2 ∂𝑤 1←1 ∂𝑤 1←2 ∂𝑤 1←1 ∂𝑤 1←2
η ∂𝐶𝐸 ∂𝐶𝐸
𝒘04 = 𝒘04 − ⁢(( 4 1 ) + ( 4 4 )) ≅ (0.6876)
2 ∂𝑤 1←0 ∂𝑤 1←0
Se ha completado una época. Ahora se continuaría con la siguiente época, se-

parando aleatoriamente el conjunto de entrenamiento en dos minilotes de tamaño
2 y actualizando de nuevo los pesos considerando primero los ejemplos del primer
minilote y luego los del segundo minilote.
22 de 22

Redes Neuronales

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Redes Neuronales

Cargado por

Copyright:

Formatos disponibles

Universidad de Sevilla Dpto.

de Ciencias de la Computación e Inteligencia Artificial

Ejemplo del dominio:

Las redes neuronales se inspiran en la estructura y funcionamiento del cerebro, aun-

ℝ𝑚 ℝ𝑛1 ℝ𝑛2 ℝ𝑛𝑘−1 ℝ𝑛

𝑓(𝑥1 , … , 𝑥𝑚 ) = 𝑓𝑘 (… 𝑓2 (𝑓1 (𝑥1 , … , 𝑥𝑚 )))

Ejemplo: Representación gráfica de una red neuronal

Capa de Capa Capa Capa de

La primera capa oculta define una función 𝑓1 : ℝ3 → ℝ4 dada por

𝑓1 (𝑥1 , 𝑥2 , 𝑥3 ) = (𝑎11 , 𝑎12 , 𝑎13 , 𝑎14 )

donde cada 𝑎1𝑖 es la salida de la neurona 𝑖-ésima de la capa, calculada a partir

La segunda capa oculta define una función 𝑓2 : ℝ4 → ℝ3 dada por

𝑓2 (𝑎11 , 𝑎12 , 𝑎13 , 𝑎14 ) = (𝑎21 , 𝑎22 , 𝑎23 )

donde cada 𝑎2𝑖 es la salida de la neurona 𝑖-ésima de la capa, calculada a partir

La capa de salida define una función 𝑓3 : ℝ3 → ℝ2 dada por

𝑓3 (𝑎21 , 𝑎22 , 𝑎23 ) = (𝑎31 , 𝑎32 )

donde cada 𝑎3𝑖 es la salida de la neurona 𝑖-ésima de la capa, calculada a partir

La red neuronal define, por tanto, una función 𝑓: ℝ3 → ℝ2 dada por

𝑓(𝑥1 , 𝑥2 , 𝑥3 ) = 𝑓3 (𝑓2 (𝑓1 (𝑥1 , 𝑥2 , 𝑥3 )))

Un perceptrón es un tipo de neurona artificial que para cada entrada proporciona

Dados los argumentos 𝑥1 , … , 𝑥𝑚 , la salida del perceptrón se calcula como sigue:

donde 𝒙 es el vector de los argumentos, 𝒘 es el vector de pesos asociados a los argu-

También es posible usar como función de activación la función signo:

en cuyo caso el perceptrón para cada entrada proporcionará como salida −1 o 1.

Ejemplo: Cálculo de la función lógica NOT mediante un perceptrón

El perceptrón con argumento 𝑥1 , peso asociado al argumento 𝑤1 = −1 y sesgo 𝑏 = 1

Para 𝑥1 = 0 se tiene que 𝑧 = 𝑤1 ⁢𝑥1 + 𝑏 = 1, por lo que la salida del perceptrón

Para 𝑥1 = 1 se tiene que 𝑧 = 𝑤1 ⁢𝑥1 + 𝑏 = 0, por lo que la salida del perceptrón

Ejemplo: Cálculo de la función lógica AND mediante un perceptrón

El perceptrón con argumentos 𝑥1 , 𝑥2 , pesos asociados a los argumentos 𝑤1 = 𝑤2 = 1

Para 𝑥1 = 0 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 + 𝑏 = −1, por lo que la salida

Para 𝑥1 = 0 y 𝑥2 = 1 se tiene que 𝑧 = 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 + 𝑏 = 0, por lo que la salida

Para 𝑥1 = 1 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 + 𝑏 = 0, por lo que la salida

Para 𝑥1 = 1 y 𝑥2 = 1 se tiene que 𝑧 = 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 + 𝑏 = 1, por lo que la salida

El sesgo 𝑏 establece con qué facilidad se activa el perceptrón. A mayor valor de 𝑏,

1 Inicializar los pesos aleatoriamente

Si (𝑥1 , … , 𝑥𝑚 , 𝑦) es un ejemplo de entrenamiento con salida 𝑎 incorrecta, entonces los

𝑤𝑖 ← 𝑤𝑖 + η⁢(𝑦 − 𝑎)⁢𝑥𝑖 , para cada 𝑖 = 0, … , 𝑚

donde el hiperparámetro η > 0 es el factor de aprendizaje.

Teorema (Minsky y Papert, 1969)

Ejemplo: Entrenamiento de un perceptrón para que calcule la función lógica OR

El conjunto de entrenamiento es linealmente separable ( representa un ejemplo

Supongamos 𝑤0 = 0.1, 𝑤1 = −0.1 y 𝑤2 = 0.1 como pesos iniciales y η = 0.1 como

Para 𝑥1 = 0 y 𝑥2 = 1 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.1, por lo que la

Los pesos se actualizan como sigue:

𝑤0 ← 𝑤0 + η⁢(1 − 0)⁢1 = 0 + 0.1 = 0.1

Para 𝑥1 = 1 y 𝑥2 = 1 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.2, por lo que la

Para 𝑥1 = 0 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.1, por lo que la

𝑤0 ← 𝑤0 + η⁢(0 − 1)⁢1 = 0.1 − 0.1 = 0

Para 𝑥1 = 0 y 𝑥2 = 1 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.1, por lo que la

Para 𝑥1 = 1 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0, por lo que la

𝑤0 ← 𝑤0 + η⁢(1 − 0)⁢1 = 0 + 0.1 = 0.1

Para 𝑥1 = 1 y 𝑥2 = 1 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.3, por lo que la

Para 𝑥1 = 0 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.1, por lo que la

𝑤0 ← 𝑤0 + η⁢(0 − 1)⁢1 = 0.1 − 0.1 = 0

Para 𝑥1 = 0 y 𝑥2 = 1 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.1, por lo que la

Para 𝑥1 = 1 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.1, por lo que la

Para 𝑥1 = 1 y 𝑥2 = 1 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0.2, por lo que la

Para 𝑥1 = 0 y 𝑥2 = 0 se tiene que 𝑧 = 𝑤0 ⁢1 + 𝑤1 ⁢𝑥1 + 𝑤2 ⁢𝑥2 = 0, por lo que la

Por lo tanto, el algoritmo proporciona un perceptrón con pesos 𝑤0 = 0, 𝑤1 = 0.1

Un ejemplo clásico de conjunto de ejemplos no linealmente separable es el que se

Ejemplo: No separabilidad lineal de la función XOR