воскресенье, 29 апреля 2018 г.

Arquitetura do sistema de negociação algo


Noções básicas de negociação algorítmica: conceitos e exemplos.


A negociação algorítmica (negociação automatizada, negociação de caixa preta ou simplesmente negociação de algoritmos) é o processo de usar computadores programados para seguir um conjunto definido de instruções (um algoritmo) para colocar uma negociação a fim de gerar lucros a uma velocidade e freqüência impossível para um comerciante humano. Os conjuntos de regras definidos são baseados em tempo, preço, quantidade ou qualquer modelo matemático. Para além das oportunidades de lucro para o comerciante, a negociação de algoritmos torna os mercados mais nítidos e torna a negociação mais sistemática ao excluir o impacto das emoções humanas nas atividades de negociação.


Suponha que um comerciante siga estes critérios comerciais simples:


Compre 50 ações de uma ação quando a média móvel de 50 dias ultrapassar a média móvel de 200 dias. (Uma média móvel é uma média de pontos de dados passados ​​que suaviza as flutuações diárias de preço e, portanto, identifica as tendências.) Venda ações do estoque quando sua média móvel de 50 dias ficar abaixo da média móvel de 200 dias.


Usando este conjunto de duas instruções simples, é fácil escrever um programa de computador que monitore automaticamente o preço das ações (e os indicadores de média móvel) e coloque as ordens de compra e venda quando as condições definidas forem atendidas. O comerciante não precisa mais ficar de olho nos preços e gráficos ativos, ou colocar os pedidos manualmente. O sistema de negociação algorítmica faz isso automaticamente, identificando corretamente a oportunidade de negociação.


Benefícios do comércio algorítmico.


Algo-trading fornece os seguintes benefícios:


operações realizadas com os melhores preços possíveis e imediatas (com altas chances de execução nos níveis desejados) operações cronometradas corretamente e instantaneamente, para evitar mudanças significativas nos preços reduzindo os custos de transação (veja o exemplo de déficit de implementação abaixo) verificações automatizadas simultâneas em múltiplos as condições de mercado reduziram o risco de erros manuais ao colocar os negócios em teste, em dados históricos e em tempo real disponíveis, para ver se é uma estratégia comercial viável, possibilidade reduzida de erros por parte de comerciantes humanos com base em fatores emocionais e psicológicos.


A maior parte da negociação de algoritmos de hoje é a negociação de alta frequência (HFT), que tenta capitalizar a colocação de um grande número de pedidos em velocidades muito rápidas em vários mercados e vários parâmetros de decisão, com base em instruções pré-programadas.


O comércio de algo é usado em muitas formas de atividades de negociação e investimento, incluindo:


Investidores de médio a longo prazo ou empresas compradoras - fundos de pensão, fundos mútuos, seguradoras - usam-no para comprar ações em grandes quantidades quando não desejam influenciar os preços das ações com investimentos discretos e de grande volume. Comerciantes de curto prazo e participantes de sell-side - formadores de mercado (como corretoras), especuladores e arbitradores - se beneficiam da execução automatizada do comércio; Além disso, o comércio de algo ajuda a criar liquidez suficiente para os vendedores no mercado. Comerciantes sistemáticos - seguidores de tendências, hedge funds ou pares de traders (uma estratégia de negociação neutra de mercado que corresponde a uma posição comprada com uma posição vendida em um par de instrumentos altamente correlacionados, como duas ações, fundos negociados em bolsa (ETFs) ou moedas) etc. - Acha muito mais eficiente programar suas regras de negociação e permitir que o programa troque automaticamente.


O comércio algorítmico fornece uma abordagem mais sistemática ao comércio ativo do que métodos baseados na intuição ou instinto de um operador humano.


Estratégias de Negociação Algorítmica.


Qualquer estratégia para negociação algorítmica requer uma oportunidade identificada que seja lucrativa em termos de ganhos aprimorados ou redução de custos. A seguir estão as estratégias de negociação comuns usadas no comércio de algo:


As estratégias de negociação algorítmica mais comuns seguem as tendências de médias móveis, desvios de canal, movimentos de níveis de preços e indicadores técnicos relacionados. Essas são as estratégias mais fáceis e simples de implementar por meio do comércio algorítmico, porque essas estratégias não envolvem previsões nem previsões de preços. As negociações são iniciadas com base na ocorrência de tendências desejáveis, que são fáceis e diretas de implementar por meio de algoritmos, sem entrar na complexidade da análise preditiva. O exemplo mencionado acima, de usar as médias móveis de 50 e 200 dias, é uma estratégia popular de acompanhamento de tendências.


Comprar uma ação com cotação dupla a um preço menor em um mercado e vendê-la simultaneamente a um preço mais alto em outro mercado oferece o diferencial de preço como lucro ou arbitragem isenta de risco. A mesma operação pode ser replicada para ações versus instrumentos futuros, já que os diferenciais de preços existem de tempos em tempos. Implementar um algoritmo para identificar esses diferenciais de preços e colocar as ordens permite oportunidades lucrativas de maneira eficiente.


Os fundos de índices definiram períodos de reequilíbrio para aproximar seus investimentos aos seus respectivos índices de referência. Isso cria oportunidades lucrativas para os traders algorítmicos, que capitalizam os negócios esperados que oferecem 20 a 80 pontos-base de lucros, dependendo do número de ações no fundo de índice, pouco antes do rebalanceamento do fundo de índice. Tais negociações são iniciadas através de sistemas de negociação algorítmica para execução atempada e melhores preços.


Modelos matemáticos comprovados, como a estratégia de negociação delta-neutral, permitem negociar com uma combinação de opções e sua segurança subjacente. (A Delta neutra é uma estratégia de carteira que consiste em múltiplas posições com deltas positivos e negativos compensatórios - uma relação que compara a mudança no preço de um ativo, geralmente um título negociável, com a mudança correspondente no preço de seu derivativo - de forma que a delta dos ativos em questão totaliza zero.)


A estratégia de reversão à média baseia-se na ideia de que os preços altos e baixos de um ativo são um fenômeno temporário que revertem para seu valor médio (valor médio) periodicamente. Identificar e definir uma faixa de preço e implementar um algoritmo baseado nele permite que as negociações sejam feitas automaticamente quando o preço do ativo entra e sai de sua faixa definida.


A estratégia de preço médio ponderado por volume divide uma ordem grande e libera partes menores da ordem para o mercado, determinadas dinamicamente, usando perfis de volume históricos específicos do estoque. O objetivo é executar o pedido próximo ao preço médio ponderado por volume (VWAP).


A estratégia de preço médio ponderada pelo tempo quebra uma ordem grande e libera dinamicamente pedaços menores da ordem para o mercado usando intervalos de tempo divididos uniformemente entre uma hora inicial e final. O objetivo é executar o pedido próximo ao preço médio entre os horários inicial e final, minimizando o impacto no mercado.


Até que a ordem de negociação esteja totalmente preenchida, este algoritmo continua enviando ordens parciais, de acordo com a taxa de participação definida e de acordo com o volume negociado nos mercados. A “estratégia de etapas” relacionada envia pedidos em uma porcentagem definida pelo usuário de volumes de mercado e aumenta ou diminui essa taxa de participação quando o preço da ação atinge níveis definidos pelo usuário.


A estratégia de déficit de implementação visa minimizar o custo de execução de um pedido negociando o mercado em tempo real, economizando assim no custo do pedido e se beneficiando do custo de oportunidade de execução atrasada. A estratégia aumentará a taxa de participação visada quando o preço das ações se mover favoravelmente e diminuirá quando o preço das ações se mover negativamente.


Existem algumas classes especiais de algoritmos que tentam identificar “acontecimentos” do outro lado. Esses "algoritmos de farejamento", usados, por exemplo, por um criador de mercado de vendas, têm a inteligência incorporada para identificar a existência de qualquer algoritmo no lado de compra de um pedido grande. Essa detecção por meio de algoritmos ajudará o criador de mercado a identificar grandes oportunidades de pedidos e permitir que eles se beneficiem do preenchimento dos pedidos a um preço mais alto. Às vezes, isso é identificado como front-running de alta tecnologia.


Requisitos técnicos para negociação algorítmica.


A implementação do algoritmo usando um programa de computador é a última parte, acompanhada de backtesting (experimentando o algoritmo em períodos históricos do desempenho passado do mercado de ações para ver se usá-lo seria lucrativo). O desafio é transformar a estratégia identificada em um processo informatizado integrado que tenha acesso a uma conta de negociação para fazer pedidos. Os seguintes são necessários:


conhecimento de programação de computadores para programar a estratégia de negociação necessária, programadores contratados ou conectividade de rede de software de negociação pré-fabricada e acesso a plataformas de negociação para colocar os pedidos em acesso a feeds de dados de mercado que serão monitorados pelo algoritmo quanto a oportunidades de fazer pedidos. infra-estrutura para backtest o sistema, uma vez que é construído - antes de ir ao vivo em mercados reais disponíveis dados históricos para backtesting, dependendo da complexidade das regras implementadas no algoritmo.


Aqui está um exemplo de como funciona a negociação algorítmica: a Royal Dutch Shell (RDS) está listada na Bolsa de Valores de Amsterdã (AEX) e na Bolsa de Valores de Londres (LSE). Começamos construindo um algoritmo para identificar oportunidades de arbitragem. Aqui estão algumas observações interessantes:


AEX negocia em euros, enquanto a LSE negocia em libras esterlinas britânicas Devido à diferença horária de uma hora, a AEX abre uma hora antes da LSE, seguida pelas duas bolsas negociadas simultaneamente pelas próximas horas e depois negociadas apenas na LSE durante a última hora como AEX fecha.


Podemos explorar a possibilidade de negociação de arbitragem sobre as ações da Royal Dutch Shell listadas nesses dois mercados em duas moedas diferentes?


um programa de computador capaz de ler os preços atuais dos preços de mercado da LSE e AEX, uma taxa forex (taxa de câmbio) para a capacidade de colocação de pedidos de GBP-EUR que pode encaminhar a ordem para a capacidade correta de backtesting de câmbio em preços históricos.


O programa de computador deve executar o seguinte:


Leia o feed de preço de entrada do estoque RDS de ambas as trocas. Usando as taxas de câmbio disponíveis, converta o preço de uma moeda para outra. Se houver uma discrepância de preço grande o suficiente (descontando os custos de corretagem) levando a uma oportunidade lucrativa, então coloque a ordem de compra na troca de preço mais baixo e na ordem de venda na troca de preço mais alto. Se as ordens forem executadas conforme desejado, o lucro da arbitragem se seguirá.


Simples e fácil! No entanto, a prática de negociação algorítmica não é tão simples de manter e executar. Lembre-se, se você puder colocar uma negociação gerada por algoritmos, os outros participantes do mercado também poderão. Consequentemente, os preços flutuam em milissegundos e até microssegundos. No exemplo acima, o que acontece se a transação de compra for executada, mas a negociação de venda não ocorre porque os preços de venda mudam quando o seu pedido chega ao mercado? Você vai acabar sentado com uma posição aberta, fazendo com que sua estratégia de arbitragem seja inútil.


Há riscos e desafios adicionais: por exemplo, riscos de falha do sistema, erros de conectividade de rede, atrasos entre ordens de negociação e execução e, o mais importante de tudo, algoritmos imperfeitos. Quanto mais complexo for um algoritmo, o backtesting mais rigoroso é necessário antes de ser colocado em ação.


The Bottom Line.


