Python para negociação algorítmica - página 20
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Como codificar uma parada de trilha no backtesting da estratégia Python
Como codificar uma parada de trilha no backtesting da estratégia Python
Hoje, tenho um tutorial de codificação interessante para você em Python. Estaremos aprendendo como implementar um trailing stop em nossa estratégia de negociação e analisar seu impacto em nosso patrimônio e retornos. Se você é novo neste canal, recomendo assistir aos vídeos anteriores desta lista de reprodução, principalmente os dois ou três últimos, onde discutimos a estratégia em detalhes. Você também pode encontrar o código Python no notebook Jupiter, que está disponível para download no link da descrição. Isso permitirá que você ajuste os parâmetros e experimente por conta própria.
Antes de mergulharmos na parte de codificação, vamos recapitular brevemente a estratégia que usaremos. Em poucas palavras, automatizamos a detecção de níveis de suporte e resistência, bem como a identificação de padrões de velas que ocorrem em torno desses níveis. Com base nesses sinais, executaremos nossas ordens de negociação. Por exemplo, se identificarmos um sinal de compra, como um padrão bullish engulfing precedido por uma forte vela de rejeição, entraremos em uma posição longa. Para gerenciar o risco, precisamos definir uma ordem de stop loss, que determina a perda máxima que estamos dispostos a tolerar. Tradicionalmente, o stop loss é fixado a uma certa distância do preço de entrada. No entanto, neste tutorial, vamos substituí-lo por um trailing stop.
Um trailing stop segue o movimento do preço na direção lucrativa, permitindo-nos capturar mais ganhos durante uma tendência de alta. No nosso exemplo, como estamos em uma posição de compra, o stop móvel acompanhará o preço conforme ele sobe, mantendo uma certa distância atrás dele. No entanto, se o preço tentar reverter e atingir o nível de stop loss, nossa negociação será fechada para evitar novas perdas. Esse mecanismo de trailing stop ajuda a maximizar os lucros, especialmente durante tendências de preço prolongadas, em vez de usar um nível fixo de lucro que pode limitar nossos ganhos potenciais.
Agora, vamos aplicar esse conceito à nossa estratégia discutida anteriormente. Usaremos o mesmo programa que detalhamos anteriormente. Se você não estiver familiarizado com isso, consulte a lista de reprodução e assista aos dois ou três últimos vídeos, que abordam os padrões de velas e a automação da detecção de níveis de suporte e resistência. A única diferença desta vez é que, em vez de usar uma taxa fixa de stop loss ou take profit, implementaremos o trailing stop. No final deste tutorial, vou testar a estratégia e demonstrar os retornos potenciais alcançáveis com este método de trailing stop.
Para começar, carregamos nossos dados, que são o gráfico diário de velas para o par de moedas EUR/USD de 2003 a 2021. Temos um conjunto de funções que ajudam a detectar níveis de suporte e resistência, bem como vários padrões de velas, como padrões envolventes, estrelas cadentes e padrões de rejeição. Se estiver interessado nos detalhes de implementação dessas funções, consulte os vídeos anteriores.
Em seguida, geramos nossos sinais de negociação. Um sinal de compra é indicado por um valor de 2, um sinal de venda por 1 e, se não houver sinal, o valor é definido como 0. Essa informação é adicionada como uma nova coluna em nosso quadro de dados. Veja como nosso quadro de dados se parece agora, com colunas para o preço de abertura, alta, baixa, preço de fechamento, volume (que não usaremos nesta estratégia) e a coluna de sinal.
Para testar nossa estratégia, usaremos o pacote de teste apresentado no último vídeo desta lista de reprodução. Definimos uma classe chamada "MyCandleStrategy" que herda da classe "Strategy" fornecida pelo pacote de backtesting. Sobrescrevemos duas funções: "inicializar" e a próxima função chamada em cada castiçal. Na função de inicialização, definimos a variável "stop_loss_trail", que representa a distância (em pips) para nosso stop móvel. Esse valor pode ser experimentado para encontrar o valor de stop móvel ideal para nossa estratégia.
Na próxima função, implementamos a lógica para nosso stop móvel. Começamos verificando se temos uma posição aberta. Se o fizermos, calculamos o nível atual de stop loss subtraindo o valor do trailing stop do preço mais alto desde que entramos na posição. Isso garante que o nível de stop loss fique atrás do preço conforme ele sobe. Em seguida, verificamos se o preço atual atingiu ou caiu abaixo do nível de stop loss. Se tiver, fechamos a posição e atualizamos nossas estatísticas de negociação. Agora que implementamos a lógica de trailing stop, podemos continuar executando o backtest e analisando os resultados. Aqui está um exemplo de como executar o backtest e imprimir a curva de patrimônio: Isso gerará um gráfico mostrando a curva de patrimônio de nossa estratégia com o stop móvel aplicado. Você também pode acessar outras métricas e estatísticas de desempenho fornecidas pelo pacote de backtesting para avaliar o desempenho da estratégia.Por fim, para ajustar o valor do trailing stop, você pode iterar em um intervalo de valores e executar vários backtests para comparar os resultados. Isso o ajudará a encontrar o valor ideal do trailing stop que maximiza seus retornos.
Isso conclui nosso tutorial sobre como implementar um trailing stop em nossa estratégia de negociação. Lembre-se de experimentar valores diferentes e testar a estratégia completamente antes de aplicá-la à negociação real. Se você tiver alguma dúvida ou precisar de mais assistência, sinta-se à vontade para perguntar. Codificação feliz e negociação feliz!
Como testar uma estratégia de negociação em Python
Como testar uma estratégia de negociação em Python
Olá a todos, sejam bem-vindos a mais um vídeo. Hoje, gostaria de discutir um tópico muito importante para nossas estratégias de negociação, que é o backtesting. Até agora, apresentamos estratégias diferentes e contamos apenas com contagens estatísticas para verificar a confiabilidade das estimativas de nosso modelo para negociação. No entanto, o backtesting da nossa estratégia traz informações adicionais, que é a quantidade de lucro que pode ser obtido em um determinado período de tempo.
Esse percentual de lucro é importante para definir se você está considerando algum tipo de investimento em sua estratégia. Antes de continuarmos, como de costume, o código é um notebook Jupyter Python que você pode baixar no link na descrição deste vídeo. Este tópico foi proposto por uma de suas mensagens, então obrigado novamente por compartilhar seus pensamentos. Estamos obtendo ideias realmente interessantes com seus comentários e peço desculpas se não tive tempo para discutir todas as ideias propostas, mas estou mantendo uma lista e acho que vamos abordá-las no futuro.
Agora, vamos falar sobre ferramentas de backtesting. Existem muitas bibliotecas disponíveis online, mas eu pessoalmente prefiro codificar minhas próprias funções. Dessa forma, sei exatamente o que está acontecendo dentro do meu código, principalmente quando se trata de backtesting. Precisamos de algo confiável e robusto. No entanto, entre os pacotes propostos, eu tinha duas opções. Um deles estava usando um pacote chamado "vectorbt", que achei um pouco difícil de aprender em algumas horas e começar a usá-lo para minhas próprias estratégias. A documentação era escassa e tive que pesquisar em fóruns e exemplos online para encontrar muitos detalhes. Embora tenha um enorme potencial e ofereça muitas opções, não queria passar um mês me familiarizando com as funções necessárias apenas para testar uma estratégia simples.
Portanto, para este vídeo, optei pela segunda opção, que é um pacote chamado "backtesting.py". Na minha opinião, oferece uma abordagem mais simples. Agora, vamos ver quanto dinheiro nossa estratégia teria gerado. Para este exemplo, vou testar a estratégia anterior que discutimos no vídeo de detecção automática de resistência e suporte e detecção de padrões de velas. Estes são dois indicadores que vamos combinar e usar neste vídeo.
Primeiro, carregarei e limparei os dados. Em seguida, aplicarei as funções de suporte e resistência para detecção. Se esta é a primeira vez que assiste a este canal, recomendo voltar e conferir os vídeos anteriores sobre como detectar as funções de suporte e resistência, bem como aquele em que explicamos como detectar padrões envolventes, estrelas cadentes, homem enforcado e outros padrões de castiçal.
Em seguida, calculamos nosso sinal, seja um sinal de compra, um sinal de venda ou nenhum sinal, com base na abordagem mencionada anteriormente. Rotulamos nossos sinais e preenchemos uma coluna em nosso quadro de dados. Podemos verificar o número de sinais que obtivemos apenas para garantir que nossas funções estejam funcionando corretamente.
Agora, alterarei os títulos das colunas para torná-los compatíveis com o pacote backtesting.py. Esta etapa diferencia maiúsculas de minúsculas, portanto, precisamos garantir que os nomes correspondam exatamente. Em seguida, seleciono uma série de linhas para trabalhar.
Depois de configurar nosso quadro de dados, passamos para a parte mais interessante: definir nossa estratégia e testá-la. Importarei as bibliotecas necessárias, incluindo o módulo "estratégia", e removerei o exemplo de cruzamento de médias móveis lentas versus rápidas.
Em seguida, defino uma nova classe chamada "MyCandlesStrategy" que estende a classe "Strategy" e substitui seus dois métodos abstratos: __init__ e next. O método __init__ é usado para inicializar as primeiras variáveis ou funções no início da estratégia. Ele é executado apenas uma vez, idealmente para pré-calcular quaisquer indicadores e sinais dos quais a estratégia depende.
No geral, o backtesting é um aspecto crucial das estratégias de negociação, pois fornece informações valiosas sobre a lucratividade potencial de uma estratégia durante um período de tempo específico. Neste vídeo, vamos nos aprofundar no backtesting e sua importância para nossas estratégias de negociação.
Antes de prosseguirmos, como de costume, o código para esta discussão está disponível como um notebook Jupyter Python, que você pode baixar no link fornecido na descrição do vídeo. O tópico de backtesting foi sugerido por um de nossos visualizadores e agradeço as ideias interessantes e o feedback que recebo de todos vocês. Embora eu não tenha a oportunidade de discutir todas as ideias propostas imediatamente, mantenho uma lista e me esforço para abordá-las em vídeos futuros.
Quando se trata de ferramentas de backtesting, existem inúmeras bibliotecas disponíveis online. Embora não esteja familiarizado com todos eles, pessoalmente, prefiro codificar minhas próprias funções. Essa abordagem me permite ter controle e compreensão completos do funcionamento interno do código, o que é particularmente crucial para backtesting. Precisamos de uma solução robusta e confiável para avaliar nossos modelos de negociação.
Entre os pacotes sugeridos, eu tinha duas opções. O primeiro foi um pacote chamado "Vectorbt", que, embora poderoso e rico em recursos, tinha uma curva de aprendizado acentuada. A documentação desse pacote era um tanto limitada e tive que pesquisar em fóruns e exemplos online para reunir as informações necessárias. Embora o Vectorbt tenha um imenso potencial, não quero gastar muito tempo me familiarizando com suas funções apenas com o objetivo de testar uma estratégia simples neste vídeo.
Portanto, optei pela segunda opção, um pacote chamado "backtesting.py". Na minha opinião, este pacote oferece uma abordagem mais simples de backtesting, tornando-o mais adequado às nossas necessidades. Dito isso, vamos nos aprofundar e ver quanto lucro nossa estratégia teria gerado.
Neste exemplo, testarei a estratégia anterior que discutimos, que envolvia a detecção automatizada de níveis de resistência e suporte, bem como a detecção de padrões de velas. Esses dois indicadores serão combinados para formar nossa estratégia. Para obter uma explicação detalhada sobre como detectar os níveis de suporte e resistência e os padrões de velas, recomendo que você assista aos vídeos correspondentes em nosso canal.
Para começar, carregamos e limpamos os dados como de costume. Em seguida, implementamos as funções de suporte e resistência para detecção. Se você é novo neste canal, recomendo conferir os vídeos anteriores sobre detecção de suporte e resistência e identificação de padrões de velas para um melhor entendimento.
Depois de calcularmos nossos sinais, que determinam se é uma situação de compra, venda ou ausência de sinal, contamos o número de sinais para garantir que nossas funções estejam funcionando corretamente.
Seguindo em frente, precisamos ajustar os nomes das colunas em nosso DataFrame para serem compatíveis com o pacote "backtesting.py". É essencial respeitar as convenções de nomenclatura e diferenciação de maiúsculas e minúsculas exigidas pelo pacote. Além disso, selecionamos uma série de linhas e fazemos as alterações necessárias nas colunas.
Para resumir, nosso DataFrame contém as seguintes colunas: tempo, abertura, preços máximos, mínimos e de fechamento, bem como o volume (que não usaremos no momento) e a coluna de sinal que calculamos anteriormente.
Em seguida, definimos uma função de sinal que retorna a coluna de sinal do nosso DataFrame. Esta função será necessária mais tarde quando definirmos nossa classe de estratégia.
Agora chegamos à parte mais interessante, onde definimos nossa estratégia e realizamos o backtesting. Para fazer isso, seguimos as diretrizes fornecidas na documentação do backtesting.py. Eles sugerem que uma nova estratégia deve estender a classe Strategy e substituir seus dois métodos abstratos: init e next.
O método init é responsável por inicializar as variáveis e funções requeridas pela estratégia. Ele é invocado antes que a estratégia seja executada e normalmente é usado para pré-computar quaisquer indicadores ou sinais dos quais a estratégia depende. Ao sobrecarregar essa função, podemos definir os indicadores necessários usando funções regulares do Python e exemplos fornecidos na documentação do backtesting.py.
Em nosso método init, definimos os indicadores necessários para nossa estratégia. Neste caso, usaremos a função de sinal que criamos anteriormente para obter a coluna de sinal do nosso DataFrame. Também definimos a taxa de comissão como zero, pois não consideraremos nenhuma taxa de negociação para este exemplo.
O próximo método é o coração da nossa estratégia. Ele é chamado para cada barra de negociação e é responsável por tomar as decisões de negociação com base nas condições atuais do mercado. Em nossa implementação, verificamos se há um sinal de compra (sinal igual a 1) e não temos uma posição no momento. Se essas condições forem atendidas, entramos em uma posição longa (compra).
Da mesma forma, se houver um sinal de venda (sinal igual a -1) e tivermos uma posição longa, saímos da posição (venda). Não consideramos posições vendidas neste exemplo, então temos apenas sinais de compra e venda.
Depois de definirmos nossa estratégia, criamos uma instância dela e passamos nosso DataFrame e função de sinal como argumentos. Em seguida, criamos uma instância da classe Backtest do pacote backtesting.py, passando nossa instância de estratégia e DataFrame como argumentos.
Por fim, executamos o backtest chamando o método run em nossa instância Backtest. Este método executa a estratégia e produz os resultados.
Os resultados incluem várias métricas de desempenho, como retorno total, retorno anualizado, redução máxima e muito mais. Podemos acessar essas métricas usando os atributos correspondentes da instância Backtest.
Além das métricas de desempenho, a instância Backtest fornece várias funções de plotagem para visualizar os resultados. Podemos traçar a curva de patrimônio, que mostra o crescimento da conta de negociação ao longo do tempo, bem como outros gráficos úteis, como rebaixamentos e log de negociação.
Em nosso exemplo, plotamos a curva de patrimônio e imprimimos o resumo dos resultados do backtest, incluindo as métricas de desempenho.
Depois de executar o código, podemos observar o gráfico da curva de patrimônio, que mostra o crescimento de nossa conta de negociação ao longo do tempo. O resumo dos resultados do backtest fornece informações valiosas sobre o desempenho de nossa estratégia.
Ao testar nossa estratégia, podemos avaliar sua lucratividade e avaliar seu desempenho. Esse processo nos permite obter insights sobre a eficácia do nosso modelo de negociação e tomar decisões informadas sobre seu uso potencial em cenários reais de negociação.
Isso conclui nossa discussão sobre backtesting usando o pacote backtesting.py. Espero que você tenha achado este vídeo informativo e que tenha fornecido uma abordagem prática para testar suas estratégias de negociação. Lembre-se de experimentar diferentes estratégias, indicadores e parâmetros para encontrar aqueles que funcionam melhor para seus objetivos de negociação.
Como sempre, sinta-se à vontade para deixar comentários, perguntas ou sugestões para futuros vídeos. Os seus comentários são extremamente apreciados. Obrigado por assistir, e vejo vocês no próximo vídeo!
Estratégia de Negociação de Ação de Preço Automatizada em Python
Estratégia de Negociação de Ação de Preço Automatizada em Python
Neste vídeo, discutiremos uma estratégia de negociação que utiliza padrões de velas e níveis de suporte e resistência. O principal objetivo desta estratégia é automatizar o processo de detecção de padrões de ação de preço e aplicá-lo aos dados históricos do Euro versus Dólar Americano.
Para começar, vamos dar uma olhada nos principais componentes dessa estratégia. Padrões de velas são representações gráficas dos movimentos de preços na forma de barras ou velas. Esses padrões fornecem informações valiosas sobre o sentimento do mercado e possíveis reversões de tendência. Ao analisar esses padrões, os traders podem tomar decisões informadas sobre quando entrar ou sair das negociações.
Os níveis de suporte e resistência, por outro lado, são pontos de preço específicos em que o mercado historicamente mostrou uma tendência de reversão ou paralisação. Esses níveis atuam como barreiras psicológicas para os traders e podem ser usados para identificar potenciais pontos de entrada e saída.
Agora, vamos passar para a implementação dessa estratégia em Python. Usaremos dados históricos do Euro versus Dólar Americano, que podem ser obtidos de várias fontes de dados financeiros ou APIs. Para este exemplo, assumiremos que já coletamos e pré-processamos os dados necessários.
Vamos automatizar a estratégia usando Python e algumas bibliotecas populares. A primeira etapa é importar as bibliotecas necessárias, incluindo pandas para manipulação de dados, matplotlib para plotagem e talib para indicadores de análise técnica. Talib é uma biblioteca amplamente utilizada que fornece uma coleção de funções de análise técnica, incluindo reconhecimento de padrões de velas.
Depois que as bibliotecas são importadas, podemos carregar os dados históricos em um Pandas DataFrame. O DataFrame deve conter as colunas necessárias, como data, abertura, alta, baixa, fechamento e volume. Essas colunas são comumente usadas em análise técnica e são necessárias para calcular indicadores e padrões.
Em seguida, podemos definir uma função para detectar padrões de velas. Neste exemplo, vamos nos concentrar em um padrão simples, o padrão bullish engulfing. Esse padrão ocorre quando uma pequena vela de baixa é seguida por uma vela de alta maior que envolve completamente a vela anterior. A função irá iterar sobre o DataFrame e identificar instâncias do padrão de engolfo de alta.
Para aprimorar a estratégia, também podemos incorporar níveis de suporte e resistência. Esses níveis podem ser identificados manualmente analisando o gráfico de preços históricos ou usando técnicas de análise técnica. Neste exemplo, assumiremos que já identificamos os níveis relevantes de suporte e resistência e os armazenamos em um DataFrame separado.
Assim que tivermos os padrões de velas e os níveis de suporte e resistência, podemos prosseguir para automatizar a estratégia. Iremos iterar sobre o DataFrame e verificar se a barra atual satisfaz as condições para um padrão de alta engolfante e se o preço atual está próximo de um nível de suporte. Se essas condições forem atendidas, geramos um sinal de compra.
Por outro lado, se a barra atual satisfizer as condições para um padrão envolvente de baixa e o preço atual estiver próximo de um nível de resistência, geramos um sinal de venda. Esses sinais serão usados para acionar ordens de compra ou venda em um ambiente de negociação ao vivo.
Para visualizar os resultados de nossa estratégia, podemos plotar o gráfico de preço histórico com os padrões de velas identificados e os níveis de suporte e resistência. Isso nos ajudará a entender a eficácia de nossa estratégia e identificar áreas de melhoria.
Por fim, podemos avaliar o desempenho de nossa estratégia fazendo um backtesting com base nos dados históricos. O backtesting envolve a simulação de negociações com base em dados históricos e a avaliação da lucratividade e do risco da estratégia. Podemos calcular várias métricas de desempenho, como retorno total, retorno anualizado, redução máxima e muito mais.
Ao testar nossa estratégia, podemos obter informações sobre seu desempenho e tomar decisões informadas sobre seu uso potencial em cenários reais de negociação. É importante observar que o backtesting é uma etapa crucial no desenvolvimento da estratégia, pois nos ajuda a avaliar a viabilidade e a lucratividade de nossa abordagem.
Este vídeo apresentou uma estratégia de negociação simples que combina padrões de velas e níveis de suporte e resistência. A estratégia foi automatizada e testada em Python usando dados históricos do Euro versus Dólar Americano. Ao alavancar essas técnicas de análise técnica, os traders podem potencialmente identificar oportunidades de negociação lucrativas e tomar decisões informadas nos mercados financeiros.
Detecção automatizada de suporte e resistência em PYTHON
Detecção automatizada de suporte e resistência em PYTHON
Olá a todos, sejam bem-vindos de volta a este vídeo. Neste vídeo, forneceremos uma explicação detalhada de como automatizar a detecção de níveis de suporte e resistência usando Python. Essa ideia foi proposta por um dos comentários, então muito obrigado por isso. Como sempre, não esqueça que o programa está disponível para download no link da descrição abaixo. É um arquivo Jupyter Notebook que você pode usar para seus próprios experimentos. Você pode querer tentar isso em diferentes moedas ou diferentes prazos, e também pode modificar as variáveis fornecidas no código.
Embora seja fácil identificar visualmente os níveis de suporte e resistência observando um gráfico de movimento de preços, defini-los programaticamente pode parecer complicado. No entanto, com um algoritmo adequado, o processo pode ser automatizado. É importante observar que o algoritmo que apresentamos neste vídeo não é o único para detectar os níveis de suporte e resistência. Existem diferentes abordagens, mas escolhemos uma que é relativamente simples de implementar no código.
A figura que você vê aqui foi produzida usando o código que estamos prestes a explicar e, como você pode ver, os níveis de suporte e resistência foram detectados corretamente pelo nosso programa. Essa abordagem funciona para qualquer moeda e em qualquer condição de mercado. No entanto, não é um algoritmo perfeito e você pode perceber que alguns níveis não foram detectados. Abordaremos isso mais adiante no vídeo.
A ideia básica por trás da definição dos níveis de suporte e resistência é olhar para trás dentro de um determinado período de tempo, como um mês ou dois, dependendo de quantos níveis você deseja incluir em sua estratégia. Quanto mais dados você tiver, mais níveis descobrirá. Por exemplo, se você está considerando um gráfico diário como o mostrado aqui e deseja prosseguir com uma negociação em uma data específica, você deve olhar para trás dentro de um determinado período de tempo, como um mês, para descobrir os níveis de suporte e resistência que ocorreu nesse período. Isso é o que vamos simular em nosso programa considerando um período de tempo limitado para detecção de nível. Se tentássemos detectar os níveis de suporte e resistência usando todos os dados disponíveis, teríamos um grande número de níveis, o que não é prático para uma estratégia de negociação. Portanto, é melhor se concentrar nos meses anteriores à data atual.
Agora vamos mergulhar no próprio algoritmo. Para níveis de suporte, procuraremos um certo número de mínimos decrescentes que precedem a vela de interesse. A vela de interesse deve ter um valor baixo mais baixo do que as outras velas. Além disso, precisamos ter três mínimos crescentes após a vela de interesse. Quando todas essas condições são atendidas para um grupo de velas, podemos identificar um nível de suporte, que é definido como o preço mais baixo entre essas velas. O mesmo princípio se aplica aos níveis de resistência. Precisamos ter máximos crescentes antes da vela de interesse e um máximo mais alto para a vela de interesse. Então, devemos ter máximos decrescentes após a vela de interesse. Isso nos permite encontrar o nível de resistência, que é o preço mais alto entre essas velas.
Um parâmetro interessante nesta fase é quantas velas devemos considerar antes e depois da vela de interesse. Isso pode ser personalizado com base na preferência do usuário e seria bom experimentar valores diferentes. Em nosso programa, nós os definimos como duas variáveis chamadas n1 e n2. O índice da vela de interesse é representado pela variável l.
Agora, vamos ver como podemos implementar esse algoritmo em Python. Estaremos usando um Jupyter Notebook para esta demonstração. Primeiro, importamos as bibliotecas necessárias, incluindo pandas para manipulação de dados. Carregamos os dados usando a função read_csv e, neste exemplo, estamos usando os gráficos diários EUR/USD de 2003 a 2021, que são aproximadamente 18 anos de dados.
Em seguida, usaremos os níveis de suporte e resistência armazenados nas listas ss e rr para traçar linhas no gráfico de velas. Faremos um loop por cada nível de suporte em ss e adicionaremos uma linha horizontal ao gráfico nesse nível de preço. Da mesma forma, percorreremos cada nível de resistência em rr e adicionaremos uma linha horizontal para cada nível. Isso facilitará a visualização dos níveis de suporte e resistência em relação ao movimento dos preços.
Ao executar o código, você gerará um gráfico de velas com níveis de suporte exibidos como linhas tracejadas roxas e níveis de resistência exibidos como linhas tracejadas azuis. O gráfico fornecerá uma representação visual dos níveis de suporte e resistência detectados, facilitando a identificação dos principais níveis de preços para decisões de negociação.
Lembre-se, o algoritmo apresentado aqui é uma das várias abordagens para detectar os níveis de suporte e resistência. Você pode experimentar diferentes valores de n1 e n2 para ver como eles afetam a detecção e mesclagem de níveis. Além disso, você pode modificar a condição para mesclar níveis ajustando o valor limite no código.
Lembre-se de que a detecção automatizada de níveis de suporte e resistência é uma ferramenta útil, mas deve ser usada em conjunto com outras técnicas de análise técnica e insights de mercado para tomar decisões de negociação informadas.
Análise Automatizada de Padrões de Ação de Preço em Python
Análise Automatizada de Padrões de Ação de Preço em PythonEste vídeo fornece uma explicação sobre como combinar padrões de análise de velas em Python e verificar o número de sinais, bem como a precisão das previsões de ação de preço. Os métodos são compatíveis com negociação automatizada. Um bom método para procurar um sinal relativamente forte de movimentos de ação de preço, análise de candlestick, padrões envolventes, análise de ação de preço.
00:00 Introdução às velas de ação de preço
00:35 Estrela Cadente, Martelo, Enforcado, Padrão Engolidor
03:10 Detecção de ação de preço do Python
12:13 Resultados da Análise de Ação de Preço
18:45 Traçando velas de preço em Python
Engolindo padrões de ação de preço automatizados em Python
Engolindo padrões de ação de preço automatizados em Python
Olá a todos, sejam bem-vindos de volta a este vídeo. Na discussão de hoje, vamos nos concentrar nas velas envolventes, especificamente nos padrões de alta e baixa. Para aqueles que já estão familiarizados com esses padrões, você entende sua importância como indicadores na negociação.
Para analisar a validade desses padrões, utilizaremos dados históricos do par de moedas EUR/USD abrangendo aproximadamente 10 anos. Nosso objetivo é aplicar técnicas estatísticas simples em Python para determinar se esses padrões têm significância estatística ou se são apenas um mito. Esta informação é crucial, especialmente se você estiver pensando em incorporar padrões de velas em sua estratégia de negociação como indicadores.
Para sua conveniência, você pode encontrar o código completo usado nesta análise seguindo o link fornecido na descrição abaixo. O código está disponível como um arquivo Jupyter Notebook, permitindo que você relaxe e aproveite este vídeo enquanto explora o código simultaneamente.
Os padrões de engolfamento podem ser observados de duas formas diferentes. O padrão de alta ocorre quando várias velas de tendência de baixa são seguidas por uma única vela de tendência de alta. Esta vela de tendência de alta começa no preço de fechamento da última vela de tendência de baixa ou abaixo dela e fecha acima do preço de abertura da vela anterior. Esse padrão normalmente indica uma tendência de alta futura no mercado.
Por outro lado, o padrão envolvente de baixa é o oposto simétrico do padrão de alta. Ocorre quando as velas de tendência de alta são seguidas por uma vela envolvente de baixa. Uma vela envolvente de baixa começa no preço de fechamento da vela anterior ou acima dela e fecha abaixo do preço de abertura da mesma vela. Este padrão significa um próximo movimento descendente no preço.
Neste vídeo, nosso objetivo é verificar se essas afirmações são verdadeiras. Nosso objetivo é determinar se esses padrões realmente indicam comportamentos específicos do mercado. Normalmente, um padrão envolvente de alta sugere que os compradores são mais fortes do que os vendedores no mercado, enquanto um padrão envolvente de baixa sugere o contrário. Para realizar essa verificação, escreveremos código Python para detectar velas envolventes de alta e baixa. Posteriormente, analisaremos as seguintes velas (variando de uma a três velas ou mais) para verificar se o preço se move na direção esperada.
Para ser mais preciso, vamos considerar o preço de fechamento da última vela envolvente. No caso de um padrão bullish engulfing, vamos considerar os valores altos das velas subseqüentes e calcular a diferença entre os preços máximos e de fechamento da vela engulfing. Isso resultará em três valores distintos, que denotaremos como "d". A seguir, testaremos se alguma dessas diferenças ultrapassa um determinado limite, representado por uma variável que definirei. Este limite pode ser definido para 20, 30 ou 40 pips, dependendo da sua preferência. Em seguida, calcularemos a porcentagem de vezes que essa diferença excede o limite do pip.
Da mesma forma, para o padrão de engolfamento de baixa, consideraremos os valores baixos das velas subsequentes. Vamos comparar a diferença entre o preço de fechamento da vela envolvente e esses valores baixos com a variável X. Mais uma vez, estamos procurando casos em que essa diferença exceda X. Em essência, estamos avaliando se o preço supera um preço de alta ou de baixa limite dentro de duas a três velas seguindo o padrão envolvente. Calcularemos a porcentagem de instâncias em que o preço se comporta conforme o esperado após a ocorrência desses padrões.
É importante observar que apenas uma dessas diferenças precisa exceder a variável X. Não estamos exigindo que todas as três diferenças ultrapassem esse limite de pip simultaneamente. Portanto, se o preço cair abaixo do valor de fechamento da vela envolvente por um número específico de pips, a previsão desse padrão é considerada bem-sucedida. O mesmo princípio se aplica ao padrão de engolfamento de alta, mas em uma direção ascendente.
Agora, vamos verificar o código Python e observar seu comportamento.
Se estou fazendo isso para a tendência igual a um, ou seja, para o padrão de engolfo de baixa e previsão de tendência de baixa, posso calcular a precisão somando os valores na coluna de resultados onde a tendência é igual a um e dividindo-a pelo número total de sinais para o padrão engulfing de baixa. Da mesma forma, posso calcular a precisão para o padrão de engolfo de alta e a previsão de tendência de alta.
Agora, vamos criar uma nova função chamada "calculate_precision" que usa o quadro de dados como entrada e calcula a precisão para ambos os padrões. Primeiro, inicializamos as variáveis "bearish_signals" e "bullish_signals" para contar o número total de sinais para cada padrão. Em seguida, iteramos pelo quadro de dados e incrementamos o contador de sinal correspondente com base no valor do sinal.
Em seguida, calculamos a precisão do padrão de engolfo de baixa somando os valores na coluna de resultados onde a tendência é igual a um e dividindo-a pelo número total de sinais de baixa. Fazemos o mesmo para o padrão de engolfo de alta e a previsão de tendência de alta.
Finalmente, retornamos os valores de precisão para ambos os padrões. Agora, vamos chamar essa função em nosso quadro de dados para calcular a precisão.
Depois de calcular a precisão, podemos imprimir os resultados para ver como nossas previsões se alinham com a tendência real. É importante observar que esses valores de precisão são baseados nos parâmetros e condições específicos que definimos em nosso código. Você pode experimentar diferentes parâmetros e condições para otimizar a precisão de sua estratégia de negociação específica.
Em conclusão, este vídeo enfocou os padrões de velas na negociação e teve como objetivo determinar se esses padrões têm significância estatística ou se são apenas um mito. Ao analisar os dados históricos do par de moedas EUR/USD usando Python, detectamos padrões de candles de baixa e alta e examinamos o comportamento da tendência subsequente dentro de um número especificado de candles. Por meio do cálculo da precisão, obtivemos informações sobre a precisão de nossas previsões. Lembre-se de considerar as limitações desta análise e continuar refinando sua estratégia de negociação com base em suas próprias preferências e objetivos.
Obrigado por assistir, e não esqueça de conferir o link na descrição do vídeo para baixar o código completo no formato Jupyter Notebook. Aproveite sua jornada de negociação e boa sorte em seus empreendimentos!
Estratégia automatizada de castiçal em Python | testando a estrela cadente
Estratégia automatizada de castiçal em Python | testando a estrela cadente
Na sessão de hoje, vamos mergulhar no fascinante mundo dos padrões Candlestick e aprender como programá-los em Python. Nosso objetivo é criar um código que possa identificar padrões específicos e potencialmente detectar reversões de tendências de preços. Além disso, realizaremos backtesting em uma estratégia que utiliza sinais de Candlestick, empregando uma abordagem estatística simples para avaliar as chances de desenvolver um bot automatizado vencedor com base em previsões de Candlestick. Se você está intrigado com este conteúdo, você pode baixar o arquivo do programa no link fornecido na descrição abaixo. Esperamos que gostem desta sessão informativa.
Antes de prosseguirmos, vamos esclarecer que este vídeo pressupõe que você já tenha algum conhecimento sobre padrões de Candlestick. Não entraremos em detalhes explicando cada padrão, pois focaremos nas formas mais conhecidas. Observe que esta lista não é exaustiva, pois existem muitos outros padrões por aí. Por enquanto, vamos nos ater ao básico. Você já deve estar familiarizado com o Doji, que representa um mercado indeciso. Outro padrão importante é a Estrela Cadente, caracterizada por uma longa cauda acima do corpo do Castiçal. Pode aparecer em duas formas, mas o que mais importa é a presença da cauda longa. Quando você encontra uma estrela cadente durante uma tendência de alta, isso pode indicar uma reversão de tendência, sugerindo uma mudança para uma tendência de baixa. Da mesma forma, temos o padrão Hammer, que é semelhante ao Shooting Star, mas invertido. Significa um ponto de rejeição durante uma tendência de alta, com uma longa cauda inferior. Esse padrão sugere que a tendência de alta está chegando ao fim e pode ocorrer uma retração da tendência de baixa.
Seguindo em frente, vamos discutir o padrão Bullish Engulfing. Isso ocorre durante uma tendência de baixa, onde a última vela vermelha é completamente coberta por uma vela ascendente maior. Esse padrão de reversão sinaliza o fim da tendência de baixa e o início de uma tendência de alta. Por outro lado, temos o padrão Bearish Engulfing, que é o oposto do padrão Bullish Engulfing. Ocorre durante uma tendência de alta, onde um Candlestick ascendente é seguido por um Candlestick maior, cobrindo o anterior. Isso indica o fim da tendência de alta e o início de uma tendência de baixa. Lembre-se de que existem vários outros padrões de castiçal que não abordaremos em detalhes aqui, como os três corvos, entre outros. No entanto, neste vídeo, vamos nos concentrar especificamente nos padrões Shooting Star e Hammer, principalmente quando uma tendência de baixa reverte para uma tendência de alta.
Os padrões Shooting Star e Hammer são os meus favoritos devido à sua indicação clara da reação do mercado a uma tendência de alta. É evidente que os vendedores entraram no mercado, rejeitando um nível de preço específico. É por isso que costumo confiar mais nesses padrões do que em outros. Obviamente, as preferências individuais podem variar, dependendo de como você utiliza e combina esses padrões com outros indicadores ou estratégias. Para o propósito deste vídeo, vamos considerar o Shooting Star como um exemplo convincente de rejeição de preço e a forte reação dos vendedores, o que dá a este Candlestick sua forma distinta. Vamos nos concentrar em codificar esse padrão em Python e ensinar nosso bot a reconhecer esses padrões. Embora você possa estender os conceitos que discutiremos a outros padrões de seu interesse, nosso foco principal será a Estrela Cadente e o Martelo.
É importante observar que confiar apenas nos padrões de Candlestick não é suficiente para gerar sinais precisos de compra ou venda. Esses padrões devem ser combinados com seus indicadores favoritos. No nosso caso, vamos combiná-los com o Índice de Força Relativa (RSI). Você pode optar por incorporar diferentes indicadores técnicos ou mesmo análises fundamentais junto com os padrões de Candlestick. O uso de castiçais sozinho não é abrangente.
Para avaliar a taxa de sucesso de nossa abordagem de previsão, precisamos combiná-lo com o RSI em combinação com o padrão Candlestick para adicionar uma confirmação adicional ao sinal. Um valor de RSI mais alto indica uma pressão de compra mais forte, que se alinha com a possível reversão de tendência sugerida pelo padrão de estrela cadente.
Se todas as condições forem atendidas, podemos gerar um sinal de compra. Atribuímos um valor de 1 à coluna de sinal para a linha correspondente no quadro de dados. Caso contrário, atribuímos o valor 0, indicando ausência de sinal. Esse processo é repetido para cada linha no quadro de dados, examinando efetivamente todo o conjunto de dados para identificar possíveis sinais de compra.
Em seguida, passamos a definir os níveis de stop loss e take profit para os sinais de compra identificados. Calculamos o valor do stop loss subtraindo o intervalo verdadeiro médio (ATR) do preço de compra. O ATR fornece uma medida de volatilidade e ajuda a determinar uma distância apropriada para o stop loss. Um ATR mais amplo indica um mercado mais volátil, exigindo um stop loss maior, enquanto um ATR menor sugere um mercado menos volátil, permitindo um stop loss mais apertado.
Para o nível de take profit, multiplicamos a taxa take profit-stop loss (que definimos como 2) pelo ATR e o adicionamos ao preço de compra. Isso garante que o nível de lucro esteja duas vezes mais longe do preço de compra do que o nível de stop loss. O nível de take profit representa a meta de lucro potencial para a negociação.
Agora que temos os sinais de compra e os níveis correspondentes de stop loss e take profit, podemos prosseguir com o backtesting da estratégia. Nós iteramos cada linha no quadro de dados e simulamos as negociações com base nos sinais gerados.
Se o preço atingir o nível de stop loss primeiro, consideramos uma negociação perdedora. Por outro lado, se o preço atingir o nível de lucro primeiro, consideramos uma negociação vencedora. Acompanhamos o número de negociações vencedoras e perdedoras.
Para avaliar o desempenho da estratégia, calculamos a taxa de vitórias como a porcentagem de negociações vencedoras sobre o total de negociações. Nesse caso, uma vez que definimos a proporção take profit-stop loss como 2, cada negociação vencedora compensa duas negociações perdidas. Portanto, para termos um sistema vencedor, precisamos acertar pelo menos 34% das vezes.
É importante observar que essa avaliação não leva em consideração os custos de negociação, como taxas e valores de swap overnight. Além disso, este é um exemplo simplificado e, nas negociações do mundo real, é essencial considerar outros fatores, como condições de mercado, gerenciamento de risco e análise geral do mercado.
Ao combinar padrões Candlestick, RSI e uma abordagem sistemática para o gerenciamento de negociações, pretendemos desenvolver uma estratégia de negociação que possa potencialmente gerar negociações lucrativas. No entanto, é crucial testar e validar minuciosamente a estratégia usando dados históricos e considerar a análise de mercado contínua para se adaptar às mudanças nas condições do mercado.
Em conclusão, este tutorial em vídeo fornece uma introdução à programação de padrões Candlestick em Python, demonstra como reconhecer padrões específicos e descreve uma abordagem de backtesting para avaliar o desempenho de uma estratégia baseada nesses padrões. É uma oportunidade de explorar o potencial dos padrões Candlestick como uma ferramenta para prever reversões de tendências de preços e desenvolver bots de negociação automatizados.
Evite erros comuns em negociação algorítmica e aprendizado de máquina
Evite erros comuns em negociação algorítmica e aprendizado de máquina
Você já se perguntou como seria ter um bot de negociação vencedor que executa negociações lucrativas em seu nome enquanto você dorme ou aproveita seu tempo livre? Talvez você tenha passado horas, meses ou até anos tentando decifrar o código e encontrar aquele programa indescritível que pode revolucionar seu estilo de vida.
Quando se trata de aprendizado de máquina, muitas pessoas acreditam que ele tem o poder de fazer maravilhas em vários campos, como marketing e vendas. No entanto, existem duas áreas em que o aprendizado de máquina ainda enfrenta dificuldades: previsão de dados meteorológicos e previsão de mercado de preços. A natureza altamente aleatória dos números nesses campos torna difícil prever preços com precisão usando apenas o aprendizado de máquina.
Mas aqui está o problema: é possível prever preços usando aprendizado de máquina, mas apenas se estiver associado a uma estratégia de negociação apropriada. Isso significa que o tipo de previsão que você faz deve estar alinhado com a estratégia de negociação que você emprega.
Agora, vamos nos aprofundar em alguns erros comuns que podem atrapalhar o sucesso do seu modelo de negociação e o que você pode fazer para evitá-los.
Erro nº 1: ajustar os valores de preço em um modelo de aprendizado de máquina como um regressor. Tentar prever o próximo valor de mercado inserindo valores de preços diretamente em um regressor de aprendizado de máquina é um erro comum de iniciantes. Embora essa abordagem possa funcionar bem para valores correlacionados, como prever preços de casas com base na área de superfície, ela não se aplica a mercados de ações ou moedas. Esses mercados não apresentam uma correlação clara apenas com a variável de tempo, tornando a regressão direta ineficaz.
Erro nº 2: Usar valores absolutos como entrada do modelo. Usar preços brutos ou valores de indicadores técnicos como entrada é outra armadilha. Simplesmente fornecer preços de abertura, fechamento, alta e baixa, juntamente com médias móveis e outros indicadores, não garante previsões precisas de preços futuros. Nossos cérebros processam informações de maneira diferente, concentrando-se na imagem geral e nas inclinações dos movimentos de preços, em vez de valores individuais. Da mesma forma, seu modelo precisa considerar as tendências e padrões gerais em vez de pontos de dados individuais.
Erro nº 3: Amostragem de dados usando divisão de dados de teste de trem aleatório. Embora a divisão de teste de trem aleatório seja uma prática comum em aprendizado de máquina, ela pode ser problemática ao trabalhar com análise de séries temporais, especialmente em mercados de preços. A divisão aleatória de seus dados para treinamento e teste pode levar a uma situação em que o conjunto de teste é muito semelhante ao conjunto de treinamento. Essa semelhança pode fazer com que o modelo pareça preciso durante o backtesting, mas não tenha um bom desempenho com novos dados ativos.
Erro nº 4: Confiar apenas na análise técnica. Embora os indicadores técnicos desempenhem um papel significativo nos modelos de aprendizado de máquina, confiar apenas neles não é suficiente para o sucesso a longo prazo. É crucial considerar fatores externos, como calendários econômicos e grandes eventos, que podem impactar significativamente o comportamento do mercado. Ignorar esses fatores pode levar a resultados ruins e desacreditar um modelo sólido.
Erro nº 5: Não considerar uma estratégia que se encaixe na precisão do modelo. A precisão do modelo por si só não determina sua lucratividade. Combinar a precisão do modelo com uma estratégia de negociação otimizada, como uma taxa favorável de take-profit para stop-loss, pode transformar um modelo aparentemente perdedor em lucrativo. Uma precisão acima de 33% pode ser suficiente se combinada com a estratégia certa.
Erro nº 6: Ignorar uma estratégia de entrada e confiar apenas nas previsões do modelo. Mesmo que seu modelo forneça previsões precisas, saber quando entrar no mercado e executar negociações é crucial. Definir uma estratégia de entrada no mercado que complemente as previsões do modelo é essencial para maximizar os lucros. Uma previsão de tendência correta não é suficiente se você entrar no mercado no momento errado e for parado antes de atingir seu alvo.
Erro nº 7: Não considerar taxas e comissões de negociação. Desconsiderar taxas e comissões pode ter um impacto significativo na lucratividade de sua estratégia de negociação. Embora uma estratégia vencedora possa ter uma pequena vantagem, as taxas de negociação podem corroer esses ganhos. É importante considerar as taxas ao projetar sua estratégia, como fechar negócios no mesmo dia para evitar taxas noturnas ou de fim de semana.
Em seguida, é crucial testar seu modelo por um período prolongado. Testar seu modelo em diferentes condições de mercado é essencial para garantir sua eficácia. Não confie apenas no desempenho de curto prazo, pois pode não refletir a viabilidade de longo prazo do modelo. Procure testar seu modelo por um período mínimo de seis meses e avalie se ele gera ganhos positivos consistentemente.
Por fim, evite ficar impaciente e interferir nas negociações. Um modelo de alta precisão tende a esperar por sinais fortes antes de executar negociações. Embora isso possa fazer com que você perca algumas oportunidades, é importante não interferir nas decisões do modelo. Evite abrir novos negócios ou fechar os existentes com base na impaciência. Às vezes, ter zero negociações é melhor do que perder uma negociação.
Em conclusão, esses insights devem ajudá-lo a melhorar sua experiência de negociação. Lembre-se de que, se o seu algoritmo ainda não estiver pronto para o mercado, é melhor não focar demais nele. Faça uma pausa, peça uma boa fatia de pizza quente e lembre-se de se divertir.
Como Calcular Indicadores Técnicos para Negociação Usando Pandas
Como Calcular Indicadores Técnicos para Negociação Usando Pandas
Olá a todos, sejam bem-vindos de volta a este vídeo. Hoje, vamos mergulhar na análise dos preços do mercado forex usando Python e explorar se as estatísticas podem revelar quaisquer correlações entre os indicadores técnicos e a direção futura dos preços. Você não precisa ser um especialista em negociação ou programação para acompanhar, mas alguma familiaridade com indicadores técnicos básicos, como médias móveis e o indicador de força relativa (RSI), seria útil. Se você está aqui para uma rápida introdução aos aplicativos de aprendizado de máquina na negociação, também está no lugar certo, pois manteremos as coisas simples.
Neste vídeo, abordaremos os seguintes tópicos:
Baixando dados de câmbio: Visitaremos o site cascope.com e selecionaremos o feed de dados históricos, especificamente para o par de moedas USD/CHF (dólar americano versus franco suíço). Escolheremos o período de candles de hora em hora para nossos dados.
Carregando dados no Python usando pandas: usaremos a função read_csv da biblioteca pandas para carregar o arquivo baixado em um DataFrame pandas. Também verificaremos se os dados foram carregados corretamente inspecionando as últimas cinco linhas do DataFrame.
Limpeza de dados e análise inicial: entender os dados é crucial, portanto, limparemos os dados removendo as linhas com volume zero e verificando os valores ausentes. Além disso, faremos uma breve análise estatística para identificar padrões ou correlações nos dados.
Adicionando indicadores técnicos: Importaremos as bibliotecas necessárias, incluindo numpy e pandas_ta (análise técnica do pandas), que fornecem vários indicadores de análise técnica. Adicionaremos vários indicadores ao nosso DataFrame, como o intervalo médio verdadeiro (ATR), RSI, médias móveis e calcularemos suas inclinações.
Definindo a meta: Para fazer previsões com base em indicadores técnicos, precisamos definir nossa meta. Em vez de prever o preço médio futuro, que pode ser desafiador, categorizaremos as tendências em três categorias: alta, baixa e nenhuma tendência clara.
Plotando histogramas: visualizaremos as distribuições de vários recursos usando histogramas. Isso inclui volume, ATR, RSI, preços médios, médias móveis, inclinações e as categorias de destino. Os histogramas fornecerão uma visão geral rápida dos dados e ajudarão a identificar quaisquer outliers.
Analisando o RSI: Vamos nos concentrar no RSI como um indicador de tendência e criar DataFrames separados para as três categorias de destino: tendências ascendentes, descendentes e obscuras. Traçaremos histogramas para os valores do RSI em cada categoria para ver se há alguma diferença distinguível.
No entanto, lembre-se de que confiar apenas no RSI pode não ser suficiente para prever com precisão as tendências de preços. É recomendável explorar outros indicadores técnicos ou combinações de indicadores para obter uma vantagem na previsão de tendências de preços.
Isso encerra o conteúdo deste vídeo. Espero que você ache as informações úteis. Se você tiver alguma dúvida específica ou precisar de mais esclarecimentos, sinta-se à vontade para perguntar na seção de comentários. Codificação feliz!
Backtesting.py - Curso completo em python
Backtesting.py - Curso completo em python
Durante o tutorial, o instrutor discute os pontos positivos e negativos do uso do backtesting.py como uma biblioteca para backtesting de estratégias de negociação. A biblioteca foi projetada para se concentrar apenas no essencial do backtesting, omitindo recursos como uma biblioteca de indicadores ou integração com corretores ou outras plataformas. Essa simplicidade permite que a biblioteca seja leve e fácil de usar. A documentação fornecida é clara e fácil de entender, permitindo que os usuários apreendam rapidamente os conceitos e funcionalidades da biblioteca.
Uma vantagem significativa do backtesting.py é sua velocidade, especialmente ao testar estratégias únicas. A biblioteca é otimizada para desempenho, permitindo que os usuários executem backtests com eficiência e obtenham resultados em tempo hábil. Essa velocidade é benéfica ao iterar por meio de várias estratégias ou combinações de parâmetros para encontrar as configurações ideais.
No entanto, há algumas limitações a serem consideradas ao usar backtesting.py. Em primeiro lugar, a biblioteca não oferece suporte à negociação com vários ativos. Ele é projetado principalmente para testar estratégias em um único ativo ou segurança. Além disso, backtesting.py não fornece suporte para ações fracionárias, o que pode ser uma desvantagem para usuários interessados em negociar com tamanhos de posição menores.
Apesar dessas limitações, o backtesting.py continua sendo uma excelente opção para quem deseja se concentrar exclusivamente no backtesting de suas estratégias de negociação. Sua simplicidade e leveza facilitam a compreensão e a integração com os fluxos de trabalho existentes.
No tutorial, o instrutor demonstra o uso de backtesting.py percorrendo as etapas para criar um ambiente virtual e instalar as dependências necessárias. Ao importar os componentes necessários, como dados de teste para preços de ações do Google de 2006 a 2013, o instrutor prepara o terreno para realizar um backtest.
O instrutor então passa a criar uma classe de estratégia onde as duas funções essenciais, __init__ e next, são definidas. Na função __init__, o instrutor calcula o valor do indicador do Índice de Força Relativa (RSI). A próxima função é usada para avaliar os critérios de compra com base nos valores do RSI.
Em seguida, o instrutor explica como implementar uma estratégia de cruzamento simples usando valores pré-calculados inseridos na próxima função. A biblioteca cruzada de backtesting.py é importada para comparar o RSI com valores de limite superior e inferior. Quando o RSI ultrapassa um determinado valor, é gerado um sinal de venda e, quando cai abaixo de outro valor, é acionado um sinal de compra. O instrutor define os valores dos limites superior e inferior e os atribui à classe para acesso na próxima função.
Para testar a estratégia, o instrutor configura um backtest fornecendo os dados, selecionando a quantia inicial de dinheiro e imprimindo as estatísticas. O instrutor enfatiza a facilidade de plotar resultados de backtesting usando backtesting.py e destaca como as caixas vermelhas e verdes na tela indicam os meses.
O instrutor passa a fornecer uma visão geral do painel backtesting.py, que oferece uma visão abrangente das informações comerciais, lucros e perdas, valor do portfólio e indicadores, entre outras métricas úteis. O instrutor demonstra como a otimização da estratégia pode ser alcançada usando backtesting.py definindo diferentes intervalos para os limites superior e inferior da janela RSI. O otimizador gera estatísticas como a proporção de Sharpe e simula várias combinações para encontrar a função mais valiosa. O instrutor enfatiza que os usuários podem definir métricas personalizadas e aplicar restrições para melhorar os resultados da otimização.
Além disso, o instrutor explica como aplicar restrições para selecionar um subconjunto de valores usando funções lambda que retornam verdadeiro ou falso com base em parâmetros específicos. O vídeo demonstra como otimizar a estratégia usando a função do otimizador para maximizar o índice de Sharpe e como definir a função de otimização como uma função regular do Python. O instrutor também discute a criação de uma métrica para maximizar os lucros e minimizar o tempo gasto no mercado.
No tutorial, o instrutor adiciona um número mínimo de filtro de negociações à função de otimização para evitar o overfitting. Ao incluir esse filtro, a função de backtesting é obrigada a olhar além de um único período de balanço, aumentando as chances de descobrir combinações de parâmetros mais lucrativas. Além disso, o instrutor mostra como criar arquivos HTML dos resultados do backtest, o que pode ser útil ao executar vários backtests e precisar acompanhar diferentes combinações de parâmetros. O instrutor também fornece orientação sobre como nomear e organizar os arquivos gerados para evitar sobrecarregar o diretório de trabalho.
O tutorial explora ainda mais o uso da função otimizar em backtesting.py para otimizar uma estratégia de forma eficiente sem ter que testar todas as combinações possíveis. Ao definir um número máximo de tentativas, o programa realiza uma busca em grade aleatória das combinações, reduzindo o tempo gasto em backtesting e o risco de overfitting. O instrutor demonstra como gerar mapas de calor para visualizar os efeitos de diferentes valores na estratégia variando os limites superior e inferior. Um grupo pandas por instrução é usado para agrupar as colunas pelos limites superior e inferior, e a média é calculada para obter valores médios para cada combinação.
O palestrante explica como a função em backtesting.py localiza todas as combinações exclusivas das colunas especificadas, como os limites superior e inferior. Essas combinações são então agrupadas e uma função de agregação, como a média, é aplicada. A saída resultante é um mapa de calor que pode ser plotado usando o módulo Seaborn. O instrutor demonstra como otimizar a proporção de Sharpe e alterar o mapa de cores para o mapa de calor. Além disso, o instrutor mostra como usar a função embutida plot_heat_maps para plotar vários mapas de calor para mais de dois parâmetros.
O instrutor demonstra como usar mapas de calor para otimização de parâmetros e implementação de estratégias de vários períodos de tempo usando a função resample apply da biblioteca backtesting.py. Os mapas de calor fornecem uma representação visual de como as variações em diferentes parâmetros afetam as estratégias de negociação. Ao combinar diferentes períodos de tempo usando a função de aplicação de reamostragem, os traders podem construir estratégias mais complexas que consideram diferentes condições de mercado.
O instrutor explica como diferentes prazos podem ser usados em uma estratégia de negociação usando a biblioteca backtesting.py. Reduzindo a resolução e aplicando funções, a biblioteca pode executar o preenchimento direto e reindexar de volta para o período de tempo menor, facilitando a análise de diferentes períodos de tempo. No exemplo fornecido, a estratégia envolve o uso do RSI diário e semanal para acionar negociações somente quando ocorre um cruzamento e o RSI está acima ou abaixo de um determinado limite. O instrutor menciona que a estratégia pode ser otimizada ajustando os parâmetros e que a biblioteca permite experimentar diferentes tipos de ordens, como stop loss e take profit.
O apresentador demonstra como iniciar uma posição vendida quando o RSI fica abaixo do limite inferior e fechar qualquer posição vendida ao comprar. Da mesma forma, o apresentador demonstra que, quando o RSI ultrapassa o limite superior, ele vende todas as posições longas e inicia uma posição curta. No entanto, o apresentador observa que não há um código que impeça o programa de assumir vários cargos, o que leva o programa a perder 80% do patrimônio investido. O apresentador explica como corrigir esse problema adicionando uma cláusula para iniciar uma nova negociação apenas se não houver posição atual ou se houver uma posição comprada/vendida na carteira.
O instrutor demonstra como usar ordens stop-loss e take-profit em backtesting.py. Ao definir um stop-loss em uma porcentagem específica abaixo do preço atual, a estratégia pode limitar as perdas em cada negociação, enquanto definir um nível de take-profit permite sair das negociações em um determinado nível de lucro. O instrutor também mostra como ajustar o parâmetro de tamanho no processo de compra para alocar uma porcentagem específica de fundos disponíveis para cada negociação. Embora existam alguns problemas com as táticas de venda no exemplo, o vídeo fornece informações úteis sobre como usar o backtesting.py para criar e testar estratégias de negociação.
O vídeo discute diferentes maneiras de implementar o dimensionamento de posição no backtesting. Uma abordagem é comprar e vender uma ação de cada vez, em vez de uma porcentagem do dinheiro disponível. Essa abordagem pode ser útil para estratégias que envolvem escalar para uma posição ou média de custo em dólares. O vídeo demonstra a modificação de uma estratégia de crossover para uma estratégia baseada no indicador RSI. Nesta estratégia modificada, as negociações são executadas quando o último valor do RSI é menor que o limite inferior. O vídeo também destaca que as negociações podem ser extraídas do backtest como um dataframe do pandas, incluindo datas de entrada e saída e outras métricas importantes. Esses dados comerciais podem ser exportados para outras ferramentas de visualização, como Excel ou outros scripts Python, para análise e exame adicionais.
O criador do backtesting.py apresenta a função "barras desde", que é uma ferramenta poderosa para otimizar estratégias e evitar a necessidade de escrever várias instruções if para comparar dados dos dias anteriores. A função permite que os usuários determinem o número de barras desde que uma determinada condição de negociação foi atendida pela última vez. Esse recurso fornece uma maneira conveniente de otimizar estratégias com base em condições específicas baseadas em tempo. Além disso, o criador enfatiza a natureza de código aberto do backtesting.py, incentivando os usuários a personalizar a biblioteca de acordo com suas necessidades e preferências específicas.
Em conclusão, o tutorial em backtesting.py termina com o instrutor incentivando os espectadores a entrar em contato com qualquer dúvida ou preocupação. O instrutor deseja-lhes boa sorte em seus esforços de backtesting e os lembra de se divertirem enquanto exploram as possibilidades de backtesting e otimizam estratégias de negociação usando backtesting.py. O instrutor enfatiza a importância de consultar a documentação backtesting.py para obter mais detalhes e descobrir recursos adicionais disponíveis para criar e otimizar a infraestrutura de backtesting.
No geral, o tutorial fornece uma visão geral abrangente do backtesting.py, suas vantagens, limitações e vários recursos. Ele orienta os usuários no processo de criação de um ambiente de backtest, implementação de estratégias, otimização de parâmetros, uso de mapas de calor para análise, incorporação de vários intervalos de tempo e aplicação de técnicas de dimensionamento de posição. Ao seguir o tutorial, os visualizadores obtêm informações valiosas e conhecimento prático que podem ajudá-los a testar e refinar com eficiência suas estratégias de negociação usando o backtesting.py.