Análise de Sentimento no Twitter com Sockets

Introdução

Este artigo apresenta um sofisticado bot de negociação que utiliza a análise de sentimento em tempo real de plataformas de mídias sociais para informar suas decisões de negociação. Ao integrar o MetaTrader 5 (MT5) com um mecanismo de análise de sentimento baseado em Python, este bot representa uma fusão de ponta entre finanças quantitativas e processamento de linguagem natural.

A arquitetura do bot é construída sobre um modelo cliente-servidor, utilizando comunicação via socket para conectar as capacidades de negociação do MT5 com o poder de processamento de dados do Python. Em seu núcleo, o sistema analisa o sentimento no Twitter relacionado a instrumentos financeiros específicos, traduzindo o buzz das mídias sociais em sinais acionáveis de negociação.

Esta abordagem inovadora não apenas demonstra o potencial das tecnologias interdisciplinares nas finanças, mas também destaca a crescente importância das fontes alternativas de dados nas estratégias modernas de negociação. À medida que aprofundamos a funcionalidade e a estrutura de código do bot, exploraremos como ele processa dados das mídias sociais, gerencia comunicações de rede e executa negociações com base nas pontuações de sentimento.

A análise a seguir fornecerá insights sobre os componentes do bot, discutindo tanto seu Expert Advisor (EA) no MetaTrader 5 escrito em MQL5 quanto seu servidor Python. Examinaremos as complexidades de sua interação, a metodologia de análise de sentimento e a lógica de negociação implementada. Esta exploração oferecerá valiosas perspectivas para traders, desenvolvedores e pesquisadores interessados na interseção entre análise de mídias sociais e negociação algorítmica.

Divisão.

Vou dividir o código tanto do Expert Advisor (EA) do MetaTrader 5 quanto do servidor Python, explicando seus componentes principais e funcionalidades.

MetaTrader 5 Expert Advisor (MQL5)

1. Inicialização e Entradas:

   O EA começa definindo os parâmetros de entrada para o símbolo de negociação, credenciais da API do Twitter e parâmetros de negociação, como níveis de stop loss e take profit. Ele também inclui bibliotecas necessárias para execução de negociações e gerenciamento de posições.

//+------------------------------------------------------------------+
//|                               Twitter_Sentiment_with_soquets.mq5 |
//|       Copyright 2024, Javier Santiago Gaston de Iriarte Cabrera. |
//|                      https://www.mql5.com/en/users/jsgaston/news |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Javier Santiago Gaston de Iriarte Cabrera."
#property link      "https://www.mql5.com/en/users/jsgaston/news"
#property version   "1.001"
#property description "This EA sends data to a Python server and receives sentiment analysis"

input group                "---- Symbol to work with ----"
input string symbol1 = "BTCUSD";                                       // Symbol

input group                "---- Passwords ----"
input string twitter_api_key = "TwitterApiKey";                        // Twitter API key
input string twitter_api_secret = "TwitterApiSecret";                  // Twitter API secret
input string twitter_access_token = "TwitterAccessToken";              // Twitter Access Token
input string twitter_access_token_secret = "TwitterAccessTokenSecret"; // Twitter Access Token Secret
input string twitter_bearer_token = "TwitterBearerToken";              // Twitter Bearer Token
input string client_id = "TwitterClientID";                            // Twitter Client ID
input string client_secret = "TwitterClientSecret";                    // Twitter Client Secret

input group                "---- Stops ----"
input bool   InpUseStops   = false;    // Use stops in trading
input int    InpTakeProfit = 1000;      // TakeProfit level
input int    InpStopLoss   = 500;      // StopLoss level
input double InpLot = 0.1;             // Lot size

#include <Trade\Trade.mqh> // Instatiate Trades Execution Library
#include <Trade\OrderInfo.mqh> // Instatiate Library for Orders Information
#include <Trade\PositionInfo.mqh> // Library for all position features and information

// Create a trade object
CTrade trade;

// Last request time
datetime lastRequestTime = 0;
int requestInterval = 30 * 60; // 30 minutes in seconds