É emocionante usar a automação auxiliada por computadores com o objetivo de ganhar dinheiro sem esforço. Mas é preciso garantir que o sistema seja completamente testado e que os limites necessários sejam definidos. Comerciantes analíticos devem considerar o aprendizado de programação e construção de sistemas por conta própria, para ter confiança em implementar as estratégias corretas de uma maneira infalível. Uso cauteloso e testes completos de negociação de algoritmos podem criar oportunidades lucrativas.


Segredos de Negociação Algorítmica.


Em outro blog, mencionamos os componentes mais importantes a serem considerados para um sistema de algo. Neste blog, lidamos com um dos componentes mais importantes: O componente do manipulador de feed de dados do marcador.


Em um sistema de feed de dados de mercado (mdf), os provedores de MDF e o programa consomem o feed. Existem várias alternativas para os fornecedores de MDF de código aberto para os mais caros.


Os gratuitos, como o Yahoo, o Google, estão disponíveis, mas para um sistema de negociação algorítmico robusto, você teria que considerar mais sistemas de alimentação de dados em tempo real, como a Bloomberg ou a Reuters. Bloomberg Terminal ou Reuters vêm com um preço, existem outros sistemas de alimentação de dados a um preço menor no entanto, para o design da arquitetura em nosso exemplo, Reuters e Bloomberg serão explicados em detalhes.


No momento, o foco não é escolher um fornecedor de feed de dados de mercado, mas todo o desenvolvimento do componente que manipula os dados brutos de um provedor de MDF determinará o curso da programação e a solução que você precisa tomar. A Reuters e a Bloomberg têm APIs que permitem que os programadores consumam certos métodos e adaptem o programa às suas necessidades.


Desde 2012, a Bloomberg fez sua fonte aberta de API. Isso permite que os desenvolvedores experimentem e criem soluções para o mercado financeiro, como mencionado em seu site & # 8220; A Bloomberg está oferecendo esta interface de programação (BLPAPI) sob uma licença de uso livre. Esta licença não inclui nem fornece acesso a nenhum dado ou conteúdo da Bloomberg. Se você deseja usar esta API para acessar os dados da Bloomberg, precisará de uma assinatura de serviço da Bloomberg e deve entrar em contato com o escritório de vendas da Bloomberg mais próximo em sua região. & # 8221; Portanto, precisamos de uma maneira de testar um feed. Uma alternativa é pagar por uma conta de desenvolvedor que custa US $ 2000 / mês. A boa notícia é que existe uma alternativa para simular o feed de dados: Bloomberg API Emulator (.Net, Java, C ++).


Escolhendo uma linguagem de programação.


A API do BB pode ser consumida usando diferentes linguagens e sistemas operacionais, como:


Arquitetura do Sistema de Negociação Algorítmica.


Anteriormente neste blog, escrevi sobre a arquitetura conceitual de um sistema inteligente de comércio algorítmico, bem como os requisitos funcionais e não funcionais de um sistema de negociação algorítmica de produção. Desde então, projetei uma arquitetura de sistema que, acredito, poderia satisfazer esses requisitos arquitetônicos. Neste post, descreverei a arquitetura seguindo as diretrizes dos padrões ISO / IEC / IEEE 42010 e o padrão de descrição da arquitetura de engenharia de software. De acordo com este padrão, uma descrição de arquitetura deve:


Contém múltiplas visualizações de arquitetura padronizadas (por exemplo, em UML) e mantém a rastreabilidade entre as decisões de design e os requisitos de arquitetura.


Definição de arquitetura de software.


Ainda não há consenso sobre o que é uma arquitetura de sistema. No contexto deste artigo, ele é definido como a infraestrutura na qual os componentes do aplicativo que satisfazem os requisitos funcionais podem ser especificados, implementados e executados. Requisitos funcionais são as funções esperadas do sistema e seus componentes. Requisitos não funcionais são medidas através das quais a qualidade do sistema pode ser medida.


Um sistema que satisfaz plenamente seus requisitos funcionais ainda pode falhar em atender às expectativas se os requisitos não funcionais forem deixados insatisfeitos. Para ilustrar esse conceito, considere o seguinte cenário: um sistema de negociação algorítmica que você acabou de comprar / construir faz excelentes decisões de negociação, mas é completamente inoperável com os sistemas de contabilidade e gerenciamento de risco da organização. Este sistema atenderia às suas expectativas?


Arquitetura conceitual.


Uma visão conceitual descreve conceitos e mecanismos de alto nível que existem no sistema no mais alto nível de granularidade. Nesse nível, o sistema de negociação algorítmica segue uma arquitetura orientada a eventos (EDA) dividida em quatro camadas e dois aspectos arquitetônicos. Para cada camada e referência, arquiteturas e padrões de referência são usados. Padrões arquitetônicos são estruturas genéricas comprovadas para atingir requisitos específicos. Aspectos arquitetônicos são preocupações transversais que abrangem múltiplos componentes.


Arquitetura orientada a eventos - uma arquitetura que produz, detecta, consome e reage a eventos. Os eventos incluem movimentos do mercado em tempo real, eventos ou tendências complexas e eventos de negociação, por ex. enviando um pedido.


Este diagrama ilustra a arquitetura conceitual do sistema de negociação algorítmica.


Arquiteturas de Referência.


Para usar uma analogia, uma arquitetura de referência é semelhante às plantas de uma parede de suporte de carga. Essa impressão em azul pode ser reutilizada para vários projetos de construção, independentemente do prédio que está sendo construído, uma vez que satisfaz um conjunto de requisitos comuns. Da mesma forma, uma arquitetura de referência define um modelo contendo estruturas e mecanismos genéricos que podem ser usados ​​para construir uma arquitetura de software concreta que atenda a requisitos específicos. A arquitetura para o sistema de negociação algorítmica usa uma arquitetura baseada em espaço (SBA) e um controlador de visão de modelo (MVC) como referências. Boas práticas, como o armazenamento de dados operacionais (ODS), o padrão de transformação e carga de extração (ETL) e um data warehouse (DW) também são usados.


Model view controller - um padrão que separa a representação da informação da interação do usuário com ela. Arquitetura baseada no espaço - especifica uma infraestrutura onde unidades de processamento fracamente acopladas interagem entre si por meio de uma memória associativa compartilhada chamada espaço (mostrada abaixo).


Visão Estrutural.


A visão estrutural de uma arquitetura mostra os componentes e subcomponentes do sistema de negociação algorítmica. Também mostra como esses componentes são implantados na infraestrutura física. Os diagramas UML usados ​​nessa exibição incluem diagramas de componentes e diagramas de implementação. Abaixo está a galeria dos diagramas de implantação do sistema de comércio algorítmico geral e as unidades de processamento na arquitetura de referência SBA, bem como diagramas de componentes relacionados para cada uma das camadas.


Diagrama do componente de comerciante / processamento de eventos automatizado Diagrama do componente da camada de origem de dados e de pré-processamento Diagrama do componente da interface com o usuário baseado no MVC.


Táticas Arquitetônicas.


De acordo com o instituto de engenharia de software, uma tática arquitetônica é um meio de satisfazer um requisito de qualidade, manipulando algum aspecto de um modelo de atributo de qualidade através de decisões de design arquitetônico. Um exemplo simples usado na arquitetura do sistema de negociação algorítmica é 'manipular' um armazenamento de dados operacional (ODS) com um componente contínuo de consulta. Esse componente analisaria continuamente o ODS para identificar e extrair eventos complexos. As seguintes táticas são usadas na arquitetura:


O padrão do disruptor nas filas de eventos e pedidos Memória compartilhada para o evento e filas de pedidos Linguagem de consulta contínua (CQL) no ODS Filtragem de dados com o padrão de design de filtro nos dados de entrada Algoritmos de prevenção de congestionamento em todas as conexões de entrada e saída Gerenciamento de filas ativas (AQM ) e notificação explícita de congestionamento Recursos de computação de commodities com capacidade de atualização (escalonável) Redundância ativa para todos os pontos únicos de falha Estrutura de indexação e otimização otimizada no ODS Agendamento de backup regular de dados e scripts de limpeza para ODS Histórico de transações em todos os bancos de dados ordens para detectar falhas Anotar eventos com registros de tempo para pular eventos 'obsoletos' Regras de validação de pedidos, por exemplo quantidades máximas de negociação Componentes de negociador automatizado usam um banco de dados em memória para análise Autenticação de dois estágios para interfaces de usuário conectando-se aos ATs Criptografia em interfaces de usuário e conexões ao padrão de projeto ATs Observer para o MVC gerenciar visualizações.


A lista acima é apenas algumas decisões de design que identifiquei durante o design da arquitetura. Não é uma lista completa de táticas. À medida que o sistema está sendo desenvolvido, táticas adicionais devem ser empregadas em vários níveis de granularidade para atender aos requisitos funcionais e não funcionais. Abaixo, há três diagramas descrevendo o padrão de design do disruptor, o padrão de design do filtro e o componente de consulta contínua.


Visão Comportamental.


Essa visão de uma arquitetura mostra como os componentes e as camadas devem interagir entre si. Isso é útil ao criar cenários para testar projetos de arquitetura e para entender o sistema de ponta a ponta. Essa visão consiste em diagramas de seqüência e diagramas de atividades. Os diagramas de atividades que mostram o processo interno do sistema de comércio algorítmico e como os comerciantes devem interagir com o sistema de comércio algorítmico são mostrados abaixo.


Tecnologias e frameworks.


A etapa final no projeto de uma arquitetura de software é identificar possíveis tecnologias e estruturas que possam ser usadas para realizar a arquitetura. Como princípio geral, é melhor aproveitar as tecnologias existentes, desde que satisfaçam adequadamente os requisitos funcionais e não funcionais. Uma estrutura é uma arquitetura de referência realizada, por ex. O JBoss é um framework que realiza a arquitetura de referência do JEE. As seguintes tecnologias e estruturas são interessantes e devem ser consideradas ao implementar um sistema de comércio algorítmico:


CUDA - A NVidia possui vários produtos que suportam modelagem de finanças computacionais de alto desempenho. É possível obter até 50x melhorias de desempenho na execução de simulações de Monte Carlo na GPU em vez da CPU. Apache River - River é um kit de ferramentas usado para desenvolver sistemas distribuídos. Ele foi usado como uma estrutura para construir aplicativos baseados no padrão SBA Apache Hadoop - no caso em que o registro generalizado é um requisito, o uso do Hadoop oferece uma solução interessante para o problema de big data. O Hadoop pode ser implementado em um ambiente em cluster que suporta tecnologias CUDA. AlgoTrader - uma plataforma de negociação algorítmica de código aberto. O AlgoTrader poderia ser implantado no lugar dos componentes do negociador automatizado. FIX Engine - um aplicativo independente que suporta os protocolos Financial Information Exchange (FIX), incluindo FIX, FAST e FIXatdl.


Embora não seja uma tecnologia ou uma estrutura, os componentes devem ser construídos com uma interface de programação de aplicativo (API) para melhorar a interoperabilidade do sistema e de seus componentes.


Conclusão.


A arquitetura proposta foi projetada para satisfazer requisitos muito genéricos identificados para sistemas de negociação algorítmica. De um modo geral, os sistemas de negociação algorítmica são complicados por três fatores que variam de acordo com cada implementação:


Dependências da empresa externa e sistemas de troca Desafiando requisitos não funcionais e Evitando restrições arquitetônicas.


A arquitetura de software proposta precisaria, portanto, ser adaptada caso a caso, a fim de satisfazer requisitos organizacionais e regulatórios específicos, bem como superar restrições regionais. A arquitetura do sistema de comércio algorítmico deve ser vista apenas como um ponto de referência para indivíduos e organizações que desejam projetar seus próprios sistemas de negociação algorítmica.


