MACHINE LEARNING CON PYTHON

SESION 05
NEURAL NETWORKS

*Cuadros e imágenes pertenecen a sus propetiarios, extraidos de internet solo con fines
educativos
 ÍNDICE
OBJETIVO ......................................................................................................................................................... 4
NEURAL NETWORKS ......................................................................................................................................... 5
NEURAL NETWORKS: FORWARD PROPAGATION .............................................................................................. 6
NEURAL NETWORKS: BACKWARD PROPAGATION ............................................................................................ 9
NEURAL NETWORKS: BACKWARD PROPAGATION .......................................................................................... 13
NEURAL NETWORKS: BACKWARD PROPAGATION .......................................................................................... 14
NEURAL NETWORKS ....................................................................................................................................... 15
NEURAL NETWORKS ....................................................................................................................................... 16
NEURAL NETWORKS ....................................................................................................................................... 18
NEURAL NETWORKS ....................................................................................................................................... 19
UNIVERSAL APPROXIMATION THEOREM ....................................................................................................... 20
UNIVERSAL APPROXIMATION THEOREM ....................................................................................................... 21
UNIVERSAL APPROXIMATION THEOREM ....................................................................................................... 22
UNIVERSAL APPROXIMATION THEOREM ....................................................................................................... 23
DEEP LEARNING ............................................................................................................................................. 24
DEEP LEARNING ............................................................................................................................................. 25
DEEP LEARNING ............................................................................................................................................. 26
DEEP LEARNING ............................................................................................................................................. 27
DEEP LEARNING ............................................................................................................................................. 28
DEEP LEARNING ............................................................................................................................................. 29
DEEP LEARNING ............................................................................................................................................. 30
DEEP LEARNING ............................................................................................................................................. 31
DEEP LEARNING ............................................................................................................................................. 32
DEEP LEARNING ............................................................................................................................................. 33
DEEP LEARNING ............................................................................................................................................. 34

3
Objetivo

El objetivo de esta sesion es analizar superficialmente las matemáticas del aprendizaje

automático y el código from scratch, en Python, una pequeña biblioteca para construir redes
neuronales con una variedad de capas (totalmente conectadas, convolucionales, etc.).

4
Neural Networks

Comprendamos la arquitectura de una red neuronal basica, lo que se puede ver en la imagen
a continuación.

Necesitamos tener en cuenta el panorama general aquí:

1 Introducimos datos de entrada en la red neuronal.

2 Los datos fluyen de una capa a otra hasta que tenemos la salida.
3 Una vez que tenemos la salida, podemos calcular el error que es un escalar.
4 Finalmente podemos ajustar un parámetro dado (peso o sesgo) restando la derivada
del error con respecto al propio parámetro.
5 Iteramos a través de ese proceso.

El paso más importante es el 4to. Queremos poder tener tantas capas como queramos, y de
cualquier tipo. Pero si modificamos/añadimos/quitamos una capa de la red, la salida de la red
va a cambiar, lo que cambiara el error, y eso a su vez cambiara la derivada del error con
respecto a los parámetros. Necesitamos poder calcular las derivadas sin importar la
arquitectura de la red, las funciones de activación, y la funcion de pérdida que usemos.

Para lograr eso, debemos implementar cada capa por separado.

Cada capa que vayamos a crear (fully conected, convolucional, maxpooling, dropout, etc.)
tiene al menos 2 cosas en común: datos de entrada y salida.

5
Neural Networks: Forward Propagation

Ya podemos enfatizar un punto importante que es: la salida de una capa es la entrada de la
siguiente.

Esto se llama forward propagation. Esencialmente, le damos los datos de entrada a la primera
capa, luego la salida de cada capa se convierte en la entrada de la siguiente capa hasta que
llegamos al final de la red. Al comparar el resultado de la red (Y) con la salida deseada (digamos
Y*), podemos calcular el error E. El objetivo es minimizar ese error cambiando los parámetros
en la red. Eso es backward propagation (backpropagation).

