Theano - Guía rápida

¿Ha desarrollado modelos de aprendizaje automático en Python? Entonces, obviamente, conoce las complejidades del desarrollo de estos modelos. El desarrollo suele ser un proceso lento que requiere horas y días de potencia computacional.

El desarrollo del modelo de aprendizaje automático requiere muchos cálculos matemáticos. Estos generalmente requieren cálculos aritméticos, especialmente matrices grandes de múltiples dimensiones. En estos días utilizamos redes neuronales en lugar de las técnicas estadísticas tradicionales para desarrollar aplicaciones de aprendizaje automático. Las redes neuronales deben entrenarse con una gran cantidad de datos. La formación se realiza en lotes de datos de tamaño razonable. Por tanto, el proceso de aprendizaje es iterativo. Por lo tanto, si los cálculos no se realizan de manera eficiente, el entrenamiento de la red puede llevar varias horas o incluso días. Por lo tanto, la optimización del código ejecutable es muy deseada. Y eso es exactamente lo que ofrece Theano.

Theano es una biblioteca de Python que le permite definir expresiones matemáticas utilizadas en Machine Learning, optimizar estas expresiones y evaluarlas de manera muy eficiente mediante el uso decisivo de GPU en áreas críticas. Puede rivalizar con las implementaciones C completas típicas en la mayoría de los casos.

Theano fue escrito en el laboratorio LISA con la intención de proporcionar un desarrollo rápido de algoritmos eficientes de aprendizaje automático. Se publica bajo una licencia BSD.

En este tutorial, aprenderá a usar la biblioteca Theano.

Theano se puede instalar en Windows, MacOS y Linux. La instalación en todos los casos es trivial. Antes de instalar Theano, debe instalar sus dependencias. La siguiente es la lista de dependencias:

• Python
• NumPy - Requerido
• SciPy: requerido solo para Sparse Matrix y funciones especiales
• BLAS: proporciona bloques de construcción estándar para realizar operaciones básicas de vectores y matrices

Los paquetes opcionales que puede elegir instalar según sus necesidades son:

• nariz: Para ejecutar la suite de pruebas de Theano
• Sphinx - Para documentación de construcción
• Graphiz y pydot: para manejar gráficos e imágenes
• Controladores NVIDIA CUDA: necesarios para la generación / ejecución de código de GPU
• libgpuarray: necesario para la generación de código de GPU / CPU en dispositivos CUDA y OpenCL

Discutiremos los pasos para instalar Theano en MacOS.

Instalación de MacOS

Para instalar Theano y sus dependencias, usa pipdesde la línea de comando de la siguiente manera. Estas son las dependencias mínimas que vamos a necesitar en este tutorial.

$ pip install Theano
$ pip install numpy
$ pip install scipy
$ pip install pydot

También necesita instalar la herramienta de desarrollo de línea de comandos OSx usando el siguiente comando:

$ xcode-select --install

Verá la siguiente pantalla. Clickea en elInstall para instalar la herramienta.

En una instalación exitosa, verá el mensaje de éxito en la consola.

Prueba de la instalación

Una vez que la instalación se complete correctamente, abra un nuevo cuaderno en Anaconda Jupyter. En la celda de código, ingrese la siguiente secuencia de comandos de Python:

Ejemplo

import theano
from theano import tensor
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
d = f(1.5, 2.5)
print (d)

Salida

Ejecute el script y debería ver el siguiente resultado:

4.0

La captura de pantalla de la ejecución se muestra a continuación para su referencia rápida:

Si obtiene el resultado anterior, su instalación de Theano es exitosa. De lo contrario, siga las instrucciones de depuración en la página de descarga de Theano para solucionar los problemas.

¿Qué es Theano?