Para uma cópia completa e fontes utilizadas, faça o download de uma cópia do meu relatório. Obrigado.


Melhor Linguagem de Programação para Sistemas de Negociação Algorítmica?


Melhor Linguagem de Programação para Sistemas de Negociação Algorítmica?


Uma das perguntas mais frequentes que recebo no mailbag do QS é "Qual é a melhor linguagem de programação para negociação algorítmica?". A resposta curta é que não há "melhor" linguagem. Parâmetros de estratégia, desempenho, modularidade, desenvolvimento, resiliência e custo devem ser considerados. Este artigo descreverá os componentes necessários de uma arquitetura de sistema de comércio algorítmico e como as decisões relativas à implementação afetam a escolha da linguagem.


Primeiramente, os principais componentes de um sistema de negociação algorítmica serão considerados, como as ferramentas de pesquisa, o otimizador de portfólio, o gerenciador de risco e o mecanismo de execução. Posteriormente, diferentes estratégias de negociação serão examinadas e como elas afetam o design do sistema. Em particular, a frequência de negociação e o volume de negociação provável serão ambos discutidos.


Uma vez que a estratégia de negociação tenha sido selecionada, é necessário arquitetar todo o sistema. Isso inclui a escolha de hardware, o sistema operacional e a resiliência do sistema contra eventos raros e potencialmente catastróficos. Enquanto a arquitetura está sendo considerada, a devida atenção deve ser dada ao desempenho - tanto para as ferramentas de pesquisa quanto para o ambiente de execução ao vivo.


Qual é o sistema de negociação tentando fazer?


Antes de decidir sobre a "melhor" linguagem com a qual escrever um sistema de negociação automatizado, é necessário definir os requisitos. O sistema será puramente baseado em execução? O sistema exigirá um módulo de gerenciamento de risco ou de construção de portfólio? O sistema exigirá um backtester de alto desempenho? Para a maioria das estratégias, o sistema de negociação pode ser dividido em duas categorias: Pesquisa e geração de sinais.


A pesquisa está preocupada com a avaliação de um desempenho da estratégia em relação aos dados históricos. O processo de avaliação de uma estratégia de negociação sobre dados de mercado anteriores é conhecido como backtesting. O tamanho dos dados e a complexidade algorítmica terão um grande impacto na intensidade computacional do backtester. A velocidade e a simultaneidade da CPU costumam ser os fatores limitantes na otimização da velocidade de execução da pesquisa.


A geração de sinais preocupa-se em gerar um conjunto de sinais de negociação de um algoritmo e enviar esses pedidos ao mercado, geralmente por meio de uma corretora. Para determinadas estratégias, é necessário um alto nível de desempenho. Problemas de E / S, como largura de banda de rede e latência, são muitas vezes o fator limitante na otimização de sistemas de execução. Assim, a escolha de idiomas para cada componente de todo o seu sistema pode ser bem diferente.


Tipo, Frequência e Volume de Estratégia.


O tipo de estratégia algorítmica empregada terá um impacto substancial no design do sistema. Será necessário considerar os mercados que estão sendo negociados, a conectividade com fornecedores de dados externos, a frequência e o volume da estratégia, o tradeoff entre facilidade de desenvolvimento e otimização de desempenho, bem como qualquer hardware personalizado, incluindo customização co-localizada servidores, GPUs ou FPGAs que possam ser necessários.


As escolhas tecnológicas para uma estratégia de ações norte-americanas de baixa frequência serão muito diferentes daquelas de uma negociação de estratégia de arbitragem estatística de alta frequência no mercado de futuros. Antes da escolha da linguagem, muitos fornecedores de dados devem ser avaliados quanto à estratégia em questão.


Será necessário considerar a conectividade com o fornecedor, a estrutura de quaisquer APIs, a pontualidade dos dados, os requisitos de armazenamento e a resiliência em face de um fornecedor ficar off-line. Também é aconselhável ter acesso rápido a vários fornecedores! Vários instrumentos têm suas próprias peculiaridades de armazenamento, exemplos dos quais incluem vários símbolos de ticker para ações e datas de vencimento para futuros (para não mencionar quaisquer dados OTC específicos). Isso precisa ser levado em conta no design da plataforma.


A frequência da estratégia é provavelmente um dos maiores impulsionadores de como a pilha de tecnologia será definida. Estratégias que empregam dados com mais freqüência do que minuciosamente ou em segundo lugar exigem consideração significativa com relação ao desempenho.


Uma estratégia que excede as segundas barras (isto é, dados de ticks) leva a um design orientado pelo desempenho como o requisito primário. Para estratégias de alta frequência, uma quantidade substancial de dados de mercado precisará ser armazenada e avaliada. Softwares como HDF5 ou kdb + são comumente usados ​​para essas funções.


Para processar os volumes extensos de dados necessários para aplicativos HFT, um backtester e um sistema de execução extensivamente otimizados devem ser usados. C / C ++ (possivelmente com algum montador) é provável que seja o candidato de idioma mais forte. Estratégias de frequência ultra-alta quase certamente exigirão hardware customizado, como FPGAs, co-location de troca e ajuste de interface de rede / kernal.


Sistemas de pesquisa.


Os sistemas de pesquisa geralmente envolvem uma mistura de desenvolvimento interativo e scripts automatizados. O primeiro ocorre com frequência dentro de um IDE, como o Visual Studio, o MatLab ou o R Studio. Este último envolve extensos cálculos numéricos sobre numerosos parâmetros e pontos de dados. Isso leva a uma escolha de idioma que fornece um ambiente simples para testar o código, mas também fornece desempenho suficiente para avaliar estratégias em várias dimensões de parâmetro.


IDEs típicos nesse espaço incluem o Microsoft Visual C ++ / C #, que contém extensos utilitários de depuração, recursos de conclusão de código (via "Intellisense") e visões gerais simples da pilha inteira do projeto (via banco de dados ORM, LINQ); MatLab, que é projetado para extensa álgebra linear numérica e operações vetorizadas, mas de uma forma de console interativo; R Studio, que envolve o console de linguagem estatística R em um IDE completo; Eclipse IDE para Linux Java e C ++; e IDEs semi-proprietários como o Enthought Canopy for Python, que incluem bibliotecas de análise de dados como NumPy, SciPy, scikit-learn e pandas em um único ambiente interativo (console).


Para backtesting numérico, todos os idiomas acima são adequados, embora não seja necessário utilizar uma GUI / IDE, pois o código será executado "em segundo plano". A consideração principal neste estágio é a velocidade de execução. Uma linguagem compilada (como C ++) é geralmente útil se as dimensões do parâmetro de backtesting forem grandes. Lembre-se que é necessário ter cuidado com esses sistemas, se for esse o caso!


Linguagens interpretadas, como Python, geralmente usam bibliotecas de alto desempenho como o NumPy / pandas para a etapa de backtesting, a fim de manter um grau razoável de competitividade com equivalentes compilados. Em última análise, a linguagem escolhida para o backtesting será determinada por necessidades algorítmicas específicas, bem como o leque de bibliotecas disponíveis na linguagem (mais sobre isso abaixo). No entanto, a linguagem usada para os ambientes de backtester e de pesquisa pode ser completamente independente daquelas usadas nos componentes de construção de portfólio, gerenciamento de risco e execução, como será visto.


Construção de Carteira e Gestão de Risco.


Os componentes de gerenciamento de risco e de construção de portfólio são frequentemente negligenciados por traders algorítmicos de varejo. Isso é quase sempre um erro. Essas ferramentas fornecem o mecanismo pelo qual o capital será preservado. Eles não apenas tentam aliviar o número de apostas "arriscadas", mas também minimizam a rotatividade dos negócios, reduzindo os custos de transação.


Versões sofisticadas desses componentes podem ter um efeito significativo na qualidade e consistência da lucratividade. É fácil criar uma estratégia estável, pois o mecanismo de construção de portfólio e o gerenciador de risco podem ser facilmente modificados para lidar com vários sistemas. Assim, eles devem ser considerados componentes essenciais no início do projeto de um sistema de negociação algorítmica.


O trabalho do sistema de construção de portfólio é pegar um conjunto de negócios desejados e produzir o conjunto de negociações reais que minimizam o churn, manter exposições a vários fatores (como setores, classes de ativos, volatilidade, etc.) e otimizar a alocação de capital para vários estratégias em um portfólio.


A construção de portfólio geralmente se reduz a um problema de álgebra linear (como uma fatoração de matriz) e, portanto, o desempenho é altamente dependente da eficácia da implementação da álgebra linear numérica disponível. Bibliotecas comuns incluem uBLAS, LAPACK e NAG para C ++. O MatLab também possui operações de matriz amplamente otimizadas. O Python utiliza o NumPy / SciPy para tais cálculos. Um portfólio freqüentemente reequilibrado exigirá uma biblioteca matricial compilada (e bem otimizada!) Para realizar este passo, de modo a não afunilar o sistema de negociação.


O gerenciamento de riscos é outra parte extremamente importante de um sistema de negociação algorítmica. O risco pode vir de várias formas: aumento da volatilidade (embora isso possa ser visto como desejável para certas estratégias!), Aumento de correlações entre classes de ativos, inadimplência de terceiros, interrupções de servidor, eventos "black swan" e erros não detectados no código de negociação. para nomear alguns.


Os componentes de gerenciamento de risco tentam antecipar os efeitos da volatilidade excessiva e correlação entre as classes de ativos e seus efeitos subsequentes sobre o capital comercial. Muitas vezes, isso reduz a um conjunto de cálculos estatísticos, como os "testes de estresse" de Monte Carlo. Isso é muito semelhante às necessidades computacionais de um mecanismo de precificação de derivativos e, como tal, será vinculado à CPU. Estas simulações são altamente paralelizáveis ​​(veja abaixo) e, até certo ponto, é possível "lançar hardware no problema".


Sistemas de Execução.


O trabalho do sistema de execução é receber sinais de negociação filtrados dos componentes de construção de carteira e gerenciamento de risco e enviá-los para uma corretora ou outros meios de acesso ao mercado. Para a maioria das estratégias de negociação algorítmica de varejo, isso envolve uma conexão API ou FIX para uma corretora como a Interactive Brokers. As principais considerações ao decidir sobre uma linguagem incluem a qualidade da API, a disponibilidade do wrapper de idioma para uma API, a frequência de execução e o escorregamento previsto.


A "qualidade" da API refere-se a quão bem documentada ela é, que tipo de desempenho ela fornece, se precisa de um software independente para ser acessado ou se um gateway pode ser estabelecido de forma desmotivada (ou seja, sem GUI). No caso dos Interactive Brokers, a ferramenta Trader WorkStation precisa estar em execução em um ambiente GUI para acessar sua API. Certa vez, tive que instalar uma edição do Ubuntu do Desktop em um servidor de nuvem da Amazon para acessar o Interactive Brokers remotamente, puramente por esse motivo!


A maioria das APIs fornecerá uma interface C ++ e / ou Java. Geralmente, cabe à comunidade desenvolver wrappers específicos de linguagem para C #, Python, R, Excel e MatLab. Observe que, com cada plug-in adicional utilizado (especialmente os wrappers de APIs), há escopo para os bugs se infiltrarem no sistema. Sempre teste plugins desse tipo e garanta que eles sejam ativamente mantidos. Um indicador que vale a pena é ver quantas novas atualizações foram feitas em uma base de código nos últimos meses.


