Forex lstm

Kashif's ML e NN BLOG.
Dados Forex e LSTM - (TensorFlow) Redes Neurais.
Eu trabalhei em dados Forex e usei Redes Neurais para prever o preço futuro do par de moedas EUR_USD ou gerar tendências futuras.
Etapas realizadas para preparar os dados baixados:
Os dados baixados estavam em formato json com recursos de moeda incorporada (alta, baixa, aberta, fechada, volume, tempo, completa). Os dados json foram analisados ​​e colocados no dataframe do Pandas e também foram salvos no arquivo csv Outros recursos curtos e longos SMA, bandas de bollinger, variação percentual e diferenças em high-low e open-close também foram adicionadas aos dados. Então os dados foram divididos em Training and Testing set. Os dados de treinamento foram alimentados com a Rede Neural Recorrente (LSTM).
3 camadas LSTM, com dropout e finalmente com saída de ativação linear de 1 neurônio.
Para perda & ndash; erro quadrático médio & # 8221; foi usado, e para o otimizador & # 8220; rmsprop & # 8221; foi usado.
Os detalhes do modelo estão abaixo:
Outras modificações do modelo também foram tentadas, o que eu não quero mencionar aqui, caso contrário, o detalhe será avassalador para você.
Depois de treinar os dados por 30 épocas, a perda caiu para 0,0114, o que você pode ver aqui:

Forex lstm
Eu tenho uma pergunta em mente que se relaciona com o uso do pybrain para fazer a regressão de uma série temporal. Eu pretendo usar a camada LSTM no pybrain para treinar e prever uma série temporal.
Eu encontrei um código de exemplo aqui no link abaixo.
No exemplo acima, a rede é capaz de prever uma sequência depois de ser treinada. Mas o problema é que a rede recebe todos os dados sequenciais, alimentando-os de uma só vez para a camada de entrada. Por exemplo, se os dados de treinamento tiverem 10 recursos cada, os 10 recursos serão simultaneamente alimentados em 10 nós de entrada por vez.
Pelo que entendi, isso não é mais uma previsão de séries temporais, estou certo? Já que não há diferença em termos de tempo em que cada recurso é alimentado na rede? Me corrija se eu estiver errado nisso.
Portanto, o que estou tentando alcançar é uma rede recorrente que possui apenas um nó de entrada e um nó de saída. O nó de entrada é onde todos os dados da série temporal serão alimentados sequencialmente em diferentes etapas de tempo. A rede será treinada para reproduzir a entrada no nó de saída.
Você poderia sugerir ou orientar-me na construção da rede que mencionei? Muito obrigado antecipadamente.

Forex lstm
O modelo abaixo lê os dados de um arquivo csv (data, abertura, alta, baixa, fechamento, volume), organiza os dados e cria um modelo LSTM tentando prever o fechamento do dia seguinte com base em um número de dias anteriores.
No entanto, a precisão da validação é de cerca de 53,8%, não importa se i. - alterar hiperparâmetros - torná-lo um modelo profundo - usa muito mais recursos do que apenas fechar.
Para testar se cometi um erro simples, eu gerava outra fonte de dados que era um sinal que criei adicionando sin, cosine e um pouco de ruído para que eu soubesse que um modelo deveria ser capaz de ser treinado e era. O modelo abaixo obteve cerca de 94% de validação sem nenhum ajuste.
Com aquilo em mente. Por que quando eu tento usá-lo em dados reais (dados de 1 min de eurusd) ele não parece funcionar.
Alguém que vê um erro ou pode me apontar na direção certa?
O que você está enfrentando é essa propriedade fundamental da maioria das séries de preços financeiros, e isso é, eles são Brownian Motion. Em tempo discreto, também é conhecido como passeio aleatório.
A propriedade mais importante do Movimento Browniano é que é sem memória, cuja expressão matemática é.
A rede neural recorrente, particularmente o sabor LSTM, é muito poderosa na captura e modelagem de um longo processo de memória. Na verdade, ele foi inventado para lidar com o estado que depende de si mesmo muitos passos atrás (o famoso papel LSTM foi datado de 20 anos atrás [1]).
O que você demonstrou usando o RNN (assumindo que seu código e treinamento estão livres de erros) é precisamente essa propriedade. Dito de outra forma, não há como vencer uma moeda justa ao prever o preço de câmbio de amanhã.
Outra perspectiva em sua tentativa. Se tal modelo ingênuo pudesse prever com precisão as séries temporais de FX, teria sido explorado pelas baleias na indústria de fundos de hedge há muito tempo e a oportunidade deixaria de existir.
[1] Hochreiter, S., & amp; Schmidhuber, J. (1997). Longa memória de curto prazo. Computação Neural, 9 (8), 1735-1780.