2. Função OnInit():

   - Verifica se as notificações push estão ativadas.

   - Inicia a comunicação com o servidor Python durante a inicialização.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(!TerminalInfoInteger(TERMINAL_NOTIFICATIONS_ENABLED))
     {
      Print("Push notifications are not enabled. Please enable them in terminal settings.");
      return INIT_FAILED;
     }

   // Call the function to communicate with the Python server during initialization
   string data = StringFormat("%s,%s,%s,%s,%s,%s,%s,%s", symbol1, twitter_api_key, twitter_api_secret, twitter_access_token, twitter_access_token_secret, twitter_bearer_token, client_id, client_secret);
   string result = CommunicateWithPython(data);
   Print("Result received from Python server during initialization: ", result);

   return(INIT_SUCCEEDED);
  }

3. Função OnTick():

   - Implementa um intervalo de 30 minutos entre as solicitações ao servidor Python.

   - Formata e envia dados para o servidor Python utilizando a função CommunicateWithPython().

   - Processa os dados de sentimento recebidos e executa negociações com base na pontuação de sentimento.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   // Check if 30 minutes have passed since the last request
   if(TimeCurrent() - lastRequestTime < requestInterval)
     {
      return; // Exit if the interval has not passed
     }

   // Update the last request time
   lastRequestTime = TimeCurrent();

   // Call the function to communicate with the Python server
   string data = StringFormat("%s,%s,%s,%s,%s,%s,%s,%s", symbol1, twitter_api_key, twitter_api_secret, twitter_access_token, twitter_access_token_secret, twitter_bearer_token, client_id, client_secret);
   string result = CommunicateWithPython(data);
   
   if(result == "")
     {
      Print("No data received from Python");
      return;
     }
   
   // Process the sentiment value
   Print("Raw result: ", result);  // Debug line
   string sentiment_values[];
   int num_elements = StringSplit(result, ',', sentiment_values);
   Print("Number of elements: ", num_elements);  // Debug line

   if(num_elements > 0)
     {
      double tweet_sentiment = StringToDouble(sentiment_values[0]);
      Print("Twitter sentiment: ", tweet_sentiment);  // Debug line
      double price = SymbolInfoDouble(symbol1, SYMBOL_BID);
      double take_profit = InpTakeProfit * _Point;
      double stop_loss = InpStopLoss * _Point;
      
      if(tweet_sentiment > 0)
        {
         // Buy if sentiment is positive
         if(PositionSelect(symbol1))
           {
            Print("Position already open. Skipping buy.");
           }
         else
           {
            if(trade.Buy(InpLot, symbol1, price, price - stop_loss, price + take_profit))
              Print("Buying ", InpLot, " lots of ", symbol1);
            else
              Print("Failed to place buy order. Error: ", GetLastError());
           }
        }
      else if(tweet_sentiment < 0)
        {
         // Sell if sentiment is negative
         if(PositionSelect(symbol1))
           {
            Print("Position already open. Skipping sell.");
           }
         else
           {
            if(trade.Sell(InpLot, symbol1, price, price + stop_loss, price - take_profit))
              Print("Selling ", InpLot, " lots of ", symbol1);
            else
              Print("Failed to place sell order. Error: ", GetLastError());
           }
        }
     }
   else if(StringFind(result, "ERROR,") == 0)
     {
      Print("Error received from Python server: ", result);
     }
   else
     {
      Print("Unexpected response format: ", result);
     }
  }

4. Comunicação via Socket:

   - A função InitSocket() cria um socket e conecta ao servidor Python.

   - A função CommunicateWithPython() gerencia o envio de dados e o recebimento de respostas do servidor Python.

//+------------------------------------------------------------------+
//| Initialize socket                                                |
//+------------------------------------------------------------------+
int InitSocket()
  {
   int socket_handle = SocketCreate();
   if(socket_handle < 0)
     {
      Print("Error creating socket");
      return -1;
     }

   Print("Socket created successfully.");

   // Connect to Python server
   bool isConnected = SocketConnect(socket_handle, "127.0.0.1", 65432, 5000);
   if(!isConnected)
     {
      int error = GetLastError();
      Print("Error connecting to Python server. Error code: ", error);
      SocketClose(socket_handle);
      return -1;
     }

   Print("Connection to Python server established.");
   return socket_handle;
  }

