Python de estratégia de negociação simples

Jon V.
BigData. Iniciantes. Negociação
BigData. Iniciantes. Negociação
Construindo um sistema de backtesting em Python: ou como eu perdi $ 3400 em duas horas.
Construir um sistema de backtest é realmente muito fácil. Fácil de estragar eu quero dizer. Embora existam toneladas de excelentes bibliotecas por aí (e nós as percorremos em algum momento), eu sempre gosto de fazer isso sozinha para ajustá-las.
De todos os sistemas de backtesting que vi, podemos supor que existem duas categorias:
Hoje, falaremos sobre loopers.
Os "loopers" são meus tipos favoritos de backtesters. Eles são triviais para escrever e super divertidos de se expandir, mas eles têm alguns fluxos vitais e, infelizmente, a maioria dos backtesters lá fora é "for-loopers" (ps: eu preciso encontrar um nome melhor para isso!).
Como funcionam os loopers? Usando um loop for (como você deve ter imaginado). É algo assim:
Muito simples né? É assim que funciona um sistema de backtesting, que executa uma estratégia de momentum:
Então qual é o problema?
Muito difícil de escalar (horizontalmente) Precisa de muito trabalho para manter seu apply_strategy () trabalhando em backtesting e produção Você precisa ter tudo na mesma linguagem de programação.
Vamos mergulhar neles, um por um.
Escalabilidade Eu estava experimentando algumas semanas atrás com um algoritmo de escalada para otimizar uma das minhas estratégias. Ainda está em execução. Depois de duas semanas. E eu construo sistemas escaláveis ​​para a vida. Por que ainda está funcionando? Você pode usar multiprocessamento, Disco, produtor / consumidor (usando ZeroMQ) ou apenas threads para acelerar isso, mas alguns problemas não são "constrangedores paralelos" (sim, este é um termo real, não uma das minhas palavras inventadas). A quantidade de trabalho para escalar um backtester como este (especialmente quando você quer fazer o mesmo aprendizado de máquina em cima dele) é enorme. Você pode fazer isso, mas é o caminho errado.
Produção e backtesting em sincronia. As vezes eu fui mordido por isso. Eu me lembro dos negócios perdidos onde eu estava "hm, porque eu entrei neste comércio?" ou o meu favorito dos velhos tempos "PORQUE PARAR DE TRAILING FOI APLICADO AGORA?"
Hora da história: Eu tive uma idéia para otimizar minha estratégia, para executar um backtester para ver o que aconteceria se eu pudesse colocar uma parada depois que o negócio fosse lucrativo, a fim de sempre garantir lucros. O backtesting funcionou como um encanto, com um aumento de 13% nos lucros e a produção perdeu todos os negócios. Eu percebi isso depois que meu algo perdeu $ 3400 em um par de horas (uma lição muito cara).
Manter o apply_strategy em sincronia é muito difícil e se torna quase impossível quando você quer fazê-lo de maneira distribuída. E você não quer ter duas versões da sua estratégia que são "quase" idênticas. A menos que você tenha $ 3400 de sobra.
Usando diferentes linguagens eu amo o Python. E Erlang. E Clojure. E J. E C. E R. E Ruby (não, na verdade, eu odeio Ruby). Eu quero ser capaz de aproveitar a força de outras linguagens no meu sistema. Eu quero experimentar estratégias em R onde existem bibliotecas muito bem testadas e há uma enorme comunidade por trás disso. Eu quero ter Erlang para escalar meu código e C para processar dados. Se você quer ser bem sucedido (não apenas na negociação), você precisa ser capaz de usar todos os recursos disponíveis sem preconceitos. Eu aprendi toneladas de coisas de sair com desenvolvedores de R sobre como você pode delta de títulos de hedge e visualizá-los ou por que razão de Sharpe pode ser uma mentira. Cada idioma tem uma multidão diferente e você quer tantas pessoas despejando ideias em seu sistema. Se você tentar ter apply_strategy em uma linguagem diferente, então boa sorte com (2).
Você está convencido agora? Bem, eu não estou tentando convencê-lo como para loopers é uma ótima maneira de executar seus testes iniciais. Foi assim que comecei e, para muitas estratégias, não as envio para o pipeline. Um "melhor" caminho (assim você pode dormir à noite) é o gerador de eventos.
Chegando em seguida, compartilhando e discutindo meu mais simples (mas mais bem sucedido) backtester!
Se você tiver mais feedback, envie-me um ping no jonromero ou inscreva-se no boletim informativo.
Outro Jurídico Este é um tutorial de engenharia sobre como construir uma plataforma de algotrading para experimentação e DIVERSÃO. Todas as sugestões aqui não são conselhos financeiros. Se você perder algum (ou todo) dinheiro porque seguiu qualquer aviso de negociação ou implantou este sistema em produção, você não pode culpar esse blog aleatório (e / ou eu). Aproveite por sua conta e risco.

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 de estratégia de negociação simples
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.

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.

