Theano - Guia Rápido
Você desenvolveu modelos de aprendizado de máquina em Python? Então, obviamente, você conhece os meandros do desenvolvimento desses modelos. O desenvolvimento é normalmente um processo lento, levando horas e dias de capacidade computacional.
O desenvolvimento do modelo de Aprendizado de Máquina requer muitos cálculos matemáticos. Isso geralmente requer cálculos aritméticos, especialmente matrizes grandes de dimensões múltiplas. Hoje em dia, usamos redes neurais em vez das técnicas estatísticas tradicionais para desenvolver aplicativos de aprendizado de máquina. As redes neurais precisam ser treinadas sobre uma grande quantidade de dados. O treinamento é feito em lotes de dados de tamanho razoável. Assim, o processo de aprendizagem é iterativo. Assim, se os cálculos não forem feitos de forma eficiente, o treinamento da rede pode levar várias horas ou até dias. Assim, a otimização do código executável é altamente desejada. E é isso que exatamente Theano oferece.
Theano é uma biblioteca Python que permite definir expressões matemáticas usadas no Aprendizado de Máquina, otimizar essas expressões e avaliá-las de forma muito eficiente usando GPUs em áreas críticas. Ele pode rivalizar com as implementações C completas típicas na maioria dos casos.
Theano foi escrito no laboratório LISA com a intenção de fornecer rápido desenvolvimento de algoritmos de aprendizado de máquina eficientes. É lançado sob uma licença BSD.
Neste tutorial, você aprenderá a usar a biblioteca Theano.
Theano pode ser instalado em Windows, MacOS e Linux. A instalação em todos os casos é trivial. Antes de instalar o Theano, você deve instalar suas dependências. A seguir está a lista de dependências -
- Python
- NumPy - Obrigatório
- SciPy - Obrigatório apenas para Sparse Matrix e funções especiais
- BLAS - Fornece blocos de construção padrão para realizar operações básicas de vetor e matriz
Os pacotes opcionais que você pode escolher para instalar dependendo de suas necessidades são -
- nariz: para executar a suíte de testes de Theano
- Sphinx - Para documentação de construção
- Graphiz e pydot - para lidar com gráficos e imagens
- Drivers NVIDIA CUDA - necessários para geração / execução de código de GPU
- libgpuarray - Obrigatório para geração de código GPU / CPU em dispositivos CUDA e OpenCL
Discutiremos as etapas para instalar o Theano no MacOS.
Instalação MacOS
Para instalar o Theano e suas dependências, você usa pipna linha de comando da seguinte maneira. Essas são as dependências mínimas de que precisaremos neste tutorial.
$ pip install Theano
$ pip install numpy
$ pip install scipy
$ pip install pydot
Você também precisa instalar a ferramenta de desenvolvedor de linha de comando OSx usando o seguinte comando -
$ xcode-select --install
Você verá a seguinte tela. Clique noInstall botão para instalar a ferramenta.
Na instalação bem-sucedida, você verá a mensagem de sucesso no console.
Testando a instalação
Após a instalação ser concluída com sucesso, abra um novo bloco de notas no Anaconda Jupyter. Na célula de código, insira o seguinte script Python -
Exemplo
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)
Resultado
Execute o script e você verá a seguinte saída -
4.0
A captura de tela da execução é mostrada abaixo para sua referência rápida -
Se você obtiver o resultado acima, a instalação do Theano foi bem-sucedida. Caso contrário, siga as instruções de depuração na página de download do Theano para corrigir os problemas.
O que é Theano?
Agora que você instalou o Theano com sucesso, vamos primeiro tentar entender o que é Theano? Theano é uma biblioteca Python. Ele permite definir, otimizar e avaliar expressões matemáticas, especialmente aquelas que são usadas no desenvolvimento de Modelos de Aprendizado de Máquina. O próprio Theano não contém nenhum modelo de ML pré-definido; apenas facilita seu desenvolvimento. É especialmente útil ao lidar com matrizes multidimensionais. Ele se integra perfeitamente ao NumPy, que é um pacote fundamental e amplamente usado para cálculos científicos em Python.
Theano facilita a definição de expressões matemáticas usadas no desenvolvimento de ML. Essas expressões geralmente envolvem aritmética de matriz, diferenciação, computação de gradiente e assim por diante.
Theano primeiro constrói todo o Grafo Computacional para o seu modelo. Em seguida, ele o compila em um código altamente eficiente, aplicando várias técnicas de otimização no gráfico. O código compilado é injetado no tempo de execução Theano por uma operação especial chamadafunctiondisponível em Theano. Nós executamos issofunctionrepetidamente para treinar uma rede neural. O tempo de treinamento é substancialmente reduzido em comparação ao uso de codificação Python pura ou mesmo uma implementação C completa.
Devemos agora entender o processo de desenvolvimento de Theano. Vamos começar explicando como definir uma expressão matemática em Theano.
Vamos começar nossa jornada de Theano definindo e avaliando uma expressão trivial em Theano. Considere a seguinte expressão trivial que adiciona dois escalares -
c = a + b
Onde a, b são variáveis e cé a saída da expressão. Em Theano, definir e avaliar até mesmo essa expressão trivial é complicado.
Vamos entender as etapas para avaliar a expressão acima.
Importando Theano
Primeiro, precisamos importar a biblioteca Theano em nosso programa, o que fazemos usando a seguinte instrução -
from theano import *
Em vez de importar os pacotes individuais, usamos * na instrução acima para incluir todos os pacotes da biblioteca Theano.
Declarando Variáveis
A seguir, vamos declarar uma variável chamada a usando a seguinte declaração -
a = tensor.dscalar()
o dscalarmétodo declara uma variável escalar decimal. A execução da instrução acima cria uma variável chamadaaem seu código de programa. Da mesma forma, vamos criar variáveisb usando a seguinte declaração -
b = tensor.dscalar()
Definindo Expressão
A seguir, definiremos nossa expressão que opera nessas duas variáveis a e b.
c = a + b
No Theano, a execução da instrução acima não realiza a adição escalar das duas variáveis a e b.
Definindo a Função Theano
Para avaliar a expressão acima, precisamos definir uma função em Theano da seguinte maneira -
f = theano.function([a,b], c)
A função functionrecebe dois argumentos, o primeiro argumento é uma entrada para a função e o segundo é sua saída. A declaração acima afirma que o primeiro argumento é um tipo de array que consiste em dois elementosa e b. A saída é uma unidade escalar chamadac. Esta função será referenciada com o nome da variávelf em nosso código posterior.
Invocando a função Theano
A chamada para a função f é feita usando a seguinte instrução -
d = f(3.5, 5.5)
A entrada para a função é uma matriz que consiste em dois escalares: 3.5 e 5.5. A saída da execução é atribuída à variável escalard. Para imprimir o conteúdo ded, vamos usar o print declaração -
print (d)
A execução faria com que o valor de d a ser impresso no console, que é 9.0 neste caso.
Lista completa do programa
A lista completa do programa é fornecida aqui para sua referência 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)
Execute o código acima e você verá a saída como 9.0. A captura de tela é mostrada aqui -
Agora, vamos discutir um exemplo um pouco mais complexo que calcula a multiplicação de duas matrizes.
Vamos calcular um produto escalar de duas matrizes. A primeira matriz é de dimensão 2 x 3 e a segunda é de dimensão 3 x 2. As matrizes que usamos como entrada e seus produtos são expressas aqui -
$$ \ begin {bmatrix} 0 & -1 & 2 \\ 4 & 11 & 2 \ end {bmatrix} \: \ begin {bmatrix} 3 e -1 \\ 1 & 2 \\ 35 & 20 \ end {bmatrix} = \ begin {bmatrix} 11 e 0 \\ 35 e 20 \ end {bmatrix} $$Declarando Variáveis
Para escrever uma expressão Theano para o acima, primeiro declaramos duas variáveis para representar nossas matrizes da seguinte forma -
a = tensor.dmatrix()
b = tensor.dmatrix()
O dmatrix é o tipo de matrizes para duplas. Observe que não especificamos o tamanho da matriz em qualquer lugar. Assim, essas variáveis podem representar matrizes de qualquer dimensão.
Definindo Expressão
Para calcular o produto escalar, usamos a função integrada chamada dot como segue -
c = tensor.dot(a,b)
A saída da multiplicação é atribuída a uma variável de matriz chamada c.
Definindo a Função Theano
A seguir, definimos uma função como no exemplo anterior para avaliar a expressão.
f = theano.function([a,b], c)
Observe que a entrada para a função são duas variáveis aeb que são do tipo matriz. A saída da função é atribuída a variávelc que seria automaticamente do tipo matriz.
Invocando a função Theano
Agora invocamos a função usando a seguinte instrução -
d = f([[0, -1, 2], [4, 11, 2]], [[3, -1],[1,2], [6,1]])
As duas variáveis na instrução acima são matrizes NumPy. Você pode definir explicitamente matrizes NumPy conforme mostrado aqui -
f(numpy.array([[0, -1, 2], [4, 11, 2]]),
numpy.array([[3, -1],[1,2], [6,1]]))
Depois de d é calculado, imprimimos seu valor -
print (d)
Você verá a seguinte saída na saída -
[[11. 0.]
[25. 20.]]
Lista completa do 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)
A captura de tela da execução do programa é mostrada aqui -
A partir dos dois exemplos acima, você deve ter notado que em Theano criamos uma expressão que eventualmente é avaliada usando o Theano function. Theano usa técnicas de otimização avançadas para otimizar a execução de uma expressão. Para visualizar o gráfico de computação, Theano fornece umprinting pacote em sua biblioteca.
Gráfico Simbólico para Adição Escalar
Para ver o gráfico de computação do nosso programa de adição escalar, use a biblioteca de impressão da seguinte forma -
theano.printing.pydotprint(f, outfile="scalar_addition.png", var_with_name_simple=True)
Quando você executa esta instrução, um arquivo chamado scalar_addition.pngserá criado em sua máquina. O gráfico de computação salvo é exibido aqui para sua referência rápida -
A lista completa do programa para gerar a imagem acima é fornecida abaixo -
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
Agora, tente criar o gráfico de computação para nosso multiplicador de matriz. A lista completa para gerar este gráfico é fornecida abaixo -
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)
O gráfico gerado é mostrado aqui -
Gráficos Complexos
Em expressões maiores, os gráficos computacionais podem ser muito complexos. Um gráfico retirado da documentação Theano é mostrado aqui -
Para entender o funcionamento de Theano, é importante primeiro saber o significado desses gráficos computacionais. Com esse entendimento, saberemos a importância de Theano.
Por que Theano?
Olhando para a complexidade dos gráficos computacionais, você agora será capaz de entender o propósito por trás do desenvolvimento do Theano. Um compilador típico forneceria otimizações locais no programa, uma vez que nunca olha para o cálculo inteiro como uma única unidade.
Theano implementa técnicas de otimização muito avançadas para otimizar o gráfico computacional completo. Ele combina os aspectos da Álgebra com os aspectos de um compilador de otimização. Uma parte do gráfico pode ser compilada em código de linguagem C. Para cálculos repetidos, a velocidade de avaliação é crítica e Theano atende a esse propósito gerando um código muito eficiente.
Agora que você entendeu o básico de Theano, vamos começar com os diferentes tipos de dados disponíveis para você criar suas expressões. A tabela a seguir fornece uma lista parcial dos tipos de dados definidos no Theano.
Tipo de dados | Tipo Theano |
---|---|
Byte | bscalar, bvector, bmatrix, brow, bcol, btensor3, btensor4, btensor5, btensor6, btensor7 |
Inteiros de 16 bits | wscalar, wvector, wmatrix, wrow, wcol, wtensor3, wtensor4, wtensor5, wtensor6, wtensor7 |
Inteiros de 32 bits | iscalar, ivector, imatrix, irow, icol, itensor3, itensor4, itensor5, itensor6, itensor7 |
Inteiros de 64 bits | lscalar, lvector, lmatrix, lrow, lcol, ltensor3, ltensor4, ltensor5, ltensor6, ltensor7 |
flutuador | fscalar, fvector, fmatrix, frow, fcol, ftensor3, ftensor4, ftensor5, ftensor6, ftensor7 |
em dobro | dscalar, dvector, dmatrix, drow, dcol, dtensor3, dtensor4, dtensor5, dtensor6, dtensor7 |
complexo | cscalar, cvector, cmatrix, corvo, ccol, ctensor3, ctensor4, ctensor5, ctensor6, ctensor7 |
A lista acima não é exaustiva e o leitor deve consultar o documento de criação do tensor para obter uma lista completa.
Agora darei alguns exemplos de como criar variáveis de vários tipos de dados no Theano.
Escalar
Para construir uma variável escalar, você usaria a sintaxe -
Sintaxe
x = theano.tensor.scalar ('x')
x = 5.0
print (x)
Resultado
5.0
Matriz unidimensional
Para criar uma matriz unidimensional, use a seguinte declaração -
Exemplo
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])
Resultado
(2.0, 5.0, 3.0)
2.0
3.0
Se você fizer f[3] isso geraria um índice fora do intervalo de erro, conforme mostrado aqui -
print f([3])
Resultado
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
Array bidimensional
Para declarar uma matriz bidimensional, você usaria o seguinte snippet de código -
Exemplo
m = theano.tensor.matrix
m = ([2,3], [4,5], [2,4])
print (m[0])
print (m[1][0])
Resultado
[2, 3]
4
Matriz 5-dimensional
Para declarar uma matriz 5-dimensional, use a seguinte sintaxe -
Exemplo
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])
Resultado
[5, 6, 7, 8, 9]
13
Você pode declarar uma matriz tridimensional usando o tipo de dados tensor3 no lugar de tensor5, uma matriz quadridimensional usando o tipo de dados tensor4, e assim por diante até tensor7.
Construtores plurais
Às vezes, você pode querer criar variáveis do mesmo tipo em uma única declaração. Você pode fazer isso usando a seguinte sintaxe -
Sintaxe
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])
Resultado
[5, 6]
[9, 10]
[13, 14]
No capítulo anterior, ao discutir os tipos de dados, criamos e usamos variáveis Theano. Para reiterar, usaríamos a seguinte sintaxe para criar uma variável em Theano -
x = theano.tensor.fvector('x')
Nesta declaração, criamos uma variável xdo tipo vetor contendo flutuadores de 32 bits. Também o estamos nomeando comox. Os nomes geralmente são úteis para depuração.
Para declarar um vetor de inteiros de 32 bits, você usaria a seguinte sintaxe -
i32 = theano.tensor.ivector
Aqui, não especificamos um nome para a variável.
Para declarar um vetor tridimensional consistindo de flutuadores de 64 bits, você usaria a seguinte declaração -
f64 = theano.tensor.dtensor3
Os vários tipos de construtores, juntamente com seus tipos de dados, estão listados na tabela abaixo -
Construtor | Tipo de dados | Dimensões |
---|---|---|
vetor | float32 | 1 |
ivector | int32 | 1 |
fscalar | float32 | 0 |
fmatriz | float32 | 2 |
ftensor3 | float32 | 3 |
dtensor3 | float64 | 3 |
Você pode usar um construtor de vetor genérico e especificar o tipo de dados explicitamente como segue -
x = theano.tensor.vector ('x', dtype=int32)
No próximo capítulo, aprenderemos como criar variáveis compartilhadas.
Muitas vezes, você precisaria criar variáveis que são compartilhadas entre diferentes funções e também entre várias chamadas para a mesma função. Para citar um exemplo, ao treinar uma rede neural, você cria um vetor de pesos para atribuir um peso a cada recurso em consideração. Este vetor é modificado a cada iteração durante o treinamento da rede. Portanto, ele deve estar acessível globalmente nas várias chamadas para a mesma função. Portanto, criamos uma variável compartilhada para esse propósito. Normalmente, Theano move essas variáveis compartilhadas para a GPU, desde que uma esteja disponível. Isso acelera o cálculo.
Sintaxe
Você cria uma variável compartilhada e usa a seguinte sintaxe -
import numpy
W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')
Exemplo
Aqui, a matriz NumPy que consiste em quatro números de ponto flutuante é criada. Para definir / obter oW valor que você usaria no seguinte snippet 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())
Resultado
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 functionatua como um gancho para interagir com o gráfico simbólico. Um gráfico simbólico é compilado em um código de execução altamente eficiente. Ele consegue isso reestruturando as equações matemáticas para torná-las mais rápidas. Ele compila algumas partes da expressão em código de linguagem C. Ele move alguns tensores para a GPU e assim por diante.
O código compilado eficiente é agora fornecido como uma entrada para o Theano function. Quando você executa o Theanofunction, ele atribui o resultado do cálculo às variáveis especificadas por nós. O tipo de otimização pode ser especificado como FAST_COMPILE ou FAST_RUN. Isso é especificado na variável de ambiente THEANO_FLAGS.
A Theano function é declarado usando a seguinte sintaxe -
f = theano.function ([x], y)
O primeiro parâmetro [x] é a lista de variáveis de entrada e o segundo parâmetro y é a lista de variáveis de saída.
Tendo agora entendido o básico do Theano, vamos começar a codificação do Theano com um exemplo trivial.
Theano é bastante útil no treinamento de redes neurais, onde temos que calcular repetidamente o custo e gradientes para atingir um ótimo. Em grandes conjuntos de dados, isso se torna intensivo em termos de computação. Theano faz isso de forma eficiente devido às suas otimizações internas do gráfico computacional que vimos anteriormente.
Declaração do Problema
Devemos agora aprender como usar a biblioteca Theano para treinar uma rede. Pegaremos um caso simples onde começamos com um conjunto de dados de quatro recursos. Calculamos a soma desses recursos após aplicar um determinado peso (importância) a cada recurso.
O objetivo do treinamento é modificar os pesos atribuídos a cada recurso para que a soma atinja o valor alvo de 100.
sum = f1 * w1 + f2 * w2 + f3 * w3 + f4 * w4
Onde f1, f2, ... são os valores do recurso e w1, w2, ... são os pesos.
Deixe-me quantizar o exemplo para uma melhor compreensão da definição do problema. Assumiremos um valor inicial de 1,0 para cada recurso e tomaremos w1 igual a0.1, w2 é igual a 0.25, w3 é igual a 0.15e w4 é igual a 0.3. Não há uma lógica definida na atribuição dos valores de peso, é apenas nossa intuição. Assim, a soma inicial é a seguinte -
sum = 1.0 * 0.1 + 1.0 * 0.25 + 1.0 * 0.15 + 1.0 * 0.3
Qual soma para 0.8. Agora, continuaremos modificando a atribuição de peso para que esta soma se aproxime de 100. O valor resultante atual de0.8 está longe de nosso valor alvo desejado de 100. Em termos de aprendizado de máquina, nós definimos costcomo a diferença entre o valor alvo menos o valor de saída atual, normalmente elevado ao quadrado para explodir o erro. Reduzimos esse custo em cada iteração, calculando os gradientes e atualizando nosso vetor de pesos.
Vamos ver como toda essa lógica é implementada no Theano.
Declarando Variáveis
Primeiro declaramos nosso vetor de entrada x da seguinte forma -
x = tensor.fvector('x')
Onde x é uma matriz unidimensional de valores flutuantes.
Nós definimos um escalar target variável conforme fornecido abaixo -
target = tensor.fscalar('target')
Em seguida, criamos um tensor de pesos W com os valores iniciais conforme discutido acima -
W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')
Definindo a Expressão Theano
Agora calculamos a saída usando a seguinte expressão -
y = (x * W).sum()
Observe que na declaração acima x e Wsão os vetores e não variáveis escalares simples. Agora calculamos o erro (custo) com a seguinte expressão -
cost = tensor.sqr(target - y)
O custo é a diferença entre o valor alvo e a saída atual, ao quadrado.
Para calcular o gradiente que nos diz a que distância estamos do alvo, usamos o sistema integrado grad método da seguinte forma -
gradients = tensor.grad(cost, [W])
Agora atualizamos o weights vetor obtendo uma taxa de aprendizagem de 0.1 como segue -
W_updated = W - (0.1 * gradients[0])
Em seguida, precisamos atualizar nosso vetor de pesos usando os valores acima. Fazemos isso na seguinte declaração -
updates = [(W, W_updated)]
Definindo / invocando a função Theano
Por último, definimos um function em Theano para calcular a soma.
f = function([x, target], y, updates=updates)
Para invocar a função acima um certo número de vezes, criamos um for loop da seguinte forma -
for i in range(10):
output = f([1.0, 1.0, 1.0, 1.0], 100.0)
Como disse anteriormente, a entrada para a função é um vetor contendo os valores iniciais para os quatro recursos - atribuímos o valor de 1.0para cada recurso sem qualquer motivo específico. Você pode atribuir valores diferentes de sua escolha e verificar se a função finalmente converge. Iremos imprimir os valores do vetor de peso e a saída correspondente em cada iteração. É mostrado no código abaixo -
print ("iteration: ", i)
print ("Modified Weights: ", W.get_value())
print ("Output: ", output)
Lista completa do programa
A lista completa do programa é reproduzida aqui para sua referência 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)
Ao executar o programa, você verá a seguinte saída -
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 após quatro iterações, a saída é 99.96 e depois de cinco iterações, é 99.99, que está perto de nossa meta desejada de 100.0.
Dependendo da precisão desejada, você pode concluir com segurança que a rede é treinada em 4 a 5 iterações. Após a conclusão do treinamento, procure o vetor de pesos, que após 5 iterações assume os seguintes valores -
iteration: 5
Modified Weights: [24.8984128 25.0484128 24.9484128 25.0984128]
Agora você pode usar esses valores em sua rede para implantar o modelo.
A construção do modelo de Machine Learning envolve cálculos intensivos e repetitivos envolvendo tensores. Isso requer recursos de computação intensivos. Como um compilador regular forneceria as otimizações no nível local, ele geralmente não produz um código de execução rápida.
Theano primeiro constrói um gráfico computacional para toda a computação. Como toda a imagem da computação está disponível como uma única imagem durante a compilação, várias técnicas de otimização podem ser aplicadas durante a pré-compilação e é exatamente isso que Theano faz. Ele reestrutura o gráfico computacional, o converte parcialmente em C, move as variáveis compartilhadas para a GPU e assim por diante para gerar um código executável muito rápido. O código compilado é então executado por um Theanofunctionque atua apenas como um gancho para injetar o código compilado no tempo de execução. Theano provou suas credenciais e é amplamente aceito tanto na academia quanto na indústria.