Al principio, tenemos nuestros datos (X) en formato vectorial que hará un producto punto con
nuestro vector de peso (W) agregado con sesgo (b), en la ecuación a continuación (i) denota
el i-ésimo elemento de X o Z, y Z siendo el vector de los resultados de W, X y b.

Con matrices, podemos calcular esta fórmula para cada neurona de salida de una sola vez
usando un producto escalar:

6
Neural Networks: Loss Function

Función de pérdida: Loss Function

Hasta ahora, para una capa dada, suponíamos que ∂E/∂Y estaba dado (por la siguiente capa).
Pero, ¿qué sucede con la última capa? ¿Cómo se obtiene ∂E/∂Y? Simplemente le damos
manualmente, y depende de cómo definamos el error.

Nosotros definimos el error de la red, el cual mide qué tan bien o mal lo hizo la red para un
dato de entrada dado. Hay muchas formas de definir el error, y una de las más conocidas se
llama MSE: error cuadrático medio.

Donde y* e y denotan la salida deseada y la salida real respectivamente. Puede pensar en la

pérdida como una última capa que toma todas las neuronas de salida y las aplasta en una sola
neurona. Lo que necesitamos ahora, como para cualquier otra capa, es definir ∂E/∂Y. ¡Excepto
que ahora finalmente llegamos a E!

Descenso de gradiente:

Básicamente, lo que queremos es cambiar algún parámetro en la red (llámelo w) para que el
error total E disminuya. Hay una forma inteligente de hacerlo (no al azar) que es la siguiente:

Donde α es un parámetro en el rango [0,1] que establecemos y que se llama tasa de

aprendizaje. De todos modos, lo importante aquí es ∂E/∂w (la derivada de E con respecto a
w). Necesitamos poder encontrar el valor de esa expresión para cualquier parámetro de la red
independientemente de su arquitectura.

7
Neural Networks: Visualizing Cost Function

Cost Function:

Gradient Descent:

8
Neural Networks: Backward Propagation 101

9
Neural Networks: Backward Propagation 101

10
Neural Networks: Backward Propagation 101

Entonces, ¿eso significa que Z es el resultado de nuestro perceptrón?

Los valores del vector Z no tienen ningún límite superior o inferior y necesitamos un valor
entre 0 y 1, por lo que usaremos la función sigmoidea que tomará los valores de Z y los
colocará entre 0 y 1, que es denotado como un vector.

Supongamos que le damos a una capa la derivada del error con respecto a su salida (∂E/∂Y),
entonces debe ser posible generar la derivada del error con respecto a su entrada (∂E/∂X).

Recordar que E es un escalar (un número) y X e Y son matrices.

Olvidémonos de ∂E/∂X por ahora. El truco aquí es que si tenemos acceso a ∂E/∂Y podemos
calcular muy fácilmente ∂E/∂W (si la capa tiene algún parámetro entrenable) sin saber nada
sobre la arquitectura de la red. Simplemente usamos la regla de la cadena:

La incógnita es ∂yj/∂w, que depende totalmente de cómo la capa calcule su salida. Entonces,
si cada capa tiene acceso a ∂E/∂Y, donde Y es su propia salida, ¡entonces podemos actualizar
nuestros parámetros!

11
Neural Networks: Backward Propagation 101

¿Por qué ∂E/∂X?

No olvidemos que la salida de una capa es la entrada de la siguiente capa. Lo que significa que
∂E/∂X para una capa es ∂E/∂Y para la capa anterior. Es una forma inteligente de propagar el
error. Nuevamente, podemos usar la regla de la cadena:

12
Neural Networks: Backward Propagation

Esto es lo que describimos anteriormente. La capa 3 actualizará sus parámetros usando ∂E/∂Y,
y luego pasará ∂E/∂H2 a la capa anterior, que es su propia “∂E/∂Y”. Luego, la capa 2 hará lo
mismo, y así sucesivamente.