Negociação com Python.
Sábado, 20 de maio de 2017.
Yahoo está morto, viva o Yahoo!
Nota: os dados fornecidos parecem ser ajustados para divisões, mas não para dividendos.
Sábado, 20 de fevereiro de 2016.
Uma borda estatística simples no SPY.
Ocorreu-me que na maioria das vezes que há muita conversa na mídia sobre a queda do mercado (depois de grandes perdas ao longo de vários dias de intervalo), uma recuperação bastante significativa às vezes acontece.
No passado cometi alguns erros ao fechar minhas posições para reduzir as perdas, apenas para perder uma recuperação nos dias seguintes.
Após um período de perdas consecutivas, muitos comerciantes liquidarão suas posições com medo de perdas ainda maiores. Muito desse comportamento é governado pelo medo, e não pelo risco calculado. Comerciantes mais espertos entram então para as barganhas.
Depois de 3 ou mais perdas consectivas, vá muito. Saia no próximo feche.
Isso não parece nada mau! Observando as taxas de sharpe, a estratégia obtém uma descida de 2,2 versus 0,44 para os B & amp; Na verdade, isso é muito bom! (não fique muito empolgado, pois não contei com custos de comissão, escorregões, etc.).
Embora a estratégia acima não seja algo que eu gostaria de negociar simplesmente por causa do longo período de tempo, a própria teoria provoca pensamentos adicionais que poderiam produzir algo útil. Se o mesmo princípio se aplica aos dados intradiários, uma forma de estratégia de escalpelamento poderia ser construída. No exemplo acima, simplifiquei um pouco o mundo contando apenas o * número * de dias de inatividade, sem prestar atenção à profundidade do rebaixamento. Além disso, a saída de posição é apenas um 'próximo dia de fechamento' básico. Há muito a melhorar, mas a essência na minha opinião é esta:
Segunda-feira, 17 de novembro de 2014.
Negociando o VXX com a previsão de vizinhos mais próximos.
Minha definição desses dois é:
prêmio de volatilidade = VIX-realizadoVol delta (inclinação da estrutura de prazo) = VIX-VXV.
Combinar tanto o prêmio quanto o delta em um modelo foi um desafio para mim, mas eu sempre quis fazer uma aproximação estatística. Em essência, para uma combinação de (delta, premium), gostaria de encontrar todos os valores históricos que estão mais próximos dos valores atuais e fazer uma estimativa dos retornos futuros com base neles. Algumas vezes comecei a escrever meus próprios algoritmos de interpolação de vizinhos mais próximos, mas toda vez tive que desistir. até me deparar com a regressão dos vizinhos mais próximos. Isso me permitiu construir rapidamente um preditor baseado em duas entradas e os resultados são tão bons que estou um pouco preocupado por ter cometido um erro em algum lugar.
criar um conjunto de dados de [delta, premium] - & gt; [Retorno do próximo dia VXX] (na amostra) cria um preditor do vizinho mais próximo com base no conjunto de dados acima da estratégia de negociação (fora da amostra) com as regras: go long if predicted return & gt; 0 vai curto se o retorno previsto & lt; 0.
Nos dois últimos gráficos, a estratégia parece realizar o mesmo dentro e fora da amostra. Relação de Sharpe é em torno de 2,3.
Estou muito satisfeito com os resultados e tenho a sensação de que só estive a arranhar a superfície do que é possível com esta técnica.
Quarta-feira, 16 de julho de 2014.
Módulo de backtesting simples.
Minha busca por uma ferramenta de backtesting ideal (minha definição de 'ideal' é descrita nos posts anteriores de 'dilemas de backtesting') não resultou em algo que eu pudesse usar imediatamente. No entanto, rever as opções disponíveis me ajudou a entender melhor o que eu realmente quero. Das opções que eu olhei, o pybacktest foi o que eu mais gostei por causa de sua simplicidade e velocidade. Depois de passar pelo código-fonte, tenho algumas ideias para simplificar e tornar um pouco mais elegante. A partir daí, foi apenas um pequeno passo para escrever meu próprio backtester, que agora está disponível na biblioteca TradingWithPython.
encontrar entrada e saídas - & gt; calcular pnl e fazer gráficos com backtester - & gt; dados de estratégia pós-processo.
Sábado, 7 de junho de 2014.
Aumentando o desempenho com o Cython.
5k amostras como dados de teste. Aí vem a versão original da minha função drawdown (como agora está implementada na biblioteca TradingWithPython)
Hmm 1,2 segundos não é muito rápido para uma função tão simples. Há algumas coisas aqui que podem ser uma ótima alternativa para o desempenho, como uma lista * highwatermark * que está sendo anexada em cada iteração de loop. Acessar Series por seu índice também deve envolver algum processamento que não seja estritamente necessário. Vamos dar uma olhada no que acontece quando esta função é reescrita para trabalhar com dados numpy.
Bem, isso é muito mais rápido que a função original, aproximadamente 40x de aumento de velocidade. Ainda há muito espaço para melhoria, movendo-se para código compilado com cython Agora eu reescrever a função dd de cima, mas usando dicas de otimização que eu encontrei no tutorial de cython. Observe que esta é minha primeira tentativa de otimização de funções com o Cython.
Uau, esta versão corre em 122 micro segundos, tornando-a dez mil vezes mais rápida que a minha versão original! Devo dizer que estou muito impressionado com o que as equipes Cython e IPython conseguiram! A velocidade em comparação com a facilidade de uso é simplesmente incrível!
P. S. Eu costumava fazer otimizações de código no Matlab usando encapsulamento C e. mex puro, era tudo apenas uma dor na bunda em comparação com isso.
Terça-feira, 27 de maio de 2014.
Dilemas de backtesting: revisão de pyalgotrade.
Primeira impressão: ativamente desenvolvida, documentação muito boa, mais do que feautures suficiente (indicadores de TA, otimizadores etc). Parece bom, então eu continuei com a instalação que também correu bem.
O tutorial parece estar um pouco desatualizado, já que o primeiro comando yahoofinance. get_daily_csv () lança um erro sobre a função desconhecida. Não se preocupe, a documentação está atualizada e acho que a função ausente agora é renomeada para yahoofinance. download_daily_bars (símbolo, ano, csvFile). O problema é que essa função só faz o download de dados por um ano, em vez de tudo, desde aquele ano até a data atual. Tão bem inútil.
Depois que eu mesmo baixei os dados e os salvei no csv, eu precisei ajustar os nomes das colunas, porque aparentemente o pyalgotrade espera que Date, Adj Close, Close, High, Low, Open e Volume estejam no cabeçalho. Isso é tudo um pequeno problema.
Seguindo para o teste de desempenho em uma estratégia de SMA que é fornecida no tutorial. Meu conjunto de dados consiste em 5370 dias de SPY:
Isso é realmente muito bom para um framework baseado em eventos.
Mas tentei pesquisar a documentação para obter a funcionalidade necessária para fazer o backtest de spreads e vários portfólios de ativos e simplesmente não consegui encontrar nenhum. Então eu tentei encontrar uma maneira de alimentar pandas DataFrame como uma entrada para uma estratégia e acontece de não ser possível, o que é novamente uma grande decepção. Eu não o afirmei como um requisito no post anterior, mas agora chego à conclusão de que o suporte a pandas é obrigatório para qualquer framework que trabalhe com dados de séries temporais. Pandas foi uma razão para eu mudar de Matlab para Python e eu nunca mais quero voltar.
Conclusão A pyalgotrade não atende ao meu requisito de flexibilidade. Parece que foi projetado com o TA clássico em mente e negociação de instrumento único. Eu não vejo isso como uma boa ferramenta para estratégias de backtesting que envolvem vários ativos, hedge etc.
Segunda-feira, 26 de maio de 2014.
Dilemas de backtesting.
Seja boa aproximação do mundo real. Este é obviamente o requisito mais importante. Permitir flexibilidade ilimitada: o ferramental não deve ficar no caminho de testar ideias prontas para uso. Tudo o que pode ser quantificado deve ser utilizável. Seja fácil de implementar & amp; manter. É tudo sobre produtividade e poder testar muitas ideias para encontrar uma que funcione. Permitir varreduras de parâmetros, testes de avanço e otimizações. Isso é necessário para investigar o desempenho e a estabilidade da estratégia, dependendo dos parâmetros da estratégia. O problema em satisfazer todos os requisitos acima é que os números 2 e 3 são conflitantes. Não há ferramenta que possa fazer tudo sem o custo de alta complexidade (= baixa manutenção). Normalmente, uma ferramenta point-and-click de terceiros limitará severamente a liberdade de teste com sinais personalizados e portfólios ímpares, enquanto no outro extremo do espectro uma solução diy personalizada precisará de dezenas ou mais horas para ser implementada, com grandes chances de terminando com código desordenado e ilegível. Então, na tentativa de combinar o melhor dos dois mundos, vamos começar de alguma forma no meio: use uma estrutura de backtesting existente e adapte-a ao nosso gosto.
Nos posts a seguir, eu vou ver três candidatos possíveis que encontrei:
Zipline é amplamente conhecida e é o motor por trás do PyPlotTub Quantopian parece ser ativamente desenvolvido e o pybacktest bem documentado é um framework baseado em vetores leve, que pode ser interessante por causa de sua simplicidade e desempenho. Eu vou estar olhando para a adequação dessas ferramentas comparando-as com uma estratégia de negociação hipotética. Se nenhuma dessas opções se encaixa nos meus requisitos, terei que decidir se quero investir na criação do meu próprio framework (pelo menos, olhando as opções disponíveis, eu sei o que não funciona) ou manter o código personalizado para cada uma delas. estratégia.
O primeiro para a avaliação é Zipline.
Minha primeira impressão de Zipline e Quantopian é positiva. O Zipline é apoiado por uma equipe de desenvolvedores e é testado em produção, então a qualidade (bugs) deve ser ótima. Existe uma boa documentação no site e um exemplo de caderno no github.
Para pegar um jeito, baixei o caderno do exame e comecei a brincar com ele. Para minha decepção, rapidamente me deparei com o primeiro exemplo do Algoritmo de Zipline Mais Simples: Compre a Apple. O conjunto de dados tem apenas 3028 dias, mas a execução deste exemplo demorou uma eternidade. Aqui está o que eu medi:
Eu não esperava um desempenho estelar, já que o zipline é um backtester baseado em eventos, mas quase um minuto para 3000 samples é muito ruim. Esse tipo de desempenho seria proibitivo para qualquer tipo de varredura ou otimização. Outro problema surgiria quando se trabalha com conjuntos de dados maiores, como dados intradiários ou vários títulos, que podem conter facilmente centenas de milhares de amostras.
Infelizmente, eu terei que eliminar o Zipline da lista de backtesters utilizáveis, já que ele não atende ao meu requisito # 4 por uma margem de gordura.
No post seguinte, eu vou estar olhando para PyAlgotrade.
Nota: Meu sistema atual é um par de anos, rodando um AMD Athlon II X2 @ 2800MHZ com 3GB de RAM. Com backtesting baseado em vetor, eu estou acostumado a calcular tempos de menos de um segundo para um único backtest e um ou dois minutos para uma varredura de parâmetro. Um teste básico de caminhada com 10 passos e uma varredura de parâmetros para 20x20 resultaria em uma convulsiva 66 horas com tirolesa. Eu não sou tão paciente assim.
Quarta-feira, 15 de janeiro de 2014.
Iniciando o notebook IPython a partir do exlorer de arquivos do Windows.
Segunda-feira, 13 de janeiro de 2014.
ETFs alavancados em 2013, onde está sua decadência agora?
Conhecendo o comportamento alavancado do etf, eu esperaria que o ETF alavancado superasse seu benchmark, então a estratégia que tentaria lucrar com a decadência perderia dinheiro.
Quando normalizamos os preços para 100 $ no início do período de backtest (250 dias), fica aparente que o 2x etf supera 1x etf.
O código fonte completo dos cálculos está disponível para os assinantes do curso Trading With Python. Caderno # 307.
Quinta-feira, 2 de janeiro de 2014.
Colocar uma etiqueta de preço no TWTR.
Preço derivado do valor do usuário.
Atualmente, o TWTR é mais valioso por usuário que é FB ou LNKD. Isso não é lógico, pois ambos os concorrentes têm dados pessoais mais valiosos à sua disposição. O GOOG tem se destacado em extrair receita publicitária de seus usuários. Para isso, tem um conjunto de ofertas altamente diversificadas, desde o mecanismo de pesquisa até o Google+, o Documentos e o Gmail. O TWTR não tem nada parecido, enquanto seu valor por usuário é apenas 35% menor do que o do Google. A TWTR tem um espaço limitado para aumentar sua base de usuários, uma vez que não oferece produtos comparáveis ​​às ofertas FB ou GOOG. O TWTR existe há sete anos e a maioria das pessoas que querem um emprego tem sua chance. O resto simplesmente não se importa. A base de usuários do TWTR é volátil e provavelmente passará para a próxima coisa quente quando estiver disponível.
Preço derivado de ganhos futuros.
Conclusão.
Quinta-feira, 19 de setembro de 2013.
Negociação Com o curso de Python disponível!
Domingo, 18 de agosto de 2013.
Estratégia VXX curta.
Em um mundo ideal, se você aguentar o tempo suficiente, um lucro gerado pela decadência do tempo no rebalanceamento dos futuros e do ETN será garantido, mas, no curto prazo, você terá que passar por alguns rebaixamentos bem pesados. Basta olhar para trás no verão de 2011. Tenho sido infeliz (ou bobo) o suficiente para manter uma posição curta do VXX pouco antes do VIX subir. Eu quase explodi minha conta até então: rebaixamento de 80% em apenas alguns dias, resultando em uma ameaça de chamada de margem pelo meu corretor. Chamada de margem significaria descontar a perda. Esta não é uma situação que eu gostaria de estar de novo. Eu sabia que não seria fácil manter a cabeça fria em todos os momentos, mas experimentar o estresse e a pressão da situação era algo diferente. Felizmente eu sabia como o VXX tende a se comportar, então eu não entrei em pânico, mas mudei de lado para o XIV para evitar uma chamada de margem. A história termina bem, oito meses depois meu portfólio voltou à força e aprendi uma lição muito valiosa.
Dito isso, vamos dar uma olhada em uma estratégia que minimiza alguns dos riscos, encurtando o VXX somente quando for apropriado.
O gráfico acima mostra dados do VIX-VXV desde janeiro de 2010. Os dados do ano passado são mostrados em vermelho.
Eu escolhi usar um ajuste quadrático entre os dois, aproximando VXV = f (VIX). O f (VIX) é plotado como uma linha azul.
Os valores acima da linha representam a situação quando os futuros estão em contango mais forte que o normal. Agora eu defino um indicador delta, que é o desvio do ajuste: delta = VXV-f (VIX).
É evidente que as áreas verdes correspondem a retornos negativos no VXX.
VXX curto quando delta & gt; 0 Capital constante (apostar em cada dia é de 100 $) Sem custos de deslize ou transação.
Obtendo um volume curto do BATS.
Quinta-feira, 15 de agosto de 2013.
Construindo um indicador a partir de dados de volume curtos.
Precisamos de mais informações adicionais sobre o que está contido no preço para adivinhar melhor o que vai acontecer no futuro próximo. Um excelente exemplo de combinação de todos os tipos de informações em uma análise inteligente pode ser encontrado no blogue The Short Side of Long. Produzir esse tipo de análise requer uma grande quantidade de trabalho, para o qual simplesmente não tenho tempo, pois troco apenas meio expediente.
Então eu construí meu próprio painel de mercado que automaticamente coleta informações para mim e as apresenta de uma forma facilmente digerível. Neste post vou mostrar como construir um indicador baseado em dados curtos de volume. Este post ilustrará o processo de coleta e processamento de dados.
A troca de BATS fornece dados de volume diários gratuitamente em seu site.
Dados de volume curto da troca de BATS estão contidos em um arquivo de texto que é compactado. Cada dia tem seu próprio arquivo zip. Depois de baixar e descompactar o arquivo txt, este é o que está dentro (primeiro várias linhas):
Esses dados precisam de algum trabalho antes de poderem ser apresentados de maneira significativa.
O que eu realmente quero não são apenas os dados de um dia, mas uma proporção de volume curto para volume total nos últimos anos, e eu realmente não sinto vontade de baixar mais de 500 arquivos zip e copiá-los no Excel manualmente.
Felizmente, a automação completa é apenas um par de linhas de código de distância:
Primeiro, precisamos criar dinamicamente um URL do qual um arquivo será baixado:
Etapa 5: crie um gráfico:
Domingo, 17 de março de 2013.
Negociação Com curso em Python - atualização de status.
A partir de hoje estarei preparando um novo site e material para o curso, que terá início na segunda semana de abril.
Quinta-feira, 12 de janeiro de 2012.
Reconstruindo o VXX a partir dos dados de futuros do CBOE.
Os scripts abaixo automatizam esse processo. O primeiro, downloadVixFutures. py, obtém os dados do cboe, salva cada arquivo em um diretório de dados e os combina em um único arquivo csv, vix_futures. csv.
O segundo script reconstructVXX. py analisa o vix_futures. csv, calcula os retornos diários do VXX e salva os resultados no reconstructedVXX. csv.
Para verificar os cálculos, comparei meus resultados simulados com os dados do índice SPVXSTR, os dois concordam muito bem, veja os gráficos abaixo.
Código para reconstruir o VXX.
Segunda-feira, 26 de dezembro de 2011.
howto: padrão de observador.
Uma classe ouvinte pode ser de qualquer tipo, aqui eu faço um monte de classes ExampleListener, chamadas Bob, Dave & amp; Charlie. Todos eles têm um método, isto é, é inscrito no Sender. A única coisa especial sobre o método inscrito é que ele deve conter três parâmetros: remetente, evento, mensagem. Remetente é a referência de classe da classe Remetente, portanto, um ouvinte saberia quem enviou a mensagem. Event é um identificador, para o qual eu costumo usar uma string. Opcionalmente, uma mensagem é os dados que são passados ​​para uma função.
Um detalhe interessante é que, se um método listener lançar uma exceção, ele será automaticamente cancelado de outros eventos.
Quarta-feira, 14 de dezembro de 2011.
Plotando com guiqwt.
aquisição de dados: ibpy & amp; tradingWithPython. lib. yahooData - verifique.
contêiner de dados: pandas e amp; sqlite - verifique.
biblioteca de plotagem: matplotlib - ehm. Não.
Mas, como muitas vezes acontece com o Python, alguém, em algum lugar, já escreveu um kit de ferramentas que é perfeito para o trabalho. E parece que guiqwt é apenas isso. Gráficos interativos estão a apenas algumas linhas de código agora, dê uma olhada em um exemplo aqui: Criando diálogo de curva. Para isso eu usei o código de exemplo guiqwt com alguns pequenos ajustes.
. Se eu soubesse como definir datas no eixo x.
Sexta-feira, 4 de novembro de 2011.
Como configurar o ambiente de desenvolvimento do Python.
2. Instale o Tortoise SVN. Este é um utilitário que você precisa para puxar o código-fonte do Google Code.
3. Instale Pandas (biblioteca de séries temporais)
Para obter o código, use o menu de contexto do explorador de janelas 'Svn Checkout' que está disponível após a instalação do Tortoise SVN. Checkout como este (mude o diretório Checkout para o local desejado, mas ele deve terminar com tradingWithPython):
Ok, tudo pronto, agora você pode executar os exemplos de \ cookbok dir.
Sexta-feira, 28 de outubro de 2011.
Os pandas do kung fu resolverão seus problemas de dados.
Algum tempo atrás eu encontrei um conjunto de ferramentas de análise de dados especialmente adequado para trabalhar com dados financeiros. Depois de apenas arranhar a superfície de suas capacidades, eu já me surpreendi com o que ela oferece. O pacote está sendo desenvolvido ativamente por Wes McKinney e sua ambição é criar a mais poderosa e flexível ferramenta de análise / manipulação de dados de código aberto disponível. Bem, acho que ele está bem a caminho!
Aqui está o resultado:
Cara, isso poderia ter me poupado uma tonelada de tempo! Mas isso ainda vai me ajudar no futuro, já que vou usar seu objeto DataFrame como padrão no meu trabalho posterior.