//+------------------------------------------------------------------+
//| Function to send and receive data                                |
//+------------------------------------------------------------------+
string CommunicateWithPython(string data)
  {
   int socket_handle = InitSocket();
   if(socket_handle < 0)
      return "";

   // Ensure data is encoded in UTF-8
   uchar send_buffer[];
   StringToCharArray(data, send_buffer);
   int bytesSent = SocketSend(socket_handle, send_buffer, ArraySize(send_buffer));
   if(bytesSent < 0)
     {
      Print("Error sending data!");
      SocketClose(socket_handle);
      return "";
     }

   Print("Data sent: ", bytesSent);

   uint timeout = 5000; // 5 seconds timeout

   uchar rsp[];
   string result;
   uint timeout_check = GetTickCount() + timeout;
   do
     {
      uint len = SocketIsReadable(socket_handle);
      if(len)
        {
         int rsp_len;
         rsp_len = SocketRead(socket_handle, rsp, len, timeout);
         if(rsp_len > 0)
           {
            result += CharArrayToString(rsp, 0, rsp_len);
           }
        }
     }
   while(GetTickCount() < timeout_check && !IsStopped());
   SocketClose(socket_handle);

   if(result == "")
     {
      Print("No data received from Python");
      return "";
     }
   
   Print("Data received from Python: ", result);
   return result;
  }

//+------------------------------------------------------------------+
//| Helper function to convert uchar array to string                 |
//+------------------------------------------------------------------+
string CharArrayToString(const uchar &arr[], int start, int length)
  {
   string result;
   char temp[];
   ArrayResize(temp, length);
   ArrayCopy(temp, arr, 0, start, length);
   result = CharArrayToString(temp);
   return result;
  }
//+------------------------------------------------------------------+

5. Lógica de Negociação:

   - Se o sentimento for positivo (> 0), tenta abrir uma posição de compra.

   - Se o sentimento for negativo (< 0), tenta abrir uma posição de venda.

   - Utiliza a classe CTrade para execução das negociações.

Servidor Python:

1. Configuração do Servidor:

   - A função start_server() inicializa um servidor socket que escuta por conexões de entrada.

def start_server():
    """Starts the server that waits for incoming connections."""
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('127.0.0.1', 65432))
    server_socket.listen(1)
    print("Python server started and waiting for connections...")

    while True:
        client_socket, addr = server_socket.accept()
        print(f"Connection from {addr}")
        
        try:
            data = client_socket.recv(1024)
            data = data.decode('utf-8', errors='ignore')
            print(f"Received data: {data}")

            inputs = data.split(',')
            if len(inputs) != 8:
                raise ValueError("Eight inputs were expected")

            symbol, twitter_api_key, twitter_api_secret, twitter_access_token, twitter_access_token_secret, twitter_bearer_token, client_id, client_secret = inputs

            result = process_data(symbol, twitter_bearer_token)
            result_string = f"{result['tweet_sentiment']}"
            client_socket.sendall(result_string.encode('utf-8'))
            print(f"Response sent to client: {result_string}")
        except Exception as e:
            print(f"Communication error: {e}")
            error_message = f"ERROR,{str(e)}"
            client_socket.sendall(error_message.encode('utf-8'))
        finally:
            client_socket.shutdown(socket.SHUT_RDWR)
            client_socket.close()
            print("Connection closed")

2. Processamento de Dados:

   - Quando uma conexão é recebida, decodifica os dados e os divide em entradas separadas.

   - Chama a função process_data() com o símbolo e o token de acesso do Twitter.

def process_data(symbol, bearer_token):
    """Processes the data obtained from news and tweets."""
    result = { "tweet_sentiment": 0}

    try:
        result["tweet_sentiment"] = analyze_tweets(bearer_token, symbol)
    except Exception as e:
        raise Exception(f"Error processing data: {e}")
    
    print(f"Data processed. Result: {result}")
    return result