Calculemos la derivada del error con respecto a los parámetros (∂E/∂W, ∂E/∂B)

Calculemos ∂E/∂W. Esta matriz debe tener el mismo tamaño que la propia W: i x j donde i es
el número de neuronas de entrada y j el número de neuronas de salida. Necesitamos un
gradiente para cada peso:

Usando la regla de la cadena establecida anteriormente, podemos escribir:

Por lo tanto:

13
Neural Networks: Backward Propagation

Con eso tenemos la primera fórmula para actualizar los pesos. Ahora calculemos ∂E/∂B.

Nuevamente, ∂E/∂B debe tener el mismo tamaño que B, un gradiente por sesgo. Podemos
usar la regla de la cadena nuevamente:

Con lo cual:

Ahora que tenemos ∂E/∂W y ∂E/∂B, nos queda ∂E/∂X, que es muy importante ya que
"actuará" como ∂E/∂Y para la capa anterior a esa.

Usando al regla de la cadena de nuevo:

Finalmente, podemos escribir la matriz completa:

14
Neural Networks

Tenemos ya las tres fórmulas que necesitábamos para la capa FC

15
Neural Networks: Activation Functions

Vanishing Gradient Problem:

Funcion de activacion:

Todos los cálculos que hicimos hasta ahora fueron completamente lineales. Es inútil aprender
algo con ese tipo de modelo. Necesitamos agregar no linealidad al modelo aplicando funciones
no lineales a la salida de algunas capas.

Llamaremos f y f' a la función de activación y su derivada respectivamente.

16
Neural Networks: Activation Functions

RELU

SOFTMAX

17
Neural Networks

Entonces, ahora, puede preguntar cómo estamos decidiendo los valores de W y b. Bueno,
estamos inicializando todos los valores de los elementos vectoriales de W como 0.0 y b como
valor escalar 0.0.

Ahora, una vez que hayamos terminado con el paso de propagación hacia adelante, debemos
volver atrás y actualizar los valores de W y b para que pueda distinguir entre las dos clases
correctamente. Y para eso, hay algo llamado Función de costo (J) que da el costo de la
predicción, lo que significa qué tan lejos están los valores predichos de los valores reales.
Entonces, para calcular eso, tenemos que encontrar el costo de cada predicción individual,
aquí el sufijo y (i) es el valor real y el sufijo (i) es el valor predicho de i-ésimos datos.

Sumelo sobre todos los valores en el conjunto de datos.

Tome la media, donde m es el número de datos de entrenamiento presentes. Esta es la función

de costo, y tenemos que minimizar esta función de costo tanto como sea posible.

Para minimizar la Función de Costo o J, tenemos que encontrar la derivada J con respecto a W
y b, lo que significa la cantidad de cambio que se requiere para que W y b diferencien entre
dos clases.

18
Neural Networks

Entonces, la derivada de W (dw) y b (db) w.r.t J se da a continuación, dw y db se llaman

gradientes de J. Todos los pasos posteriores a la propagación hacia adelante hasta ahora se
denominan propagación hacia atrás.

Ahora, en los siguientes pasos, tenemos que disminuir iterativamente la Función de Costo y
para hacer eso tenemos que restar la derivada de W(dw) y b(db) muy lentamente en cada
iteración pero el valor de dw y db es bastante grande y restar sus valores directamente no
funcionará debido a la sobreoscilación, como solución multiplicamos dw y db con un número
muy pequeño que se llama Tasa de aprendizaje. Aquí l es la tasa de aprendizaje y “:=” es el
operador de asignación.

Este cambio gradual en el valor de W y b se denomina descenso de gradiente. En la imagen de

abajo, el balón de fútbol indica los valores de W y b.

19
Universal Approximation Theorem