Freqüência de execução é da maior importância no algoritmo de execução. Observe que centenas de pedidos podem ser enviados a cada minuto e, como tal, o desempenho é crítico. A derrapagem será incorrida através de um sistema de execução com péssimo desempenho e isso terá um impacto dramático na lucratividade.


As linguagens com tipagem estática (veja abaixo), como C ++ / Java, são geralmente ótimas para execução, mas há um trade-off em tempo de desenvolvimento, teste e facilidade de manutenção. Linguagens dinamicamente tipificadas, como Python e Perl, são geralmente "rápidas o suficiente". Certifique-se sempre de que os componentes são projetados de maneira modular (veja abaixo) para que possam ser "trocados" conforme o sistema é dimensionado.


Planejamento arquitetônico e processo de desenvolvimento.


Os componentes de um sistema de negociação, seus requisitos de freqüência e volume foram discutidos acima, mas a infra-estrutura do sistema ainda não foi coberta. Aqueles que atuam como comerciantes de varejo ou que trabalham em um pequeno fundo provavelmente estarão "usando muitos chapéus". Será necessário estar cobrindo o modelo alfa, os parâmetros de gerenciamento e execução de riscos, e também a implementação final do sistema. Antes de aprofundar em linguagens específicas, o design de uma arquitetura de sistema ideal será discutido.


Separação de preocupações.


Uma das decisões mais importantes que devem ser tomadas no início é como "separar as preocupações" de um sistema de negociação. No desenvolvimento de software, isso significa essencialmente dividir os diferentes aspectos do sistema de negociação em componentes modulares separados.


Ao expor as interfaces em cada um dos componentes, é fácil trocar partes do sistema por outras versões que auxiliem o desempenho, a confiabilidade ou a manutenção, sem modificar nenhum código de dependência externo. Essa é a "melhor prática" para esses sistemas. Para estratégias em freqüências mais baixas, tais práticas são recomendadas. Para negociação de ultra alta frequência, o livro de regras pode ter que ser ignorado em detrimento do ajuste do sistema para um desempenho ainda maior. Um sistema mais fortemente acoplado pode ser desejável.


Criar um mapa de componentes de um sistema de negociação algorítmico vale um artigo em si. No entanto, uma abordagem ideal é garantir que haja componentes separados para as entradas de dados de mercado históricas e em tempo real, armazenamento de dados, API de acesso a dados, backtester, parâmetros estratégicos, construção de portfólio, gerenciamento de risco e sistemas automatizados de execução.


Por exemplo, se o armazenamento de dados em uso estiver atualmente com baixo desempenho, mesmo em níveis significativos de otimização, ele poderá ser substituído com reescritas mínimas para a API de acesso a dados ou acesso a dados. Tanto quanto o backtester e componentes subseqüentes estão em causa, não há diferença.


Outro benefício dos componentes separados é que ele permite que uma variedade de linguagens de programação seja usada no sistema geral. Não há necessidade de se restringir a um único idioma se o método de comunicação dos componentes for independente de idioma. Este será o caso se eles estiverem se comunicando via TCP / IP, Zero ou algum outro protocolo independente de linguagem.


Como um exemplo concreto, considere o caso de um sistema de backtesting sendo escrito em C ++ para desempenho "processamento de números", enquanto o gerenciador de portfólio e os sistemas de execução são escritos em Python usando SciPy e IBPy.


Considerações de desempenho.


O desempenho é uma consideração significativa para a maioria das estratégias de negociação. Para estratégias de maior frequência, é o fator mais importante. "Desempenho" abrange uma ampla gama de problemas, como velocidade de execução algorítmica, latência de rede, largura de banda, E / S de dados, simultaneidade / paralelismo e dimensionamento. Cada uma dessas áreas é coberta individualmente por grandes livros didáticos, portanto, este artigo apenas arranhará a superfície de cada tópico. A arquitetura e a escolha de idiomas serão agora discutidas em termos de seus efeitos no desempenho.


A sabedoria predominante, como afirma Donald Knuth, um dos pais da Ciência da Computação, é que "a otimização prematura é a raiz de todo o mal". Isso é quase sempre o caso - exceto quando se constrói um algoritmo de negociação de alta frequência! Para aqueles que estão interessados ​​em estratégias de baixa frequência, uma abordagem comum é construir um sistema da maneira mais simples possível e apenas otimizar à medida que os gargalos começam a aparecer.


As ferramentas de criação de perfil são usadas para determinar onde os gargalos surgem. Os perfis podem ser feitos para todos os fatores listados acima, seja em um ambiente MS Windows ou Linux. Existem muitas ferramentas de sistema operacional e idioma disponíveis para isso, bem como utilitários de terceiros. A escolha da língua será agora discutida no contexto do desempenho.


C ++, Java, Python, R e MatLab contêm bibliotecas de alto desempenho (como parte de seus padrões ou externamente) para estrutura de dados básica e trabalho algorítmico. O C ++ é fornecido com a Biblioteca de Modelos Padrão, enquanto o Python contém o NumPy / SciPy. Tarefas matemáticas comuns são encontradas nessas bibliotecas e raramente é benéfico escrever uma nova implementação.


Uma exceção é se a arquitetura de hardware altamente personalizada for necessária e um algoritmo estiver fazendo uso extensivo de extensões proprietárias (como caches personalizados). No entanto, muitas vezes a "reinvenção da roda" desperdiça tempo que poderia ser mais bem gasto desenvolvendo e otimizando outras partes da infraestrutura de negociação. O tempo de desenvolvimento é extremamente precioso, especialmente no contexto de desenvolvedores únicos.


A latência é frequentemente uma questão do sistema de execução, pois as ferramentas de pesquisa geralmente estão situadas na mesma máquina. Para o primeiro, a latência pode ocorrer em vários pontos ao longo do caminho de execução. Os bancos de dados devem ser consultados (latência de disco / rede), os sinais devem ser gerados (sistema operacional, latência do sistema de mensagens kernal), sinais comerciais enviados (latência NIC) e pedidos processados ​​(latência interna dos sistemas de troca).


Para operações de freqüência mais alta, é necessário tornar-se intimamente familiarizado com a otimização do kernal, bem como com a otimização da transmissão da rede. Esta é uma área profunda e está significativamente além do escopo do artigo, mas se um algoritmo UHFT for desejado, esteja ciente da profundidade do conhecimento necessário!


O cache é muito útil no kit de ferramentas de um desenvolvedor de comércio quantitativo. O armazenamento em cache se refere ao conceito de armazenamento de dados acessados ​​com freqüência de uma maneira que permite acesso de melhor desempenho, em detrimento do possível staleness dos dados. Um caso de uso comum ocorre no desenvolvimento da Web ao obter dados de um banco de dados relacional baseado em disco e colocá-lo na memória. Quaisquer solicitações subseqüentes para os dados não precisam "atingir o banco de dados" e, portanto, os ganhos de desempenho podem ser significativos.


Para situações de negociação, o armazenamento em cache pode ser extremamente benéfico. Por exemplo, o estado atual de um portfólio de estratégias pode ser armazenado em um cache até que seja reequilibrado, de modo que a lista não precise ser regenerada em cada loop do algoritmo de negociação. Essa regeneração provavelmente será uma operação alta de CPU ou E / S de disco.


No entanto, o armazenamento em cache não é isento de seus próprios problemas. A regeneração dos dados de cache de uma só vez, devido à natureza volátil do armazenamento em cache, pode colocar uma demanda significativa na infraestrutura. Outro problema é o empilhamento de cães, em que múltiplas gerações de uma nova cópia de cache são realizadas sob uma carga extremamente alta, o que leva a uma falha em cascata.


Alocação de memória dinâmica é uma operação cara na execução de software. Assim, é imperativo que os aplicativos de negociação de desempenho mais alto conheçam bem como a memória está sendo alocada e desalocada durante o fluxo do programa. Novos padrões de linguagem, como Java, C # e Python, executam a coleta automática de lixo, que se refere à desalocação da memória alocada dinamicamente quando os objetos saem do escopo.


A coleta de lixo é extremamente útil durante o desenvolvimento, pois reduz os erros e ajuda na legibilidade. No entanto, muitas vezes é sub-ótimo para certas estratégias de negociação de alta frequência. A coleta de lixo personalizada é geralmente desejada para esses casos. Em Java, por exemplo, ajustando o coletor de lixo e a configuração de heap, é possível obter alto desempenho para estratégias de HFT.


O C ++ não fornece um coletor de lixo nativo e, portanto, é necessário manipular toda alocação / desalocação de memória como parte da implementação de um objeto. Embora potencialmente sujeito a erros (potencialmente levando a ponteiros pendentes), é extremamente útil ter um controle refinado de como os objetos aparecem no heap para determinados aplicativos. Ao escolher um idioma, certifique-se de estudar como o coletor de lixo funciona e se ele pode ser modificado para otimizar um determinado caso de uso.


Muitas operações em sistemas de negociação algorítmica são passíveis de paralelização. Isto refere-se ao conceito de realizar múltiplas operações programáticas ao mesmo tempo, isto é, em "paralelo". Os chamados algoritmos "embarassingly parallel" incluem etapas que podem ser calculadas de forma totalmente independente de outras etapas. Certas operações estatísticas, como as simulações de Monte Carlo, são um bom exemplo de algoritmos embarassingly paralelos, já que cada sorteio aleatório e a subsequente operação de caminho podem ser computadas sem o conhecimento de outros caminhos.


Outros algoritmos são apenas parcialmente paralelizáveis. Simulações de dinâmica de fluidos são um exemplo, em que o domínio de computação pode ser subdividido, mas, em última instância, esses domínios devem se comunicar entre si e, assim, as operações são parcialmente sequenciais. Os algoritmos paralelizáveis ​​estão sujeitos à Lei de Amdahl, que fornece um limite superior teórico para o aumento de desempenho de um algoritmo paralelizado quando sujeito a processos separados por $ N $ (por exemplo, em um núcleo ou encadeamento da CPU).


A paralelização tornou-se cada vez mais importante como um meio de otimização, uma vez que as velocidades de clock do processador estagnaram, pois os processadores mais recentes contêm muitos núcleos com os quais executar cálculos paralelos. O aumento do hardware gráfico do consumidor (predominantemente para videogames) levou ao desenvolvimento de Unidades de Processamento Gráfico (Graphical Processing Units - GPUs), que contêm centenas de "núcleos" para operações altamente concorrentes. Essas GPUs agora são muito acessíveis. Estruturas de alto nível, como o CUDA da Nvidia, levaram à adoção generalizada na academia e nas finanças.


Esse hardware GPU geralmente é adequado apenas para o aspecto de pesquisa de finanças quantitativas, enquanto outros hardwares mais especializados (incluindo Field-Programmable Gate Arrays - FPGAs) são usados ​​para (U) HFT. Atualmente, os idiomas mais modernos suportam um grau de simultaneidade / multithreading. Assim, é fácil otimizar um backtester, já que todos os cálculos são geralmente independentes dos demais.


O dimensionamento em engenharia de software e operações refere-se à capacidade do sistema de manipular cargas crescentes de forma consistente na forma de solicitações maiores, maior uso do processador e mais alocação de memória. No comércio algorítmico, uma estratégia é capaz de escalonar se puder aceitar maiores quantidades de capital e ainda produzir retornos consistentes. A pilha de tecnologia de negociação é dimensionada se puder suportar maiores volumes de negócios e maior latência, sem gargalos.