Forex lstm
A rede LSTM é um algoritmo que lida com problemas de séries temporais, como reconhecimento de speach ou composição de música automática, e é ideal para forex, que é uma série temporal muito longa.
Realmente prever pode diferir, alguns podem prever um nível em que colocar um take-profit e outros prevêem algo como o lucro / fator de rebaixamento, mas é sempre uma maneira de decidir se um deve ir longo ou curto, nada realmente importa à parte para o gerenciamento adequado da conta.
também. Os melhores resultados são obtidos filtrando algum ruído com & ldquo; renko & rdquo; barras de estilo com um tamanho de cerca de 0,25 pips.
alguns meses de cada vez e muitas vezes é menos do que isso.
A rede LSTM não prevê movimentos precisos, mas sim uma probabilidade de que o próximo movimento seja positivo ou negativo. Portanto, apostar apenas quando a probabilidade prevista é muito alta ou muito baixa aumenta o desempenho. É quando decidimos abrir uma posição. Nós então fechamos a posição.
quando as previsões se invertem.
rentável em média.
negociações para um spread menor diminui muito os custos de negociação, embora não funcione sempre. Isso também é problemático quando a estratégia não consegue se livrar de uma posição ruim porque o spread é muito grande.
Como eu disse no começo, fazer mais lucro do que trocar os custos de fato é muito difícil com a negociação de alta frequência. Para avaliar nossa estratégia, comparei-a a uma estratégia que se abre de forma oposta.
posições em cada tick e, portanto, está apenas sujeita a custos de negociação. Eu chamo isso de "puro hedge". Os resultados são obtidos nos últimos seis meses.
Os resultados mostram que somos capazes de bater uma boa parte dos custos de negociação. Além disso, os resultados são obtidos através de uma quantidade tão grande de negócios que podemos seguramente assumir que eles são reprodutíveis. Contudo,
não podemos, até agora, lucrar com essa estratégia. Mesmo com as menores comissões oferecidas pela dukascopy, com um grande depósito ou faturamento, os custos ainda seriam de 1 dólar por milhão negociados.

