Sistema de negociação usando python

Python para desenvolver uma plataforma de negociação automatizada em tempo real.
Abstract-Python, hoje em dia, parece ser o ambiente perfeito para o desenvolvimento de uma ferramenta de negociação automatizada em tempo real. Nesta palestra, vamos falar sobre como temos desenvolvido: um módulo de sistema multiagente de uso geral usando Pyro e ZeroMQ; uma plataforma, baseada nele, para desenvolver estratégias de negociação automatizadas usando Numpy, Numba, Theano. ; e uma ferramenta para visualizar dados de mercado em tempo real usando PyQtGraph e Qt.
Termos de indexação - Python, ZeroMQ, multi-agente, Pyro, NumPy, Numba, Theano, PyQtGraph, Qt.
I. UM SISTEMA MULTI-AGENTE.
A arquitetura de qualquer sistema pode variar e ainda executar a mesma tarefa. Uma arquitetura monolítica é melhor quando se busca por desempenho, mas, por outro lado, a divisão fornece mais robustez no caso de um único módulo falhar e permite fazer modificações sem a necessidade de compilar (se este for o caso) toda a infraestrutura. Além disso, quando se fala de tarefas intensivas em computação, em que a relação entre a transmissão de dados e o tempo de computação é muito baixa, uma arquitetura baseada em módulos quase não afeta o desempenho geral.
Além disso, uma arquitetura baseada em módulos permite a criação de sistemas paralelos, distribuíveis e altamente disponíveis. Um sistema multiagente é composto de múltiplos agentes interagentes que tentam resolver problemas que são difíceis para um agente individual. As principais características são:
• Autonomia: os agentes são pelo menos parcialmente independentes, autoconscientes e autônomos.
• Visualizações locais: nenhum agente tem uma visão global completa do sistema.
• Descentralização: não há agente controlador designado.
No OpenSistemas, desenvolvemos um sistema multi-agente de uso geral que está escrito no Python puro: osBrain.
Cada agente é um processo do sistema gerado usando o módulo de multiprocessamento, o que significa que ele é executado independentemente dos outros e que não afeta os problemas de desempenho ao usar intérpretes Python habilitados para GIL.
Este processo do sistema inicia um servidor Pyro e se registra no servidor de nomes. O servidor Pyro é usado para servir um objeto: uma instância do agente real, que é descrita abaixo. Esta implementação permite ao usuário acessar o objeto através de um proxy Pyro, tratando o agente, que poderia estar em uma máquina remota, como um objeto local e podendo alterar seus atributos e seu comportamento.
Embora o Pyro não seja a maneira mais eficiente de comunicação entre processos, é muito conveniente para a implementação, permitindo a criação de sistemas complexos e distribuídos de múltiplos agentes de maneira simples.
Os agentes, no entanto, comunicam entre si usando o ZeroMQ. O ZeroMQ é mais eficiente e muito flexível, permitindo ao usuário definir diferentes padrões de comunicação com base em suas necessidades. Um processo típico de agente estará executando um servidor Pyro no qual o thread principal executa um loop que simplesmente aguarda para receber mensagens do lado de fora. Esse comportamento pode, naturalmente, ser modificado à vontade, mas seria definitivamente o caso mais comum.
Os agentes também podem usar multithreading e são fornecidos com um soquete inproc consultado pelo thread principal para garantir acesso seguro à memória, mesmo em intérpretes Python com deficiência de GIL.
II. A PLATAFORMA DE NEGOCIAÇÃO AUTOMÁTICA DE TEMPO REAL.
Na OpenSistemas desenvolveram uma plataforma independente de corretor para negociação automatizada em tempo real: osMarkets. Qualquer corretor pode fornecer os dados necessários e a plataforma executará todos os cálculos necessários para produzir ordens que serão enviadas de volta ao corretor a ser executado.
Esta plataforma é implementada através do osBrain, mas com agentes especializados.
O Alimentador é um agente que recebe dados em tempo real do corretor. Ele normalmente usa multithreading e o soquete de loopback para poder transmitir os dados do mercado enquanto pode enviar solicitações ativas ao broker (por exemplo, solicitação de dados históricos). Ele também converte os dados para que ele possa estar no formato adequado para o resto da plataforma.
O roteador é um agente que recebe dados de alimentadores. Ele gerencia os dados históricos e a criação de novas barras usando dados de ticks em tempo real. O roteador distribui atualizações sobre os dados do mercado para todos os agentes interessados ​​na rede.
Cérebro é o agente mais comum. É receber dados do roteador ou de outros cérebros e processá-lo, enviar os resultados para outros cérebros ou enviar ordens para serem executados. É aqui que as estratégias de negociação automatizadas devem ser implementadas. Os cérebros podem fazer uso de muitos pacotes úteis disponíveis no ecossistema Python: NumPy, SciPy, Numba, Theano. apenas para citar alguns. Cérebros podem formar uma hierarquia que pode ser usada para abstrair dados de mercado.
O Trader é um agente que é projetado para interagir com o corretor, assim como o alimentador, mas para executar ordens de mercado (ou seja, comprar / vender). Outros parâmetros como stop-loss ou take-profit podem ser manipulados pelo broker ou internamente pelo osMarkets também.
Para gerenciar os dados de mercado, estão sendo usados ​​os Nairys de NumPy. Ao trabalhar com dados em tempo real, as séries temporais estão sempre mudando. Para evitar cópias de memória completas em cada atualização, criamos uma classe personalizada que usa uma estrutura maior como um buffer. Esse buffer, que é um ndarray real do NumPy, é preenchido e modificado na atualização, e a classe personalizada simplesmente atualiza a exibição de if na memória.
III. VISUALIZANDO DADOS DE MERCADO EM TEMPO REAL.
Embora o Matplotlib seja provavelmente a ferramenta mais conhecida para visualização de dados e, embora seja muito bom em exibir todos os tipos de gráficos com qualidade muito boa, ele não é adequado para visualizações em tempo real e não é muito bom em interação.
PyQtGraph, por outro lado, é uma ótima ferramenta para visualização em tempo real e para gráficos interativos. Está escrito em Python puro, então instalar este pacote é bem direto.
Por baixo, ele usa o Qt e o OpenGL para permitir exibições e interações rápidas.
Embora ainda esteja em seus estágios iniciais, estamos desenvolvendo uma ferramenta para visualização em tempo real de estratégias de negociação usando o PyQtGraph. Essa ferramenta atua como um agente no sistema multiagente, o que significa que ele simplesmente assina atualizações nos dados de mercado para o roteador e nas saídas de cérebros selecionados.
É capaz de desenhar gráficos de candelabro e indicadores básicos e permite ao usuário lidar com cérebros da interface.