El teorema de aproximación universal es, muy literalmente, la base teórica de por qué
funcionan las redes neuronales. En pocas palabras, establece que una red neuronal con una
capa oculta que contiene un número suficiente pero finito de neuronas puede aproximarse a
cualquier función continua con una precisión razonable, bajo ciertas condiciones para las
funciones de activación (a saber, que deben ser similares a sigmoides).

Formulado en 1989 por George Cybenko solo para activaciones sigmoideas y probado por Kurt
Hornik en 1991 para aplicarse a todas las funciones de activación (la arquitectura de la red
neuronal, no la elección de la función, fue el impulsor detrás del rendimiento), su
descubrimiento fue un impulsor significativo en estimular el desarrollo entusiasta de las redes
neuronales en la plétora de aplicaciones en las que se utilizan hoy en día.

Sin embargo, lo más importante es que el teorema es una explicación reveladora de por qué
las redes neuronales parecen comportarse de manera tan inteligente. Comprenderlo es un
paso clave para desarrollar una comprensión sólida y profunda de las redes neuronales.

Supongamos que tenemos una función ondulada, digamos f(x) como se muestra a
continuación.

Una de las características sorprendentes del uso de una red neuronal es que puede calcular
cualquier función, sin importar cuán complicada sea.

Hay una garantía de que habrá una red neuronal para cualquier función, de modo que para
cada entrada posible, x, el valor f(x) (o alguna aproximación cercana) salga de la red, por
ejemplo:

20
Universal Approximation Theorem

El resultado mencionado anteriormente se mantiene incluso si la función tiene múltiples

entradas, f=f(x1,…, xm) y muchas salidas. Por ejemplo, aquí hay una computación en red para
una función con m=3 entradas y n=2 salidas:

Esto nos dice que las redes neuronales tienen algún tipo de universalidad, es decir, cualquiera
que sea la función que queramos calcular, ya existe una red neuronal disponible para ello.

El teorema de la universalidad es bien conocido por las personas que usan redes neuronales.
Pero por qué es cierto no se entiende tan ampliamente.

Casi cualquier proceso que pueda imaginar se puede considerar como cálculo de funciones.
Considere el problema de nombrar una pieza musical con base en una breve muestra de la
pieza. Eso se puede considerar como calcular una función. O considere el problema de traducir
un texto chino al inglés. Nuevamente, eso puede considerarse como calcular una función.

Por supuesto, solo porque sabemos que existe una red neuronal que puede traducir texto
chino al inglés, eso no significa que tengamos buenas técnicas para construir o incluso
reconocer dicha red. Esta limitación se aplica también a los teoremas de universalidad
tradicionales para modelos como los circuitos booleanos.

Universalidad con una entrada y una salida:

21
Universal Approximation Theorem

Si se observa con atención, este es el núcleo del problema de la universalidad. Una vez que
hemos entendido este caso especial, es bastante fácil extenderlo a funciones con muchas
entradas y muchas salidas.

Para obtener información sobre cómo construir una red para calcular f, comencemos con una
red que contenga una sola capa oculta, con dos neuronas ocultas y una capa de salida que
contenga una sola neurona de salida:

Para tener una idea de cómo funcionan los componentes de la red, concentrémonos en la
neurona oculta superior. Comencemos con peso w = 0 y sesgo b = 0.
Considerando la funcion de activacion σ(wx+b), donde σ(z) ≡ 1/(1+e-z)

Aumentemos el peso 'w' manteniendo el sesgo constante. Las siguientes imágenes muestran
la función f(x) en el espacio 2D para diferentes valores de peso 'w'.

22
Universal Approximation Theorem

Esta representación visual de pesos y sesgos en una red neuronal simple debe haberte
ayudado a comprender la intuición detrás del teorema de aproximación universal.

23
Deep Learning

La inteligencia artificial es la capacidad de una máquina para imitar el comportamiento humano