Embora os sistemas devam ser projetados para escalar, muitas vezes é difícil prever antecipadamente onde ocorrerá um gargalo. Registro, testes, criação de perfil e monitoramento rigorosos ajudarão muito a permitir que um sistema seja dimensionado. Os próprios idiomas são geralmente descritos como "não escaláveis". Isso geralmente é resultado de desinformação, e não de fatos concretos. É a pilha total de tecnologia que deve ser verificada para escalabilidade, não para o idioma. É claro que certas linguagens têm um desempenho maior do que outras em casos de uso específicos, mas uma linguagem nunca é "melhor" que outra em todos os sentidos.


Um meio de gerenciar a escala é separar as preocupações, como dito acima. De modo a introduzir ainda a capacidade de lidar com "picos" no sistema (isto é, volatilidade súbita que desencadeia uma série de operações), é útil criar uma "arquitectura de fila de mensagens". Isso significa simplesmente colocar um sistema de fila de mensagens entre os componentes para que os pedidos sejam "empilhados" se um determinado componente não puder processar muitas solicitações.


Em vez de solicitações serem perdidas, elas são simplesmente mantidas em uma pilha até que a mensagem seja manipulada. Isso é particularmente útil para enviar negociações para um mecanismo de execução. Se o motor estiver sofrendo sob latência pesada, ele fará o backup dos negócios. Uma fila entre o gerador de sinais de negociação e a API de execução aliviará essa questão às custas do escorregamento comercial em potencial. Um corretor de fila de mensagens de código aberto bem respeitado é o Rabbit.


Hardware e Sistemas Operacionais.


O hardware que executa sua estratégia pode ter um impacto significativo na lucratividade de seu algoritmo. Este não é um problema restrito a operadores de alta frequência. Uma má escolha em hardware e sistema operacional pode levar a uma falha da máquina ou reinicializar no momento mais inoportuno. Assim, é necessário considerar onde seu aplicativo irá residir. A escolha é geralmente entre uma máquina desktop pessoal, um servidor remoto, um provedor "nuvem" ou um servidor co-localizado em troca.


As máquinas desktop são simples de instalar e administrar, especialmente com sistemas operacionais mais novos e amigáveis ​​ao usuário, como o Windows 7/8, o Mac OSX e o Ubuntu. Sistemas de desktop possuem algumas desvantagens significativas, no entanto. O principal é que as versões dos sistemas operacionais projetados para máquinas de mesa provavelmente exigirão reinicializações / patches (e geralmente no pior dos casos!). Eles também usam mais recursos computacionais pela necessidade de uma interface gráfica de usuário (GUI).


Utilizar hardware em um ambiente doméstico (ou escritório local) pode levar a problemas de conectividade à Internet e de tempo de atividade. O principal benefício de um sistema de desktop é que a potência computacional significativa pode ser adquirida pela fração do custo de um servidor dedicado remoto (ou sistema baseado em nuvem) de velocidade comparável.


Um servidor dedicado ou uma máquina baseada na nuvem, embora frequentemente mais caro do que uma opção de desktop, permite uma infraestrutura de redundância mais significativa, como backups automáticos de dados, a capacidade de garantir mais tempo de atividade e monitoramento remoto. Eles são mais difíceis de administrar, pois exigem a capacidade de usar os recursos de login remoto do sistema operacional.


No Windows, isso geralmente é feito através do protocolo RDP (Remote Desktop Protocol) da GUI. Em sistemas baseados em Unix, a linha de comando Secure SHell (SSH) é usada. A infra-estrutura de servidor baseada em Unix é quase sempre baseada em linha de comando, o que imediatamente torna as ferramentas de programação baseadas em GUI (como MatLab ou Excel) inutilizáveis.


Um servidor co-localizado, como a frase é usada no mercado de capitais, é simplesmente um servidor dedicado que reside dentro de uma troca a fim de reduzir a latência do algoritmo de negociação. Isso é absolutamente necessário para certas estratégias de negociação de alta frequência, que dependem de baixa latência para gerar alfa.


O aspecto final da escolha de hardware e a escolha da linguagem de programação é a independência de plataforma. Existe a necessidade de o código ser executado em vários sistemas operacionais diferentes? O código foi projetado para ser executado em um tipo específico de arquitetura de processador, como o Intel x86 / x64 ou será possível executar em processadores RISC, como os fabricados pela ARM? Essas questões serão altamente dependentes da frequência e do tipo de estratégia que está sendo implementada.


Resiliência e Teste.


Uma das melhores maneiras de perder muito dinheiro em negociações algorítmicas é criar um sistema sem resiliência. Isso se refere à durabilidade do sistema quando sujeito a eventos raros, como falências de corretagem, volatilidade excessiva súbita, tempo de inatividade em toda a região para um provedor de servidor em nuvem ou a exclusão acidental de um banco de dados comercial inteiro. Anos de lucros podem ser eliminados em segundos com uma arquitetura mal projetada. É absolutamente essencial considerar problemas como depuração, teste, registro, backups, alta disponibilidade e monitoramento como componentes principais de seu sistema.


É provável que, em qualquer aplicação de negociação quantitativa personalizada razoavelmente complicada, pelo menos 50% do tempo de desenvolvimento seja gasto em depuração, teste e manutenção.


Quase todas as linguagens de programação são enviadas com um depurador associado ou possuem alternativas de terceiros bem respeitadas. Em essência, um depurador permite a execução de um programa com a inserção de pontos de interrupção arbitrários no caminho do código, que interrompem temporariamente a execução para investigar o estado do sistema. The main benefit of debugging is that it is possible to investigate the behaviour of code prior to a known crash point .


Debugging is an essential component in the toolbox for analysing programming errors. However, they are more widely used in compiled languages such as C++ or Java, as interpreted languages such as Python are often easier to debug due to fewer LOC and less verbose statements. Despite this tendency Python does ship with the pdb, which is a sophisticated debugging tool. The Microsoft Visual C++ IDE possesses extensive GUI debugging utilities, while for the command line Linux C++ programmer, the gdb debugger exists.


Testing in software development refers to the process of applying known parameters and results to specific functions, methods and objects within a codebase, in order to simulate behaviour and evaluate multiple code-paths, helping to ensure that a system behaves as it should. A more recent paradigm is known as Test Driven Development (TDD), where test code is developed against a specified interface with no implementation. Prior to the completion of the actual codebase all tests will fail. As code is written to "fill in the blanks", the tests will eventually all pass, at which point development should cease.


TDD requires extensive upfront specification design as well as a healthy degree of discipline in order to carry out successfully. In C++, Boost provides a unit testing framework. In Java, the JUnit library exists to fulfill the same purpose. Python also has the unittest module as part of the standard library. Many other languages possess unit testing frameworks and often there are multiple options.


In a production environment, sophisticated logging is absolutely essential. Logging refers to the process of outputting messages, with various degrees of severity, regarding execution behaviour of a system to a flat file or database. Logs are a "first line of attack" when hunting for unexpected program runtime behaviour. Unfortunately the shortcomings of a logging system tend only to be discovered after the fact! As with backups discussed below, a logging system should be given due consideration BEFORE a system is designed.


Both Microsoft Windows and Linux come with extensive system logging capability and programming languages tend to ship with standard logging libraries that cover most use cases. It is often wise to centralise logging information in order to analyse it at a later date, since it can often lead to ideas about improving performance or error reduction, which will almost certainly have a positive impact on your trading returns.


While logging of a system will provide information about what has transpired in the past, monitoring of an application will provide insight into what is happening right now . All aspects of the system should be considered for monitoring. System level metrics such as disk usage, available memory, network bandwidth and CPU usage provide basic load information.


Trading metrics such as abnormal prices/volume, sudden rapid drawdowns and account exposure for different sectors/markets should also be continuously monitored. Further, a threshold system should be instigated that provides notification when certain metrics are breached, elevating the notification method (email, SMS, automated phone call) depending upon the severity of the metric.


System monitoring is often the domain of the system administrator or operations manager. However, as a sole trading developer, these metrics must be established as part of the larger design. Many solutions for monitoring exist: proprietary, hosted and open source, which allow extensive customisation of metrics for a particular use case.


Backups and high availability should be prime concerns of a trading system. Consider the following two questions: 1) If an entire production database of market data and trading history was deleted (without backups) how would the research and execution algorithm be affected? 2) If the trading system suffers an outage for an extended period (with open positions) how would account equity and ongoing profitability be affected? The answers to both of these questions are often sobering!


It is imperative to put in place a system for backing up data and also for testing the restoration of such data. Many individuals do not test a restore strategy. If recovery from a crash has not been tested in a safe environment, what guarantees exist that restoration will be available at the worst possible moment?


Similarly, high availability needs to be "baked in from the start". Redundant infrastructure (even at additional expense) must always be considered, as the cost of downtime is likely to far outweigh the ongoing maintenance cost of such systems. I won't delve too deeply into this topic as it is a large area, but make sure it is one of the first considerations given to your trading system.


Choosing a Language.


Considerable detail has now been provided on the various factors that arise when developing a custom high-performance algorithmic trading system. The next stage is to discuss how programming languages are generally categorised.


Type Systems.


When choosing a language for a trading stack it is necessary to consider the type system . The languages which are of interest for algorithmic trading are either statically - or dynamically-typed . A statically-typed language performs checks of the types (e. g. integers, floats, custom classes etc) during the compilation process. Such languages include C++ and Java. A dynamically-typed language performs the majority of its type-checking at runtime. Such languages include Python, Perl and JavaScript.


For a highly numerical system such as an algorithmic trading engine, type-checking at compile time can be extremely beneficial, as it can eliminate many bugs that would otherwise lead to numerical errors. However, type-checking doesn't catch everything, and this is where exception handling comes in due to the necessity of having to handle unexpected operations. 'Dynamic' languages (i. e. those that are dynamically-typed) can often lead to run-time errors that would otherwise be caught with a compilation-time type-check. For this reason, the concept of TDD (see above) and unit testing arose which, when carried out correctly, often provides more safety than compile-time checking alone.


Another benefit of statically-typed languages is that the compiler is able to make many optimisations that are otherwise unavailable to the dynamically - typed language, simply because the type (and thus memory requirements) are known at compile-time. In fact, part of the inefficiency of many dynamically-typed languages stems from the fact that certain objects must be type-inspected at run-time and this carries a performance hit. Libraries for dynamic languages, such as NumPy/SciPy alleviate this issue due to enforcing a type within arrays.


Open Source or Proprietary?


One of the biggest choices available to an algorithmic trading developer is whether to use proprietary (commercial) or open source technologies. Existem vantagens e desvantagens para ambas as abordagens. It is necessary to consider how well a language is supported, the activity of the community surrounding a language, ease of installation and maintenance, quality of the documentation and any licensing/maintenance costs.