Crie uma estratégia de negociação do zero no Python.
Para mostrar todo o processo de criação de uma estratégia de negociação, vou trabalhar em uma estratégia super simples baseada no VIX e seus futuros. Eu estou apenas pulando os dados de download do Quandl, eu estou usando o índice VIX daqui e os futuros VIX daqui, apenas os conjuntos de dados de contratos contínuos VX1 e VX2.
Carregamento de dados.
Primeiro precisamos carregar todas as importações necessárias, a importação do backtest será usada mais tarde:
Para simplificar, vou colocar todos os valores em um DataFrame e em colunas diferentes. Nós temos o índice VIX, VX1 e VX2, isso nos dá este código:
E aqui está o resultado:
Para este tutorial eu vou usar um sinal muito básico, a estrutura é a mesma e você pode substituir a lógica com qualquer estratégia que você queira, usando algoritmos de aprendizado de máquina muito complexos ou apenas cruzando médias móveis.
O VIX é um recurso que reverte a média, pelo menos em teoria, significa que ele vai subir e descer, mas no final seu valor se moverá em torno de uma média. Nossa estratégia será ser curta quando for muito maior do que seu valor médio e ser curta quando for muito baixa, com base em valores absolutos para mantê-la simples.
Agora, gostaríamos de visualizar o sinal para verificar se, pelo menos, a estratégia parece lucrativa:
O resultado é muito bom, embora não haja comércio entre 2009 e 2013, poderíamos melhorar isso mais tarde:
Backtesting
Vamos verificar se a estratégia é lucrativa e obter algumas métricas. Nós vamos comparar nossos retornos estratégicos com o & # 8220; Compre e segure & # 8221; estratégia, o que significa que apenas compramos o futuro do VX1 e esperamos (e lançamos em cada expiração), assim podemos ver se a nossa estratégia é mais lucrativa do que passiva.
Eu coloquei o método backtest em um arquivo separado para tornar o código principal menos pesado, mas você pode manter o método no mesmo arquivo:
No código principal eu vou usar o método backtest assim:
É importante mostrar o retorno anualizado, uma estratégia com um retorno de 20% em 10 anos é diferente de um retorno de 20% em 2 meses, nós anualizamos tudo para que possamos comparar as estratégias facilmente. O índice de Sharpe é uma métrica útil, permite-nos ver se o retorno vale a pena o risco, neste exemplo eu apenas assumi uma taxa livre de risco de 0%, se a relação é & gt; 1 significa que o retorno ajustado ao risco é interessante, se for & gt; 10 isso significa que o retorno ajustado ao risco é muito interessante, basicamente alto retorno para uma baixa volatilidade.
Em nosso exemplo, temos um bom índice de Sharpe de 4,6, o que é muito bom:
Finalmente, queremos traçar a estratégia PnL versus o & # 8220; Compre e segure & # 8221; PnL:
A estratégia teve um desempenho muito bom até 2010, mas a partir de 2013 o PnL começa a estagnar:
Conclusão.
Mostrei-lhe uma estrutura básica de criação de uma estratégia, você pode adaptá-la às suas necessidades, por exemplo, você pode implementar sua estratégia usando zipline em vez de um módulo de teste personalizado. Com o zipline, você terá muito mais métricas e poderá executar facilmente sua estratégia em diferentes ativos, já que os dados de mercado são gerenciados por tirolesa.
Eu não mencionei nenhuma taxa de transação ou lance-pergunte espalhado neste post, o backtest não leva em conta tudo isso então talvez se nós os incluirmos a estratégia perderia dinheiro!