Python estratégia de negociação

Biblioteca de Negociação Algorítmica Python.
O PyAlgoTrade é uma Biblioteca de Negociação Algorítmica Python, com foco em backtesting e suporte para negociação de papéis e negociação ao vivo. Digamos que você tenha uma ideia para uma estratégia de negociação e gostaria de avaliá-la com dados históricos e ver como ela se comporta. O PyAlgoTrade permite que você faça isso com o mínimo de esforço.
Principais características.
Totalmente documentado. Evento dirigido. Suporta ordens Market, Limit, Stop e StopLimit. Suporta o Yahoo! Arquivos Finanças, Google Finance e NinjaTrader CSV. Suporta qualquer tipo de dados de séries temporais no formato CSV, por exemplo, o Quandl. Suporte de negociação Bitcoin através do Bitstamp. Indicadores técnicos e filtros como SMA, WMA, EMA, RSI, Bandas de Bollinger, expoente de Hurst e outros. Métricas de desempenho como a taxa de Sharpe e a análise de rebaixamento. Manipulando eventos do Twitter em tempo real. Criador de perfil de eventos. Integração TA-Lib.
Muito fácil de dimensionar horizontalmente, isto é, usando um ou mais computadores para fazer backtest de uma estratégia.
O PyAlgoTrade é gratuito, de código aberto e está licenciado sob a Licença Apache, Versão 2.0.

Backtesting um Crossover Média Móvel em Python com pandas.
Backtesting um Crossover Média Móvel em Python com pandas.
No artigo anterior sobre Ambientes de Backtesting de Pesquisa Em Python Com Pandas, criamos um ambiente de backtesting baseado em pesquisa orientado a objeto e o testamos em uma estratégia de previsão aleatória. Neste artigo, utilizaremos as máquinas que introduzimos para realizar pesquisas sobre uma estratégia real, a saber, o Moving Average Crossover na AAPL.
Estratégia de Crossover Média Móvel.
A técnica Moving Average Crossover é uma estratégia de momentum simplista extremamente bem conhecida. Muitas vezes, é considerado o exemplo "Hello World" para negociação quantitativa.
A estratégia descrita aqui é longa apenas. Dois filtros de média móvel simples separados são criados, com períodos de lookback variáveis, de uma determinada série temporal. Os sinais para comprar o ativo ocorrem quando a média móvel de lookback menor excede a média móvel de lookback mais longa. Se a média mais longa subsequentemente exceder a média mais curta, o ativo é vendido de volta. A estratégia funciona bem quando uma série temporal entra em um período de forte tendência e então lentamente inverte a tendência.
Para este exemplo, escolhi a Apple, Inc. (AAPL) como a série temporal, com uma pequena retrospectiva de 100 dias e uma longa retrospectiva de 400 dias. Este é o exemplo fornecido pela biblioteca de negociação algorítmica de tirolesa. Assim, se quisermos implementar nosso próprio backtester, precisamos garantir que ele corresponda aos resultados em zipline, como um meio básico de validação.
Implementação.
Certifique-se de seguir o tutorial anterior aqui, que descreve como a hierarquia inicial do objeto para o backtester é construída, caso contrário, o código abaixo não funcionará. Para esta implementação específica, usei as seguintes bibliotecas:
A implementação do ma_cross. py requer o backtest. py do tutorial anterior. O primeiro passo é importar os módulos e objetos necessários:
Como no tutorial anterior, vamos subclassificar a classe base abstrata Strategy para produzir MovingAverageCrossStrategy, que contém todos os detalhes sobre como gerar os sinais quando as médias móveis de AAPL se cruzam.
O objeto requer um short_window e um long_window no qual operar. Os valores foram definidos para padrões de 100 dias e 400 dias, respectivamente, que são os mesmos parâmetros usados ​​no exemplo principal da tirolesa.
As médias móveis são criadas usando a função pandas rolling_mean no preço de fechamento das barras ['Fechar'] do estoque AAPL. Uma vez que as médias móveis individuais tenham sido construídas, a série de sinais é gerada ajustando-se a coluna igual a 1,0 quando a média móvel curta é maior que a média móvel longa, ou 0,0. A partir disso, as ordens de posições podem ser geradas para representar sinais de negociação.
O MarketOnClosePortfolio é subclassificado do Portfolio, que é encontrado em backtest. py. É quase idêntica à implementação descrita no tutorial anterior, com a exceção de que as negociações agora são executadas em uma base Close-to-Close, em vez de uma base Open-to-Open. Para detalhes sobre como o objeto Portfolio está definido, veja o tutorial anterior. Deixei o código para ser completo e manter este tutorial autocontido:
Agora que as classes MovingAverageCrossStrategy e MarketOnClosePortfolio foram definidas, uma função __main__ será chamada para unir todas as funcionalidades. Além disso, o desempenho da estratégia será examinado através de um gráfico da curva de capital.
O objeto DataReader dos pandas baixa os preços do OHLCV das ações da AAPL para o período de 1º de janeiro de 1990 a 1º de janeiro de 2002, quando os sinais DataFrame são criados para gerar os sinais de longa duração. Subsequentemente, a carteira é gerada com uma base de capital inicial de 100.000 USD e os retornos são calculados na curva de capital.
O passo final é usar o matplotlib para traçar um gráfico de dois dígitos de ambos os preços AAPL, sobrepostos às médias móveis e sinais de compra / venda, bem como a curva de capital com os mesmos sinais de compra / venda. O código de plotagem é obtido (e modificado) a partir do exemplo de implementação da tirolesa.
A saída gráfica do código é a seguinte. Eu usei o comando IPython% paste para colocar isso diretamente no console do IPython enquanto no Ubuntu, para que a saída gráfica permanecesse visível. Os upticks rosa representam a compra do estoque, enquanto os downticks pretos representam a venda de volta:
AAPL Moving Average Crossover Performance de 01-01-1990 a 01-01-2001.
Como pode ser visto, a estratégia perde dinheiro ao longo do período, com cinco operações de ida e volta. Isso não é surpreendente, dado o comportamento da AAPL no período, que estava em ligeira tendência decrescente, seguido por um significativo aumento a partir de 1998. O período de retrospectiva dos sinais médios móveis é bastante grande e isso impactou o lucro do comércio final. , que de outra forma poderia ter tornado a estratégia lucrativa.
Nos artigos subseqüentes, criaremos um meio mais sofisticado de analisar o desempenho, além de descrever como otimizar os períodos de lookback dos sinais médios móveis individuais.
A Quantcademy.
Participe do portal de associação da Quantcademy que atende à crescente comunidade de traders de quantificação de varejo e aprenda como aumentar a lucratividade de sua estratégia.
Negociação Algorítmica Bem Sucedida.
Como encontrar novas ideias de estratégia de negociação e avaliá-las objetivamente para o seu portfólio usando um mecanismo de backtesting personalizado no Python.
Comércio Algorítmico Avançado.
Como implementar estratégias de negociação avançadas usando análise de séries temporais, aprendizado de máquina e estatísticas Bayesianas com R e Python.