The Microsoft. NET stack (including Visual C++, Visual C#) and MathWorks' MatLab are two of the larger proprietary choices for developing custom algorithmic trading software. Both tools have had significant "battle testing" in the financial space, with the former making up the predominant software stack for investment banking trading infrastructure and the latter being heavily used for quantitative trading research within investment funds.


Microsoft and MathWorks both provide extensive high quality documentation for their products. Further, the communities surrounding each tool are very large with active web forums for both. The. NET software allows cohesive integration with multiple languages such as C++, C# and VB, as well as easy linkage to other Microsoft products such as the SQL Server database via LINQ. MatLab also has many plugins/libraries (some free, some commercial) for nearly any quantitative research domain.


There are also drawbacks. With either piece of software the costs are not insignificant for a lone trader (although Microsoft does provide entry-level version of Visual Studio for free). Microsoft tools "play well" with each other, but integrate less well with external code. Visual Studio must also be executed on Microsoft Windows, which is arguably far less performant than an equivalent Linux server which is optimally tuned.


MatLab also lacks a few key plugins such as a good wrapper around the Interactive Brokers API, one of the few brokers amenable to high-performance algorithmic trading. The main issue with proprietary products is the lack of availability of the source code. This means that if ultra performance is truly required, both of these tools will be far less attractive.


Open source tools have been industry grade for sometime. Much of the alternative asset space makes extensive use of open-source Linux, MySQL/PostgreSQL, Python, R, C++ and Java in high-performance production roles. However, they are far from restricted to this domain. Python and R, in particular, contain a wealth of extensive numerical libraries for performing nearly any type of data analysis imaginable, often at execution speeds comparable to compiled languages, with certain caveats.


The main benefit of using interpreted languages is the speed of development time. Python and R require far fewer lines of code (LOC) to achieve similar functionality, principally due to the extensive libraries. Further, they often allow interactive console based development, rapidly reducing the iterative development process.


Given that time as a developer is extremely valuable, and execution speed often less so (unless in the HFT space), it is worth giving extensive consideration to an open source technology stack. Python and R possess significant development communities and are extremely well supported, due to their popularity. Documentation is excellent and bugs (at least for core libraries) remain scarce.


Open source tools often suffer from a lack of a dedicated commercial support contract and run optimally on systems with less-forgiving user interfaces. A typical Linux server (such as Ubuntu) will often be fully command-line oriented. In addition, Python and R can be slow for certain execution tasks. There are mechanisms for integrating with C++ in order to improve execution speeds, but it requires some experience in multi-language programming.


While proprietary software is not immune from dependency/versioning issues it is far less common to have to deal with incorrect library versions in such environments. Open source operating systems such as Linux can be trickier to administer.


I will venture my personal opinion here and state that I build all of my trading tools with open source technologies. In particular I use: Ubuntu, MySQL, Python, C++ and R. The maturity, community size, ability to "dig deep" if problems occur and lower total cost ownership (TCO) far outweigh the simplicity of proprietary GUIs and easier installations. Having said that, Microsoft Visual Studio (especially for C++) is a fantastic Integrated Development Environment (IDE) which I would also highly recommend.


Batteries Included?


The header of this section refers to the "out of the box" capabilities of the language - what libraries does it contain and how good are they? This is where mature languages have an advantage over newer variants. C++, Java and Python all now possess extensive libraries for network programming, HTTP, operating system interaction, GUIs, regular expressions (regex), iteration and basic algorithms.


C++ is famed for its Standard Template Library (STL) which contains a wealth of high performance data structures and algorithms "for free". Python is known for being able to communicate with nearly any other type of system/protocol (especially the web), mostly through its own standard library. R has a wealth of statistical and econometric tools built in, while MatLab is extremely optimised for any numerical linear algebra code (which can be found in portfolio optimisation and derivatives pricing, for instance).


Outside of the standard libraries, C++ makes use of the Boost library, which fills in the "missing parts" of the standard library. In fact, many parts of Boost made it into the TR1 standard and subsequently are available in the C++11 spec, including native support for lambda expressions and concurrency.


Python has the high performance NumPy/SciPy/Pandas data analysis library combination, which has gained widespread acceptance for algorithmic trading research. Further, high-performance plugins exist for access to the main relational databases, such as MySQL++ (MySQL/C++), JDBC (Java/MatLab), MySQLdb (MySQL/Python) and psychopg2 (PostgreSQL/Python). Python can even communicate with R via the RPy plugin!


An often overlooked aspect of a trading system while in the initial research and design stage is the connectivity to a broker API. Most APIs natively support C++ and Java, but some also support C# and Python, either directly or with community-provided wrapper code to the C++ APIs. In particular, Interactive Brokers can be connected to via the IBPy plugin. If high-performance is required, brokerages will support the FIX protocol.


Conclusão.


As is now evident, the choice of programming language(s) for an algorithmic trading system is not straightforward and requires deep thought. The main considerations are performance, ease of development, resiliency and testing, separation of concerns, familiarity, maintenance, source code availability, licensing costs and maturity of libraries.


The benefit of a separated architecture is that it allows languages to be "plugged in" for different aspects of a trading stack, as and when requirements change. A trading system is an evolving tool and it is likely that any language choices will evolve along with it.


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.


Algorithmic Trading Platform | Programas.


ALGORITHMIC TRADING PLATFORM.


design for professionals!


Algorithmic Trading Platform.


Professional algorithmic trading tools give you the power, speed and precision. Power over how and when to react to any situation that appears on the market. With our tools, you can organize the chaos of market information – automatically analyse thousands of events and react on the most important. React in a very precise manner, measured in milliseconds. The speed of reaction and the ability to process huge amounts of data is an advantage over other market participants, who are not equipped with professional tools and algorithms. This will be your advantage over the market.


Algorithmic trading tools will work for you doing the tedious processing work, while you can concentrate on the essentials – control and strategic issues. They have the ability to change the balance of power in the market. They can multiply the power of your capital. Compensate for a smaller number of people employed in the fund. They improve processes, portfolio management and risk management. Our tools multiply your strength in the market. Multiply the spectrum of investment opportunities that you will be able to respond. Our tools give you the power. Multiplied.


Advantages for traders and quants.


Screenshot from Empirica TradePad application.


Algorithmic Trading Platform is a complete environment, dedicated to create, test and execute algorithmic strategies for financial institutions. It aids traders and quants in financial institutions with:


possibility of implementation of investment strategies inaccessible by traditional methods savings in transaction costs for large orders exploit market inefficiencies with usage of quantitative analysis portfolio & risk management automation real-time monitoring of hundreds of instruments for occurrence of certain market events performance, stability and security parameters at the highest level required by financial institutions direct connectivity to exchanges, easy integration with brokerage systems our support for the ROI estimation before starting of the project.


Build, Test, Trade.


Construir. Development process of trading algorithms using tools and libraries provided by Empirica has been greatly simplified. At the same time such simplification by no means restricts users in creation of complex algorithms, which is often the case when working with tools based on scripting languages or block diagrams.


Teste. Empirica Trading Platform allows users to safely test algorithms before deployment on live markets. Those tests include the ability to verify algorithm behaviour against historical market data, user generated situations or on the real market without executing actual transactions.


Comércio. Empirica Trading Platform takes care of all technical operations concerning connections to financial markets, brokerage systems, orders processing, and feeding algorithms with market data. This allows users to fully focus on their algorithm’s market performance.


Algorithmic Trading Platform has been developed according to high requirements of financial institutions regarding stability, reliability, security, efficiency, low latency, and built-in real time replication mechanisms.


high throughput – ability to process thousands of orders per second, low latency – minimal delay generated by system components itself, efficiency of server side processing, possibility of collocation in exchange infrastructure, built-in mechanisms of scalability to accommodate workload growth.


system certified by the Warsaw Stock Exchange, ability to concurrently trade on multiple markets and connect to multiple data sources, standard market access support for connecting to new markets, open, modular architecture allowing easy integration with financial institutions’ sistemas.


dedicated component for processing user’s positions data, implemented Black-Scholes model for options pricing.


set of powerful tools including stock exchange simulator, back-tests on historical data, live market tests, paper trading possibility to simulate all possible market scenarios.


feature rich desktop application – TradePad, ample functionality including among other things manual trading functions, variety of graphical data presentation and charting, rich set of configuration options to fit user requirements.


set of safeguards and warnings against most common human errors, configurable set of limitations and protection mechanisms on the server level, extensive, configurable alerts system.


Platform Architecture.


Open and efficient architecture of Algorithmic Trading Platform allows scalability along with financial institution growing demands.


Algorithmic Trading Platform can be connected to the market via the brokerage system or directly to the exchange system.


Client GUI application, installed on the user’s workstation. From this application end users can monitor and manage theirs orders and strategies.


Order Engine.


Designed for maximal efficiency server component responsible for sending orders directly to the exchange or via the brokerage system.


Strategy Executor.


Server component responsible for executing strategies.


Portfolio Monitor.


Server component processing information on the user’s transactions and providing status information about positions, profit&loss and risk.


Exchange Simulator.


Multifunctional component for strategy testing.


Experienced team of developers, testers and quants is ready to support our customers in functionality development, integration with external systems as well as assistance in implementation of algorithmic strategies.


Algorithmic Strategy Development.


tools used by professional developers, users can define custom screens for strategies being developed.


programming the logic of algorithm is based on incoming events from defined data sources, event example are: change in instrument order book or transactions, algorithm’s logic defines possible reactions to events like: sending, modifying or cancelling orders, computing statistics, etc. advanced logic can be build upon those simple mechanism.


Empirica offers ready-to-use implementations of the most popular algorithmic strategies like VWAP, TWAP, pairs trading, basket orders for educational purposes source code of example algorithms is provided. This way users can quickly learn how to use Empirica Trading Platform API and write their own strategies documentation, along with examples of implementing API elements is also provided in addition number of free, open-source libraries (mathematical, statistical, technical analysis) which contain immense amount of implemented functions, indexes and models can be used.


Technologies are irreversibly changing both the picture and the structure of financial markets, promoting those institutions that invest in their IT infrastructure. At Empirica we support our partners in technological aspects of those challenges.


How Does An Algorithmic Trading System Work?


Whether you are a retail trader investing your savings in stock market or a technical analysis expert or a hedge fund manager, the first step to start your own algorithmic trading is to understand how it works.


Algorithmic Trading requires removing a human trader by a machine, which can make its own trading decisions and executes those decisions. The algorithmic trading system consists of three major components which are shown in the diagram below:


Market Adapter.


Exchange or any market data vendor sends data in their own format. Your algorithmic trading system may or may not understand that language. Exchange provides you with an API or an Application Program Interface which allows you program and create your own adapter which can convert the format of the data into the format your system can understand.


Complex Event Processing Engine.


This part is the brain of your strategy. Once you have the data, you would need to work with it as per your strategy which involves doing various statistical calculations, comparisons with historical data and decision making for order generation. The order terms of type of order, order quantity is prepared in this block.


Order Routing System.


The order is encrypted in the language which exchange can understand, again using the APIs which are provided by the exchange. There are two kinds of APIs provided by the exchange: native API and FIX API. Native APIs are those which are specific to a certain exchange. The FIX (Financial Information Exchange) protocol is a set of rules used across different exchanges to make the data flow in security markets easier and effective.


In case of open economy, one can send orders to exchanges or non-exchanges and ORP should be able to handle orders to different destinations.


Se você é um profissional de varejo ou um profissional da área de tecnologia que deseja iniciar sua própria agência de negociação automatizada, comece a aprender o comércio de algoritmos hoje mesmo! Comece com conceitos básicos como arquitetura de negociação automatizada, microestrutura de mercado, sistema de backtesting de estratégia e sistema de gerenciamento de pedidos. You can also enrol in EPAT, one of the most extensive algorithmic trading training programme available in the industry.


Começando: Construindo um Sistema de Negociação Totalmente Automatizado.


Nos últimos 6 meses, tenho focado no processo de construção da pilha completa de tecnologia de um sistema de negociação automatizado. Eu me deparei com muitos desafios e aprendi muito sobre os dois métodos diferentes de backtesting (Vectorised e Event driven). Na minha jornada para construir um backtester orientado a eventos, veio a minha surpresa que o que você iria acabar é perto de toda a pilha de tecnologia necessária para construir uma estratégia, fazer backtest e executar a execução ao vivo.


Meu maior problema ao enfrentar o problema foi a falta de conhecimento. Procurei em muitos lugares uma introdução à construção da tecnologia ou um blog que me orientasse. Eu encontrei alguns recursos que vou compartilhar com vocês hoje.


Para iniciantes:


Para os leitores novatos em negociações quantitativas, eu recomendaria o livro de Ernie P. Chan intitulado: Negociação Quantitativa: Como construir seu próprio negócio de comércio algorítmico. Este livro é o básico. Na verdade, é o primeiro livro que li sobre negociação quantitativa e mesmo assim achei muito básico, mas há algumas notas que você deve tomar.


Da página 81-84 Ernie escreve sobre como, no nível de varejo, uma arquitetura de sistema pode ser dividida em estratégias semi-automatizadas e totalmente automatizadas.


Um sistema semi-automatizado é adequado se você quiser fazer algumas transações por semana. Ernie recomenda usar o Matlab, R ou até mesmo o Excel. Eu usei todas as 3 plataformas e este é o meu conselho:


Saltar do Matlab, custou muito dinheiro e só consegui acesso aos laboratórios da universidade. Não há muito material de treinamento como blogs ou livros que ensinem como codificar uma estratégia usando o Matlab. R tem toneladas de recursos que você pode utilizar para aprender como construir uma estratégia. Meu blog favorito cobrindo o tópico é: QuantStratTradeR é ​​executado por Ilya Kipnis. É mais provável que o Microsoft Excel inicie onde você não tem experiência em programação. Você pode usar o Excel para negociações semi-automáticas, mas isso não vai funcionar quando se trata de construir a pilha completa de tecnologias.


Estrutura semiautomática pg 81.


Sistemas de negociação totalmente automatizados são para quando você deseja colocar automaticamente as negociações com base em um feed de dados ao vivo. Eu codifiquei o meu em C #, o QuantConnect também usa o C #, o QuantStart orienta o leitor através da construção em Python, o Quantopian usa o Python, o HFT provavelmente usará o C ++. Java também é popular.


Estrutura de negociação completamente automatizada página 84.


Passo 1: Conseguir um bom começo.


Faça o Programa Executivo em Algorithmic Trading oferecido pela QuantInsti. Acabei de começar o curso e o primeiro conjunto de palestras foi na arquitetura do sistema. Teria me poupado cerca de 3 meses de pesquisa se eu tivesse começado aqui. As palestras me acompanharam através de cada componente que eu precisaria, bem como uma descrição detalhada do que cada componente precisa fazer. Abaixo está uma captura de tela de um de seus slides usados ​​na apresentação:


Você também pode usar essa estrutura geral ao avaliar outros sistemas de negociação automáticos.


No momento em que escrevo, estou apenas na terceira semana de palestras, mas estou confiante de que um praticante será capaz de construir uma estratégia comercial totalmente automatizada que poderia, com um pouco de refinamento, ser transformada no começo de um fundo de hedge quantitativo. .


Nota: o curso não está focado na construção da pilha de tecnologia.


Etapa 2: codifique um backtester baseado em eventos básicos.


Blog de Michael Hallsmore, quantstart & amp; livro “Negociação Algorítmica Bem Sucedida”


Este livro tem seções dedicadas à construção de um robusto backtester orientado a eventos. Ele orienta o leitor através de vários capítulos que explicarão sua escolha de idioma, os diferentes tipos de backtesting, a importância do backtesting orientado a eventos e como codificar o backtester.


Michael introduz o leitor às diferentes classes necessárias em um projeto orientado a objetos. Ele também ensina o leitor a construir um banco de dados mestre de títulos. É aqui que você verá como a arquitetura do sistema da QuantInsti se encaixa.


Nota: Você precisará comprar o livro dele: “Successful Algorithmic Trading”, seu blog deixa de fora muita informação.


Passo 3: Volte para o TuringFinance.


O programa EPAT Reading “Successful Algorithmic Trading” & amp; codificando um backtester em um idioma diferente de sua escolha.


Você deve ir para um blog chamado TuringFinance e ler o artigo intitulado "Algorithmic Trading System Architecture" Por: Stuart Gordon Reid. Em seu post ele descreve a arquitetura seguindo as diretrizes dos padrões ISO / IEC / IEEE 42010 e padrão de descrição de arquitetura de engenharia de software.


Eu achei este post muito técnico e tem algumas ótimas idéias que você deve incorporar em sua própria arquitetura.


Uma captura de tela de seu post.


Etapa 4: Estude os sistemas de negociação de código aberto.


4.1) Quantopian.