Ahora que ha instalado con éxito Theano, primero intentemos entender qué es Theano. Theano es una biblioteca de Python. Le permite definir, optimizar y evaluar expresiones matemáticas, especialmente las que se utilizan en el desarrollo de modelos de aprendizaje automático. Theano en sí no contiene ningún modelo de aprendizaje automático predefinido; simplemente facilita su desarrollo. Es especialmente útil cuando se trata de matrices multidimensionales. Se integra perfectamente con NumPy, que es un paquete fundamental y ampliamente utilizado para cálculos científicos en Python.

Theano facilita la definición de expresiones matemáticas utilizadas en el desarrollo de ML. Tales expresiones generalmente involucran aritmética matricial, diferenciación, cálculo de gradientes, etc.

Theano primero construye el gráfico computacional completo para su modelo. Luego lo compila en un código altamente eficiente aplicando varias técnicas de optimización en el gráfico. El código compilado se inyecta en el tiempo de ejecución de Theano mediante una operación especial llamadafunctiondisponible en Theano. Ejecutamos estofunctionrepetidamente para entrenar una red neuronal. El tiempo de entrenamiento se reduce sustancialmente en comparación con el uso de codificación Python pura o incluso una implementación completa de C.

Ahora entenderemos el proceso de desarrollo de Theano. Comencemos con cómo definir una expresión matemática en Theano.

Comencemos nuestro viaje de Theano definiendo y evaluando una expresión trivial en Theano. Considere la siguiente expresión trivial que agrega dos escalares:

c = a + b

Dónde a, b son variables y ces la salida de la expresión. En Theano, definir y evaluar incluso esta expresión trivial es complicado.

Entendamos los pasos para evaluar la expresión anterior.

Importando Theano

Primero, necesitamos importar la biblioteca Theano en nuestro programa, lo cual hacemos usando la siguiente declaración:

from theano import *

En lugar de importar los paquetes individuales, hemos usado * en la declaración anterior para incluir todos los paquetes de la biblioteca Theano.

Declaración de variables

A continuación, declararemos una variable llamada a usando la siguiente declaración -

a = tensor.dscalar()

los dscalarEl método declara una variable escalar decimal. La ejecución de la declaración anterior crea una variable llamadaaen su código de programa. Asimismo, crearemos variableb usando la siguiente declaración -

b = tensor.dscalar()

Definición de expresión

A continuación, definiremos nuestra expresión que opera sobre estas dos variables a y b.

c = a + b

En Theano, la ejecución de la declaración anterior no realiza la suma escalar de las dos variables a y b.

Definición de la función Theano

Para evaluar la expresión anterior, necesitamos definir una función en Theano de la siguiente manera:

f = theano.function([a,b], c)

La función functiontoma dos argumentos, el primer argumento es una entrada a la función y el segundo es su salida. La declaración anterior establece que el primer argumento es de tipo matriz que consta de dos elementosa y b. La salida es una unidad escalar llamadac. Esta función será referenciada con el nombre de la variable.f en nuestro código adicional.

Invocación de la función Theano

La llamada a la función f se realiza mediante la siguiente declaración:

d = f(3.5, 5.5)

La entrada a la función es una matriz que consta de dos escalares: 3.5 y 5.5. La salida de ejecución se asigna a la variable escalard. Para imprimir el contenido ded, usaremos el print declaración -

print (d)

La ejecución causaría el valor de d que se imprimirá en la consola, que en este caso es 9.0.

Listado completo del programa

La lista completa del programa se proporciona aquí para su referencia rápida:

from theano import *
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
d = f(3.5, 5.5)
print (d)

Ejecute el código anterior y verá la salida como 9.0. La captura de pantalla se muestra aquí:

Ahora, analicemos un ejemplo un poco más complejo que calcula la multiplicación de dos matrices.

Calcularemos un producto escalar de dos matrices. La primera matriz es de dimensión 2 x 3 y la segunda es de dimensión 3 x 2. Las matrices que usamos como entrada y su producto se expresan aquí -