Python da estratégia de negociação
Se você é um profissional ou um investidor e gostaria de adquirir um conjunto de habilidades de negociação quantitativa, você está no lugar certo.
O curso de Negociação com o Python fornecerá as melhores ferramentas e práticas para pesquisa de negociação quantitativa, incluindo funções e scripts escritos por especialistas em negociações quantitativas. O curso dá o máximo impacto ao seu tempo e dinheiro investidos. Centra-se na aplicação prática da programação à negociação, em vez da informática teórica. O curso se pagará rapidamente economizando seu tempo no processamento manual de dados. Você passará mais tempo pesquisando sua estratégia e implementando negociações lucrativas.
Visão geral do curso.
Parte 1: Noções básicas Você aprenderá por que o Python é uma ferramenta ideal para negociações quantitativas. Começaremos configurando um ambiente de desenvolvimento e, em seguida, apresentaremos as bibliotecas científicas.
Parte 2: Manipulando os dados Aprenda como obter dados de várias fontes gratuitas como Yahoo Finance, CBOE e outros sites. Leia e escreva vários formatos de dados, incluindo arquivos CSV e Excel.
Parte 3: Pesquisando estratégias Aprenda a calcular P & L e acompanhar as métricas de desempenho como Sharpe e Drawdown. Construa uma estratégia de negociação e otimize seu desempenho. Vários exemplos de estratégias são discutidos nesta parte.
Parte 4: Indo ao vivo! Esta parte é centralizada em torno da API Interactive Brokers. Você aprenderá como obter dados de estoque em tempo real e fazer pedidos ao vivo.
Muito código de exemplo.
O material do curso consiste em 'cadernos' que contêm texto juntamente com código interativo como este. Você poderá aprender interagindo com o código e modificando-o ao seu gosto. Será um ótimo ponto de partida para escrever suas próprias estratégias.
Embora alguns tópicos sejam explicados detalhadamente para ajudá-lo a entender os conceitos subjacentes, na maioria dos casos você não precisará escrever seu próprio código de baixo nível, devido ao suporte de bibliotecas de código aberto existentes:
A biblioteca TradingWithPython combina grande parte da funcionalidade discutida neste curso como uma função pronta para uso e será usada durante todo o curso. Os pandas fornecerão a você todo o poder de levantamento pesado necessário para a compactação de dados.
Todo o código é fornecido sob a licença BSD, permitindo seu uso em aplicações comerciais.
Classificação do curso.
Um piloto do curso foi realizado na primavera de 2013, isso é o que os alunos puderam dizer:
Matej curso bem planejado e bom treinador. Definitivamente vale seu preço e meu tempo Lave Jev obviamente sabia suas coisas. A profundidade da cobertura foi perfeita. Se Jev executar algo assim novamente, eu serei o primeiro a me inscrever. John Phillips Seu curso realmente me fez começar a considerar o python para análise de sistemas de estoque.