Escusado será dizer que Quantopian deve ser adicionado a esta lista e tenho vergonha de dizer que não passei muito tempo usando sua plataforma (devido à minha escolha de idioma). Quantopian tem muitas vantagens, mas as que mais se destacam para mim são as seguintes:


Fácil de aprender Python Acesso gratuito a muitos conjuntos de dados Uma grande comunidade e competições Eu amo como eles hospedam a QuantCon!


Quantopian é os líderes de mercado neste campo e é amado por todos os quants! Seu projeto de código aberto está sob o nome de código Zipline e isso é um pouco sobre isso:


“O Zipline é o nosso mecanismo de código aberto que alimenta o backtester no IDE. Você pode ver o repositório de código no Github e contribuir com solicitações de pull para o projeto. Há um grupo do Google disponível para procurar ajuda e facilitar discussões. ”


Aqui está um link para sua documentação:


4.2) QuantConnect.


Para aqueles que não estão familiarizados com o QuantConnect, eles fornecem um mecanismo completo de negociação algorítmica de código aberto. Aqui está um link.


Você deve dar uma olhada no código deles, estudá-lo, & amp; dê-lhes louvor. Eles são competição de quantopianos.


Eu gostaria de aproveitar esta oportunidade para agradecer à equipe da QuantConnect por me deixar escolher o cérebro deles e pelo serviço brilhante que eles fornecem.


Aqui está um link para sua documentação:


Observações finais:


Espero que este guia ajude os membros da comunidade. Eu gostaria de ter essa percepção 6 meses atrás quando comecei a codificar nosso sistema.


Eu gostaria de falar com a comunidade e perguntar: “Que bons cursos de negociação algorítmica você conhece?” Eu gostaria de escrever um post que analise o tópico e forneça uma classificação. Há alguma recomendação para criar um sistema de negociação totalmente automatizado que você gostaria de adicionar a este post?


Como funcionam os sistemas de negociação


A negociação automatizada algorítmica ou a Algorithmic Trading estão no centro do mercado mundial há mais de uma década. A porcentagem de volumes atribuídos ao comércio automatizado algorítmico registrou um aumento significativo na última década. Como resultado, tornou-se um mercado altamente competitivo e altamente dependente da tecnologia. Consequentemente, a arquitetura básica dos sistemas de negociação automatizados que executam estratégias algorítmicas sofreu grandes mudanças na última década e continua a fazê-lo. Para as empresas, especialmente aquelas que utilizam sistemas de negociação de alta frequência, tornou-se uma necessidade inovar em tecnologia para competir no mundo do comércio algorítmico, tornando o campo de negociação algorítmica um foco de avanços em tecnologias de computadores e redes.


Neste post, desmistificaremos a arquitetura por trás dos sistemas automatizados de negociação para nossos leitores. Comparamos a nova arquitetura de sistemas de negociação automatizada com a arquitetura de negociação tradicional e entendemos alguns dos principais componentes por trás desses sistemas.


Arquitetura Tradicional.


Qualquer sistema de negociação, conceitualmente, nada mais é do que um bloco computacional que interage com a troca em dois fluxos diferentes.


Recebe dados de mercado Envia solicitações de pedidos e recebe respostas da troca.


Os dados de mercado recebidos normalmente informam o sistema do último pedido. Pode conter algumas informações adicionais, como o volume negociado até agora, o último preço negociado e quantidade para um script. No entanto, para tomar uma decisão sobre os dados, o comerciante pode precisar olhar para valores antigos ou derivar determinados parâmetros do histórico. Para atender a isso, um sistema convencional teria um banco de dados histórico para armazenar os dados de mercado e ferramentas para usar esse banco de dados. A análise também envolveria um estudo das negociações passadas pelo comerciante. Daí outro banco de dados para armazenar as decisões de negociação também. Por último, mas não menos importante, uma interface gráfica para o comerciante para ver todas essas informações na tela.


Todo o sistema de negociação agora pode ser dividido em.


A troca (s) - o mundo externo O servidor Dados de mercado receptor Armazenar dados de mercado Armazenar ordens geradas pelo usuário Aplicação Tomar entradas do usuário, incluindo as decisões de negociação Interface para visualizar as informações, incluindo os dados e ordens Um gerente de pedidos enviando ordens para o troca.


Nova Arquitetura.


A arquitetura tradicional não podia escalar até as necessidades e demandas do comércio automatizado com o DMA. A latência entre a origem do evento e a geração da ordem foi além da dimensão do controle humano e entrou nos domínios de milissegundos e microssegundos. Portanto, as ferramentas para lidar com dados de mercado e sua análise precisavam se adaptar de acordo. O gerenciamento de pedidos também precisa ser mais robusto e capaz de lidar com muito mais pedidos por segundo. Como o período de tempo é muito pequeno comparado ao tempo de reação humano, o gerenciamento de risco também precisa lidar com pedidos em tempo real e de maneira totalmente automatizada.


Por exemplo, mesmo que o tempo de reação de um pedido seja de 1 milissegundo (o que é muito comparado às latências que vemos hoje), o sistema ainda é capaz de tomar 1000 decisões de negociação em um único segundo. Isso significa que cada uma dessas 1000 decisões de negociação precisa passar pelo gerenciamento de riscos dentro do mesmo segundo para alcançar a troca. Este é apenas um problema de complexidade. Como a arquitetura agora envolve lógica automatizada, 100 traders podem agora ser substituídos por um único sistema de negociação automatizado. Isso adiciona escala ao problema. Assim, cada uma das unidades lógicas gera 1000 pedidos e 100 dessas unidades significam 100.000 pedidos por segundo. Isso significa que a parte de tomada de decisão e envio de pedidos precisa ser muito mais rápida que o receptor de dados de mercado para corresponder à taxa de dados.


Portanto, o nível de infraestrutura que este módulo exige precisaria ser muito superior ao de um sistema tradicional (discutido na seção anterior). Portanto, o mecanismo que executa a lógica de tomada de decisão, também conhecido como mecanismo de "Processamento de Eventos Complexos", ou CEP, foi movido de dentro do aplicativo para o servidor. A camada Application, agora, é pouco mais que uma interface de usuário para visualizar e fornecer parâmetros para o CEP.


O problema de escalonamento também leva a uma situação interessante. Digamos que 100 lógicas diferentes estão sendo executadas em um único evento de dados de mercado (conforme discutido no exemplo anterior). No entanto, pode haver partes comuns de cálculos complexos que precisam ser executados para a maioria das 100 unidades lógicas. Por exemplo, cálculo de gregos para opções. Se cada lógica funcionasse independentemente, cada unidade faria o mesmo cálculo grego, o que consumiria desnecessariamente os recursos do processador. Para otimizar a redundância de cálculos, os cálculos redundantes complexos são tipicamente transferidos para um mecanismo de cálculo separado, que fornece os gregos como uma entrada para o CEP.


Embora a camada de aplicação seja basicamente uma visão, algumas das verificações de risco (que agora são operações famintas por recursos devido ao problema de escala) podem ser transferidas para a camada de aplicação, especialmente aquelas relacionadas à integridade das entradas do usuário. erros. As demais verificações de risco são executadas agora por um Sistema de Gerenciamento de Riscos (RMS) separado no Order Manager (OM), imediatamente antes de liberar um pedido. O problema de escala também significa que onde antes havia 100 traders diferentes gerenciando seu risco, agora há apenas um sistema RMS para gerenciar riscos em todas as unidades / estratégias lógicas. No entanto, algumas verificações de risco podem ser específicas de determinadas estratégias e algumas podem precisar ser feitas em todas as estratégias. Portanto, o próprio RMS envolve nível de estratégia RMS (SLRMS) e global RMS (GRMS). Também pode envolver uma interface do usuário para visualizar o SLRMS e o GRMS.