$$ \ begin {bmatrix} 0 & -1 & 2 \\ 4 & 11 & 2 \ end {bmatrix} \: \ begin {bmatrix} 3 & -1 \\ 1 & 2 \\ 35 & 20 \ end {bmatrix} = \ begin {bmatrix} 11 y 0 \\ 35 y 20 \ end {bmatrix} $$

Declaración de variables

Para escribir una expresión Theano para lo anterior, primero declaramos dos variables para representar nuestras matrices de la siguiente manera:

a = tensor.dmatrix()
b = tensor.dmatrix()

La dmatrix es el tipo de matrices para dobles. Tenga en cuenta que no especificamos el tamaño de la matriz en ninguna parte. Por tanto, estas variables pueden representar matrices de cualquier dimensión.

Definición de expresión

Para calcular el producto escalar, usamos la función incorporada llamada dot como sigue -

c = tensor.dot(a,b)

La salida de la multiplicación se asigna a una variable de matriz llamada c.

Definición de la función Theano

A continuación, definimos una función como en el ejemplo anterior para evaluar la expresión.

f = theano.function([a,b], c)

Tenga en cuenta que la entrada a la función son dos variables ayb que son de tipo matriz. La salida de la función se asigna a la variablec que sería automáticamente de tipo matriz.

Invocación de la función Theano

Ahora invocamos la función usando la siguiente declaración:

d = f([[0, -1, 2], [4, 11, 2]], [[3, -1],[1,2], [6,1]])

Las dos variables en la declaración anterior son matrices NumPy. Puede definir explícitamente matrices NumPy como se muestra aquí -

f(numpy.array([[0, -1, 2], [4, 11, 2]]),
numpy.array([[3, -1],[1,2], [6,1]]))

Después d se calcula imprimimos su valor -

print (d)

Verá la siguiente salida en la salida:

[[11. 0.]
[25. 20.]]

Listado completo del programa

The complete program listing is given here:
from theano import *
a = tensor.dmatrix()
b = tensor.dmatrix()
c = tensor.dot(a,b)
f = theano.function([a,b], c)
d = f([[0, -1, 2],[4, 11, 2]], [[3, -1],[1,2],[6,1]])
print (d)

La captura de pantalla de la ejecución del programa se muestra aquí:

De los dos ejemplos anteriores, es posible que haya notado que en Theano creamos una expresión que finalmente se evalúa utilizando el Theano function. Theano utiliza técnicas de optimización avanzadas para optimizar la ejecución de una expresión. Para visualizar el gráfico de cálculo, Theano proporciona unprinting paquete en su biblioteca.

Gráfico simbólico para la suma escalar

Para ver el gráfico de cálculo de nuestro programa de suma escalar, use la biblioteca de impresión de la siguiente manera:

theano.printing.pydotprint(f, outfile="scalar_addition.png", var_with_name_simple=True)

Cuando ejecuta esta declaración, un archivo llamado scalar_addition.pngse creará en su máquina. El gráfico de cálculo guardado se muestra aquí para su referencia rápida:

La lista completa de programas para generar la imagen anterior se muestra a continuación:

from theano import *
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
theano.printing.pydotprint(f, outfile="scalar_addition.png", var_with_name_simple=True)

Gráfico simbólico para multiplicador de matriz

Ahora, intente crear el gráfico de cálculo para nuestro multiplicador de matriz. La lista completa para generar este gráfico se da a continuación:

from theano import *
a = tensor.dmatrix()
b = tensor.dmatrix()
c = tensor.dot(a,b)
f = theano.function([a,b], c)
theano.printing.pydotprint(f, outfile="matrix_dot_product.png", var_with_name_simple=True)

El gráfico generado se muestra aquí:

Gráficos complejos

En expresiones más grandes, los gráficos computacionales pueden ser muy complejos. Aquí se muestra uno de esos gráficos tomados de la documentación de Theano:

Para comprender el funcionamiento de Theano, es importante conocer primero el significado de estos gráficos computacionales. Con este entendimiento, conoceremos la importancia de Theano.