Sistema de negociação usando python
Se você é um comerciante ou um investidor e gostaria de adquirir um conjunto de habilidades de negociação quantitativas, você está no lugar certo.
O curso de Trading With Python fornecerá as melhores ferramentas e práticas para pesquisa quantitativa de negociação, incluindo funções e scripts escritos por especialistas em negociações quantitativas. O curso dá o máximo impacto para o seu tempo investido e dinheiro. Centra-se na aplicação prática da programação à negociação, em vez da informática teórica. O curso irá pagar por si mesmo rapidamente, economizando 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: princípios Você vai aprender por que a Python é uma ferramenta ideal para negociação quantitativa. Começaremos configurando um ambiente de desenvolvimento e, em seguida, apresentaremos as bibliotecas científicas.
Parte 2: Manipulação dos dados Saiba 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. Desenvolva uma estratégia de negociação e otimize seu desempenho. Múltiplos 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 em estoque em tempo real e colocar ordens ao vivo.
Muito código de exemplo.
O material do curso consiste em "cadernos" que contêm texto junto com um 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 uma grande parte da funcionalidade discutida neste curso como uma função pronta para usar e será usada ao longo do curso. Pandas irá fornecer-lhe todo o poder de levantamento pesado necessário no trituraçã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, é o que os alunos conseguiram dizer:
Matej curso bem projetado e bom treinador. Definitivamente valeu o preço e meu tempo, Lave Jev, obviamente, conhecia 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.

Conteúdo.
O curso foca tanto quanto possível em exemplos práticos de problemas reais envolvidos no comércio quantitativo. Vamos começar com a criação de ambientes de desenvolvimento e obter dados históricos de preços. Depois disso, faremos backtest de algumas estratégias típicas de negociação. Uma parte final do curso se concentra no comércio automatizado através da Interactive Brokers API. A parte teórica (matemática e ciência da computação) será reduzida ao mínimo e somente tratada quando necessário.
Parte 1: princípios básicos.
Antes de fazer o curso, você configurará seu próprio ambiente em Python e terá uma noção básica do idioma. Esta parte do curso está disponível gratuitamente. Vamos pular direto e usar dois estudos de caso para nos acostumarmos a trabalhar com ferramentas científicas.
Por que Python Configurando o ambiente Python Fundamentos do Python Escrevendo, executando e depurando código. Introdução ao Numpy Plotting com o matplotlib.
Simulação Monte-carlo de etfs alavancados.
Parte 2: Manipulação dos dados.
Antes de começar com a parte divertida do desenvolvimento da estratégia, precisamos coletar e classificar os dados de preços. Esta semana é sobre como obter os dados de várias fontes. Para apimentá-lo com uma caixa de teste, vamos baixar todos os preços diários do universo S & amp; P500 da base de dados do Yahoo.
Introdução às Pandas Trabalhando com horários e datas. Leitura e escrita de arquivos CSV Leitura de arquivos excel Leitura de arquivos HDF5 Obtendo dados da web (Yahoo finance, CBOE, etc.)
Sazonalidade de SPY: existe uma vantagem com base no dia da semana? Obtenha todo o histórico do universo S & amp; P500 e guarde-o em um banco de dados.
Parte 3: estratégias de backtesting.
Esta é a parte divertida, que é apenas limitada pela sua própria criatividade. Passaremos por vários casos de teste estratégico.
Calculando pnl e métricas de desempenho: sharpe en drawdown Estratégia de impulso simples usando médias móveis Estratégia de portfólio permanente Estratégia XLP Estratégia de negociação de pares (construção de um spread neutro e backtesting) Estratégias de volatilidade Estratégia de ETFs alavancadas.
Parte 4: Indo ao vivo!
A última coisa que você precisa para construir um sistema comercial automatizado é uma conexão com um corretor. Nesta semana, vamos nos concentrar no uso da Interactive Brokers API para receber dados em tempo real e enviar pedidos.
Conectando-se a intermediários interativos com ibpy Fazendo o download de dados históricos intraday Obtendo dados de estoque em tempo real Fazendo pedidos.

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