Surgimento de protocolos para sistemas de negociação automatizados.


Com inovações vêm as necessidades. Como a nova arquitetura era capaz de escalonar várias estratégias por servidor, surgiu a necessidade de se conectar a vários destinos a partir de um único servidor. Assim, o gerente de pedidos hospedou vários adaptadores para enviar pedidos para vários destinos e receber dados de várias trocas. Cada adaptador atua como um intérprete entre o protocolo entendido pela troca e o protocolo de comunicação dentro do sistema. Várias trocas significam vários adaptadores.


No entanto, para adicionar uma nova troca ao sistema, um novo adaptador deve ser projetado e conectado à arquitetura, já que cada troca segue seu protocolo apenas que é otimizado para recursos que a troca fornece. Para evitar esse incômodo de adição do adaptador, os protocolos padrão foram projetados. O mais proeminente entre eles é o protocolo FIX (Financial Information Exchange) (veja nosso post sobre introdução ao protocolo FIX). Isso não só torna possível conectar-se a diferentes destinos rapidamente, mas também reduz drasticamente a entrada no mercado quando se trata de conectar-se a um novo destino. Para obter mais informações adicionais: Conectando o FXCM ao FIX, um tutorial detalhado.


A presença de protocolos padrão facilita a integração com fornecedores de terceiros, para análises ou feeds de dados de mercado. Como resultado, o mercado torna-se muito eficiente, pois a integração com um novo destino / fornecedor não é mais uma restrição.


Além disso, a simulação torna-se muito fácil, já que receber dados do mercado real e enviar pedidos a um simulador é apenas uma questão de usar o protocolo FIX para conectar-se a um simulador. O simulador em si pode ser construído internamente ou adquirido de um fornecedor terceirizado. Da mesma forma, os dados gravados podem ser reproduzidos apenas com os adaptadores agnósticos para saber se os dados estão sendo recebidos do mercado ao vivo ou de um conjunto de dados gravados.


Surgimento de arquiteturas de baixa latência.


Com os blocos de construção de um sistema de comércio algorítmico implementado, as estratégias otimizam a capacidade de processar enormes quantidades de dados em tempo real e tomar decisões comerciais rápidas. Mas com o advento dos protocolos de comunicação padrão, como o FIX, a barreira de entrada de tecnologia para configurar uma mesa de operações algorítmica, tornou-se mais baixa e, portanto, mais competitiva. Como os servidores obtiveram mais memória e freqüências de clock mais altas, o foco mudou para reduzir a latência na tomada de decisões. Com o tempo, reduzir a latência tornou-se uma necessidade por vários motivos, como:


Estratégia só faz sentido em um ambiente de baixa latência Sobrevivência do mais forte - os competidores o escolhem se você não for rápido o suficiente.


O problema, no entanto, é que a latência é realmente um termo abrangente que engloba vários atrasos diferentes. Quantificar todos eles em um termo genérico pode não fazer muito sentido. Embora seja muito fácil de entender, é muito difícil quantificar. Portanto, torna-se cada vez mais importante como o problema de reduzir a latência é abordado.


Se olharmos para o ciclo de vida básico,


Um pacote de dados de mercado é publicado pela troca O pacote viaja pelo fio O pacote chega a um roteador no lado do servidor. O roteador encaminha o pacote pela rede no lado do servidor. O pacote chega na porta Ethernet do servidor. Dependendo se este é o processamento UDP / TCP ocorre e o pacote retirado de seus cabeçalhos e trailers faz o seu caminho para a memória do adaptador. O adaptador então analisa o pacote e o converte em um formato interno para a plataforma de negociação algorítmica. Este pacote agora percorre os vários módulos do sistema - CEP, tick store, etc. O CEP analisa e envia um pedido de pedido. através do reverso do ciclo como o pacote de dados de mercado.


A alta latência em qualquer uma dessas etapas garante uma alta latência para todo o ciclo. Portanto, a otimização da latência geralmente começa com o primeiro passo neste ciclo que está sob nosso controle, ou seja, “o pacote viaja pelo fio”. A coisa mais fácil de fazer aqui seria encurtar a distância até o destino, tanto quanto possível. Colocações são facilidades fornecidas pelas trocas para hospedar o servidor de negociação nas proximidades da troca. O diagrama a seguir ilustra os ganhos que podem ser obtidos cortando a distância.


Para qualquer tipo de estratégia de alta frequência envolvendo um único destino, Colocation tornou-se um imperdível. No entanto, estratégias que envolvem vários destinos precisam de um planejamento cuidadoso. Vários fatores como, o tempo gasto pelo destino para responder a solicitações de pedidos e sua comparação com o tempo de ping entre os dois destinos devem ser considerados antes de tomar tal decisão. A decisão também pode depender da natureza da estratégia.


A latência de rede é geralmente o primeiro passo para reduzir a latência geral de um sistema de negociação algorítmica. No entanto, existem muitos outros lugares onde a arquitetura pode ser otimizada.


Latência de propagação.


A latência de propagação significa o tempo necessário para enviar os bits ao longo do fio, limitado pela velocidade da luz, é claro.


Diversas otimizações foram introduzidas para reduzir a latência de propagação além de reduzir a distância física. Por exemplo, o tempo de ida e volta estimado para um cabo comum entre Chicago e Nova York é de 13,1 milissegundos. As redes de spread, em outubro de 2012, anunciaram melhorias de latência que trouxeram o tempo estimado de ida e volta para 12,98 milissegundos. A comunicação por microondas foi adotada ainda por firmas como a Tradeworx, trazendo o tempo estimado de ida e volta para 8,5 milissegundos. Observe que o mínimo teórico é de aproximadamente 7,5 milissegundos. Inovações contínuas estão forçando os limites da ciência e atingindo rapidamente o limite teórico da velocidade da luz. Os desenvolvimentos mais recentes em comunicação a laser, adotados anteriormente nas tecnologias de defesa, eliminaram ainda mais uma latência já diminuída em nanossegundos em distâncias curtas.


Latência de processamento de rede.


A latência do processamento de rede significa a latência introduzida pelos roteadores, comutadores etc.


O próximo nível de otimização na arquitetura de um sistema de negociação algorítmico seria o número de saltos que um pacote levaria para viajar do ponto A para o ponto B. Um salto é definido como uma parte do caminho entre a origem eo destino durante o qual um pacote não passa por um dispositivo físico como um roteador ou um switch. Por exemplo, um pacote pode viajar pela mesma distância através de dois caminhos diferentes. Mas pode ter dois saltos no primeiro caminho versus 3 saltos no segundo. Assumindo que o atraso de propagação é o mesmo, os roteadores e switches introduzem sua própria latência e normalmente como uma regra geral, e mais o latido é a latência adicionada.


A latência do processamento da rede também pode ser afetada pelo que nos referimos como microbursts. Microbursts são definidos como um aumento repentino na taxa de transferência de dados que pode não necessariamente afetar a taxa média de transferência de dados. Como os sistemas de negociação algorítmica são baseados em regras, todos esses sistemas reagirão ao mesmo evento da mesma maneira. Como resultado, muitos sistemas participantes podem enviar pedidos levando a uma súbita enxurrada de transferência de dados entre os participantes e o destino, levando a uma microburst. O diagrama a seguir representa o que é uma microburst.


A primeira figura mostra uma visualização de 1 segundo da taxa de transferência de dados. Podemos ver que a taxa média está bem abaixo da largura de banda disponível de 1Gbps. No entanto, se mergulhar mais fundo e olhar a imagem dos segundos (a visualização de 5 milissegundos), vemos que a taxa de transferência subiu acima da largura de banda disponível várias vezes por segundo. Como resultado, os buffers de pacote na pilha de rede, tanto nos pontos de extremidade da rede como nos roteadores e switches, podem transbordar. Para evitar isso, normalmente uma largura de banda muito maior do que a taxa média observada é geralmente alocada para um sistema de comércio algorítmico.


Latência de serialização.


A latência de serialização significa o tempo necessário para puxar os bits do fio.


Um tamanho de pacote de 1500 bytes transmitidos em uma linha T1 (1.544.000 bps) produziria um atraso de serialização de cerca de 8 milissegundos. No entanto, o mesmo pacote de 1500 bytes usando um modem de 56K (57344bps) levaria 200 milissegundos. Uma linha Ethernet 1G reduziria essa latência para cerca de 11 microssegundos.


Interromper latência.


Latência de interrupção significa uma latência introduzida por interrupções ao receber os pacotes em um servidor.


A latência de interrupção é definida como o tempo decorrido entre o momento em que uma interrupção é gerada e quando a fonte da interrupção é atendida. Quando uma interrupção é gerada? Interrupções são sinais para o processador emitido pelo hardware ou software, indicando que um evento precisa de atenção imediata. O processador, por sua vez, responde suspendendo sua atividade atual, salvando seu estado e manipulando a interrupção. Sempre que um pacote é recebido na NIC, uma interrupção é enviada para manipular os bits que foram carregados no buffer de recebimento da NIC. O tempo gasto para responder a essa interrupção não afeta apenas o processamento da carga útil recém-chegada, mas também a latência dos processos existentes no processador.


A Solarflare introduziu o onload aberto em 2011, que implementa uma técnica conhecida como bypass do kernel, em que o processamento do pacote não é deixado para o kernel do sistema operacional, mas para o próprio espaço do usuário. O pacote inteiro é mapeado diretamente no espaço do usuário pela NIC e é processado lá. Como resultado, as interrupções são completamente evitadas.


Como resultado, a taxa de processamento de cada pacote é acelerada. O diagrama a seguir demonstra claramente as vantagens do desvio do kernel.


Latência do aplicativo.


A latência do aplicativo significa o tempo gasto pelo aplicativo para processar.


Isso depende dos vários pacotes, do processamento alocado à lógica do aplicativo, da complexidade do cálculo envolvido, da eficiência de programação, etc. Aumentar o número de processadores no sistema reduziria, em geral, a latência do aplicativo. O mesmo acontece com o aumento da freqüência do clock. Muitos sistemas de negociação algorítmica aproveitam a dedicação dos núcleos do processador aos elementos essenciais do aplicativo, como a lógica da estratégia, por exemplo. Isso evita a latência introduzida pelo processo de alternância entre os núcleos.


Da mesma forma, se a programação da estratégia tiver sido feita, tenha em mente os tamanhos de cache e a localidade de acesso à memória, então haveria muitos hits de cache de memória, resultando em uma redução adicional de latência. Para facilitar isso, muitos sistemas usam linguagens de programação de baixo nível para otimizar o código para a arquitetura específica dos processadores. Algumas empresas até chegaram a gravar cálculos complexos em hardware usando matrizes de portas totalmente programáveis ​​(FPGA). Com o aumento da complexidade, vem aumentando o custo e o diagrama a seguir ilustra bem isso.


Níveis de sofisticação.


O mundo da negociação algorítmica de alta frequência entrou em uma era de intensa competição. Com cada participante adotando novos métodos de derrubar a concorrência, a tecnologia progrediu aos trancos e barrancos. As arquiteturas modernas de negociação algorítmica são bastante complexas em comparação com suas contrapartes em estágio inicial. Consequentemente, os sistemas avançados são mais caros de construir em termos de tempo e dinheiro.

Комментариев нет:

Отправить комментарий