¿Por qué Theano?

Al observar la complejidad de los gráficos computacionales, ahora podrá comprender el propósito detrás del desarrollo de Theano. Un compilador típico proporcionaría optimizaciones locales en el programa, ya que nunca considera el cálculo completo como una sola unidad.

Theano implementa técnicas de optimización muy avanzadas para optimizar el gráfico computacional completo. Combina los aspectos de Álgebra con aspectos de un compilador optimizador. Una parte del gráfico se puede compilar en código en lenguaje C. Para cálculos repetidos, la velocidad de evaluación es crítica y Theano cumple este propósito generando un código muy eficiente.

Ahora que ha entendido los conceptos básicos de Theano, comencemos con los diferentes tipos de datos disponibles para crear sus expresiones. La siguiente tabla le brinda una lista parcial de los tipos de datos definidos en Theano.

Tipo de datos	Tipo Theano
Byte	bscalar, bvector, bmatrix, brow, bcol, btensor3, btensor4, btensor5, btensor6, btensor7
Enteros de 16 bits	wscalar, wvector, wmatrix, wrow, wcol, wtensor3, wtensor4, wtensor5, wtensor6, wtensor7
Enteros de 32 bits	iscalar, ivector, imatrix, irow, icol, itensor3, itensor4, itensor5, itensor6, itensor7
Enteros de 64 bits	lscalar, lvector, lmatrix, lrow, lcol, ltensor3, ltensor4, ltensor5, ltensor6, ltensor7
flotador	fscalar, fvector, fmatrix, fruncir el ceño, fcol, ftensor3, ftensor4, ftensor5, ftensor6, ftensor7
doble	dscalar, dvector, dmatrix, drow, dcol, dtensor3, dtensor4, dtensor5, dtensor6, dtensor7
complejo	cscalar, cvector, cmatrix, cuervo, ccol, ctensor3, ctensor4, ctensor5, ctensor6, ctensor7

La lista anterior no es exhaustiva y se remite al lector al documento de creación del tensor para obtener una lista completa.

Ahora le daré algunos ejemplos de cómo crear variables de varios tipos de datos en Theano.

Escalar

Para construir una variable escalar, usaría la sintaxis:

Sintaxis

x = theano.tensor.scalar ('x')
x = 5.0
print (x)

Salida

5.0

Matriz unidimensional

Para crear una matriz unidimensional, use la siguiente declaración:

Ejemplo

f = theano.tensor.vector
f = (2.0, 5.0, 3.0)
print (f)f = theano.tensor.vector
f = (2.0, 5.0, 3.0)
print (f)
print (f[0])
print (f[2])

Salida

(2.0, 5.0, 3.0)
2.0
3.0

Si lo haces f[3] generaría un error de índice fuera de rango como se muestra aquí -

print f([3])

Salida

IndexError                          Traceback (most recent call last)
<ipython-input-13-2a9c2a643c3a> in <module>
   4 print (f[0])
   5 print (f[2])
----> 6 print (f[3])
IndexError: tuple index out of range

Matriz bidimensional

Para declarar una matriz bidimensional, usaría el siguiente fragmento de código:

Ejemplo

m = theano.tensor.matrix
m = ([2,3], [4,5], [2,4])
print (m[0])
print (m[1][0])

Salida

[2, 3]
4

Matriz de 5 dimensiones

Para declarar una matriz de 5 dimensiones, use la siguiente sintaxis:

Ejemplo

m5 = theano.tensor.tensor5
m5 = ([0,1,2,3,4], [5,6,7,8,9], [10,11,12,13,14])
print (m5[1])
print (m5[2][3])

Salida

[5, 6, 7, 8, 9]
13

Puede declarar una matriz tridimensional utilizando el tipo de datos tensor3 en lugar de tensor5, una matriz de 4 dimensiones que utiliza el tipo de datos tensor4y así sucesivamente hasta tensor7.