3. Análise de Tweets:

   - A função analyze_tweets() usa a API do Twitter para buscar tweets recentes sobre o símbolo fornecido.

   - Utiliza o TextBlob para realizar a análise de sentimento de cada tweet.

   - Calcula a pontuação média de sentimento de todos os tweets recuperados.

def analyze_tweets(bearer_token, symbol):
    """Analyzes recent tweets related to the given symbol."""
    try:
        headers = {
            'Authorization': f'Bearer {bearer_token}',
        }
        query = f"{symbol} lang:en -is:retweet"

        # Get the current time and subtract an hour
        end_time = datetime.now(timezone.utc) - timedelta(seconds=10)  # Subtract 10 seconds from the current time
        start_time = end_time - timedelta(hours=4)

        # Convert to RFC 3339 (ISO 8601) format with second precision and 'Z' at the end
        start_time_str = start_time.strftime('%Y-%m-%dT%H:%M:%SZ')
        end_time_str = end_time.strftime('%Y-%m-%dT%H:%M:%SZ')

        search_url = f"https://api.twitter.com/2/tweets/search/recent?query={query}&max_results=100&start_time={start_time_str}&end_time={end_time_str}&sort_order=relevancy"
        
        print(f"Performing tweet search with query: {query}")
        print(f"Search URL: {search_url}")

        response = requests.get(search_url, headers=headers)
        print(f"Response status code: {response.status_code}")
        print(f"Response text: {response.text}")

        if response.status_code != 200:
            raise Exception(f"Error searching tweets: {response.status_code} - {response.text}")

        tweets = response.json().get('data', [])
        if not tweets:
            print("No tweets found")
            return 0
        
        sentiments = [TextBlob(tweet['text']).sentiment.polarity for tweet in tweets]
        if not sentiments:
            print("No sentiments found")
            return 0
        
        average_sentiment = sum(sentiments) / len(sentiments)
        return average_sentiment
    except Exception as e:
        print(f"Error: {e}")
        raise Exception(f"Error analyzing tweets: {e}")

4. Tratamento de Erros

   - Implementa blocos try-except para capturar e tratar erros potenciais durante o processamento de dados e requisições à API.

5. Resposta:

   - Envia a pontuação de sentimento calculada de volta para o cliente MT5.

Pontos Principais:

1. Integração em Tempo Real: O sistema fornece análise de sentimento quase em tempo real, buscando e analisando tweets recentes a cada 30 minutos.

2. Negociação Baseada em Sentimento: O EA usa a pontuação de sentimento para tomar decisões de negociação, abrindo posições de compra para sentimentos positivos e posições de venda para sentimentos negativos.

3. Tratamento de Erros: Tanto o EA quanto o servidor Python implementam tratamento de erros para gerenciar problemas potenciais com requisições à API, processamento de dados ou comunicação.

4. Escalabilidade: A comunicação via socket permite a expansão potencial, como adicionar mais fontes de dados ou análises mais complexas no servidor Python sem alterar significativamente o EA do MT5.

5. Considerações de Segurança: O sistema passa as credenciais da API com cada requisição. Em um ambiente de produção, isso precisaria ser mais seguro.

6. Limitações: A implementação atual só abre novas posições e não gerencia as posições existentes com base em mudanças no sentimento.

Este bot demonstra uma abordagem interessante para integrar análise de dados externos com a negociação no MT5. No entanto, exigiria testes rigorosos e possivelmente refinamento de sua lógica de negociação antes de ser usado em um ambiente de negociação ao vivo.

Como Proceder?

1st. Insira a URL (em Ferramentas -> Expert Advisor)

2nd. Inicie o servidor Python

Servidor Python iniciado e aguardando conexões...

3rd. Inicie a conexão com o EA e aguarde o recebimento de dados 

2024.07.24 23:29:45.087 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Socket created successfully.
2024.07.24 23:29:45.090 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Connection to Python server established.
2024.07.24 23:29:45.090 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Data sent: 380

Processamento de Dados Result: {'tweet_sentiment': 0.20970252525252508}
Response sent to client: 0.20970252525252508
Connection closed