inteligente. El aprendizaje automático permite que un sistema aprenda y mejore a partir de la
experiencia automáticamente. El aprendizaje profundo es una aplicación de aprendizaje
automático que utiliza algoritmos complejos y redes neuronales profundas para entrenar un
modelo.

Deep Learning es una subdivisión del aprendizaje automático que imita el funcionamiento de
un cerebro humano con la ayuda de redes neuronales artificiales. Es útil en el procesamiento de
Big Data y puede crear patrones importantes que brindan información valiosa sobre la toma de
decisiones importantes. El etiquetado manual de datos no supervisados requiere mucho tiempo
y es costoso. Los tutoriales de DeepLearning ayudan a superar esto con la ayuda de algoritmos
altamente sofisticados que brindan información esencial al analizar y acumular los datos.

Deep Learning aprovecha las diferentes capas de redes neuronales que permiten aprender,
desaprender y volver a aprender. Cubre todas las habilidades y algoritmos esenciales de CNN
a RNN y, por lo tanto, proporciona soluciones más inteligentes.

Importancia del aprendizaje profundo:

El aprendizaje automático funciona solo con conjuntos de datos estructurados y

semiestructurados, mientras que el aprendizaje profundo funciona tanto con datos estructurados
como no estructurados.

Los algoritmos de aprendizaje profundo pueden realizar operaciones complejas de manera

eficiente, mientras que los algoritmos de aprendizaje automático no.

Los algoritmos de aprendizaje automático utilizan datos de muestra etiquetados para extraer
patrones, mientras que el aprendizaje profundo acepta grandes volúmenes de datos como
entrada y analiza los datos de entrada para extraer características de un objeto.

24
Deep Learning

El rendimiento de los algoritmos de aprendizaje automático disminuye a medida que aumenta

la cantidad de datos; por lo que para mantener el rendimiento del modelo, necesitamos un
aprendizaje profundo.

¿Qué son las Redes Neuronales?

Ahora que sabemos qué es exactamente el aprendizaje profundo, su aplicación e importancia,

a continuación, veamos las redes neuronales y sus operaciones. Una red neuronal es un sistema
modelado en el cerebro humano, que consta de una capa de entrada, varias capas ocultas y una
capa de salida. Los datos se alimentan como entrada a las neuronas. La información se transfiere
a la siguiente capa utilizando pesos y sesgos apropiados. La salida es el valor final predicho por
la neurona artificial.

Cada neurona en una red neuronal realiza las siguientes operaciones:

Se encuentra el producto de cada entrada y el peso del canal por el que se pasa.

Se calcula la suma de los productos ponderados, que se denomina suma ponderada

Se suma un valor de sesgo de la neurona a la suma ponderada

La suma final se somete a una función particular conocida como función de activación.

25
Deep Learning

Función de costo:

La función de costo es uno de los componentes significativos de una red neuronal. El valor del
costo es la diferencia entre la salida prevista de las redes neuronales y la salida real de un
conjunto de datos de entrenamiento etiquetados. El valor de menor costo se obtiene al hacer
ajustes a los pesos y sesgos de forma iterativa a lo largo del proceso de entrenamiento.

Veamos el proceso completo paso a paso:

Cada píxel se alimenta como entrada a las neuronas en la primera capa. Las capas ocultas
mejoran la precisión de la salida. Los datos se transmiten de una capa a otra sobre los canales
de sobrepeso. Cada neurona de una capa se pondera con respecto a cada una de las neuronas de
la siguiente capa.

26
Deep Learning

Cada neurona en la primera capa oculta toma un subconjunto de las entradas y las procesa.
Todas las entradas se multiplican por sus respectivos pesos y se agrega un sesgo. La salida de
la suma ponderada se aplica a una función de activación. Los resultados de la función de
activación determinan qué neuronas se activarán en la siguiente capa.

Paso 1: x1*w1 + x2*w2 + b1