Constructores plurales

A veces, es posible que desee crear variables del mismo tipo en una sola declaración. Puede hacerlo utilizando la siguiente sintaxis:

Sintaxis

from theano.tensor import * x, y, z = dmatrices('x', 'y', 'z') 
x = ([1,2],[3,4],[5,6]) 
y = ([7,8],[9,10],[11,12]) 
z = ([13,14],[15,16],[17,18]) 
print (x[2]) 
print (y[1]) 
print (z[0])

Salida

[5, 6] 
[9, 10] 
[13, 14]

En el capítulo anterior, mientras discutíamos los tipos de datos, creamos y usamos variables Theano. Para reiterar, usaríamos la siguiente sintaxis para crear una variable en Theano:

x = theano.tensor.fvector('x')

En esta declaración, hemos creado una variable xde tipo vector que contiene flotantes de 32 bits. También lo estamos nombrando comox. Los nombres son generalmente útiles para depurar.

Para declarar un vector de enteros de 32 bits, usaría la siguiente sintaxis:

i32 = theano.tensor.ivector

Aquí, no especificamos un nombre para la variable.

Para declarar un vector tridimensional que consta de flotantes de 64 bits, debe usar la siguiente declaración:

f64 = theano.tensor.dtensor3

Los diversos tipos de constructores junto con sus tipos de datos se enumeran en la siguiente tabla:

Constructor	Tipo de datos	Dimensiones
fvector	float32	1
ivector	int32	1
fscalar	float32	0
fmatrix	float32	2
ftensor3	float32	3
dtensor3	float64	3

Puede usar un constructor de vector genérico y especificar el tipo de datos explícitamente de la siguiente manera:

x = theano.tensor.vector ('x', dtype=int32)

En el próximo capítulo, aprenderemos cómo crear variables compartidas.

Muchas veces, necesitará crear variables que se comparten entre diferentes funciones y también entre múltiples llamadas a la misma función. Para citar un ejemplo, mientras entrena una red neuronal, crea un vector de pesos para asignar un peso a cada característica en consideración. Este vector se modifica en cada iteración durante el entrenamiento de la red. Por lo tanto, debe ser accesible globalmente a través de las múltiples llamadas a la misma función. Entonces creamos una variable compartida para este propósito. Normalmente, Theano mueve estas variables compartidas a la GPU, siempre que haya una disponible. Esto acelera el cálculo.

Sintaxis

Creas una variable compartida y usas la siguiente sintaxis:

import numpy
W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')

Ejemplo

Aquí se crea la matriz NumPy que consta de cuatro números de punto flotante. Para configurar / obtener elW valor, usaría el siguiente fragmento de código:

import numpy
W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')
print ("Original: ", W.get_value())
print ("Setting new values (0.5, 0.2, 0.4, 0.2)")
W.set_value([0.5, 0.2, 0.4, 0.2])
print ("After modifications:", W.get_value())

Salida

Original: [0.1 0.25 0.15 0.3 ]
Setting new values (0.5, 0.2, 0.4, 0.2)
After modifications: [0.5 0.2 0.4 0.2]

Theano functionactúa como un gancho para interactuar con el gráfico simbólico. Un gráfico simbólico se compila en un código de ejecución altamente eficiente. Lo logra reestructurando las ecuaciones matemáticas para hacerlas más rápidas. Compila algunas partes de la expresión en código de lenguaje C. Mueve algunos tensores a la GPU, y así sucesivamente.

El código compilado eficiente ahora se proporciona como entrada al Theano function. Cuando ejecutas el Theanofunction, asigna el resultado del cálculo a las variables especificadas por nosotros. El tipo de optimización se puede especificar como FAST_COMPILE o FAST_RUN. Esto se especifica en la variable de entorno THEANO_FLAGS.

Un Theano function se declara utilizando la siguiente sintaxis:

f = theano.function ([x], y)

El primer parámetro [x] es la lista de variables de entrada y el segundo parámetro y es la lista de variables de salida.

Habiendo entendido ahora los conceptos básicos de Theano, comencemos la codificación de Theano con un ejemplo trivial.

Theano es bastante útil en el entrenamiento de redes neuronales donde tenemos que calcular repetidamente el costo y los gradientes para lograr un óptimo. En grandes conjuntos de datos, esto se vuelve computacionalmente intensivo. Theano hace esto de manera eficiente debido a sus optimizaciones internas del gráfico computacional que hemos visto anteriormente.

Planteamiento del problema

Ahora aprenderemos cómo usar la biblioteca Theano para entrenar una red. Tomaremos un caso simple en el que comenzamos con un conjunto de datos de cuatro características. Calculamos la suma de estas características después de aplicar un cierto peso (importancia) a cada característica.

El objetivo de la capacitación es modificar los pesos asignados a cada característica para que la suma alcance un valor objetivo de 100.

sum = f1 * w1 + f2 * w2 + f3 * w3 + f4 * w4

Dónde f1, f2, ... son los valores de las características y w1, w2, ... son los pesos.

Permítanme cuantificar el ejemplo para comprender mejor el enunciado del problema. Asumiremos un valor inicial de 1.0 para cada característica y tomaremos w1 igual0.1, w2 es igual a 0.25, w3 es igual a 0.15y w4 es igual a 0.3. No hay una lógica definida para asignar los valores de peso, es solo nuestra intuición. Por lo tanto, la suma inicial es la siguiente:

sum = 1.0 * 0.1 + 1.0 * 0.25 + 1.0 * 0.15 + 1.0 * 0.3

Que suma a 0.8. Ahora, seguiremos modificando la asignación de peso para que esta suma se acerque a 100. El valor actual resultante de0.8 está muy lejos de nuestro valor objetivo deseado de 100. En términos de aprendizaje automático, definimos costcomo la diferencia entre el valor objetivo menos el valor de salida actual, típicamente al cuadrado para aumentar el error. Reducimos este costo en cada iteración calculando los gradientes y actualizando nuestro vector de pesos.

Veamos cómo se implementa toda esta lógica en Theano.

Declaración de variables

Primero declaramos nuestro vector de entrada x de la siguiente manera:

x = tensor.fvector('x')

Dónde x es una matriz unidimensional de valores flotantes.

Definimos un escalar target variable como se indica a continuación -

target = tensor.fscalar('target')

A continuación, creamos un tensor de pesos. W con los valores iniciales como se discutió anteriormente -

W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')

Definición de la expresión Theano

Ahora calculamos la salida usando la siguiente expresión:

y = (x * W).sum()

Tenga en cuenta que en la declaración anterior x y Wson los vectores y no simples variables escalares. Ahora calculamos el error (costo) con la siguiente expresión:

cost = tensor.sqr(target - y)

El costo es la diferencia entre el valor objetivo y la producción actual, al cuadrado.

Para calcular el gradiente que nos dice qué tan lejos estamos del objetivo, usamos el grad método de la siguiente manera -

gradients = tensor.grad(cost, [W])

Ahora actualizamos el weights vector tomando una tasa de aprendizaje de 0.1 como sigue -

W_updated = W - (0.1 * gradients[0])

A continuación, necesitamos actualizar nuestro vector de pesos utilizando los valores anteriores. Hacemos esto en la siguiente declaración:

updates = [(W, W_updated)]

Definición / invocación de la función Theano

Por último, definimos un function en Theano para calcular la suma.

f = function([x, target], y, updates=updates)

Para invocar la función anterior un cierto número de veces, creamos un for bucle de la siguiente manera:

for i in range(10):
output = f([1.0, 1.0, 1.0, 1.0], 100.0)