Tutorial Recorrente de Rede Neural, Parte 4 & # 8211; Implementando um GRU / LSTM RNN com Python e Theano.
O código desta postagem está no Github. Esta é a parte 4, a última parte do Tutorial da Rede Neural Recorrente. As partes anteriores são:
Neste post vamos aprender sobre redes LSTM (Long Short Term Memory) e GRUs (Gated Recurrent Units). Os LSTMs foram propostos pela primeira vez em 1997 por Sepp Hochreiter e Jürgen Schmidhuber, e estão entre os modelos mais amplamente utilizados no Deep Learning for PNL atualmente. As GRUs, usadas pela primeira vez em 2014, são uma variante mais simples dos LSTMs que compartilham muitas das mesmas propriedades. Vamos começar analisando os LSTMs e, em seguida, veremos como as GRUs são diferentes.
Redes LSTM.
Na parte 3, examinamos como o problema do gradiente de fuga impede que os RNNs padrão aprendam dependências de longo prazo. Os LSTMs foram projetados para combater gradientes de desaparecimento por meio de um mecanismo de disparo. Para entender o que isso significa, vamos ver como um LSTM calcula um estado oculto (estou usando para significar multiplicação elementar):
Essas equações parecem bastante complicadas, mas na verdade não são tão difíceis. Primeiro, observe que uma camada LSTM é apenas outra maneira de calcular um estado oculto. Anteriormente, calculamos o estado oculto como. As entradas para esta unidade foram, a entrada atual na etapa e o estado oculto anterior. A saída foi um novo estado oculto. Uma unidade LSTM faz exatamente a mesma coisa, apenas de uma maneira diferente! Isso é fundamental para entender o quadro geral. Você pode essencialmente tratar as unidades LSTM (e GRU) como caixas pretas. Dada a entrada atual e o estado oculto anterior, eles calculam o próximo estado oculto de alguma forma.
Com isso em mente, vamos tentar ter uma intuição de como uma unidade LSTM calcula o estado oculto. Chris Olah tem um excelente post que entra em detalhes sobre isso e para evitar a duplicação de seus esforços, vou apenas dar uma breve explicação aqui. Eu recomendo que você leia o post dele para uma visão mais profunda e visualizações agradáveis. Mas, para resumir:
são chamados os portões de entrada, esqueça e saída, respectivamente. Note que eles têm exatamente as mesmas equações, apenas com matrizes de parâmetros diferentes. Eles se importam, chamados de portas, porque a função sigmoide esmaga os valores desses vetores entre 0 e 1, e multiplicando-os elementarmente por outro vetor, você define quanto desse outro vetor você quer "deixar passar". O gate de entrada define quanto do estado recém-calculado para a entrada atual que você quer deixar passar. O portão do esquecimento define quanto do estado anterior você quer deixar passar. Por fim, o gate de saída define quanto do estado interno você deseja expor à rede externa (camadas superiores e o próximo intervalo de tempo). Todos os portões têm as mesmas dimensões, o tamanho do seu estado oculto. é uma candidata & # 8220; & # 8221; estado oculto que é calculado com base na entrada atual e no estado oculto anterior. É exatamente a mesma equação que tivemos em nosso RNN baunilha, nós apenas renomeamos os parâmetros e para e. No entanto, em vez de tomar como o novo estado oculto como fizemos no RNN, vamos usar o gate de entrada de cima para pegar um pouco dele. é a memória interna da unidade. É uma combinação da memória anterior multiplicada pelo gate forget, e o estado oculto recém-calculado, multiplicado pelo gate de entrada. Assim, intuitivamente, é uma combinação de como queremos combinar a memória anterior e a nova entrada. Poderíamos optar por ignorar completamente a memória antiga (esquecer o gate de todos os 0) ou ignorar completamente o estado recém-computado (porta de entrada todos os 0s), mas muito provavelmente queremos algo entre esses dois extremos. Dada a memória, finalmente calculamos o estado oculto da saída multiplicando a memória pelo gate de saída. Nem toda a memória interna pode ser relevante para o estado oculto usado por outras unidades na rede. Gating LSTM. Chung, Junyoung, et al. "Avaliação empírica de redes neurais recorrentes gated na modelagem de seqüências. & # 8221; (2014)
Intuitivamente, as RNNs simples podem ser consideradas um caso especial de LSTMs. Se você consertar o gate de entrada todos os 1's, o gate de esquecimento para todos os 0 (você sempre esquece a memória anterior) e o gate de saída para todos os "one" (você expor toda a memória) você quase obter RNN padrão. Há apenas um adicional que atrasa a saída um pouco. O mecanismo de ativação é o que permite que os LSTMs modelem explicitamente as dependências de longo prazo. Aprendendo os parâmetros para seus portões, a rede aprende como sua memória deve se comportar.
Notavelmente, existem várias variações na arquitetura básica do LSTM. Um comum é criar conexões peephole que permitem que as portas não dependam apenas do estado oculto anterior, mas também do estado interno anterior, adicionando um termo adicional nas equações do gate. Existem muitas outras variações. LSTM: Um Search Space Odyssey avalia empiricamente diferentes arquiteturas LSTM.
A ideia por trás de uma camada GRU é bastante semelhante à de uma camada LSTM, assim como as equações.
Um GRU possui dois portões, um gate de reset e um gate de atualização. Intuitivamente, o gate de reset determina como combinar a nova entrada com a memória anterior, e o gate de atualização define quanto da memória anterior deve ser mantida. Se definirmos a redefinição para todos os 1 e atualizar o gate para todos os 0, chegaremos novamente ao nosso modelo RNN simples. A idéia básica de usar um mecanismo de bloqueio para aprender dependências de longo prazo é a mesma que em um LSTM, mas existem algumas diferenças fundamentais:
Um GRU tem duas portas, um LSTM tem três portas. As GRUs não possuem e a memória interna () é diferente do estado oculto exposto. Eles não possuem o gate de saída que está presente nos LSTMs. As portas de entrada e de esquecimento são acopladas por um gate de atualização e o gate de reset é aplicado diretamente ao estado oculto anterior. Assim, a responsabilidade do gate reset em um LSTM é realmente dividida em ambos e. Não aplicamos uma segunda não-linearidade ao calcular a saída. GRU Gating. Chung, Junyoung, et al. “Avaliação empírica de redes neurais recorrentes bloqueadas na modelagem de seqüências.” (2014)
GRU vs LSTM.
Agora que você viu dois modelos para combater o problema do gradiente de desaparecimento, você pode estar se perguntando: Qual deles usar? As GRUs são muito novas (2014), e suas compensações ainda não foram totalmente exploradas. De acordo com avaliações empíricas em Avaliação Empírica de Redes Neurais Recorrentes Conectadas em Modelagem de Seqüências e uma Exploração Empírica de Arquiteturas de Rede Recorrentes, não há um vencedor claro. Em muitas tarefas, ambas as arquiteturas produzem desempenho comparável e hiperparâmetros de ajuste, como o tamanho da camada, é provavelmente mais importante do que escolher a arquitetura ideal. As GRUs têm menos parâmetros (U e W são menores) e, portanto, podem treinar um pouco mais rápido ou precisar de menos dados para generalizar. Por outro lado, se você tiver dados suficientes, o maior poder expressivo dos LSTMs pode levar a melhores resultados.
Implementação.
Vamos voltar para a implementação do Modelo de linguagem da parte 2 e vamos usar as unidades de GRU em nosso RNN. Não há nenhuma razão de princípio porque eu escolhi GRUs ao invés de LSTMs nesta parte (outra que eu também queria me familiarizar mais com GRUs). Suas implementações são quase idênticas, então você deve ser capaz de modificar o código para ir do GRU para o LSTM facilmente alterando as equações.
Nós baseamos o código em nossa implementação anterior do Theano. Lembre-se de que uma camada GRU (LSTM) é apenas outra maneira de calcular o estado oculto. Então, tudo o que precisamos fazer é alterar o cálculo do estado oculto na nossa função de propagação direta.
Em nossa implementação, também adicionamos unidades de polarização. É bastante típico que estes não sejam mostrados nas equações. É claro que também precisamos alterar a inicialização de nossos parâmetros e porque agora eles têm tamanhos diferentes. Eu não mostro o código de inicialização aqui, mas está no Gitub. Eu também adicionei uma camada de incorporação de palavras, mas mais sobre isso abaixo.
Isso foi bem simples. Mas e os gradientes? Poderíamos derivar os gradientes para e manualmente usando a regra da cadeia, assim como fizemos antes. Mas, na prática, a maioria das pessoas usa bibliotecas como a Theano que suportam auto-diferenciação de expressões. Se você for de alguma forma forçado a calcular os gradientes, provavelmente desejará modularizar diferentes unidades e ter sua própria versão de autodiferenciação usando a regra da cadeia. Nós deixamos Theano calcular os gradientes para nós:
Isso é muito bonito. Para obter melhores resultados, também usamos alguns truques adicionais em nossa implementação.
Usando o rmsprop para atualizações de parâmetros.
Na parte 2, usamos a versão mais básica do Descentramento Estocástico de Gradiente (SGD) para atualizar nossos parâmetros. Acontece que esta não é uma ótima idéia. Se você definir sua taxa de aprendizado baixa o suficiente, a SGD tem a garantia de avançar em direção a uma boa solução, mas na prática isso levaria muito tempo. Existe uma série de variações comumente usadas no SGD, incluindo o Método Momentum (Nesterov), AdaGrad, AdaDelta e rmsprop. Este post contém uma boa visão geral de muitos desses métodos. Eu também estou planejando explorar a implementação de cada um desses métodos em detalhes em um post futuro. Para esta parte do tutorial eu escolhi ir com o rmsprop. A idéia básica por trás do rmsprop é ajustar a taxa de aprendizado por parâmetro de acordo com a soma (suavizada) dos gradientes anteriores. Intuitivamente, isso significa que os recursos que ocorrem com frequência obtêm uma taxa de aprendizado menor (porque a soma de seus gradientes é maior) e os recursos raros obtêm uma taxa de aprendizado maior.
A implementação do rmsprop é bem simples. Para cada parâmetro nós mantemos uma variável de cache e durante a descida de gradiente nós atualizamos o parâmetro e o cache da seguinte forma (exemplo para):
O decaimento é tipicamente definido como 0,9 ou 0,95 e o termo 1e-6 é adicionado para evitar a divisão por 0.
Adicionando uma camada de incorporação.
A utilização de word embeddings, como word2vec e GloVe, é um método popular para melhorar a precisão do seu modelo. Em vez de usar vetores quentes para representar nossas palavras, os vetores de baixa dimensão aprendidos usando word2vec ou GloVe possuem significado semântico & # 8211; palavras semelhantes têm vetores semelhantes. Usar esses vetores é uma forma de pré-treinamento. Intuitivamente, você está dizendo à rede quais palavras são semelhantes para que ela precise aprender menos sobre a linguagem. Usar vetores pré-treinados é particularmente útil se você não possui muitos dados porque permite que a rede generalize para palavras invisíveis. Eu não usei vetores de palavras pré-treinados em meus experimentos, mas adicionar uma camada de incorporação (a matriz em nosso código) facilita a conexão. A matriz de incorporação é realmente apenas uma tabela de pesquisa & # 8211; o vetor da coluna i corresponde à palavra i em nosso vocabulário. Ao atualizar a matriz, estamos aprendendo vetores de palavras por nós mesmos, mas eles são muito específicos para a nossa tarefa (e conjunto de dados) e não tão gerais quanto aqueles que você pode baixar, que são treinados em milhões ou bilhões de documentos.
Adicionando uma segunda camada GRU.
Adicionar uma segunda camada à nossa rede permite que nosso modelo capture interações de nível superior. Você poderia adicionar camadas adicionais, mas eu não tentei isso para essa experiência. Você provavelmente verá retornos decrescentes após 2-3 camadas e, a menos que tenha uma quantidade enorme de dados (o que não é o caso), é improvável que mais camadas façam uma grande diferença e possam levar a superajuste.
Adicionando uma segunda camada à nossa rede é simples, nós (novamente) só precisamos modificar a função de cálculo e inicialização de propagação direta.
Uma nota sobre desempenho.
Eu recebi perguntas sobre isso no passado, então quero esclarecer que o código que mostrei aqui não é muito eficiente. É otimizado para maior clareza e foi escrito principalmente para fins educacionais. É provavelmente bom o suficiente para brincar com o modelo, mas você não deve usá-lo na produção ou esperar treinar em um grande conjunto de dados com ele. Existem muitos truques para otimizar o desempenho do RNN, mas talvez o mais importante seja agrupar suas atualizações. Em vez de aprender de uma frase de cada vez, você deseja agrupar sentenças do mesmo tamanho (ou até mesmo preencher todas as sentenças para ter o mesmo tamanho) e, em seguida, executar multiplicações de matriz grandes e somar gradientes para todo o lote. Isso porque essas grandes multiplicações de matrizes são eficientemente tratadas por uma GPU. Ao não fazer isso, podemos obter pouca aceleração do uso de uma GPU e o treinamento pode ser extremamente lento.
Portanto, se você quiser treinar um modelo grande, é altamente recomendável usar uma das bibliotecas Deep Learning existentes que são otimizadas para desempenho. Um modelo que levaria dias / semanas para treinar com o código acima levará apenas algumas horas com essas bibliotecas. Eu pessoalmente gosto de Keras, que é bastante simples de usar e vem com bons exemplos para RNNs.
Para poupá-lo da dor de treinar um modelo durante muitos dias, treinei um modelo muito semelhante ao da parte 2. Usei um tamanho de vocabulário de 8000, mapeei palavras em vetores de 48 dimensões e usei duas camadas de GRU de 128 dimensões. O notebook iPython contém código para carregar o modelo para que você possa brincar com ele, modificá-lo e usá-lo para gerar texto.
Aqui estão alguns bons exemplos da saída da rede (capitalização adicionada por mim).
Eu sou um bot e essa ação foi executada automaticamente. Eu me imponho ridiculamente bem o suficiente para apenas o youtube. Eu tenho um bom ritmo! Não há problema aqui, mas pelo menos ainda acenar! Depende de quão plausível é o meu julgamento. (com a constituição que torna impossível)
É interessante observar as dependências semânticas dessas sentenças ao longo de vários passos de tempo. Por exemplo, bot e automaticamente estão claramente relacionados, assim como os colchetes de abertura e fechamento. Nossa rede foi capaz de aprender isso, muito legal!
Isso é por agora. Espero que você tenha se divertido e por favor deixe perguntas / comentários nos comentários!