Paso 2: Φ(x1* w1 + x2* w2 + b1)

donde Φ es una función de activación

Los pasos anteriores se realizan nuevamente para garantizar que la información llegue a la capa
de salida, después de lo cual se activa una sola neurona en la capa de salida según el valor de la
función de activación.

Como se puede ver, nuestra entrada real fue un cuadrado, pero la red neuronal predijo la salida
como un círculo. ¿Qué salió mal?

La red neuronal debe entrenarse hasta que la salida pronosticada sea correcta y la salida
pronosticada se compare con la salida real mediante el cálculo de la función de costo.

27
Deep Learning

La función de costo se calcula usando la fórmula donde y es el valor real e ŷ es el valor

pronosticado. La función de costo determina el error en la predicción y lo informa a la red
neuronal. Esto se llama backpropagation:

Los pesos se ajustan para reducir el error. La red está entrenada con los nuevos pesos:

Una vez más, se determina el costo y se continúa con el procedimiento de backpropagation

hasta que el costo no se puede reducir más:

28
Deep Learning

Las funciones de activación son una parte crítica del diseño de una red neuronal.

La elección de la función de activación en la capa oculta controlará qué tan bien aprende el
modelo de red el conjunto de datos de entrenamiento. La elección de la función de activación
en la capa de salida definirá el tipo de predicciones que puede hacer el modelo.

Como tal, se debe hacer una elección cuidadosa de la función de activación para cada proyecto
de red neuronal de aprendizaje profundo.

Una función de activación en una red neuronal define cómo la suma ponderada de la entrada se
transforma en una salida de un nodo o nodos en una capa de la red.

A veces, la función de activación se denomina "función de transferencia". Muchas funciones

de activación no son lineales y pueden denominarse como la "no linealidad" en la capa o el
diseño de la red.

La elección de la función de activación tiene un gran impacto en la capacidad y el rendimiento

de la red neuronal, y se pueden usar diferentes funciones de activación en diferentes partes del
modelo.

Una red puede tener tres tipos de capas: capas de entrada que toman la entrada sin procesar del
dominio, capas ocultas que toman la entrada de otra capa y pasan la salida a otra capa y capas
de salida que hacen una predicción.

Todas las capas ocultas suelen utilizar la misma función de activación. La capa de salida
generalmente usará una función de activación diferente de las capas ocultas y depende del tipo
de predicción requerida por el modelo.

Las funciones de activación también suelen ser diferenciables, lo que significa que la derivada
de primer orden se puede calcular para un valor de entrada dado. Esto es necesario dado que las
redes neuronales normalmente se entrenan utilizando el algoritmo de backpropagation del error
lo cual requiere la derivada del error de predicción para actualizar los pesos del modelo.

Hay muchos tipos diferentes de funciones de activación que se usan en las redes neuronales,
aunque quizás solo se use una pequeña cantidad de funciones en la práctica para las capas
ocultas y de salida.

Por lo general, se utiliza una función de activación no lineal diferenciable en las capas ocultas
de una red neuronal. Esto permite que el modelo aprenda funciones más complejas que una red
entrenada usando una función de activación lineal.

Echemos un vistazo a las funciones de activación utilizadas para las capas ocultas

29
Deep Learning

Función ReLU (unidad lineal rectificada):

La función de activación lineal rectificada, o función de activación ReLU, es quizás la función

más común utilizada para capas ocultas.

Es común porque es simple de implementar y efectiva para superar las limitaciones de otras
funciones de activación populares anteriormente, como la sigmoide y tanh . Específicamente,
es menos susceptible a gradientes que se desvanecen que evitan que se entrenen modelos
profundos, aunque puede sufrir otros problemas como unidades saturadas o "muertas".

La función ReLU (unidad lineal rectificada) devuelve 1 si x es superior a 1 y si x es menor que

0, devolvera 0.

Función Sigmoide:

La función de activación sigmoide también se denomina función logística.