Como se dijo anteriormente, la entrada a la función es un vector que contiene los valores iniciales de las cuatro características; asignamos el valor de 1.0a cada función sin ningún motivo específico. Puede asignar diferentes valores de su elección y verificar si la función finalmente converge. Imprimiremos los valores del vector de peso y la salida correspondiente en cada iteración. Se muestra en el siguiente código:

print ("iteration: ", i)
print ("Modified Weights: ", W.get_value())
print ("Output: ", output)

Listado completo del programa

La lista completa de programas se reproduce aquí para su referencia rápida:

from theano import *
import numpy

x = tensor.fvector('x')
target = tensor.fscalar('target')

W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')
print ("Weights: ", W.get_value())

y = (x * W).sum()
cost = tensor.sqr(target - y)
gradients = tensor.grad(cost, [W])
W_updated = W - (0.1 * gradients[0])
updates = [(W, W_updated)]

f = function([x, target], y, updates=updates)
for i in range(10):
   output = f([1.0, 1.0, 1.0, 1.0], 100.0)
   print ("iteration: ", i)
   print ("Modified Weights: ", W.get_value())
   print ("Output: ", output)

Cuando ejecute el programa, verá el siguiente resultado:

Weights: [0.1 0.25 0.15 0.3 ]
iteration: 0
Modified Weights: [19.94 20.09 19.99 20.14]
Output: 0.8
iteration: 1
Modified Weights: [23.908 24.058 23.958 24.108]
Output: 80.16000000000001
iteration: 2
Modified Weights: [24.7016 24.8516 24.7516 24.9016]
Output: 96.03200000000001
iteration: 3
Modified Weights: [24.86032 25.01032 24.91032 25.06032]
Output: 99.2064
iteration: 4
Modified Weights: [24.892064 25.042064 24.942064 25.092064]
Output: 99.84128
iteration: 5
Modified Weights: [24.8984128 25.0484128 24.9484128 25.0984128]
Output: 99.968256
iteration: 6
Modified Weights: [24.89968256 25.04968256 24.94968256 25.09968256]
Output: 99.9936512
iteration: 7
Modified Weights: [24.89993651 25.04993651 24.94993651 25.09993651]
Output: 99.99873024
iteration: 8
Modified Weights: [24.8999873 25.0499873 24.9499873 25.0999873]
Output: 99.99974604799999
iteration: 9
Modified Weights: [24.89999746 25.04999746 24.94999746 25.09999746]
Output: 99.99994920960002

Observe que después de cuatro iteraciones, la salida es 99.96 y después de cinco iteraciones, es 99.99, que está cerca de nuestro objetivo deseado de 100.0.

Dependiendo de la precisión deseada, puede concluir con seguridad que la red está entrenada en 4 a 5 iteraciones. Una vez que se completa el entrenamiento, busque el vector de pesos, que después de 5 iteraciones toma los siguientes valores:

iteration: 5
Modified Weights: [24.8984128 25.0484128 24.9484128 25.0984128]

Ahora puede usar estos valores en su red para implementar el modelo.

La construcción del modelo de aprendizaje automático implica cálculos intensivos y repetitivos que involucran tensores. Estos requieren recursos informáticos intensivos. Como un compilador normal proporcionaría las optimizaciones a nivel local, generalmente no produce un código de ejecución rápida.

Theano primero construye un gráfico computacional para todo el cálculo. Como la imagen completa de la computación está disponible como una sola imagen durante la compilación, se pueden aplicar varias técnicas de optimización durante la compilación previa y eso es exactamente lo que hace Theano. Reestructura el gráfico computacional, lo convierte parcialmente en C, mueve las variables compartidas a la GPU y así sucesivamente para generar un código ejecutable muy rápido. El código compilado es luego ejecutado por un Theanofunctionque simplemente actúa como un gancho para inyectar el código compilado en el tiempo de ejecución. Theano ha demostrado sus credenciales y es ampliamente aceptado tanto en el mundo académico como en la industria.