Redes LSTM para Análise de Sentimentos¶
Este tutorial tem como objetivo fornecer um exemplo de como uma Rede Neural Recorrente (RNN) usando a arquitetura LSTM (Long Short Term Memory) pode ser implementada usando Theano. Neste tutorial, esse modelo é usado para realizar a análise de sentimentos em análises de filmes do Conjunto de dados de revisão de filmes grandes, às vezes conhecido como o conjunto de dados do IMDB.
Nesta tarefa, dada uma revisão de filme, o modelo tenta prever se é positivo ou negativo. Esta é uma tarefa de classificação binária.
Como mencionado anteriormente, os scripts fornecidos são usados ​​para treinar uma rede neural recorrente LSTM no conjunto de dados do Conjunto de dados de revisão de filme grande.
Embora o conjunto de dados seja público, neste tutorial nós fornecemos uma cópia do conjunto de dados que foi pré-processado de acordo com as necessidades dessa implementação do LSTM. A execução do código fornecido neste tutorial fará o download automático dos dados para o diretório local. Para usar seus próprios dados, use um (script de pré-processamento) fornecido como parte deste tutorial.
Uma vez que o modelo é treinado, você pode testá-lo com seu próprio corpus usando o dicionário de índice de palavras (imdb. dict. pkl. gz) fornecido como parte deste tutorial.
Em uma rede neural recorrente tradicional, durante a fase de propagação de gradiente para trás, o sinal de gradiente pode ser multiplicado por um grande número de vezes (tantos quanto o número de timesteps) pela matriz de peso associada às conexões entre os neurônios do camada oculta recorrente. Isso significa que a magnitude dos pesos na matriz de transição pode ter um forte impacto no processo de aprendizagem.
Se os pesos nessa matriz forem pequenos (ou, mais formalmente, se o principal autovalor da matriz de peso for menor que 1.0), isso pode levar a uma situação chamada gradientes de fuga, onde o sinal de gradiente fica tão pequeno que o aprendizado se torna muito lento ou pára de funcionar completamente. Também pode dificultar a tarefa de aprender dependências de longo prazo nos dados. Por outro lado, se os pesos nessa matriz forem grandes (ou, mais uma vez, mais formalmente, se o principal autovalor da matriz de peso for maior que 1,0), isso poderá levar a uma situação em que o sinal de gradiente é tão grande que pode causar aprendizado. para divergir. Isso é geralmente chamado de gradiente explosivo.
Essas questões são a principal motivação por trás do modelo LSTM, que introduz uma nova estrutura chamada célula de memória (veja a Figura 1 abaixo). Uma célula de memória é composta de quatro elementos principais: uma porta de entrada, um neurônio com uma conexão auto-recorrente (uma conexão a si mesma), uma porta de esquecimento e uma porta de saída. A conexão auto-recorrente tem um peso de 1,0 e garante que, salvo qualquer interferência externa, o estado de uma célula de memória possa permanecer constante de um ponto no tempo para outro. Os portões servem para modular as interações entre a própria célula de memória e seu ambiente. O gate de entrada pode permitir que o sinal de entrada altere o estado da célula de memória ou bloqueie-a. Por outro lado, a porta de saída pode permitir que o estado da célula de memória tenha um efeito sobre outros neurônios ou a impeça. Finalmente, o gate do forget pode modular a conexão auto-recorrente da célula de memória, permitindo que a célula se lembre ou esqueça do estado anterior, conforme necessário.
Figura 1: Ilustração de uma célula de memória LSTM.
As equações abaixo descrevem como uma camada de células de memória é atualizada a cada timestep. Nestas equações:
é a entrada para a camada de célula de memória no tempo,,,,, e são matrizes de peso, e são vetores de polarização.
Primeiro, calculamos os valores para, a porta de entrada e o valor candidato para os estados das células de memória no momento:
Segundo, calculamos o valor para a ativação das células de memória & # 8217; esqueça os portões da hora:
Dado o valor da ativação do gate de entrada, a ativação do forget gate e o valor do estado candidato, podemos calcular as células de memória & # 8217; novo estado na hora:
Com o novo estado das células de memória, podemos calcular o valor de suas portas de saída e, subsequentemente, suas saídas:
O modelo que usamos neste tutorial é uma variação do modelo LSTM padrão. Nesta variante, a ativação da porta de saída de uma célula não depende do estado da célula de memória. Isso nos permite executar parte do cálculo com mais eficiência (veja a nota de implementação, abaixo, para detalhes). Isso significa que, na variante que implementamos, não há matriz e a equação (5) é substituída pela equação (7):
Nosso modelo é composto por uma única camada LSTM seguida por uma camada média e uma camada de regressão logística, conforme ilustrado na Figura 2 abaixo. Assim, a partir de uma seqüência de entrada, as células de memória na camada LSTM produzirão uma seqüência de representação. Esta seqüência de representação é então calculada sobre todos os tempos, resultando na representação h. Por fim, essa representação é enviada a uma camada de regressão logística cujo objetivo é o rótulo de classe associado à sequência de entrada.
Figura 2: Ilustração do modelo usado neste tutorial. É composto por uma única camada LSTM seguida por pool médio ao longo do tempo e regressão logística.
Nota de implementação: No código incluído neste tutorial, as equações (1), (2), (3) e (7) são realizadas em paralelo para tornar a computação mais eficiente. Isso é possível porque nenhuma dessas equações depende de um resultado produzido pelas outras. Consegue-se concatenando as quatro matrizes em uma matriz de peso única e executando a mesma concatenação nas matrizes de peso para produzir a matriz e os vetores de polarização para produzir o vetor. Então, as ativações de pré-não-linearidade podem ser calculadas com:
O resultado é então fatiado para obter as ativações de pré-não-linearidade para,, e e as não linearidades são então aplicadas independentemente para cada uma.
Código - Citações - Contato
A implementação do LSTM pode ser encontrada nos dois arquivos a seguir:
lstm. py: roteiro principal. Define e treina o modelo. imdb. py: Script secundário. Lida com o carregamento e pré-processamento do conjunto de dados do IMDB.
Depois de baixar os dois scripts e colocá-los na mesma pasta, o usuário pode executar o código chamando:
O script baixará automaticamente os dados e os descomprimirá.
Nota: O código fornecido suporta os métodos de otimização Estocástico de Gradiente Descendente (SGD), AdaDelta e RMSProp. Você é aconselhado a usar AdaDelta ou RMSProp porque o SGD parece ter um desempenho ruim nesta tarefa com este modelo em particular.
Se você usar este tutorial, cite os seguintes documentos.
Introdução do modelo LSTM:
[pdf] Hochreiter, S., & amp; Schmidhuber, J. (1997). Longa memória de curto prazo. Computação Neural, 9 (8), 1735-1780.
Adição do portão do esquecimento ao modelo LSTM:
[pdf] Gers, F. A., Schmidhuber, J., & amp; Cummins, F. (2000). Aprendendo a esquecer: Previsão contínua com LSTM. Computação Neural, 12 (10), 2451-2471.
Papel LSTM mais recente:
[pdf] Graves, Alex. Marcação de sequência supervisionada com redes neurais recorrentes. Vol. 385. Springer, 2012.
Artigos relacionados a Theano:
[pdf] Bastien, Frédéric, Lamblin, Pascal, Pascanu, Razvan, Bergstra, James, Goodfellow, Ian, Bergeron, Arnaud, Bouchard, Nicolas e Bengio, Yoshua. Theano: novos recursos e melhorias de velocidade. Oficina da NIPS sobre Aprendizado Profundo e Aprendizado não supervisionado, 2012. [pdf] Bergstra, James, Breuleux, Olivier, Bastien, Frédéric, Lamblin, Pascal, Pascanu, Razvan, Desjardins, Guillaume, Turian, Joseph, Warde-Farley, David e Bengio, Yoshua. Theano: um compilador de expressões matemáticas de CPU e GPU. Em Proceedings of the Python para Scientific Computing Conference (SciPy), junho de 2010.
Por favor, envie um e-mail para Pierre Luc Carrier ou Kyunghyun Cho para qualquer relatório de problema ou feedback. Teremos o maior prazer em ouvi-lo.