Es la misma función utilizada en el algoritmo de clasificación de regresión logística.

La función toma cualquier valor real como entrada y genera valores en el rango de 0 a 1. Cuanto
mayor sea la entrada (más positiva), más cerca estará el valor de salida de 1.0, mientras que
cuanto más pequeña sea la entrada (más negativa), más cerca estará la función de salida de 0.0.

30
Deep Learning

Función de umbral:

La función de umbral se usa cuando no quiere preocuparse por la incertidumbre en el medio.

Función tangente hiperbólica

La función de activación de la tangente hiperbólica también se conoce simplemente como la

función Tanh (también "tanh" y "TanH").

Es muy similar a la función de activación sigmoide e incluso tiene la misma forma de S.

La función toma cualquier valor real como entrada y genera valores en el rango de -1 a 1.
Cuanto mayor sea la entrada (más positiva), más cerca estará el valor de salida de 1,0, mientras
que cuanto más pequeña sea la entrada (más negativa), más cerca la salida será a -1.0.

Si no estamos seguros de qué función de activación usar para nuestra red, se deben probar
algunas y comparar los resultados.1

La siguiente figura resume cómo elegir una función de activación para las capas ocultas de su
modelo de red neuronal.

31
Deep Learning

En el caso de las capas de salida hay 3 funciones de activacion que se deben contemplar.

Las funcion de activacion sigmoide que ya describimos en la sesion anterior.

La función de activación lineal también se denomina "identidad" (multiplicada por 1,0) o "sin
activación". Esto se debe a que la función de activación lineal no cambia la suma ponderada de
la entrada de ninguna manera y, en cambio, devuelve el valor directamente.

La función softmax genera un vector de valores que suman 1,0 que se pueden interpretar como
probabilidades de pertenencia a una clase.

Está relacionado con la función argmax que genera un 0 para todas las opciones y un 1 para la
opción elegida. Softmax es una versión "más suave" de argmax que permite una salida similar
a la probabilidad de una función en la que el ganador se lo lleva todo.

Como tal, la entrada a la función es un vector de valores reales y la salida es un vector de la

misma longitud con valores que suman 1.0 como probabilidades.

La siguiente figura resume cómo elegir una función de activación para la capa de salida de su
modelo de red neuronal.

32
Deep Learning

Types of Algorithms used in Deep Learning

Los algoritmos de aprendizaje profundo funcionan con casi cualquier tipo de datos y requieren
grandes cantidades de potencia informática e información para resolver problemas
complicados.

1. Convolutional Neural Networks (CNNs)

2. Long Short Term Memory Networks (LSTMs)
3. Recurrent Neural Networks (RNNs)
4. Generative Adversarial Networks (GANs)
5. Radial Basis Function Networks (RBFNs)
6. Multilayer Perceptrons (MLPs)
7. Self Organizing Maps (SOMs)
8. Deep Belief Networks (DBNs)
9. Restricted Boltzmann Machines( RBMs)
10. Autoencoders

33
Deep Learning

Deep Learning Platforms:

Keras
Keras es un marco de Python para el aprendizaje profundo. Su USP es la reutilización de código
para CPU y GPU.

TensorFlow
TensorFlow es una biblioteca de aprendizaje profundo de código abierto desarrollada por
Google. Está desarrollado en C++ y tiene su implementación en Python. Keras ahora se puede
ejecutar sobre TensorFlow.

DL4J
Deep Learning for Java (DL4J) es la primera biblioteca de aprendizaje profundo escrita para
Java y Scala. Está integrado con Hadoop y Apache Spark.

TensorFlow de Google es actualmente la biblioteca de aprendizaje más popular del mundo. Se

basa en el concepto de tensores, que se pueden considerer son vectores o matrices de n
dimensiones.

A continuación se muestra un ejemplo de tensores que tienen 1D, 2D y multidimensionalidad.

34