2024.07.24 23:29:50.082 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Data received from Python: 0.20970252525252508
2024.07.24 23:29:50.082 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Result received from Python server during initialization: 0.20970252525252508
2024.07.24 23:29:50.082 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Socket created successfully.
2024.07.24 23:29:50.084 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Connection to Python server established.
2024.07.24 23:29:50.084 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Data sent: 380
2024.07.24 23:29:55.083 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Data received from Python: 0.20970252525252508
2024.07.24 23:29:55.083 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Raw result: 0.20970252525252508
2024.07.24 23:29:55.083 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Number of elements: 1
2024.07.24 23:29:55.084 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Twitter sentiment: 0.20970252525252508
2024.07.24 23:29:55.201 Twitter_Sentiment_with_soquets_v4 (EURUSD,H1)   Buying 0.1 lots of EURUSD

Como Obter Bons Resultados?

Para melhorar a estratégia e a análise de sentimento para melhores resultados, considere as seguintes modificações:

1. Refinar a Análise de Sentimento:

   - Implementar técnicas mais avançadas de PLN:

     * Usar modelos de linguagem pré-treinados como BERT ou GPT para análise de sentimento mais detalhada.

     * Incorporar análise de sentimento baseada em aspectos para focar em atributos específicos do ativo.

   - Expandir as fontes de dados:

     * Incluir artigos de notícias financeiras, registros da SEC e outras fontes relevantes de texto.

     * Analisar dados de várias plataformas de mídias sociais, não apenas o Twitter.

   - Implementar análise de tendências de sentimento:

     * Acompanhar as mudanças no sentimento ao longo do tempo, em vez de apenas valores absolutos.

     * Usar médias móveis das pontuações de sentimento para suavizar flutuações de curto prazos.

2. Aprimorar a Lógica de Negociação:

   - Implementar limiares de sentimento:

     * Definir níveis específicos de sentimento para abrir posições longas ou curtas.

     * Usar limiares diferentes para entrar e sair das negociações.

   - Combinar sentimento com análise técnica:

     * Usar o sentimento como uma ferramenta de confirmação para indicadores técnicos.

     * Por exemplo, só abrir uma posição longa se o sentimento for positivo e o preço estiver acima de uma média móvel.

   - Incorporar análise de volume:

     * Considerar o volume de postagens nas mídias sociais junto ao sentimento.

     * Maior volume com forte sentimento pode indicar um sinal mais confiável.

3. Tamanho de Posição e Gerenciamento de Risco:

   - Implementar tamanho de posição dinâmico:

     * Ajustar o tamanho da posição com base na força do sinal de sentimento.

     * Considerar o saldo da conta e a volatilidade geral do mercado ao dimensionar as posições.

   - Usar sentimento para definir níveis de stop-loss e take-profit:

     * Ajustar os níveis de stop-loss com base na volatilidade do sentimento.

     * Definir metas de take-profit que considerem mudanças potenciais no sentimento.

4. Considerações de Intervalo de Tempo:

   - Analisar sentimento em múltiplos intervalos de tempo:

     * Sentimento de curto prazo para timing de entrada/saída.

     * Tendências de sentimento de longo prazo para direção geral do mercado.

   - Implementar filtros baseados no tempo:

     * Considerar a hora do dia ou da semana ao analisar sentimento e fazer negociações.

     * Alguns ativos podem ter sinais de sentimento mais confiáveis durante horas específicas do mercado.

5. Ajuste Específico do Ativo:

   - Personalizar a estratégia para diferentes classes de ativos:

     * Criptomoedas podem reagir de maneira diferente ao sentimento em comparação com ações tradicionais.

     * Desenvolver dicionários ou modelos específicos de sentimento para cada ativo.

6. Integração com Aprendizado de Máquina:

   - Desenvolver um modelo de aprendizado de máquina para prever movimentos de preço:

     * Usar pontuações de sentimento como características junto a dados tradicionais de mercado.

     * Implementar aprendizado por reforço para melhorar continuamente a estratégia.