LearnDataSci.
Home »Python for Finance, Parte 3: Uma estratégia de negociação média móvel.
Python for Finance, Parte 3: Uma estratégia de negociação média móvel.
Python for Finance, Parte 3: Estratégia de Negociação Média Móvel.
No artigo anterior desta série, continuamos a discutir conceitos gerais que são fundamentais para o design e backtesting de qualquer estratégia de negociação quantitativa. Em detalhe, nós discutimos sobre.
retornos relativos e de log, suas propriedades, diferenças e como usar cada um, uma representação genérica de uma estratégia de negociação usando os pesos de ativos normalizados $ w_i \ left (t \ right) $ para um conjunto de $ N $
ativos negociáveis ​​e uma estratégia muito simples, mas rentável, a maneira de representá-lo e como calcular seu retorno total.
Se você acabou de encontrar este artigo, consulte a Parte 1 e a Parte 2.
Neste artigo, começaremos a projetar uma estratégia de negociação mais complexa, que terá pesos não constantes $ w_i \ left (t \ right) $ e, assim, se adaptará de alguma forma ao comportamento recente do preço de nossos ativos.
Voltaremos a supor que temos um universo de apenas 3 ativos negociáveis, os estoques da Apple e da Microsoft (com tickers AAPL e MSFT, respectivamente) e o índice S & P 500 (ticker ^ GSPC).
Como um lembrete, o dataframe contendo os três & # 8220; limpos & # 8221; preço timeeries tem o seguinte formato:
Considerações Médias Móveis.
Uma das estratégias de negociação mais antigas e mais simples que existe é aquela que usa uma média móvel das séries de tempo de preço (ou retornos) para representar a tendência recente do preço.
A ideia é bem simples, mas poderosa; se usarmos uma média móvel de 100 dias das nossas séries de tempo de preço, então uma porção significativa do ruído de preço diário terá sido "calculada como média" & # 8221 ;. Assim, podemos observar mais de perto o comportamento de longo prazo do ativo.
Vamos, novamente, calcular as médias móveis simples rolantes (SMA) dessas três séries temporais como segue. Lembre-se, novamente, que ao calcular o SMA de $ M $ dias, os primeiros $ M-1 $ não são válidos, pois os preços M $ M $ são necessários para o primeiro ponto de dados da média móvel.
Vamos traçar os últimos $ 2 $ anuais para essas três séries temporais para as ações da Microsoft, para ter uma idéia de como elas se comportam.
É fácil observar que as séries de tempos da SMA são muito menos barulhentas do que as séries temporais de preços originais. No entanto, isso tem um custo: as séries de tempo da SMA ficam abaixo das séries temporais de preços originais, o que significa que as mudanças na tendência são vistas apenas com um atraso (lag) de $ L $ dias.
Quanto custa esse lag $ L $? Para uma média móvel SMA calculada usando $ M $ dias, o atraso é de aproximadamente $ \ frac $ days. Assim, se estamos usando um SMA de $ 100 $ nos dias, isso significa que podemos estar atrasados ​​em quase $ 50 $ dias, o que pode afetar significativamente nossa estratégia.
Uma maneira de reduzir o atraso induzido pelo uso do SMA é usar a chamada Média Móvel Exponencial (EMA), definida como.
& amp; \ text \ left (t \ right) & amp; = \ left (1- \ alpha \ right) \ text \ left (t-1 \ right) + \ alpha \ p \ left (t \ right) \ & amp; \ text \ left (t_0 \ right) & amp; = p \ left (t_0 \ right)
onde $ p \ left (t \ right) $ é o preço no momento $ t $ e $ \ alpha $ é chamado de parâmetro de decaimento para o EMA. $ \ alpha $ está relacionado ao lag como $$ \ alpha = \ frac $$ e ao comprimento da janela (span) $ M $ como $$ \ alpha = \ frac $$.
A razão pela qual o EMA reduz o atraso é que ele coloca mais peso em observações mais recentes, enquanto o SMA avalia todas as observações igualmente por $ \ frac $. Usando Pandas, calcular a média móvel exponencial é fácil. Precisamos fornecer um valor de retardo, a partir do qual o parâmetro de decaimento $ \ alpha $ é calculado automaticamente. Para poder comparar com o SMA de curto prazo, usaremos um valor de span de $ 20 $.
Uma estratégia de negociação média móvel.
Vamos tentar usar as médias móveis calculadas acima para projetar uma estratégia de negociação. Nossa primeira tentativa será relativamente difícil e vai tirar proveito do fato de que uma série de tempo média móvel (seja SMA ou EMA) fica atrás do comportamento real do preço.
Tendo isso em mente, é natural supor que, quando ocorre uma mudança no comportamento de longo prazo do ativo, as séries de tempo reais de preço reagirão mais rapidamente do que o da EMA. Portanto, vamos considerar o cruzamento dos dois como potenciais sinais de negociação.
Quando o preço timeseries $ p \ left (t \ right) $ cruza as datas e horas da EMA à esquerda (t \ right) $ abaixo, fechamos qualquer posição curta existente e compramos uma unidade do ativo.
Quando as séries de tempo de preço $ p \ left (t \ right) $ cruzarem as datas e horas da EMA (t \ right) $ acima, fecharemos qualquer posição longa existente e entraremos em curto (venderemos) uma unidade do ativo.
Como isso é traduzido para o framework descrito em nosso artigo anterior sobre os pesos $ w \ left (t \ right) $?
Bem, para esta estratégia, é muito estranho. Tudo o que precisamos é ter uma posição longa, ou seja, $ w_i \ left (t \ right) $ & gt; 0, desde que o preço esteja acima das séries temporais da EMA e uma posição curta, ou seja, $ w_i \ left (t \ right ) $ & lt; 0, desde que o preço timeseries esteja abaixo do timeseries da EMA.
Como, neste momento, ainda não estamos interessados ​​no dimensionamento da posição, vamos supor que usamos todos os nossos fundos disponíveis para negociar o ativo $ i $. Também vamos supor que nossos fundos sejam divididos igualmente entre todos os ativos de $ 3 $ (MSFT, AAPL e ^ GSPC).
Com base nessas suposições, nossa estratégia para cada um dos ativos $ i, i = 1, \ ldots, 3 $ pode ser traduzida da seguinte maneira:
Condição longa: se $ p_i \ left (t \ right) & gt; e_i \ left (t \ right) $, depois $ w_i \ left (t \ right) = \ frac $ Ir condição curta: Se $ p_i \ left (t \ right) & lt; e_i \ left (t \ right) $, depois $ w_i \ left (t \ right) = - \ frac $
Sempre que as condições de negociação são satisfeitas, os pesos são $ \ frac $ porque $ \ frac $ do total dos fundos são atribuídos a cada ativo e sempre que somos longos ou curtos, todos os fundos disponíveis são investidos.
Como isso é implementado em Python? O truque é pegar o sinal da diferença entre o preço $ p_i \ left (t \ right) $ e o EMA $ e_i \ left (t \ right) $.
Uma advertência final.
Antes de ver o desempenho dessa estratégia, vamos nos concentrar no primeiro dia $ t_o $ quando o preço das séries de tempo $ p \ left (t_o \ right) $ cruzar acima e das séries de tempo EMA $ e_i \ left (t_o \ right) $. Desde $ p \ left (t_o \ right) & gt; e_i \ left (t_o \ right) $. Nesse ponto, o peso da negociação $ w_i \ left (t_o \ right) $ torna-se positivo e, assim, de acordo com nossa estratégia de negociação, precisamos definir para esse dia $ w_i \ left (t_o \ right) = \ frac $.
Entretanto, tenha em mente que $ p \ left (t_o \ right) $ é o preço do ativo no fechamento do dia $ t_o $. Por esse motivo, não saberemos que $ p \ left (t_o \ right) & gt; e_i \ left (t_o \ right) $ até o fechamento do dia de negociação. Portanto, ao calcular os retornos da estratégia, assumir que no dia $ t_o $ nós tivemos uma posição longa é um erro; é o equivalente a nós chegarmos ao futuro, já que só sabemos que temos que ir muito longe no final do dia $ t_o $.
O melhor que podemos fazer é assumir que negociamos no final do dia $ t_o $. Portanto, nossa posição será longa começando no dia seguinte, $ t_o + 1 $. Isso é facilmente corrigido atrasando nossas posições de negociação em um dia, de modo que, no dia $ t_o $, nossa posição real é a do dia anterior $ t_o & # 8211; 1 $ e somente no dia $ t_o + 1 $ temos uma posição longa. Portanto:
Vamos examinar como são as séries temporais e a respectiva posição de negociação para um de nossos ativos, a Microsoft.
Agora que a posição que nossa estratégia determina a cada dia foi calculada, o desempenho dessa estratégia pode ser facilmente estimado. Para esse fim, precisaremos novamente dos retornos de log dos três ativos $ r_i \ left (t \ right) $. Estes são calculados como:
Observe que nossa estratégia negocia cada ativo separadamente e é independente de qual é o comportamento dos outros ativos. Se vamos ser longos ou curtos (e quanto) na MSFT não é de forma alguma afetado pelos outros dois ativos. Com isso em mente, os retornos de log diários da estratégia para cada ativo $ i $, $ r_ ^ s \ left (t \ right) $ são calculados como.
r_ ^ s \ left (t \ right) = w_i \ left (t \ right) r_i \ left (t \ right)
onde $ w_i \ left (t \ right) $ é a posição de estratégia no dia $ t $ que já foi atingido no final do pregão $ t-1 $.
O que isto significa?
Suponha que $ p \ left (t \ right) $ cruza acima de $ e_i \ left (t \ right) $ em algum momento durante a sessão de negociação na segunda-feira, dia $ t-1 $. Assumimos que ao fechar na segunda-feira nós compramos unidades suficientes de ativo $ i $ para gastar $ \ frac $ de nosso total de fundos, que é $ \ $ \ frac $ e que o preço que compramos é $ p \ left (t -1 \ right) = \ $ 10 $. Vamos supor também que na terça-feira, dia $ t $, o preço fecha em $ p \ left (t \ right) = \ $ 10.5 $. Então, nosso log-retorno para o ativo $ i $ na terça-feira é simplesmente.
O retorno real $ r_, i> ^ s \ left (t \ right) $ é.
r_, i> ^ s \ left (t \ right) = w_i \ left (t \ right) \ vezes \ left [\ exp \ left (r_i \ left (t \ right) \ right) & # 8211; 1 \ right] = \ frac.
Em termos de dólares, na terça-feira, dia $ t $, fizemos $ N \ times r_, i> ^ s \ left (t \ right) = \ $ \ frac $.
Para obter todos os retornos de log da estratégia para todos os dias, é necessário simplesmente multiplicar as posições da estratégia pelos retornos do log de ativos.
Lembrando que os retornos de log podem ser adicionados para mostrar o desempenho ao longo do tempo, vamos plotar os retornos de log cumulativos e os retornos relativos totais acumulados de nossa estratégia para cada um dos ativos.
Qual é o retorno total da estratégia?
Estritamente falando, só podemos adicionar retornos relativos para calcular os retornos da estratégia. Portanto $$ r_> ^ s \ left (t \ right) = \ sum_ ^ r_, i> ^ s \ left (t \ right) $$.
Vimos no artigo anterior, no entanto, que para valores pequenos dos retornos relativos, a seguinte aproximação contém $$ r_i \ left (t \ right) \ simeq r_, i> \ left (t \ right) $$
Assim, uma maneira alternativa é simplesmente adicionar todos os retornos de log da estratégia primeiro e depois convertê-los em retornos relativos. Vamos examinar o quão boa é essa aproximação.
Como podemos ver, por intervalos de tempo relativamente pequenos e por tanto tempo a suposição de que os retornos relativos são pequenos o suficiente, o cálculo dos retornos da estratégia total usando a aproximação log-retorno pode ser satisfatório. No entanto, quando a suposição de pequena escala se quebra, a aproximação é fraca. Portanto, o que precisamos lembrar o seguinte:
Os retornos de log podem e devem ser adicionados ao longo do tempo para um único ativo calcular as séries de tempo de retorno cumulativas ao longo do tempo. No entanto, ao somar (ou calcular a média) log-retornos entre ativos, deve-se ter cuidado. Retornos relativos podem ser adicionados, mas retornos de log somente se pudermos assumir seguramente que eles são uma aproximação suficientemente boa dos retornos relativos.
O desempenho geral anual da nossa estratégia pode ser calculado novamente como:
Pode-se observar que essa estratégia tem um desempenho significativamente inferior à estratégia de compra e manutenção apresentada no artigo anterior. Vamos compará-los novamente:
Qual estratégia é melhor?
Esta não é uma pergunta simples para alguém responder neste ponto. Quando precisamos escolher entre duas ou mais estratégias, precisamos definir uma métrica (ou métricas) com base na qual compará-las. Este tópico muito importante será abordado no próximo artigo.
Além disso, observamos neste último gráfico que o desempenho das duas estratégias não é constante ao longo do tempo. Existem alguns períodos em que um supera o outro e outros períodos quando não o é. Então, uma segunda questão que naturalmente surge é como podemos mitigar o risco de ser enganado & # 8221; por um bom desempenho de backtesting em um determinado período.
Georgios Efstathopoulos.
Georgios tem mais de 7 anos de experiência como analista quantitativo no setor financeiro e trabalhou extensivamente em modelos estatísticos e de aprendizado de máquina para negociação quantitativa, gestão de risco de mercado e crédito e modelagem comportamental. Georgios é PhD em Matemática Aplicada e Estatística no Imperial College London e é fundador e CEO da QuAnalytics Limited, uma consultoria focada em soluções quantitativas e analíticas de dados para indivíduos e organizações que desejam colher o potencial de seus próprios dados para expandir seus negócios. .
Recomendado.
Python for Finance, Parte I: Yahoo Finance API, pandas e matplotlib.
Em detalhes, no primeiro de nossos tutoriais, mostraremos como é fácil usar o Python para baixar dados financeiros de bancos de dados on-line gratuitos, manipular os dados baixados e, em seguida, criar alguns indicadores técnicos básicos que serão utilizados como base nossa estratégia quantitativa.
Python for Finance, Parte 2: Introdução às Estratégias Quantitativas de Negociação.
Com base nesses resultados, nosso objetivo final será criar uma estratégia comercial simples, porém realista. No entanto, primeiro precisamos passar por alguns dos conceitos básicos relacionados a estratégias quantitativas de negociação, bem como as ferramentas e técnicas no processo.
Top Cursos Online de Ciência de Dados em 2017.
A seguir, uma lista extensa de cursos e recursos de Ciência de Dados, de plataformas como Coursera, edX e Udacity, que fornecem as habilidades necessárias para se tornar um cientista de dados.
Ei, eu preciso de ajuda "# 8211; quando eu passo pelos tutoriais, o script pára de funcionar no segundo tutorial. Especificamente, quando eu tento a primeira coisa (depois de ligar tudo desde o primeiro tutorial)
Eu recebo: FileNotFoundError: [Errno 2] Nenhum tal arquivo ou diretório: & # 8216; ./data. pkl & # 8217;
Como posso consertar isso?
Além disso, no primeiro tutorial btw não gosta de ".ix & # 8221; então eu mudo para & # 8220;.loc & # 8221; b / c eu recebo este erro:
DeprecationWarning:.ix está obsoleto. Por favor, use.
.loc para indexação baseada em etiquetas ou.
.iloc para indexação posicional.
Eu sei que isso acabou sendo respondido no tópico do Reddit, mas eu vou re-responder aqui caso alguém tenha um problema semelhante.
O FileNotFoundError foi causado porque o arquivo data. pkl não estava presente no repositório local do GitHub. Este foi o arquivo que contém os dados de amostra para este exercício. Isso agora foi corrigido.
A DeprecationWarning não é nada para se preocupar, é causada por uma atualização no pacote Pandas.
Copyright © 2017 LearnDataSci. Todos os direitos reservados.

Python da estratégia de negociação
Vamos criar uma estratégia de crossover Average Moving Simple neste tutorial de Finanças com Python, que nos permitirá ficar confortáveis ​​com a criação do nosso próprio algoritmo e utilizando os recursos do Quantopian. Para começar, vá para a guia Algoritmos e escolha o botão "Novo Algoritmo". Aqui, você pode nomear seu algoritmo como quiser, e então você deve ter algum código inicial como:
Como você pode ver, algum código inicial foi preparado para nós.
Se você não estiver familiarizado com as médias móveis, o que elas fazem é obter um certo número de "janelas" de dados. No caso de correr contra os preços diários, uma janela seria um dia. Se você pegasse uma média móvel de 20, isso significaria uma média móvel de 20 dias. A partir daqui, a ideia é dizer que você tem uma média móvel de 20 e uma média móvel de 50. Plotar isso em um gráfico pode ser algo como:
Aqui, a linha azul é o preço das ações, a linha vermelha é a média móvel de 20 e a linha amarela é a média móvel de 50. A ideia é que, quando a média móvel de 20, que reage mais rápido, se mover acima da média móvel de 50, isso significa que o preço pode estar subindo, e podemos querer investir. Inversamente, se a média móvel de 20 cair abaixo da média móvel de 50, isso sinaliza talvez que o preço está tendendo para baixo, e que poderíamos querer vender ou investir ou mesmo vender a empresa a descoberto.
Venda a descoberto.
A venda a descoberto é o ato de vender um título que não se possui. Geralmente, isso é feito emprestando a parte de outra pessoa para vender, com a promessa de comprá-la de volta. O objetivo aqui é vender ações de alguém por, digamos, US $ 100, porque você acha que vai cair. Então, cai para $ 90, você o compra de volta e depois devolve ao dono original. A diferença de US $ 10 é sua para manter.
A venda a descoberto é arriscada por duas razões principais. A primeira é que, na maioria das vezes, a outra pessoa está lhe emprestando as ações da empresa, então este é um empréstimo, e você pode acabar perdendo dinheiro que nunca teve.
A próxima razão pela qual isso é arriscado é porque um curto pode ser infinitamente ruim. Por exemplo, se você comprar uma empresa por US $ 100, o máximo que você pode perder é US $ 100 por ação, porque a ação pode chegar a zero. Se você comprou uma empresa que é de US $ 100, talvez você perca uma quantia infinita de dinheiro, porque essa empresa deve ir para US $ 200 por ação, US $ 2.000 por ação. ou US $ 200.000 por ação. É claro que é improvável que fique assim tão ruim, mas o ponto é: você pode perder muito mais do que seu investimento original, e isso é geralmente associado ao fato de que o investimento original não era nem mesmo com dinheiro, era um empréstimo.
Normalmente, você será emprestado a parte por seu corretor ou banco, que também tem o direito de recuperar as ações sempre que quiserem. Isso significa que o estoque de US $ 100 pode subir para US $ 110 antes de cair para US $ 90, mas o banco pode recuperar as ações na marca de US $ 110 e você está pagando essa conta.
Olhando para o gráfico acima, parece-nos que faríamos muito bem. Perdemos os altos e baixos absolutos do preço, mas, no geral, achamos que faríamos bem com essa estratégia.
Toda vez que você criar um algoritmo com Zipline ou Quantopian, você precisará ter os métodos initialize e handle_data. Eles devem ser incluídos em todos os algoritmos iniciados novos.
O método initialize é executado uma vez no início do algoritmo (ou uma vez por dia, se você estiver executando o algoritmo ao vivo em tempo real). Handle_data é executado uma vez por período. No nosso caso, estamos usando dados diários, o que significa que será executado uma vez por dia.
Dentro do nosso método initialize, geralmente passamos esse parâmetro de contexto. Contexto é um Dicionário Python, que é o que vamos usar para rastrear o que poderíamos usar para variáveis ​​globais. O Context irá acompanhar vários aspectos do nosso algoritmo de negociação com o passar do tempo, para que possamos referenciar essas coisas dentro do nosso script.
Dentro do nosso método inicializar:
O que isto faz, é definir nossa segurança para negociação para o SPY. Este é o ETF do Spyder S & P 500 (Exchange Traded Fund), que é um método que podemos usar para negociar o índice S & P 500.
Isso é tudo o que faremos por agora no nosso método initialize, em seguida começaremos nosso método handle_data:
Observe aqui que passamos o contexto e um novo parâmetro chamado data. Os dados acompanham os dados atuais das empresas dentro do nosso "universo comercial". O universo é a coleção de empresas nas quais estamos plausivelmente interessados ​​em investir. No nosso caso, definimos este universo no início do método de inicialização, definindo todo o nosso universo para o SPY.
Simplificando, o contexto var é usado para rastrear nossa atual situação de investimento, com coisas como nosso portfólio e dinheiro. A variável de dados é usada para rastrear nosso universo de empresas e suas informações.
O. mavg () é um método embutido no Quantopian, e "data [context. security]" nos referencia a chave por este nome em nosso dicionário de contexto.
Poderíamos chamar esses context. MA1 e context. MA2 se quiséssemos armazená-los em nosso dicionário de contexto e usá-los fora de nosso método handle_data, mas não precisamos acessar esses dados fora daqui, então vamos apenas torná-los variáveis ​​locais.
Agora que calculamos as médias móveis, estamos prontos para mais lógica. Para negociar, precisamos ter lógica como se os MAs tivessem atravessado, mas também, antes de podermos fazer uma negociação, precisamos ver se temos dinheiro suficiente para fazer uma compra, precisamos saber o preço da transação. segurança, e devemos verificar para ver se já temos essa posição. Para fazer isso, adicionamos o seguinte ao nosso método handle_data:
Nós pegamos o preço atual referenciando dados, que é nossa maneira de rastrear nosso universo de empresas (atualmente apenas o S ​​& P 500 ETF $ SPY). Em seguida, verificamos todas as posições atuais que temos referenciando nosso context. portfolio. Aqui, podemos fazer referência a todo tipo de coisas em relação ao nosso portfólio, mas, agora, só queremos verificar nossas posições. Isso retorna um dicionário de todas as suas posições, a quantidade, o quanto foi preenchido e assim por diante. Então, estamos interessados ​​em uma posição específica em uma empresa, então fazemos context. portfolio. positions [symbol ('SPY')]. A partir daqui, nossa única preocupação agora é apenas ver se temos algum investimento, então o atributo que mais nos interessa é a quantidade de posições que temos, então usamos a quantidade no final.
Até agora, criamos as informações necessárias para sabermos antes de usarmos alguma lógica para executar negociações, mas não escrevemos nada para realmente fazer a negociação. Isso é o que vamos cobrir no próximo tutorial.

Python da estratégia de negociação
Ainda tem uma pergunta? Pergunte o seu próprio!
Minha resposta é útil para investidores individuais que levam a sério a negociação algorítmica (existem outras soluções que são mais apropriadas se você for uma instituição com bolsos mais fundos).
Eu estou supondo que você tenha uma estratégia de negociação em Python e é por isso que você está procurando uma estrutura de teste de volta também em Python.
Meu conselho para você seria usar o NinjaTrader, que tem uma versão gratuita. Importe seus dados para o Ninjatrader e exponha sua estratégia Python como um microsserviço no servidor localhost / socket. NT usa C #, então você pode definir suas variáveis ​​para backtesting em C # e passá-las para a estratégia através de chamadas de rede (GET / POST) / chamadas de soquete. Faça suas decisões de negociação (EnterLong () / ExitLong () /…) em C # com base nos valores de retorno da estratégia e o NT gerará relatórios de backtest muito exaustivos.
Se você tem uma compreensão básica do C & amp; Python, você deve conseguir executar essa configuração em um dia.
Boa sorte e me deixe saber como foi!
Aqui está um bom blog que detalha as bibliotecas Python mais usadas para negociação quantitativa.
Se você estiver interessado em implementar suas estratégias do Python em mercados ativos, poderá verificar o seguinte blog que usa o IBridgePy com a API de agentes interativos.