Redes LSTM para Análise de Sentimentos¶
Este tutorial tem como objetivo fornecer um exemplo de como uma Rede Neural Recorrente (RNN) usando a arquitetura LSTM (Long Short Term Memory) pode ser implementada usando Theano. Neste tutorial, esse modelo é usado para realizar a análise de sentimentos em análises de filmes do Conjunto de dados de revisão de filmes grandes, às vezes conhecido como o conjunto de dados do IMDB.
Nesta tarefa, dada uma revisão de filme, o modelo tenta prever se é positivo ou negativo. Esta é uma tarefa de classificação binária.
Como mencionado anteriormente, os scripts fornecidos são usados ​​para treinar uma rede neural recorrente LSTM no conjunto de dados do Conjunto de dados de revisão de filme grande.
Embora o conjunto de dados seja público, neste tutorial nós fornecemos uma cópia do conjunto de dados que foi pré-processado de acordo com as necessidades dessa implementação do LSTM. A execução do código fornecido neste tutorial fará o download automático dos dados para o diretório local. Para usar seus próprios dados, use um (script de pré-processamento) fornecido como parte deste tutorial.
Uma vez que o modelo é treinado, você pode testá-lo com seu próprio corpus usando o dicionário de índice de palavras (imdb. dict. pkl. gz) fornecido como parte deste tutorial.
Em uma rede neural recorrente tradicional, durante a fase de propagação de gradiente para trás, o sinal de gradiente pode ser multiplicado por um grande número de vezes (tantos quanto o número de timesteps) pela matriz de peso associada às conexões entre os neurônios do camada oculta recorrente. Isso significa que a magnitude dos pesos na matriz de transição pode ter um forte impacto no processo de aprendizagem.
Se os pesos nessa matriz forem pequenos (ou, mais formalmente, se o principal autovalor da matriz de peso for menor que 1.0), isso pode levar a uma situação chamada gradientes de fuga, onde o sinal de gradiente fica tão pequeno que o aprendizado se torna muito lento ou pára de funcionar completamente. Também pode dificultar a tarefa de aprender dependências de longo prazo nos dados. Por outro lado, se os pesos nessa matriz forem grandes (ou, mais uma vez, mais formalmente, se o principal autovalor da matriz de peso for maior que 1,0), isso poderá levar a uma situação em que o sinal de gradiente é tão grande que pode causar aprendizado. para divergir. Isso é geralmente chamado de gradiente explosivo.
Essas questões são a principal motivação por trás do modelo LSTM, que introduz uma nova estrutura chamada célula de memória (veja a Figura 1 abaixo). Uma célula de memória é composta de quatro elementos principais: uma porta de entrada, um neurônio com uma conexão auto-recorrente (uma conexão a si mesma), uma porta de esquecimento e uma porta de saída. A conexão auto-recorrente tem um peso de 1,0 e garante que, salvo qualquer interferência externa, o estado de uma célula de memória possa permanecer constante de um ponto no tempo para outro. Os portões servem para modular as interações entre a própria célula de memória e seu ambiente. O gate de entrada pode permitir que o sinal de entrada altere o estado da célula de memória ou bloqueie-a. Por outro lado, a porta de saída pode permitir que o estado da célula de memória tenha um efeito sobre outros neurônios ou a impeça. Finalmente, o gate do forget pode modular a conexão auto-recorrente da célula de memória, permitindo que a célula se lembre ou esqueça do estado anterior, conforme necessário.
Figura 1: Ilustração de uma célula de memória LSTM.
As equações abaixo descrevem como uma camada de células de memória é atualizada a cada timestep. In these equations:
is the input to the memory cell layer at time , , , , , , , and are weight matrices , , and are bias vectors.
First, we compute the values for , the input gate, and the candidate value for the states of the memory cells at time :
Second, we compute the value for , the activation of the memory cells’ forget gates at time :
Given the value of the input gate activation , the forget gate activation and the candidate state value , we can compute the memory cells’ new state at time :
With the new state of the memory cells, we can compute the value of their output gates and, subsequently, their outputs:
The model we used in this tutorial is a variation of the standard LSTM model. In this variant, the activation of a cell’s output gate does not depend on the memory cell’s state . This allows us to perform part of the computation more efficiently (see the implementation note, below, for details). This means that, in the variant we have implemented, there is no matrix and equation (5) is replaced by equation (7):
Our model is composed of a single LSTM layer followed by an average pooling and a logistic regression layer as illustrated in Figure 2 below. Thus, from an input sequence , the memory cells in the LSTM layer will produce a representation sequence . This representation sequence is then averaged over all timesteps resulting in representation h. Finally, this representation is fed to a logistic regression layer whose target is the class label associated with the input sequence.
Figure 2 : Illustration of the model used in this tutorial. It is composed of a single LSTM layer followed by mean pooling over time and logistic regression.
Implementation note : In the code included this tutorial, the equations (1), (2), (3) and (7) are performed in parallel to make the computation more efficient. This is possible because none of these equations rely on a result produced by the other ones. It is achieved by concatenating the four matrices into a single weight matrix and performing the same concatenation on the weight matrices to produce the matrix and the bias vectors to produce the vector . Then, the pre-nonlinearity activations can be computed with:
The result is then sliced to obtain the pre-nonlinearity activations for , , , and and the non-linearities are then applied independently for each.
Code - Citations - Contact¶
The LSTM implementation can be found in the two following files:
lstm. py: Main script. Defines and train the model. imdb. py: Secondary script. Handles the loading and preprocessing of the IMDB dataset.
After downloading both scripts and putting both in the same folder, the user can run the code by calling:
The script will automatically download the data and decompress it.
Note : The provided code supports the Stochastic Gradient Descent (SGD), AdaDelta and RMSProp optimization methods. You are advised to use AdaDelta or RMSProp because SGD appears to performs poorly on this task with this particular model.
If you use this tutorial, please cite the following papers.
Introduction of the LSTM model:
[pdf] Hochreiter, S., & Schmidhuber, J. (1997). Long short-term memory. Neural computation, 9(8), 1735-1780.
Addition of the forget gate to the LSTM model:
[pdf] Gers, F. A., Schmidhuber, J., & Cummins, F. (2000). Learning to forget: Continual prediction with LSTM. Neural computation, 12(10), 2451-2471.
More recent LSTM paper:
[pdf] Graves, Alex. Supervised sequence labelling with recurrent neural networks. Vol. 385. Springer, 2012.
Papers related to Theano:
[pdf] Bastien, Frédéric, Lamblin, Pascal, Pascanu, Razvan, Bergstra, James, Goodfellow, Ian, Bergeron, Arnaud, Bouchard, Nicolas, and Bengio, Yoshua. Theano: new features and speed improvements. NIPS Workshop on Deep Learning and Unsupervised Feature Learning, 2012. [pdf] Bergstra, James, Breuleux, Olivier, Bastien, Frédéric, Lamblin, Pascal, Pascanu, Razvan, Desjardins, Guillaume, Turian, Joseph, Warde-Farley, David, and Bengio, Yoshua. Theano: a CPU and GPU math expression compiler. In Proceedings of the Python for Scientific Computing Conference (SciPy), June 2010.
Please email Pierre Luc Carrier or Kyunghyun Cho for any problem report or feedback. We will be glad to hear from you.

Forex lstm

The purpose of this code is to predict the future values of forex market for the general currencies.
At first, I made a unified data frame, this unified data frame is combination of 11 forex market data sets for the most widely traded currencies plus a group of 900 economic indicators.
After combining these 911 data sets in the unified data frame with no problems of any sort after being tested, I begun the LSTM neural network which I also tested with just single data set and it works great.
The problem begins when I combined the unified data frame with the LSTM neural network.