Jon V.
BigData. Iniciantes. Negociação.
BigData. Iniciantes. Negociação.
Construindo um sistema backtesting em Python: ou como 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 as abordaremos em algum momento), eu sempre gosto de fazer isso por conta própria para ajustá-la.
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 para 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ê pode ter adivinhado). É algo assim:
Muito simples, certo? É assim que funciona um sistema de backtesting, que executa uma estratégia de impulso:
Então qual é o problema?
Muito difícil de escalar (horizontalmente) Precisa de muito trabalho para manter sua estratégia de aplicação () trabalhando no backtesting e na 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 robustos para uma vida. Por que ainda está funcionando? Você pode usar multiprocessamento, Disco, produtor / consumidor (usando o ZeroMQ) ou apenas threads para acelerar isso, mas alguns problemas não são "paralisações embaraçosas" (sim, este é um termo real, e 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 fazê-lo, mas é o caminho errado.
Produção e backtesting em sincronia. As vezes que fui mordido por isso. Posso recordar as trocas perdidas onde eu estava "hm, por que eu entrei nesse comércio?" ou o meu antigo favorito "POR QUE A PARADA DE REALIZAÇÃO FOI APLICADA 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. Backtesting funcionou como um charme com um aumento de 13% nos ganhos e a produção perdeu todo comércio. Eu percebi isso depois que meu algo perdeu $ 3400 em um par de horas (uma lição muito cara).
Manter a estratégia apply_strategy em sincronia é muito difícil e torna-se quase impossível quando você deseja fazê-lo de forma 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 US $ 3400 de sobra.
Usando diferentes idiomas, adoro Python. E Erlang. E Clojure. E J. E C. E R. E Ruby (não, na verdade, eu odeio Ruby). Eu quero poder aproveitar a força de outros idiomas no meu sistema. Quero experimentar estratégias em R onde há 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. Todo idioma tem uma multidão diferente e você quer que muitas pessoas despejam idéias em seu sistema. Se você tentar aplicar a estratégia apply_strategy em idioma diferente, então, boa sorte com (2).
Você está convencido agora? Bem, eu não estou tentando convencê-lo como for-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.
Próximamente, compartilhando e discutindo meu backtester mais simples (mas com maior sucesso)!
Se você tiver mais comentários, clique-me no jonromero ou inscreva-se no boletim informativo.
Outro Jurídico Este é um tutorial de engenharia sobre como construir uma plataforma algotrading para experimentação e FUN. Qualquer sugestão aqui não é um conselho financeiro. Se você perder qualquer (ou todos) o seu dinheiro porque seguiu quaisquer conselhos de negociação ou implantou este sistema na produção, não pode culpar este blog aleatório (e / ou eu). Aproveite a seu próprio risco.

Blog do Mee Blog do Mee.
Eu tropecei com este artigo de blog muito interessante no Investor. blog sobre como construir um sistema de negociação de ações com Aprendizado de Máquinas.
O autor passou muito tempo recentemente em como construir e testar uma estratégia de negociação de ações usando a Aprendizagem de Máquinas. No final da pesquisa, o autor achou uma tarefa bastante impossível, no entanto, é muito divertido no processo e às vezes pode até ser rentável.
O artigo oferece explicação detalhada e código-fonte do sistema de negociação. Primeiro, examinou o mercado de ações e formulou várias estratégias de negociação. Em seguida, construiu a primeira estratégia usando uma regressão de vetor de suporte e a segunda usando a distorção de tempo dinâmico.
Espero que isso sirva como um ponto de salto para suas próprias explorações.