7. Backtesting e Otimização:

   - Realizar backtesting extensivo:

     * Testar a estratégia em diferentes condições de mercado e períodos de tempo.

     * Usar otimização walk-forward para evitar overfitting.

   - Implementar otimização de parâmetros:

     * Usar algoritmos genéticos ou outras técnicas de otimização para ajustar parâmetros da estratégia.

8. Validação de Sentimento:

   - Implementar um sistema para validar a precisão da análise de sentimento:

     * Verificar regularmente uma amostra de textos analisados manualmente.

     * Acompanhar a correlação entre as pontuações de sentimento e os movimentos subsequentes dos preços.

9. Estratégia Adaptativa:

   - Desenvolver um sistema que possa se adaptar às mudanças nas condições do mercado:

     * Ajustar limiares de sentimento com base na volatilidade geral do mercado.

     * Implementar detecção de regime para alternar entre diferentes subestratégias.

10. Decaimento de Sentimento:

    - Implementar um fator de decaimento de tempo para o sentimento:

      * Dar mais peso aos dados de sentimento recentes.

      * Reduzir gradualmente o impacto de pontuações de sentimento mais antigas.

11. Abordagem Contrária:

    - Considerar implementar uma estratégia contrária em determinadas condições:

      * Sentimento extremo em uma direção pode indicar uma possível reversão.

Lembre-se, embora essas modificações possam melhorar a estratégia, elas também aumentam a complexidade. É crucial testar cada mudança minuciosamente e entender seu impacto no sistema geral. Comece com modificações mais simples e aumente gradualmente a complexidade à medida que valida cada etapa. Além disso, esteja sempre ciente de que o desempenho passado não garante resultados futuros, especialmente no dinâmico mundo dos mercados financeiros.

Além disso, para obter tweets do Twitter, usei a conta X para Desenvolvedores.

Conclusão

O bot de negociação apresentado neste artigo representa um avanço significativo na integração da análise de sentimento das mídias sociais com a negociação algorítmica. Ao aproveitar o poder do MetaTrader 5 e do Python, este sistema demonstra o potencial de tomada de decisões em tempo real, orientadas por dados, nos mercados financeiros.

A abordagem inovadora do bot, combinando comunicação via socket, análise de sentimento de dados do Twitter e execução automatizada de negociações, mostra as possibilidades que surgem da integração tecnológica interdisciplinar. Destaca a crescente importância das fontes alternativas de dados nas estratégias modernas de negociação e o potencial do processamento de linguagem natural para fornecer insights valiosos para a tomada de decisões financeiras.

No entanto, como qualquer sistema de negociação, há espaço para melhorias e refinamentos. As sugestões fornecidas para aprimorar a estratégia – desde a implementação de técnicas mais sofisticadas de análise de sentimento até a incorporação de modelos de aprendizado de máquina – oferecem um caminho para o desenvolvimento futuro. Essas melhorias podem potencialmente levar a sinais de negociação mais robustos e confiáveis, melhor gerenciamento de risco e um desempenho geral aprimorado.

É crucial observar que, embora este bot apresente uma abordagem interessante para a negociação baseada em sentimento, ele deve ser rigorosamente testado e validado antes de ser implantado em ambientes de negociação ao vivo. As complexidades dos mercados financeiros, o potencial para mudanças rápidas no sentimento e os riscos inerentes da negociação algorítmica exigem uma abordagem cautelosa e metódica para implementação e otimização.

À medida que os campos de processamento de linguagem natural, aprendizado de máquina e negociação algorítmica continuam a evoluir, sistemas como este bot provavelmente desempenharão um papel cada vez mais importante no cenário financeiro. Eles representam não apenas uma nova ferramenta para traders, mas um novo paradigma em como entendemos e interagimos com os mercados financeiros.

A jornada dessa implementação inicial até um sistema totalmente otimizado e pronto para o mercado é uma jornada de aprendizado contínuo, testes e refinamento. É uma jornada que reflete a evolução mais ampla da tecnologia financeira – sempre ultrapassando limites, sempre buscando novos insights e sempre se esforçando para tomar decisões mais informadas em um ambiente de mercado em constante mudança.