Upload 147 files

agents/config.py

@@ -101,8 +101,8 @@ LEARNING_RATE=0.0005
 PPO_LEARNING_RATE = 0.0003 # Padrão do SB3 PPO, pode ajustar
 PPO_N_STEPS = 2048
 PPO_BATCH_SIZE_RL = 64 # Mini-batch size do PPO
-PPO_ENT_COEF = 0.01
-PPO_TOTAL_TIMESTEPS = 1000000 # Comece com menos para teste (ex: 50k-100k)
+PPO_ENT_COEF = 0.0
+PPO_TOTAL_TIMESTEPS = 2048 #1000000 # Comece com menos para teste (ex: 50k-100k)
 
 # --- Parâmetros do Ambiente RL ---
 # RISK_FREE_RATE_ANNUAL = 0.02 # Taxa livre de risco anual (ex: 2%)

agents/custom_policies.py

@@ -39,7 +39,7 @@ from stable_baselines3.common.policies import ActorCriticPolicy
 from typing import List, Dict, Any, Optional, Union, Type
 # Importar sua rede e configs
 #import agents.DeepPortfolioAgent as DeepPortfolioAgent
-from portfolio_features_extractor_torch import PortfolioFeaturesExtractorTorch
+from agents.portfolio_features_extractor_torch import PortfolioFeaturesExtractorTorch
 # from ..config import (NUM_ASSETS, WINDOW_SIZE, NUM_FEATURES_PER_ASSET, ...) # Importe do seu config real
 # VALORES DE EXEMPLO (PEGUE DO SEU CONFIG.PY REAL)
 NUM_ASSETS_POLICY = 4

agents/portfolio_environment.py

@@ -28,7 +28,7 @@ class PortfolioEnv(gym.Env): # Renomeado para seguir convenção de Gymnasium (O
                  initial_balance=100000, 
                  window_size=WINDOW_SIZE_ENV,
                  transaction_cost_pct=0.001,
-                 reward_window_size=60, # Janela para cálculo do Sharpe Ratio (ex: 60 passos/horas)
+                 reward_window_size=240, # Janela para cálculo do Sharpe Ratio (ex: 60 passos/horas)
                  risk_free_rate_per_step=None): # Custo de transação de 0.1%
         super(PortfolioEnv, self).__init__()
         

agents/portfolio_features_extractor_torch.py

@@ -1,7 +1,7 @@
 import torch
 import torch.nn as nn
 from stable_baselines3.common.torch_layers import BaseFeaturesExtractor
-from deep_portfolio_torch import DeepPortfolioAgentNetworkTorch
+from agents.deep_portfolio_torch import DeepPortfolioAgentNetworkTorch
 
 class PortfolioFeaturesExtractorTorch(BaseFeaturesExtractor):
     def __init__(self, observation_space, features_dim=32,

agents/ppo_deep_portfolio_tensorboard/PPO_10/events.out.tfevents.1750497081.codespaces-72cb68.2589.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ea8284249717efcc6b46e7957eef6b8ceff0c6d92487095fdbe12f141125074
+size 254591

agents/ppo_deep_portfolio_tensorboard/PPO_11/events.out.tfevents.1750534135.codespaces-72cb68.3018.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c4af51ef094dc62cefc525b73b30f2f35ea2a3572dc386c6653c97511d71d8f
+size 255329

agents/ppo_deep_portfolio_tensorboard/PPO_12/events.out.tfevents.1750560310.codespaces-72cb68.253920.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37b09133c93eec65e524f5a76873048d399c6dab52f5516f1a01e4c6df736f2a
+size 14741

agents/ppo_deep_portfolio_tensorboard/PPO_13/events.out.tfevents.1750568153.codespaces-72cb68.2534.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:790362af681bc65a145098768cb0d33b0537524b368420f92f1902de8c559e1b
+size 177101

agents/ppo_deep_portfolio_tensorboard/PPO_14/events.out.tfevents.1750587177.verticalagent-X555LPB.125274.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a125c886db6fb22c394b8fc76d1ac2c99ed0fe68ba5713a69e4fea0551c5c35
+size 36143

agents/ppo_deep_portfolio_tensorboard/PPO_15/events.out.tfevents.1750636729.verticalagent-X555LPB.266088.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed84c8ebfc3274f6f2d0dff3f5f7278f4aca81954e7f45121a0180504654e164
+size 135

agents/ppo_deep_portfolio_tensorboard/PPO_16/events.out.tfevents.1750638335.verticalagent-X555LPB.270772.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68d42ca276a5b5bc587bd082ac51200daca54a62ba8a75af0bcd916712f4ebf4
+size 88

agents/ppo_deep_portfolio_tensorboard/PPO_17/events.out.tfevents.1750638480.verticalagent-X555LPB.271132.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e42d9077440ade5a761b7142c9645030018a476581f6e1701f809afe490c58ac
+size 135

agents/ppo_deep_portfolio_tensorboard/PPO_18/events.out.tfevents.1750639418.verticalagent-X555LPB.273960.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:811fff7b41423665bb07a8490f6d6c8eb4cba229a7f40de47eb2e51fba4e35a3
+size 1353

agents/ppo_deep_portfolio_tensorboard/PPO_19/events.out.tfevents.1750642515.verticalagent-X555LPB.284046.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41a733e48ed3b1b43aff5d822a5446021f1c7cbb8a3623c7f52ed5922cf56ba5
+size 6623

agents/ppo_deep_portfolio_tensorboard/PPO_4/events.out.tfevents.1750432903.verticalagent-X555LPB.48747.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bac721e2582379367b5c5d34d2c4701faa4acd5e7636209da9d24e159745dce7
+size 4409

agents/ppo_deep_portfolio_tensorboard/PPO_5/events.out.tfevents.1750410414.codespaces-72cb68.3578.0

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ba6ebefbf1cee5edb5d52fa22c9f6ca11c3e3db0214711cfdacd96d54d0c9c98
-size 744
+oid sha256:f2be104d088941c9ada02fc21bc986f601b40ccedb0ef248d24b693691e0d112
+size 75995

agents/ppo_deep_portfolio_tensorboard/PPO_6/events.out.tfevents.1750420189.codespaces-72cb68.98042.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4bf0bafaf0ed17d2ecfbf48d6e7f5373463e0f80d31d2073815c9e2f01bd0d7d
+size 3789

agents/ppo_deep_portfolio_tensorboard/PPO_7/events.out.tfevents.1750426315.codespaces-72cb68.6534.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b47ae9addc8cf7c11c10ffb947882b6ecfccb18e81edc411914e69befbdad729
+size 8837

agents/ppo_deep_portfolio_tensorboard/PPO_8/events.out.tfevents.1750432976.codespaces-72cb68.3219.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0bd83f315568a2b8f49e639649430e8b1ab42914debb7d427bd0e53d26fcc2fd
+size 165293

agents/ppo_deep_portfolio_tensorboard/PPO_9/events.out.tfevents.1750459752.codespaces-72cb68.259038.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f12a32b38018d82fb198d90d7f18f1eb5c6ca5ead634f29032fe9cfb887a69ba
+size 140939

agents/requirements.txt

@@ -10,7 +10,7 @@ httpx
 pydantic
 python-dotenv
 loguru
-# agno @ git+https://github.com/agno-agi/agno.git
+# agno @ git+https://github.com/agno-agi/agno.git  Obs importante
 jinja2
 yfinance
 PyJWT

agents/rl_agent.py

@@ -5,5 +5,5 @@ from atcoin_env import TradingEnv  # custom env
 def train_rl_model():
     env = TradingEnv()
     model = PPO("MlpPolicy", env, verbose=1)
-    model.learn(total_timesteps=10000)
+    model.learn(total_timesteps=50000)
     model.save("models/ppo_trading")

agents/train_rl_portfolio_agent.py

@@ -635,7 +635,7 @@ print("Ambiente de Portfólio Criado.")
 learning_rate_ppo = PPO_LEARNING_RATE # Ex: 3e-4 ou 1e-4 (do config.py)
 n_steps_ppo = 2048 
 batch_size_ppo = 64
-ent_coef_ppo = 0.01 
+ent_coef_ppo = 0.0 
 
 # policy_kwargs para passar para o __init__ da CustomPortfolioPolicySB3, se necessário
 # (além dos que já são passados para o features_extractor_kwargs)
@@ -659,7 +659,7 @@ model_ppo = PPO(
 )
 
 print("Iniciando treinamento do agente PPO com rede customizada...")
-model_ppo.learn(total_timesteps=1000000, progress_bar=True) # Comece com menos timesteps para teste (ex: 50k)
+model_ppo.learn(total_timesteps=100000, progress_bar=True) # Comece com menos timesteps para teste (ex: 50k)
 
 model_ppo.save("app/model/ppo_custom_deep_portfolio_agent")
 print("Modelo RL com política customizada treinado e salvo.")

agents/train_rl_portfolio_agent_from_app.py

@@ -0,0 +1,763 @@
+# train_rl_portfolio_agent.py
+from stable_baselines3 import PPO
+from stable_baselines3.common.env_checker import check_env
+#from transformers import logger
+
+# rnn/agents/custom_policies.py (NOVO ARQUIVO, ou adicione ao deep_portfolio.py)
+
+import gymnasium as gym # Usar gymnasium
+import tensorflow as tf
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor as PyTorchBaseFeaturesExtractor
+
+from stable_baselines3.common.torch_layers import MlpExtractor
+import torch.nn as nn
+
+class CustomMlpExtractor(MlpExtractor):
+    def __init__(self, input_dim, net_arch, activation_fn, device):
+        super().__init__(input_dim, net_arch, activation_fn, device)
+
+    def forward(self, features):
+        for layer in self.policy_net:
+            if isinstance(layer, nn.ReLU):
+                features = layer(features)  # Passando 'features' como argumento
+            else:
+                features = layer(features)
+        return features
+# Para TensorFlow, precisamos de um extrator de features compatível ou construir a política de forma diferente.
+# Stable Baselines3 tem melhor suporte nativo para PyTorch. Para TF, é um pouco mais manual.
+# VAMOS USAR A ABORDAGEM DE POLÍTICA CUSTOMIZADA COM TF DIRETAMENTE.
+from stable_baselines3.common.policies import ActorCriticPolicy
+from typing import List, Dict, Any, Optional, Union, Type
+# Importar sua rede e configs
+#import agents.DeepPortfolioAgent as DeepPortfolioAgent
+from agents.DeepPortfolioAgent import DeepPortfolioAgentNetwork 
+# from ..config import (NUM_ASSETS, WINDOW_SIZE, NUM_FEATURES_PER_ASSET, ...) # Importe do seu config real
+# VALORES DE EXEMPLO (PEGUE DO SEU CONFIG.PY REAL)
+NUM_ASSETS_POLICY = 4
+WINDOW_SIZE_POLICY = 60
+NUM_FEATURES_PER_ASSET_POLICY = 26
+# Hiperparâmetros para DeepPortfolioAgentNetwork quando usada como extrator
+ASSET_CNN_FILTERS1_POLICY = 32
+ASSET_CNN_FILTERS2_POLICY = 64
+ASSET_LSTM_UNITS1_POLICY = 64
+ASSET_LSTM_UNITS2_POLICY = 32 # Esta será a dimensão das features latentes para ator/crítico
+ASSET_DROPOUT_POLICY = 0.2
+MHA_NUM_HEADS_POLICY = 4
+MHA_KEY_DIM_DIVISOR_POLICY = 2 # Para key_dim = 32 // 2 = 16
+FINAL_DENSE_UNITS1_POLICY = 128
+FINAL_DENSE_UNITS2_POLICY = ASSET_LSTM_UNITS2_POLICY # A saída da dense2 SÃO as features latentes
+FINAL_DROPOUT_POLICY = 0.3
+
+
+class TFPortfolioFeaturesExtractor(tf.keras.layers.Layer): # Herda de tf.keras.layers.Layer
+    """
+    Extrator de features customizado para SB3 que usa DeepPortfolioAgentNetwork.
+    A observação do ambiente é (batch, window, num_assets * num_features_per_asset).
+    A saída são as features latentes (batch, latent_dim).
+    """
+    def __init__(self, observation_space: gym.spaces.Box, features_dim: int = ASSET_LSTM_UNITS2_POLICY):
+        super(TFPortfolioFeaturesExtractor, self).__init__()
+        self.features_dim = features_dim # SB3 usa isso para saber o tamanho da saída
+
+        # Instanciar a rede base para extrair features
+        # Ela deve retornar as ativações ANTES da camada softmax de alocação.
+        self.network = DeepPortfolioAgentNetwork(
+            num_assets=NUM_ASSETS_POLICY,
+            sequence_length=WINDOW_SIZE_POLICY,
+            num_features_per_asset=NUM_FEATURES_PER_ASSET_POLICY,
+            asset_cnn_filters1=ASSET_CNN_FILTERS1_POLICY, 
+            asset_cnn_filters2=ASSET_CNN_FILTERS2_POLICY,
+            asset_lstm_units1=ASSET_LSTM_UNITS1_POLICY, 
+            asset_lstm_units2=ASSET_LSTM_UNITS2_POLICY, # Define a saída do asset_processor
+            asset_dropout=ASSET_DROPOUT_POLICY,
+            mha_num_heads=MHA_NUM_HEADS_POLICY, 
+            mha_key_dim_divisor=MHA_KEY_DIM_DIVISOR_POLICY,
+            final_dense_units1=FINAL_DENSE_UNITS1_POLICY, 
+            final_dense_units2=self.features_dim, # A saída da dense2 é a nossa feature latente
+            final_dropout=FINAL_DROPOUT_POLICY,
+            output_latent_features=True,
+            use_sentiment_analysis=True # MUITO IMPORTANTE!
+        )
+        print("TFPortfolioFeaturesExtractor inicializado e usando DeepPortfolioAgentNetwork (output_latent_features=True).")
+
+    def call(self, observations: tf.Tensor, training: bool = False) -> tf.Tensor:
+        # A DeepPortfolioAgentNetwork já lida com o fatiamento e processamento.
+        # Ela foi configurada para retornar features latentes.
+        return self.network(observations, training=training)
+
+
+class CustomPolicy(ActorCriticPolicy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mlp_extractor = CustomMlpExtractor(
+            input_dim=self.observation_space.shape[0],
+            net_arch=[64, 64],  # Exemplo de arquitetura
+            activation_fn=nn.ReLU,
+            device=self.device
+        )
+
+
+
+class CustomPortfolioPolicySB3(ActorCriticPolicy):
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule, # Função que retorna a taxa de aprendizado
+        net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None, # Arquitetura para MLPs pós-extrator
+        activation_fn: Type[tf.Module] = tf.nn.relu, # Usar tf.nn.relu para TF
+        # Adicionar quaisquer outros parâmetros específicos que o extrator precise
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        if features_extractor_kwargs is None:
+            features_extractor_kwargs = {}
+        
+        # A dimensão das features que o nosso extrator PortfolioFeatureExtractor vai cuspir.
+        # Deve ser igual a ASSET_LSTM_UNITS2_POLICY (ou final_dense_units2 do extrator)
+        # Se não for passado, o construtor do ActorCriticPolicy pode tentar inferir.
+        # Vamos passar explicitamente para garantir.
+        features_extractor_kwargs.setdefault("features_dim", ASSET_LSTM_UNITS2_POLICY) # Ou o valor que você definiu
+
+        super().__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch=net_arch, # Para camadas Dense APÓS o extrator de features
+            activation_fn=activation_fn,
+            features_extractor_class=TFPortfolioFeaturesExtractor,
+            features_extractor_kwargs=features_extractor_kwargs,
+            **kwargs,
+        )
+        # Otimizador é criado na classe base.
+        # As redes de ator e crítico são construídas no método _build da classe base,
+        # usando o self.features_extractor e depois o self.mlp_extractor (que é
+        # construído com base no net_arch).
+
+    # Não precisamos sobrescrever _build_mlp_extractor se o features_extractor
+    # já fizer o trabalho pesado e o net_arch padrão para as cabeças for suficiente.
+    # Se quisermos MLPs customizados para ator e crítico APÓS o extrator:
+    # def _build_mlp_extractor(self) -> None:
+    #     # self.mlp_extractor é uma instância de MlpExtractor (ou similar)
+    #     # A entrada para ele é self.features_extractor.features_dim
+    #     # Aqui, net_arch definiria a estrutura do mlp_extractor
+    #     self.mlp_extractor = MlpExtractor(
+    #         feature_dim=self.features_extractor.features_dim,
+    #         net_arch=self.net_arch, # net_arch é uma lista de ints para camadas da política e valor
+    #         activation_fn=self.activation_fn,
+    #         device=self.device,
+    #     )
+    # As redes de ação e valor (action_net, value_net) são então criadas
+    # no _build da classe ActorCriticPolicy, no topo do mlp_extractor.# rnn/agents/custom_policies.py (NOVO ARQUIVO, ou adicione ao deep_portfolio.py)
+
+import gymnasium as gym # Usar gymnasium
+import tensorflow as tf
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor as PyTorchBaseFeaturesExtractor
+
+from stable_baselines3.common.torch_layers import MlpExtractor
+import torch.nn as nn
+
+class CustomMlpExtractor(MlpExtractor):
+    def __init__(self, input_dim, net_arch, activation_fn, device):
+        super().__init__(input_dim, net_arch, activation_fn, device)
+
+    def forward(self, features):
+        for layer in self.policy_net:
+            if isinstance(layer, nn.ReLU):
+                features = layer(features)  # Passando 'features' como argumento
+            else:
+                features = layer(features)
+        return features
+# Para TensorFlow, precisamos de um extrator de features compatível ou construir a política de forma diferente.
+# Stable Baselines3 tem melhor suporte nativo para PyTorch. Para TF, é um pouco mais manual.
+# VAMOS USAR A ABORDAGEM DE POLÍTICA CUSTOMIZADA COM TF DIRETAMENTE.
+from stable_baselines3.common.policies import ActorCriticPolicy
+from typing import List, Dict, Any, Optional, Union, Type
+# Importar sua rede e configs
+#import agents.DeepPortfolioAgent as DeepPortfolioAgent
+from agents.DeepPortfolioAgent import DeepPortfolioAgentNetwork 
+# from ..config import (NUM_ASSETS, WINDOW_SIZE, NUM_FEATURES_PER_ASSET, ...) # Importe do seu config real
+# VALORES DE EXEMPLO (PEGUE DO SEU CONFIG.PY REAL)
+NUM_ASSETS_POLICY = 4
+WINDOW_SIZE_POLICY = 60
+NUM_FEATURES_PER_ASSET_POLICY = 26
+# Hiperparâmetros para DeepPortfolioAgentNetwork quando usada como extrator
+ASSET_CNN_FILTERS1_POLICY = 32
+ASSET_CNN_FILTERS2_POLICY = 64
+ASSET_LSTM_UNITS1_POLICY = 64
+ASSET_LSTM_UNITS2_POLICY = 32 # Esta será a dimensão das features latentes para ator/crítico
+ASSET_DROPOUT_POLICY = 0.2
+MHA_NUM_HEADS_POLICY = 4
+MHA_KEY_DIM_DIVISOR_POLICY = 2 # Para key_dim = 32 // 2 = 16
+FINAL_DENSE_UNITS1_POLICY = 128
+FINAL_DENSE_UNITS2_POLICY = ASSET_LSTM_UNITS2_POLICY # A saída da dense2 SÃO as features latentes
+FINAL_DROPOUT_POLICY = 0.3
+
+
+class TFPortfolioFeaturesExtractor(tf.keras.layers.Layer): # Herda de tf.keras.layers.Layer
+    """
+    Extrator de features customizado para SB3 que usa DeepPortfolioAgentNetwork.
+    A observação do ambiente é (batch, window, num_assets * num_features_per_asset).
+    A saída são as features latentes (batch, latent_dim).
+    """
+    def __init__(self, observation_space: gym.spaces.Box, features_dim: int = ASSET_LSTM_UNITS2_POLICY):
+        super(TFPortfolioFeaturesExtractor, self).__init__()
+        self.features_dim = features_dim # SB3 usa isso para saber o tamanho da saída
+
+        # Instanciar a rede base para extrair features
+        # Ela deve retornar as ativações ANTES da camada softmax de alocação.
+        self.network = DeepPortfolioAgentNetwork(
+            num_assets=NUM_ASSETS_POLICY,
+            sequence_length=WINDOW_SIZE_POLICY,
+            num_features_per_asset=NUM_FEATURES_PER_ASSET_POLICY,
+            asset_cnn_filters1=ASSET_CNN_FILTERS1_POLICY, 
+            asset_cnn_filters2=ASSET_CNN_FILTERS2_POLICY,
+            asset_lstm_units1=ASSET_LSTM_UNITS1_POLICY, 
+            asset_lstm_units2=ASSET_LSTM_UNITS2_POLICY, # Define a saída do asset_processor
+            asset_dropout=ASSET_DROPOUT_POLICY,
+            mha_num_heads=MHA_NUM_HEADS_POLICY, 
+            mha_key_dim_divisor=MHA_KEY_DIM_DIVISOR_POLICY,
+            final_dense_units1=FINAL_DENSE_UNITS1_POLICY, 
+            final_dense_units2=self.features_dim, # A saída da dense2 é a nossa feature latente
+            final_dropout=FINAL_DROPOUT_POLICY,
+            output_latent_features=True,
+            use_sentiment_analysis=True # MUITO IMPORTANTE!
+        )
+        print("TFPortfolioFeaturesExtractor inicializado e usando DeepPortfolioAgentNetwork (output_latent_features=True).")
+
+    def call(self, observations: tf.Tensor, training: bool = False) -> tf.Tensor:
+        # A DeepPortfolioAgentNetwork já lida com o fatiamento e processamento.
+        # Ela foi configurada para retornar features latentes.
+        return self.network(observations, training=training)
+
+
+class CustomPolicy(ActorCriticPolicy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mlp_extractor = CustomMlpExtractor(
+            input_dim=self.observation_space.shape[0],
+            net_arch=[64, 64],  # Exemplo de arquitetura
+            activation_fn=nn.ReLU,
+            device=self.device
+        )
+
+
+
+class CustomPortfolioPolicySB3(ActorCriticPolicy):
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule, # Função que retorna a taxa de aprendizado
+        net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None, # Arquitetura para MLPs pós-extrator
+        activation_fn: Type[tf.Module] = tf.nn.relu, # Usar tf.nn.relu para TF
+        # Adicionar quaisquer outros parâmetros específicos que o extrator precise
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        if features_extractor_kwargs is None:
+            features_extractor_kwargs = {}
+        
+        # A dimensão das features que o nosso extrator PortfolioFeatureExtractor vai cuspir.
+        # Deve ser igual a ASSET_LSTM_UNITS2_POLICY (ou final_dense_units2 do extrator)
+        # Se não for passado, o construtor do ActorCriticPolicy pode tentar inferir.
+        # Vamos passar explicitamente para garantir.
+        features_extractor_kwargs.setdefault("features_dim", ASSET_LSTM_UNITS2_POLICY) # Ou o valor que você definiu
+
+        super().__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch=net_arch, # Para camadas Dense APÓS o extrator de features
+            activation_fn=activation_fn,
+            features_extractor_class=TFPortfolioFeaturesExtractor,
+            features_extractor_kwargs=features_extractor_kwargs,
+            **kwargs,
+        )
+        # Otimizador é criado na classe base.
+        # As redes de ator e crítico são construídas no método _build da classe base,
+        # usando o self.features_extractor e depois o self.mlp_extractor (que é
+        # construído com base no net_arch).
+
+    # Não precisamos sobrescrever _build_mlp_extractor se o features_extractor
+    # já fizer o trabalho pesado e o net_arch padrão para as cabeças for suficiente.
+    # Se quisermos MLPs customizados para ator e crítico APÓS o extrator:
+    # def _build_mlp_extractor(self) -> None:
+    #     # self.mlp_extractor é uma instância de MlpExtractor (ou similar)
+    #     # A entrada para ele é self.features_extractor.features_dim
+    #     # Aqui, net_arch definiria a estrutura do mlp_extractor
+    #     self.mlp_extractor = MlpExtractor(
+    #         feature_dim=self.features_extractor.features_dim,
+    #         net_arch=self.net_arch, # net_arch é uma lista de ints para camadas da política e valor
+    #         activation_fn=self.activation_fn,
+    #         device=self.device,
+    #     )
+    # As redes de ação e valor (action_net, value_net) são então criadas
+    # no _build da classe ActorCriticPolicy, no topo do mlp_extractor.# rnn/agents/custom_policies.py (NOVO ARQUIVO, ou adicione ao deep_portfolio.py)
+
+import gymnasium as gym # Usar gymnasium
+import tensorflow as tf
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor as PyTorchBaseFeaturesExtractor
+
+from stable_baselines3.common.torch_layers import MlpExtractor
+import torch.nn as nn
+
+class CustomMlpExtractor(MlpExtractor):
+    def __init__(self, input_dim, net_arch, activation_fn, device):
+        super().__init__(input_dim, net_arch, activation_fn, device)
+
+    def forward(self, features):
+        for layer in self.policy_net:
+            if isinstance(layer, nn.ReLU):
+                features = layer(features)  # Passando 'features' como argumento
+            else:
+                features = layer(features)
+        return features
+# Para TensorFlow, precisamos de um extrator de features compatível ou construir a política de forma diferente.
+# Stable Baselines3 tem melhor suporte nativo para PyTorch. Para TF, é um pouco mais manual.
+# VAMOS USAR A ABORDAGEM DE POLÍTICA CUSTOMIZADA COM TF DIRETAMENTE.
+from stable_baselines3.common.policies import ActorCriticPolicy
+from typing import List, Dict, Any, Optional, Union, Type
+# Importar sua rede e configs
+#import agents.DeepPortfolioAgent as DeepPortfolioAgent
+from agents.DeepPortfolioAgent import DeepPortfolioAgentNetwork 
+# from ..config import (NUM_ASSETS, WINDOW_SIZE, NUM_FEATURES_PER_ASSET, ...) # Importe do seu config real
+# VALORES DE EXEMPLO (PEGUE DO SEU CONFIG.PY REAL)
+NUM_ASSETS_POLICY = 4
+WINDOW_SIZE_POLICY = 60
+NUM_FEATURES_PER_ASSET_POLICY = 26
+# Hiperparâmetros para DeepPortfolioAgentNetwork quando usada como extrator
+ASSET_CNN_FILTERS1_POLICY = 32
+ASSET_CNN_FILTERS2_POLICY = 64
+ASSET_LSTM_UNITS1_POLICY = 64
+ASSET_LSTM_UNITS2_POLICY = 32 # Esta será a dimensão das features latentes para ator/crítico
+ASSET_DROPOUT_POLICY = 0.2
+MHA_NUM_HEADS_POLICY = 4
+MHA_KEY_DIM_DIVISOR_POLICY = 2 # Para key_dim = 32 // 2 = 16
+FINAL_DENSE_UNITS1_POLICY = 128
+FINAL_DENSE_UNITS2_POLICY = ASSET_LSTM_UNITS2_POLICY # A saída da dense2 SÃO as features latentes
+FINAL_DROPOUT_POLICY = 0.3
+
+
+class TFPortfolioFeaturesExtractor(tf.keras.layers.Layer): # Herda de tf.keras.layers.Layer
+    """
+    Extrator de features customizado para SB3 que usa DeepPortfolioAgentNetwork.
+    A observação do ambiente é (batch, window, num_assets * num_features_per_asset).
+    A saída são as features latentes (batch, latent_dim).
+    """
+    def __init__(self, observation_space: gym.spaces.Box, features_dim: int = ASSET_LSTM_UNITS2_POLICY):
+        super(TFPortfolioFeaturesExtractor, self).__init__()
+        self.features_dim = features_dim # SB3 usa isso para saber o tamanho da saída
+
+        # Instanciar a rede base para extrair features
+        # Ela deve retornar as ativações ANTES da camada softmax de alocação.
+        self.network = DeepPortfolioAgentNetwork(
+            num_assets=NUM_ASSETS_POLICY,
+            sequence_length=WINDOW_SIZE_POLICY,
+            num_features_per_asset=NUM_FEATURES_PER_ASSET_POLICY,
+            asset_cnn_filters1=ASSET_CNN_FILTERS1_POLICY, 
+            asset_cnn_filters2=ASSET_CNN_FILTERS2_POLICY,
+            asset_lstm_units1=ASSET_LSTM_UNITS1_POLICY, 
+            asset_lstm_units2=ASSET_LSTM_UNITS2_POLICY, # Define a saída do asset_processor
+            asset_dropout=ASSET_DROPOUT_POLICY,
+            mha_num_heads=MHA_NUM_HEADS_POLICY, 
+            mha_key_dim_divisor=MHA_KEY_DIM_DIVISOR_POLICY,
+            final_dense_units1=FINAL_DENSE_UNITS1_POLICY, 
+            final_dense_units2=self.features_dim, # A saída da dense2 é a nossa feature latente
+            final_dropout=FINAL_DROPOUT_POLICY,
+            output_latent_features=True,
+            use_sentiment_analysis=True # MUITO IMPORTANTE!
+        )
+        print("TFPortfolioFeaturesExtractor inicializado e usando DeepPortfolioAgentNetwork (output_latent_features=True).")
+
+    def call(self, observations: tf.Tensor, training: bool = False) -> tf.Tensor:
+        # A DeepPortfolioAgentNetwork já lida com o fatiamento e processamento.
+        # Ela foi configurada para retornar features latentes.
+        return self.network(observations, training=training)
+
+
+class CustomPolicy(ActorCriticPolicy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mlp_extractor = CustomMlpExtractor(
+            input_dim=self.observation_space.shape[0],
+            net_arch=[64, 64],  # Exemplo de arquitetura
+            activation_fn=nn.ReLU,
+            device=self.device
+        )
+
+
+
+class CustomPortfolioPolicySB3(ActorCriticPolicy):
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule, # Função que retorna a taxa de aprendizado
+        net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None, # Arquitetura para MLPs pós-extrator
+        activation_fn: Type[tf.Module] = tf.nn.relu, # Usar tf.nn.relu para TF
+        # Adicionar quaisquer outros parâmetros específicos que o extrator precise
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        if features_extractor_kwargs is None:
+            features_extractor_kwargs = {}
+        
+        # A dimensão das features que o nosso extrator PortfolioFeatureExtractor vai cuspir.
+        # Deve ser igual a ASSET_LSTM_UNITS2_POLICY (ou final_dense_units2 do extrator)
+        # Se não for passado, o construtor do ActorCriticPolicy pode tentar inferir.
+        # Vamos passar explicitamente para garantir.
+        features_extractor_kwargs.setdefault("features_dim", ASSET_LSTM_UNITS2_POLICY) # Ou o valor que você definiu
+
+        super().__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch=net_arch, # Para camadas Dense APÓS o extrator de features
+            activation_fn=activation_fn,
+            features_extractor_class=TFPortfolioFeaturesExtractor,
+            features_extractor_kwargs=features_extractor_kwargs,
+            **kwargs,
+        )
+        # Otimizador é criado na classe base.
+        # As redes de ator e crítico são construídas no método _build da classe base,
+        # usando o self.features_extractor e depois o self.mlp_extractor (que é
+        # construído com base no net_arch).
+
+    # Não precisamos sobrescrever _build_mlp_extractor se o features_extractor
+    # já fizer o trabalho pesado e o net_arch padrão para as cabeças for suficiente.
+    # Se quisermos MLPs customizados para ator e crítico APÓS o extrator:
+    # def _build_mlp_extractor(self) -> None:
+    #     # self.mlp_extractor é uma instância de MlpExtractor (ou similar)
+    #     # A entrada para ele é self.features_extractor.features_dim
+    #     # Aqui, net_arch definiria a estrutura do mlp_extractor
+    #     self.mlp_extractor = MlpExtractor(
+    #         feature_dim=self.features_extractor.features_dim,
+    #         net_arch=self.net_arch, # net_arch é uma lista de ints para camadas da política e valor
+    #         activation_fn=self.activation_fn,
+    #         device=self.device,
+    #     )
+    # As redes de ação e valor (action_net, value_net) são então criadas
+    # no _build da classe ActorCriticPolicy, no topo do mlp_extractor.# rnn/agents/custom_policies.py (NOVO ARQUIVO, ou adicione ao deep_portfolio.py)
+
+import gymnasium as gym # Usar gymnasium
+import tensorflow as tf
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor as PyTorchBaseFeaturesExtractor
+
+from stable_baselines3.common.torch_layers import MlpExtractor
+import torch.nn as nn
+
+class CustomMlpExtractor(MlpExtractor):
+    def __init__(self, input_dim, net_arch, activation_fn, device):
+        super().__init__(input_dim, net_arch, activation_fn, device)
+
+    def forward(self, features):
+        for layer in self.policy_net:
+            if isinstance(layer, nn.ReLU):
+                features = layer(features)  # Passando 'features' como argumento
+            else:
+                features = layer(features)
+        return features
+# Para TensorFlow, precisamos de um extrator de features compatível ou construir a política de forma diferente.
+# Stable Baselines3 tem melhor suporte nativo para PyTorch. Para TF, é um pouco mais manual.
+# VAMOS USAR A ABORDAGEM DE POLÍTICA CUSTOMIZADA COM TF DIRETAMENTE.
+from stable_baselines3.common.policies import ActorCriticPolicy
+from typing import List, Dict, Any, Optional, Union, Type
+# Importar sua rede e configs
+#import agents.DeepPortfolioAgent as DeepPortfolioAgent
+from agents.DeepPortfolioAgent import DeepPortfolioAgentNetwork 
+# from ..config import (NUM_ASSETS, WINDOW_SIZE, NUM_FEATURES_PER_ASSET, ...) # Importe do seu config real
+# VALORES DE EXEMPLO (PEGUE DO SEU CONFIG.PY REAL)
+NUM_ASSETS_POLICY = 4
+WINDOW_SIZE_POLICY = 60
+NUM_FEATURES_PER_ASSET_POLICY = 26
+# Hiperparâmetros para DeepPortfolioAgentNetwork quando usada como extrator
+ASSET_CNN_FILTERS1_POLICY = 32
+ASSET_CNN_FILTERS2_POLICY = 64
+ASSET_LSTM_UNITS1_POLICY = 64
+ASSET_LSTM_UNITS2_POLICY = 32 # Esta será a dimensão das features latentes para ator/crítico
+ASSET_DROPOUT_POLICY = 0.2
+MHA_NUM_HEADS_POLICY = 4
+MHA_KEY_DIM_DIVISOR_POLICY = 2 # Para key_dim = 32 // 2 = 16
+FINAL_DENSE_UNITS1_POLICY = 128
+FINAL_DENSE_UNITS2_POLICY = ASSET_LSTM_UNITS2_POLICY # A saída da dense2 SÃO as features latentes
+FINAL_DROPOUT_POLICY = 0.3
+
+
+class TFPortfolioFeaturesExtractor(tf.keras.layers.Layer): # Herda de tf.keras.layers.Layer
+    """
+    Extrator de features customizado para SB3 que usa DeepPortfolioAgentNetwork.
+    A observação do ambiente é (batch, window, num_assets * num_features_per_asset).
+    A saída são as features latentes (batch, latent_dim).
+    """
+    def __init__(self, observation_space: gym.spaces.Box, features_dim: int = ASSET_LSTM_UNITS2_POLICY):
+        super(TFPortfolioFeaturesExtractor, self).__init__()
+        self.features_dim = features_dim # SB3 usa isso para saber o tamanho da saída
+
+        # Instanciar a rede base para extrair features
+        # Ela deve retornar as ativações ANTES da camada softmax de alocação.
+        self.network = DeepPortfolioAgentNetwork(
+            num_assets=NUM_ASSETS_POLICY,
+            sequence_length=WINDOW_SIZE_POLICY,
+            num_features_per_asset=NUM_FEATURES_PER_ASSET_POLICY,
+            asset_cnn_filters1=ASSET_CNN_FILTERS1_POLICY, 
+            asset_cnn_filters2=ASSET_CNN_FILTERS2_POLICY,
+            asset_lstm_units1=ASSET_LSTM_UNITS1_POLICY, 
+            asset_lstm_units2=ASSET_LSTM_UNITS2_POLICY, # Define a saída do asset_processor
+            asset_dropout=ASSET_DROPOUT_POLICY,
+            mha_num_heads=MHA_NUM_HEADS_POLICY, 
+            mha_key_dim_divisor=MHA_KEY_DIM_DIVISOR_POLICY,
+            final_dense_units1=FINAL_DENSE_UNITS1_POLICY, 
+            final_dense_units2=self.features_dim, # A saída da dense2 é a nossa feature latente
+            final_dropout=FINAL_DROPOUT_POLICY,
+            output_latent_features=True,
+            use_sentiment_analysis=True # MUITO IMPORTANTE!
+        )
+        print("TFPortfolioFeaturesExtractor inicializado e usando DeepPortfolioAgentNetwork (output_latent_features=True).")
+
+    def call(self, observations: tf.Tensor, training: bool = False) -> tf.Tensor:
+        # A DeepPortfolioAgentNetwork já lida com o fatiamento e processamento.
+        # Ela foi configurada para retornar features latentes.
+        return self.network(observations, training=training)
+
+
+class CustomPolicy(ActorCriticPolicy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mlp_extractor = CustomMlpExtractor(
+            input_dim=self.observation_space.shape[0],
+            net_arch=[64, 64],  # Exemplo de arquitetura
+            activation_fn=nn.ReLU,
+            device=self.device
+        )
+
+
+
+class CustomPortfolioPolicySB3(ActorCriticPolicy):
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule, # Função que retorna a taxa de aprendizado
+        net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None, # Arquitetura para MLPs pós-extrator
+        activation_fn: Type[tf.Module] = tf.nn.relu, # Usar tf.nn.relu para TF
+        # Adicionar quaisquer outros parâmetros específicos que o extrator precise
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        if features_extractor_kwargs is None:
+            features_extractor_kwargs = {}
+        
+        # A dimensão das features que o nosso extrator PortfolioFeatureExtractor vai cuspir.
+        # Deve ser igual a ASSET_LSTM_UNITS2_POLICY (ou final_dense_units2 do extrator)
+        # Se não for passado, o construtor do ActorCriticPolicy pode tentar inferir.
+        # Vamos passar explicitamente para garantir.
+        features_extractor_kwargs.setdefault("features_dim", ASSET_LSTM_UNITS2_POLICY) # Ou o valor que você definiu
+
+        super().__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch=net_arch, # Para camadas Dense APÓS o extrator de features
+            activation_fn=activation_fn,
+            features_extractor_class=TFPortfolioFeaturesExtractor,
+            features_extractor_kwargs=features_extractor_kwargs,
+            **kwargs,
+        )
+        # Otimizador é criado na classe base.
+        # As redes de ator e crítico são construídas no método _build da classe base,
+        # usando o self.features_extractor e depois o self.mlp_extractor (que é
+        # construído com base no net_arch).
+
+    # Não precisamos sobrescrever _build_mlp_extractor se o features_extractor
+    # já fizer o trabalho pesado e o net_arch padrão para as cabeças for suficiente.
+    # Se quisermos MLPs customizados para ator e crítico APÓS o extrator:
+    # def _build_mlp_extractor(self) -> None:
+    #     # self.mlp_extractor é uma instância de MlpExtractor (ou similar)
+    #     # A entrada para ele é self.features_extractor.features_dim
+    #     # Aqui, net_arch definiria a estrutura do mlp_extractor
+    #     self.mlp_extractor = MlpExtractor(
+    #         feature_dim=self.features_extractor.features_dim,
+    #         net_arch=self.net_arch, # net_arch é uma lista de ints para camadas da política e valor
+    #         activation_fn=self.activation_fn,
+    #         device=self.device,
+    #     )
+    # As redes de ação e valor (action_net, value_net) são então criadas
+    # no _build da classe ActorCriticPolicy, no topo do mlp_extractor.
+
+from agents.custom_policies import CustomPortfolioPolicySB3 # Importar a política customizada
+#from .deep_portfolio import NUM_ASSETS_CONF, WINDOW_SIZE_CONF, NUM_FEATURES_PER_ASSET_CONF # Se precisar para policy_kwargs
+# (Importe as configs do config.py)
+#from ..config import LEARNING_RATE as PPO_LEARNING_RATE 
+PPO_LEARNING_RATE = 0.0005
+
+
+from agents.data_handler_multi_asset import get_multi_asset_data_for_rl, MULTI_ASSET_SYMBOLS # Do seu config/data_handler
+from agents.portfolio_environment import PortfolioEnv 
+from agents.deep_portfolio import DeepPortfolioAI # Seu modelo (usado como policy)
+# from config import ... # Outras configs
+
+RISK_FREE_RATE_ANNUAL = 0.2
+REWARD_WINDOW = 252
+frisk_free_per_step = 0.0 
+
+# Janela de recompensa para Sharpe (ex: últimos 60 passos/horas)
+# Deve ser menor ou igual ao ep_len_mean ou um valor razoável
+reward_calc_window = 60
+
+# 1. Carregar e preparar dados multi-ativos
+# (MULTI_ASSET_SYMBOLS viria do config.py)
+asset_keys_list = list(MULTI_ASSET_SYMBOLS.keys()) # ['crypto_eth', 'crypto_ada', ...]
+
+multi_asset_df = get_multi_asset_data_for_rl(
+    MULTI_ASSET_SYMBOLS, 
+    timeframe_yf='1h', # Ou TIMEFRAME_YFINANCE do config
+    days_to_fetch=365*2,
+    logger_instance=any
+    # Ou DAYS_TO_FETCH do config
+)
+
+print("Imprimindo retorno para df_combined passado para train_rl_portifolio")
+print(multi_asset_df)
+
+
+#-------------------
+
+if multi_asset_df is None or multi_asset_df.empty:
+    print("Falha ao carregar dados multi-ativos. Encerrando treinamento RL.")
+    exit()
+
+env = PortfolioEnv(df_multi_asset_features=multi_asset_df, asset_symbols_list=asset_keys_list) 
+print("Ambiente de Portfólio Criado.")
+
+# --- Usar a Política Customizada ---
+# Hiperparâmetros para o PPO
+learning_rate_ppo = PPO_LEARNING_RATE # Ex: 3e-4 ou 1e-4 (do config.py)
+n_steps_ppo = 2048 
+batch_size_ppo = 64
+ent_coef_ppo = 0.0 
+
+# policy_kwargs para passar para o __init__ da CustomPortfolioPolicySB3, se necessário
+# (além dos que já são passados para o features_extractor_kwargs)
+# Exemplo: Se você adicionou mais args ao __init__ de CustomPortfolioPolicySB3
+# policy_custom_kwargs = dict(
+#    meu_parametro_customizado=valor,
+#    # features_extractor_kwargs já é tratado pela classe base se você passar features_extractor_class
+# )
+
+print("Instanciando PPO com Política Customizada (DeepPortfolioAgentNetwork)...")
+model_ppo = PPO(
+    CustomPortfolioPolicySB3, 
+    env, 
+    verbose=1, 
+    learning_rate=learning_rate_ppo, # Pode ser uma função lr_schedule
+    n_steps=n_steps_ppo,
+    batch_size=batch_size_ppo,
+    ent_coef=ent_coef_ppo,
+    # policy_kwargs=policy_custom_kwargs, # Se tiver kwargs específicos para a política
+    tensorboard_log="./ppo_deep_portfolio_tensorboard/"
+)
+
+print("Iniciando treinamento do agente PPO com rede customizada...")
+model_ppo.learn(total_timesteps=100000, progress_bar=True) # Comece com menos timesteps para teste (ex: 50k)
+
+model_ppo.save("app/model/ppo_custom_deep_portfolio_agent")
+print("Modelo RL com política customizada treinado e salvo.")
+
+model_ppo.save("app/model/model3")
+print("Modelo RL com política customizada treinado e salvo.")
+
+model_ppo.save("app/model/model2.h5")
+print("Modelo RL com política customizada treinado e salvo.")
+
+
+
+#----------
+
+
+
+
+# if multi_asset_df is None or multi_asset_df.empty:
+#     print("Falha ao carregar dados multi-ativos. Encerrando treinamento RL.")
+#     exit()
+
+# # 2. Criar o Ambiente
+# # O multi_asset_df já deve ter as features para observação E as colunas de preço de close original
+# env = PortfolioEnv(df_multi_asset_features=multi_asset_df, asset_symbols_list=asset_keys_list)
+
+
+# risk_free_per_step = 0.0 
+
+# # Janela de recompensa para Sharpe (ex: últimos 60 passos/horas)
+# # Deve ser menor ou igual ao ep_len_mean ou um valor razoável
+# reward_calc_window = 60
+
+# env = PortfolioEnv(
+#     df_multi_asset_features=multi_asset_df, 
+#     asset_symbols_list=asset_keys_list,
+#     initial_balance=100000, # Do config
+#     window_size=60, # Do config
+#     transaction_cost_pct=0.001, # Do config ou defina aqui
+#     reward_window_size=reward_calc_window,
+#     risk_free_rate_per_step=risk_free_per_step
+# )
+
+# # Opcional: Verificar se o ambiente está em conformidade com a API do Gymnasium
+# # check_env(env) # Pode dar avisos/erros se algo estiver errado
+# print("Ambiente de Portfólio Criado.")
+# print(f"Observation Space: {env.observation_space.shape}")
+# print(f"Action Space: {env.action_space.shape}")
+
+
+
+
+# # 3. Definir a Política de Rede Neural
+# # Stable-Baselines3 permite que você defina uma arquitetura customizada.
+# # Precisamos de uma forma de passar sua arquitetura DeepPortfolioAI para o PPO.
+# # Uma maneira é criar uma classe de política customizada.
+# # Por agora, vamos usar a política padrão "MlpPolicy" e depois vemos como integrar a sua.
+# # Ou, se DeepPortfolioAI for uma tf.keras.Model, podemos tentar usá-la em policy_kwargs.
+
+# # Para usar sua DeepPortfolioAI, você precisaria de uma FeatureExtractor customizada
+# # ou uma política que a incorpore, o que é mais avançado com Stable-Baselines3.
+# # Vamos começar com MlpPolicy para testar o ambiente.
+
+# # policy_kwargs = dict(
+# #     features_extractor_class=YourCustomFeatureExtractor, # Se a entrada precisar de tratamento especial
+# #     features_extractor_kwargs=dict(features_dim=128),
+# #     net_arch=[dict(pi=[256, 128], vf=[256, 128])] # Exemplo de arquitetura para policy e value networks
+# # )
+# # Ou, se o DeepPortfolioAI puder ser adaptado para ser a policy_network:
+# policy_kwargs = dict(
+#    net_arch=dict(
+#        pi=[{'model': DeepPortfolioAI(num_assets=env.num_assets)}], # Não é direto assim
+#        vf=[] # Value function pode ser separada ou compartilhada
+#    )
+# )
+
+# # Para começar e testar o ambiente, use a MlpPolicy padrão.
+# # O input da MlpPolicy será a observação achatada (WINDOW_SIZE * num_total_features).
+# # Isso pode não ser ideal para dados sequenciais. "MlpLstmPolicy" é melhor.
+
+# model_ppo = PPO("MlpPolicy", env, verbose=1, ent_coef=0.01, tensorboard_log="./ppo_portfolio_tensorboard/")
+# # Se "MlpLstmPolicy" não funcionar bem com o shape da observação (janela, features_totais),
+# # você pode precisar de um FeatureExtractor que achate a janela, ou uma política customizada.
+
+# # 4. Treinar o Agente
+# print("Iniciando treinamento do agente PPO...")
+# model_ppo.learn(total_timesteps=int("1000000"), progress_bar=True) # Aumente timesteps para treino real
+
+# # 5. Salvar o Modelo Treinado
+# model_ppo.save("rl_models/ppo_deep_portfolio_agent")
+# print("Modelo RL treinado salvo.")
+
+
+# # (Opcional) Testar o agente treinado
+# obs, _ = env.reset()
+# for _ in range(200):
+#     action, _states = model_ppo.predict(obs, deterministic=True)
+#     obs, rewards, terminated, truncated, info = env.step(action)
+#     env.render()
+#     if terminated or truncated:
+#         obs, _ = env.reset()
+# env.close()

app.py

@@ -1,752 +1,752 @@
-# rnn/app.py
-
-from agents.train_rl_portfolio_agent import model_ppo
-model_ppo() 
-import os
-import uuid
-import time
-import hmac
-import hashlib
-import json
-from datetime import datetime, timedelta
-from typing import Dict, Any, List, Optional
-from rnn.app.ccxt_utils import get_ccxt_exchange, fetch_crypto_data
-
-import httpx # Para fazer chamadas HTTP assíncronas (para o callback)
-from fastapi import FastAPI, Request, HTTPException, Depends, Header, BackgroundTasks
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse, JSONResponse
-from fastapi.staticfiles import StaticFiles
-from jinja2 import Environment, FileSystemLoader
-from pydantic import BaseModel, Field
-
-from rnn.app.model.rnn_predictor import RNNModelPredictor
-from rnn.app.utils.logger import get_logger 
-
-
-
-logger = get_logger()
-
-# --- Configuração Inicial e Variáveis de Ambiente (Secrets do Hugging Face) ---
-AIBANK_API_KEY = os.environ.get("AIBANK_API_KEY") # Chave que o aibank usa para chamar esta API RNN
-AIBANK_CALLBACK_URL = os.environ.get("AIBANK_CALLBACK_URL") # URL no aibank para onde esta API RNN enviará o resultado
-CALLBACK_SHARED_SECRET = os.environ.get("CALLBACK_SHARED_SECRET") # Segredo para assinar/verificar o payload do callback
-
-# Chaves para serviços externos 
-MARKET_DATA_API_KEY = os.environ.get("MARKET_DATA_API_KEY")
-EXCHANGE_API_KEY = os.environ.get("EXCHANGE_API_KEY")
-EXCHANGE_API_SECRET = os.environ.get("EXCHANGE_API_SECRET")
-
-if not AIBANK_API_KEY:
-    logger.warning("AIBANK_API_KEY não configurada. A autenticação para /api/invest falhou.")
-if not AIBANK_CALLBACK_URL:
-    logger.warning("AIBANK_CALLBACK_URL não configurada. O callback para o aibank falhou.")
-if not CALLBACK_SHARED_SECRET:
-    logger.warning("CALLBACK_SHARED_SECRET não configurado. A segurança do callback está comprometida.")
-
-
-
-
-app = FastAPI(title="ATCoin Neural Agents - Investment API")
-
-# --- Middlewares ---
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[
-        "http://localhost:3000",  # URL desenvolvimento local
-        "http://aibank.app.br",   # URL de produção 
-        "https://*.aibank.app.br", # subdomínios
-        "https://*.hf.space"      # HF Space
-    ],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# --- Simulação de Banco de Dados de Transações DEV ---
-# Em produção  MongoDB
-transactions_db: Dict[str, Dict[str, Any]] = {}
-
-# --- Modelos Pydantic ---
-class InvestmentRequest(BaseModel):
-    client_id: str
-    amount: float = Field(..., gt=0) # Garante que o montante seja positivo
-    aibank_transaction_token: str # Token único gerado pelo aibank para rastreamento
-
-class InvestmentResponse(BaseModel):
-    status: str
-    message: str
-    rnn_transaction_id: str # ID da transação this.API
-
-class InvestmentResultPayload(BaseModel): # Payload para o callback para o aibank
-    rnn_transaction_id: str
-    aibank_transaction_token: str
-    client_id: str
-    initial_amount: float
-    final_amount: float
-    profit_loss: float
-    status: str #  "completed", "failed"
-    timestamp: datetime
-    details: str = ""
-
-
-# --- Dependência de Autenticação ---
-async def verify_aibank_key(authorization: str = Header(None)):
-    if not AIBANK_API_KEY: # Checagem se a chave do servidor está configurada
-        logger.error("CRITICAL: AIBANK_API_KEY (server-side) não está configurada nos Secrets.")
-        raise HTTPException(status_code=500, detail="Internal Server Configuration Error: Missing server API Key.")
-
-    if authorization is None:
-        logger.warning("Authorization header ausente na chamada do AIBank.")
-        raise HTTPException(status_code=401, detail="Authorization header is missing")
-
-    parts = authorization.split()
-    if len(parts) != 2 or parts[0].lower() != 'bearer':
-        logger.warning(f"Formato inválido do Authorization header: {authorization}")
-        raise HTTPException(status_code=401, detail="Authorization header must be 'Bearer <token>'")
-
-    token_from_aibank = parts[1]
-    if not hmac.compare_digest(token_from_aibank, AIBANK_API_KEY):
-        logger.warning(f"Chave de API inválida fornecida pelo AIBank. Token: {token_from_aibank[:10]}...")
-        raise HTTPException(status_code=403, detail="Invalid API Key provided by AIBank.")
-    logger.info("API Key do AIBank verificada com sucesso.")
-    return True
-
-
-# --- Lógica de Negócio Principal (Simulada e em Background) ---
-
-
-async def execute_investment_strategy_background(
-    rnn_tx_id: str,
-    client_id: str,
-    amount: float,
-    aibank_tx_token: str
-):
-    logger.info(f"BG TASK [{rnn_tx_id}]: Iniciando estratégia de investimento para cliente {client_id}, valor {amount}.")
-    transactions_db[rnn_tx_id]["status"] = "processing"
-    transactions_db[rnn_tx_id]["status_details"] = "Initializing investment cycle"
-    
-    final_status = "completed"
-    error_details = "" # Acumula mensagens de erro de várias etapas
-    calculated_final_amount = amount 
-
-    # Inicializa a exchange ccxt usando o utilitário
-    # O logger do app.py é passado para ccxt_utils para que os logs apareçam no mesmo stream
-    exchange = await get_ccxt_exchange(logger_instance=logger) # MODIFICADO
-
-    if not exchange:
-        # get_ccxt_exchange já loga o erro. Se a exchange é crucial, podemos falhar aqui.
-        logger.warning(f"BG TASK [{rnn_tx_id}]: Falha ao inicializar a exchange. A estratégia pode não funcionar como esperado para cripto.")
-        # Se as chaves CCXT foram fornecidas no ambiente mas a exchange falhou, considere isso um erro de config.
-        if os.environ.get("CCXT_API_KEY") and os.environ.get("CCXT_API_SECRET"):
-            error_details += "Failed to initialize CCXT exchange despite API keys being present; "
-            final_status = "failed_config" 
-            # (PULAR PARA CALLBACK - veja a seção de tratamento de erro crítico abaixo)
-    
-    # =========================================================================
-    # 1. COLETAR DADOS DE MERCADO
-    # =========================================================================
-    logger.info(f"BG TASK [{rnn_tx_id}]: Coletando dados de mercado...")
-    transactions_db[rnn_tx_id]["status_details"] = "Fetching market data"
-    market_data_results = {"crypto": {}, "stocks": {}, "other": {}}
-    critical_data_fetch_failed = False # Flag para falha crítica na coleta de dados
-
-    # --- Coleta de dados de Cripto via ccxt_utils ---
-    if exchange:
-        crypto_pairs_to_fetch = ["BTC/USDT", "ETH/USDT", "SOL/USDT"] # Mantenha configurável
-        
-        crypto_data, crypto_fetch_ok, crypto_err_msg = await fetch_crypto_data(
-            exchange, 
-            crypto_pairs_to_fetch, 
-            logger_instance=logger
-        )
-        market_data_results["crypto"] = crypto_data
-        if not crypto_fetch_ok:
-            error_details += f"Crypto data fetch issues: {crypto_err_msg}; "
-            # Decida se a falha na coleta de cripto é crítica
-            # Se for, defina critical_data_fetch_failed = True
-            if os.environ.get("CCXT_API_KEY"): # Se esperávamos dados de cripto
-                critical_data_fetch_failed = True 
-                logger.error(f"BG TASK [{rnn_tx_id}]: Falha crítica na coleta de dados de cripto.")
-    else:
-        logger.info(f"BG TASK [{rnn_tx_id}]: Instância da exchange ccxt não disponível. Pulando coleta de dados de cripto.")
-        if os.environ.get("CCXT_API_KEY"): # Se esperávamos dados de cripto mas a exchange não inicializou
-            error_details += "CCXT exchange not initialized, crypto data skipped; "
-            critical_data_fetch_failed = True
-
-
-    # --- Coleta de dados para outros tipos de ativos (ex: Ações com yfinance) ---
-    # (Sua lógica yfinance aqui, se aplicável, similarmente atualizando market_data_results["stocks"])
-    # try:
-    #     import yfinance as yf # Mova para o topo do app.py se for usar
-    #     # ... lógica yfinance ...
-    # except Exception as e_yf:
-    #     logger.warning(f"BG TASK [{rnn_tx_id}]: Falha ao buscar dados de ações com yfinance: {e_yf}")
-    #     error_details += f"YFinance data fetch failed: {str(e_yf)}; "
-    #     # Decida se isso é crítico: critical_data_fetch_failed = True
-
-    market_data_results["other"]['simulated_index_level'] = random.uniform(10000, 15000) # Mantém simulação
-    
-    transactions_db[rnn_tx_id]["market_data_collected"] = market_data_results
-    
-    # --- PONTO DE CHECAGEM PARA FALHA CRÍTICA NA COLETA DE DADOS ---
-    if critical_data_fetch_failed:
-        final_status = "failed_market_data"
-        logger.error(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado falhou criticamente. {error_details}")
-        # Pular para a seção de callback
-        # (A lógica de envio do callback precisa ser alcançada)
-    else:
-        logger.info(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado concluída.")
-        transactions_db[rnn_tx_id]["status_details"] = "Processing RNN analysis"
-
-
-
-
-
-    # =========================================================================
-    # 2. ANÁLISE PELA RNN E TOMADA DE DECISÃO
-    # =========================================================================
-    investment_decisions: List[Dict[str, Any]] = [] 
-    total_usd_allocated_by_rnn = 0.0
-    loop = asyncio.get_running_loop() 
-
-    if final_status == "completed": 
-        logger.info(f"BG TASK [{rnn_tx_id}]: Executando análise RNN...")
-        transactions_db[rnn_tx_id]["status_details"] = "Running RNN model"
-        rnn_analysis_success = True
-        
-        # CORRIGIDO: Acessando app.state.rnn_predictor
-        predictor: Optional[RNNModelPredictor] = getattr(app.state, 'rnn_predictor', None)
-
-        try:
-                crypto_data_for_rnn = market_data_results.get("crypto", {})
-                candidate_assets = [
-                    asset_key for asset_key, data in crypto_data_for_rnn.items() 
-                    if data and not data.get("error") and data.get("ohlcv_1h") # Apenas com dados válidos
-                ]
-                
-                # --- Parâmetros de Gerenciamento de Risco e Alocação (AJUSTE FINO É CRUCIAL) ---
-                # Risco total do portfólio para este ciclo (ex: não usar mais que 50% do capital total em novas posições)
-                MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE = 0.75 # Usar até 75% do 'amount'
-                
-                # Risco por ativo individual (percentual do 'amount' TOTAL)
-                MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL = 0.15 # Ex: máx 15% do capital total em UM ativo
-                MIN_ALLOCATION_PER_ASSET_PCT_OF_TOTAL = 0.02 # Ex: mín 2% do capital total para valer a pena
-
-                MIN_USD_PER_ORDER = 25.00     # Mínimo de USD por ordem
-                MAX_CONCURRENT_POSITIONS = 4  # Máximo de posições abertas simultaneamente
-                
-                # Limiares de Confiança da RNN
-                CONFIDENCE_STRONG_BUY = 0.80 # Confiança para considerar uma alocação maior
-                CONFIDENCE_MODERATE_BUY = 0.65 # Confiança mínima para considerar uma alocação base
-                CONFIDENCE_WEAK_BUY = 0.55    # Confiança para uma alocação muito pequena ou nenhuma
-
-                allocated_capital_this_cycle = 0.0
-                
-                # Para diversificação, podemos querer limitar a avaliação ou dar pesos
-                # random.shuffle(candidate_assets) 
-
-                for asset_key in candidate_assets:
-                    if len(investment_decisions) >= MAX_CONCURRENT_POSITIONS:
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de {MAX_CONCURRENT_POSITIONS} posições concorrentes atingido.")
-                        break
-                    
-                    # Verifica se já usamos o capital máximo para o ciclo
-                    if allocated_capital_this_cycle >= amount * MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE:
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de capital para o ciclo ({MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE*100}%) atingido.")
-                        break
-
-                    asset_symbol = asset_key.replace("_", "/")
-                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN avaliando ativo: {asset_symbol}")
-                    
-                    signal, confidence_prob = await predictor.predict_for_asset(
-                        crypto_data_for_rnn[asset_key], 
-                        loop=loop
-                    )
-
-                    if signal == 1 and confidence_prob is not None: # Sinal de COMPRA e confiança válida
-                        target_usd_allocation = 0.0
-
-                        if confidence_prob >= CONFIDENCE_STRONG_BUY:
-                            # Alocação maior para sinais fortes
-                            # Ex: entre 60% e 100% da alocação máxima permitida por ativo
-                            alloc_factor = 0.6 + 0.4 * ((confidence_prob - CONFIDENCE_STRONG_BUY) / (1.0 - CONFIDENCE_STRONG_BUY + 1e-6))
-                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
-                            reason = f"RNN STRONG BUY signal (Conf: {confidence_prob:.3f})"
-                        elif confidence_prob >= CONFIDENCE_MODERATE_BUY:
-                            # Alocação base para sinais moderados
-                            # Ex: entre 30% e 60% da alocação máxima permitida por ativo
-                            alloc_factor = 0.3 + 0.3 * ((confidence_prob - CONFIDENCE_MODERATE_BUY) / (CONFIDENCE_STRONG_BUY - CONFIDENCE_MODERATE_BUY + 1e-6))
-                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
-                            reason = f"RNN MODERATE BUY signal (Conf: {confidence_prob:.3f})"
-                        elif confidence_prob >= CONFIDENCE_WEAK_BUY:
-                             # Alocação pequena para sinais fracos (ou nenhuma)
-                            alloc_factor = 0.1 + 0.2 * ((confidence_prob - CONFIDENCE_WEAK_BUY) / (CONFIDENCE_MODERATE_BUY - CONFIDENCE_WEAK_BUY + 1e-6))
-                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
-                            reason = f"RNN WEAK BUY signal (Conf: {confidence_prob:.3f})"
-                        else:
-                            logger.info(f"BG TASK [{rnn_tx_id}]: Sinal COMPRA para {asset_symbol} mas confiança ({confidence_prob:.3f}) abaixo do limiar WEAK_BUY ({CONFIDENCE_WEAK_BUY}). Pulando.")
-                            continue
-                        
-                        # Garantir que a alocação não seja menor que a mínima permitida (percentual do total)
-                        target_usd_allocation = max(target_usd_allocation, amount * MIN_ALLOCATION_PER_ASSET_PCT_OF_TOTAL)
-
-                        # Garantir que não exceda o capital restante disponível neste CICLO
-                        capital_left_for_this_cycle = (amount * MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE) - allocated_capital_this_cycle
-                        actual_usd_allocation = min(target_usd_allocation, capital_left_for_this_cycle)
-                        
-                        # Garantir que a ordem mínima em USD seja respeitada
-                        if actual_usd_allocation < MIN_USD_PER_ORDER:
-                            logger.info(f"BG TASK [{rnn_tx_id}]: Alocação final ({actual_usd_allocation:.2f}) para {asset_symbol} abaixo do mínimo de ordem ({MIN_USD_PER_ORDER}). Pulando.")
-                            continue
-                        
-                        # Adicionar à lista de decisões
-                        investment_decisions.append({
-                            "asset_id": asset_symbol, "type": "CRYPTO", "action": "BUY",
-                            "target_usd_amount": round(actual_usd_allocation, 2),
-                            "rnn_confidence": round(confidence_prob, 4),
-                            "reasoning": reason
-                        })
-                        allocated_capital_this_cycle += round(actual_usd_allocation, 2)
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Decisão: COMPRAR {actual_usd_allocation:.2f} USD de {asset_symbol}. {reason}")
-                    
-                    # ... (restante da lógica para signal 0 ou None) ...
-        except Exception as e: # Captura exceções da lógica da RNN
-                logger.error(f"BG TASK [{rnn_tx_id}]: Erro CRÍTICO durante análise/predição RNN: {str(e)}", exc_info=True)
-                rnn_analysis_success = False # Marca que a análise RNN falhou
-                error_details += f"Critical RNN analysis/prediction error: {str(e)}; "
-
-
-        total_usd_allocated_by_rnn = allocated_capital_this_cycle 
-      
-      
-        
-
-        if not predictor or not predictor.model: # Verifica se o preditor e o modelo interno existem
-            logger.warning(f"BG TASK [{rnn_tx_id}]: Instância do preditor RNN não disponível ou modelo interno não carregado. Pulando análise RNN.")
-            rnn_analysis_success = False 
-            error_details += "RNN model/predictor not available for prediction; "
-        else:
-            try:
-                # ... (lógica de iteração sobre `candidate_assets` e chamada a `predictor.predict_for_asset` como na resposta anterior)
-                # ... (lógica de alocação de capital como na resposta anterior)
-                # Garantir que toda essa lógica está dentro deste bloco 'else'
-                crypto_data_for_rnn = market_data_results.get("crypto", {})
-                candidate_assets = [
-                    asset_key for asset_key, data in crypto_data_for_rnn.items() 
-                    if data and not data.get("error") and data.get("ohlcv_1h")
-                ]
-                
-                MAX_RISK_PER_ASSET_PCT = 0.05 
-                MIN_USD_PER_ORDER = 20.00    
-                MAX_CONCURRENT_POSITIONS = 5 
-                CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC = 0.85 
-                CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC = 0.60 
-                BASE_ALLOCATION_PCT_OF_TOTAL_CAPITAL = 0.10 
-
-                allocated_capital_this_cycle = 0.0
-                
-                for asset_key in candidate_assets:
-                    if len(investment_decisions) >= MAX_CONCURRENT_POSITIONS:
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de posições concorrentes ({MAX_CONCURRENT_POSITIONS}) atingido.")
-                        break
-                    if allocated_capital_this_cycle >= amount * 0.90:
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de capital do ciclo atingido.")
-                        break
-
-                    asset_symbol = asset_key.replace("_", "/")
-                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN avaliando ativo: {asset_symbol}")
-                    
-                    signal, confidence_prob = await predictor.predict_for_asset(
-                        crypto_data_for_rnn[asset_key], 
-                        loop=loop
-                        # window_size e expected_features serão os defaults de rnn_predictor.py
-                        # ou podem ser passados explicitamente se você quiser variar por ativo
-                    )
-
-                    if signal == 1: 
-                        if confidence_prob is None or confidence_prob < CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC:
-                            logger.info(f"BG TASK [{rnn_tx_id}]: Sinal COMPRA para {asset_symbol} mas confiança ({confidence_prob}) abaixo do mínimo {CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC}. Pulando.")
-                            continue
-
-                        confidence_factor = 0.5 
-                        if confidence_prob >= CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC:
-                            confidence_factor = 1.0
-                        elif confidence_prob > CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC: 
-                            confidence_factor = 0.5 + 0.5 * (
-                                (confidence_prob - CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC) /
-                                (CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC - CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC)
-                            )
-                        
-                        potential_usd_allocation = amount * BASE_ALLOCATION_PCT_OF_TOTAL_CAPITAL * confidence_factor
-                        potential_usd_allocation = min(potential_usd_allocation, amount * MAX_RISK_PER_ASSET_PCT)
-                        remaining_capital_for_cycle = amount - allocated_capital_this_cycle # Recalcula a cada iteração
-                        actual_usd_allocation = min(potential_usd_allocation, remaining_capital_for_cycle)
-
-                        if actual_usd_allocation < MIN_USD_PER_ORDER:
-                            logger.info(f"BG TASK [{rnn_tx_id}]: Alocação calculada ({actual_usd_allocation:.2f}) para {asset_symbol} abaixo do mínimo ({MIN_USD_PER_ORDER}). Pulando.")
-                            continue
-                        
-                        investment_decisions.append({
-                            "asset_id": asset_symbol, "type": "CRYPTO", "action": "BUY",
-                            "target_usd_amount": round(actual_usd_allocation, 2),
-                            "rnn_confidence": round(confidence_prob, 4) if confidence_prob is not None else None,
-                            "reasoning": f"RNN signal BUY for {asset_symbol} with confidence {confidence_prob:.2f}"
-                        })
-                        allocated_capital_this_cycle += round(actual_usd_allocation, 2)
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Decisão: COMPRAR {actual_usd_allocation:.2f} USD de {asset_symbol} (Conf: {confidence_prob:.2f})")
-                    
-                    elif signal == 0: 
-                        logger.info(f"BG TASK [{rnn_tx_id}]: RNN sinal NÃO COMPRAR para {asset_symbol} (Conf: {confidence_prob:.2f if confidence_prob is not None else 'N/A'})")
-                    else: 
-                        logger.warning(f"BG TASK [{rnn_tx_id}]: RNN não gerou sinal para {asset_symbol}.")
-                
-                if not investment_decisions:
-                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN não gerou decisões de COMPRA válidas após avaliação e alocação.")
-            
-            except Exception as e: # Captura exceções da lógica da RNN
-                logger.error(f"BG TASK [{rnn_tx_id}]: Erro CRÍTICO durante análise/predição RNN: {str(e)}", exc_info=True)
-                rnn_analysis_success = False # Marca que a análise RNN falhou
-                error_details += f"Critical RNN analysis/prediction error: {str(e)}; "
-        
-        if not rnn_analysis_success: # Se a flag foi setada para False
-            final_status = "failed_rnn_analysis" 
-        
-        transactions_db[rnn_tx_id]["rnn_decisions"] = investment_decisions
-    
-    total_usd_allocated_by_rnn = allocated_capital_this_cycle 
-    transactions_db[rnn_tx_id]["status_details"] = "Preparing to execute orders"
-
-   
-   
-
-
-
-
-
-
-
-    # =========================================================================
-    # 3. EXECUÇÃO DE ORDENS (Só executa se a RNN não falhou e gerou ordens)
-    # =========================================================================
-    executed_trades_info: List[Dict[str, Any]] = []
-    current_portfolio_value = 0.0 # Valor dos ativos comprados, baseado no custo
-    cash_remaining_after_execution = amount # Começa com todo o montante
-    
-    if final_status == "completed" and investment_decisions and exchange:
-        logger.info(f"BG TASK [{rnn_tx_id}]: Executando {len(investment_decisions)} ordens...")
-        transactions_db[rnn_tx_id]["status_details"] = "Executing investment orders"
-        order_execution_overall_success = True
-
-        # Placeholder para LÓGICA REAL DE EXECUÇÃO DE ORDENS (CREATE_ORDER_PLACEHOLDER)
-        # Esta seção precisa ser preenchida com:
-        # 1. Iterar sobre `investment_decisions`.
-        # 2. Para cada decisão de "BUY":
-        #    a. Determinar o símbolo correto na exchange (ex: "BTC/USDT").
-        #    b. Obter o preço atual (ticker) para calcular a quantidade de ativo a comprar.
-        #       `amount_of_asset = target_usd_amount / current_price_of_asset`
-        #    c. Considerar saldo disponível na exchange (se estiver gerenciando isso).
-        #    d. Criar a ordem via `await exchange.create_market_buy_order(symbol, amount_of_asset)`
-        #       ou `create_limit_buy_order(symbol, amount_of_asset, limit_price)`.
-        #       Para ordens limite, a RNN precisaria fornecer o `limit_price`.
-        #    e. Tratar respostas da exchange (sucesso, falha, ID da ordem).
-        #       `ccxt.InsufficientFunds`, `ccxt.InvalidOrder`, etc.
-        #    f. Armazenar detalhes da ordem em `executed_trades_info`:
-        #       { "asset_id": ..., "order_id_exchange": ..., "type": "market/limit", "side": "buy",
-        #         "requested_usd_amount": ..., "asset_quantity_ordered": ..., 
-        #         "status_from_exchange": ..., "filled_quantity": ..., "average_fill_price": ...,
-        #         "cost_in_usd": ..., "fees_paid": ..., "timestamp": ... }
-        #    g. Atualizar `current_portfolio_value` com o `cost_in_usd` da ordem preenchida.
-        #    h. Deduzir `cost_in_usd` de `cash_remaining_after_execution`.
-        # 3. Para decisões de "SELL" (se sua RNN gerar):
-        #    a. Verificar se você possui o ativo (requer gerenciamento de portfólio).
-        #    b. Criar ordem de venda.
-        #    c. Atualizar `current_portfolio_value` e `cash_remaining_after_execution`.
-
-        # Simulação atual:
-        for decision in investment_decisions:
-            if decision.get("action") == "BUY" and decision.get("type") == "CRYPTO":
-                asset_symbol = decision["asset_id"]
-                usd_to_spend = decision["target_usd_amount"]
-                
-                # Simular pequena chance de falha na ordem
-                if random.random() < 0.05:
-                    logger.warning(f"BG TASK [{rnn_tx_id}]: Falha simulada ao executar ordem para {asset_symbol}.")
-                    executed_trades_info.append({
-                        "asset_id": asset_symbol, "status": "failed_simulated", 
-                        "requested_usd_amount": usd_to_spend, "error": "Simulated exchange rejection"
-                    })
-                    order_execution_overall_success = False # Marca que pelo menos uma falhou
-                    continue # Pula para a próxima decisão
-
-                # Simular slippage e custo
-                simulated_cost = usd_to_spend * random.uniform(0.995, 1.005) # +/- 0.5% slippage
-                
-                # Garantir que não estamos gastando mais do que o caixa restante
-                if simulated_cost > cash_remaining_after_execution:
-                    simulated_cost = cash_remaining_after_execution # Gasta apenas o que tem
-                    if simulated_cost < 1: # Se não há quase nada, não faz a ordem
-                        logger.info(f"BG TASK [{rnn_tx_id}]: Saldo insuficiente ({cash_remaining_after_execution:.2f}) para ordem de {asset_symbol}, pulando.")
-                        continue
-
-
-                if simulated_cost > 0:
-                    current_portfolio_value += simulated_cost
-                    cash_remaining_after_execution -= simulated_cost
-                    executed_trades_info.append({
-                        "asset_id": asset_symbol, "order_id_exchange": f"sim_ord_{uuid.uuid4()}",
-                        "type": "market", "side": "buy",
-                        "requested_usd_amount": usd_to_spend,
-                        "status_from_exchange": "filled", "cost_in_usd": round(simulated_cost, 2),
-                        "timestamp": datetime.utcnow().isoformat()
-                    })
-                    logger.info(f"BG TASK [{rnn_tx_id}]: Ordem simulada para {asset_symbol} (custo: {simulated_cost:.2f} USD) preenchida.")
-        
-        await asyncio.sleep(random.uniform(1, 2) * len(investment_decisions) if investment_decisions else 1)
-
-        if not order_execution_overall_success:
-            error_details += "One or more orders failed during execution; "
-            # Decida se isso torna o status final 'failed_order_execution' ou se 'completed_with_partial_failure'
-            # final_status = "completed_with_partial_failure" # Exemplo de um novo status
-    
-    elif not exchange and investment_decisions:
-        logger.warning(f"BG TASK [{rnn_tx_id}]: Decisões de investimento geradas, mas a exchange não está disponível para execução.")
-        error_details += "Exchange not available for order execution; "
-        final_status = "failed_order_execution" # Se a execução é crítica
-        cash_remaining_after_execution = amount # Nada foi gasto
-    
-    transactions_db[rnn_tx_id]["executed_trades"] = executed_trades_info
-    transactions_db[rnn_tx_id]["cash_after_execution"] = round(cash_remaining_after_execution, 2)
-    transactions_db[rnn_tx_id]["portfolio_value_after_execution"] = round(current_portfolio_value, 2)
-    
-
-    # =========================================================================
-    # 4. SIMULAÇÃO DO PERÍODO DE INVESTIMENTO E CÁLCULO DE LUCRO/PERDA (Só se não houve falha crítica antes)
-    # =========================================================================
-    value_of_investments_at_eod = current_portfolio_value # Começa com o valor de custo
-
-    if final_status == "completed": # Ou "completed_with_partial_failure"
-        transactions_db[rnn_tx_id]["status_details"] = "Simulating EOD valuation"
-        logger.info(f"BG TASK [{rnn_tx_id}]: Simulando valorização do portfólio no final do dia...")
-        await asyncio.sleep(random.uniform(3, 7)) 
-
-        if current_portfolio_value > 0:
-            # Simular mudança de valor do portfólio. A meta de 4.2% é sobre o capital INVESTIDO.
-            # O lucro/perda é aplicado ao `current_portfolio_value` (o que foi efetivamente comprado).
-            daily_return_factor = 0.042 # A meta
-            simulated_performance_factor = random.uniform(0.7, 1.3) # Variação em torno da meta (pode ser prejuízo)
-            # Para ser mais realista, o fator de performance deveria ser algo como:
-            # random.uniform(-0.05, 0.08) -> -5% a +8% de retorno diário sobre o investido (ainda alto)
-            # E não diretamente ligado à meta de 4.2%
-            
-            # Ajuste para uma simulação de retorno mais plausível (ainda agressiva)
-            # Suponha que o retorno diário real possa variar de -3% a +5% sobre o investido
-            actual_daily_return_on_portfolio = random.uniform(-0.03, 0.05) 
-            
-            profit_or_loss_on_portfolio = current_portfolio_value * actual_daily_return_on_portfolio
-            value_of_investments_at_eod = current_portfolio_value + profit_or_loss_on_portfolio
-            logger.info(f"BG TASK [{rnn_tx_id}]: Portfólio inicial: {current_portfolio_value:.2f}, Retorno simulado: {actual_daily_return_on_portfolio*100:.2f}%, "
-                        f"Lucro/Prejuízo no portfólio: {profit_or_loss_on_portfolio:.2f}, Valor EOD do portfólio: {value_of_investments_at_eod:.2f}")
-        else: 
-            logger.info(f"BG TASK [{rnn_tx_id}]: Nenhum portfólio para valorizar no EOD (nada foi comprado).")
-            value_of_investments_at_eod = 0.0
-        
-        # O calculated_final_amount é o valor dos investimentos liquidados + o caixa que não foi usado
-        calculated_final_amount = value_of_investments_at_eod + cash_remaining_after_execution
-    
-    else: # Se houve falha antes, o valor final é o que sobrou após a falha
-        calculated_final_amount = cash_remaining_after_execution + current_portfolio_value # current_portfolio_value pode ser 0 ou parcial
-        logger.warning(f"BG TASK [{rnn_tx_id}]: Ciclo de investimento não concluído normalmente ({final_status}). Valor final baseado no estado atual.")
-
-    transactions_db[rnn_tx_id]["eod_portfolio_value_simulated"] = round(value_of_investments_at_eod, 2)
-    transactions_db[rnn_tx_id]["final_calculated_amount"] = round(calculated_final_amount, 2)
-
-
-    # =========================================================================
-    # 5. TOKENIZAÇÃO / REGISTRO DA OPERAÇÃO (Só se não houve falha crítica antes)
-    # =========================================================================
-    if final_status not in ["failed_config", "failed_market_data", "failed_rnn_analysis"]: # Prossegue se ao menos tentou executar
-        transactions_db[rnn_tx_id]["status_details"] = "Finalizing transaction log (tokenization)"
-        logger.info(f"BG TASK [{rnn_tx_id}]: Registrando (tokenizando) operação detalhadamente...")
-        # Placeholder para LÓGICA REAL DE TOKENIZAÇÃO (TOKENIZATION_PLACEHOLDER)
-        # 1. Coletar todos os dados relevantes da transação de `transactions_db[rnn_tx_id]`
-        #    (market_data_collected, rnn_decisions, executed_trades, eod_portfolio_value_simulated, etc.)
-        # 2. Se for usar blockchain:
-        #    a. Preparar os dados para um contrato inteligente.
-        #    b. Interagir com o contrato (ex: web3.py para Ethereum).
-        #    c. Armazenar o hash da transação da blockchain.
-        # 3. Se for um registro interno avançado:
-        #    a. Assinar digitalmente os dados da transação.
-        #    b. Armazenar em um sistema de log imutável ou banco de dados com auditoria.
-        
-        # Simulação atual (hash dos dados da transação):
-        transaction_data_for_hash = {
-            "rnn_tx_id": rnn_tx_id, "client_id": client_id, "initial_amount": amount,
-            "final_amount_calculated": calculated_final_amount,
-            # Incluir resumos ou hashes dos dados coletados para não tornar o hash gigante
-            "market_data_summary_keys": list(transactions_db[rnn_tx_id].get("market_data_collected", {}).keys()),
-            "rnn_decisions_count": len(transactions_db[rnn_tx_id].get("rnn_decisions", [])),
-            "executed_trades_count": len(transactions_db[rnn_tx_id].get("executed_trades", [])),
-            "eod_portfolio_value": transactions_db[rnn_tx_id].get("eod_portfolio_value_simulated"),
-            "timestamp": datetime.utcnow().isoformat()
-        }
-        ordered_tx_data_str = json.dumps(transaction_data_for_hash, sort_keys=True)
-        proof_token_hash = hashlib.sha256(ordered_tx_data_str.encode('utf-8')).hexdigest()
-        
-        transactions_db[rnn_tx_id]["proof_of_operation_token"] = proof_token_hash
-        transactions_db[rnn_tx_id]["tokenization_method"] = "internal_summary_hash_proof"
-        await asyncio.sleep(0.5) # Simula tempo de escrita/hash
-        logger.info(f"BG TASK [{rnn_tx_id}]: Operação registrada. Prova (hash): {proof_token_hash[:10]}...")
-
-
-    # =========================================================================
-    # 6. PREPARAR E ENVIAR CALLBACK PARA AIBANK
-    # =========================================================================
-    if exchange and hasattr(exchange, 'close'):
-        try:
-            await exchange.close()
-            logger.info(f"BG TASK [{rnn_tx_id}]: Conexão ccxt fechada.")
-        except Exception as e_close: # Especificar o tipo de exceção se souber
-            logger.warning(f"BG TASK [{rnn_tx_id}]: Erro ao fechar conexão ccxt: {str(e_close)}")
-
-    if not AIBANK_CALLBACK_URL or not CALLBACK_SHARED_SECRET:
-        logger.error(f"BG TASK [{rnn_tx_id}]: Configuração de callback ausente. Não é possível notificar o AIBank.")
-        transactions_db[rnn_tx_id]["callback_status"] = "config_missing_critical"
-        return 
-
-    # Certifique-se que `final_status` reflete o estado real da operação
-    # Se `error_details` não estiver vazio e `final_status` ainda for "completed", ajuste-o
-    if error_details and final_status == "completed":
-        final_status = "completed_with_warnings" # Ou um status mais apropriado
-
-    callback_payload_data = InvestmentResultPayload(
-        rnn_transaction_id=rnn_tx_id, aibank_transaction_token=aibank_tx_token, client_id=client_id,
-        initial_amount=amount, final_amount=round(calculated_final_amount, 2), # Arredonda para 2 casas decimais
-        profit_loss=round(calculated_final_amount - amount, 2),
-        status=final_status, timestamp=datetime.utcnow(),
-        details=error_details if error_details else "Investment cycle processed."
-    )
-    payload_json_str = callback_payload_data.model_dump_json() # Garante que está usando a string serializada
-    
-    signature = hmac.new(CALLBACK_SHARED_SECRET.encode('utf-8'), payload_json_str.encode('utf-8'), hashlib.sha256).hexdigest()
-    headers = {'Content-Type': 'application/json', 'X-RNN-Signature': signature}
-
-    logger.info(f"BG TASK [{rnn_tx_id}]: Enviando callback para AIBank ({AIBANK_CALLBACK_URL}) com status final '{final_status}'. Payload: {payload_json_str}")
-    transactions_db[rnn_tx_id]["callback_status"] = "sending"
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client: # Timeout global para o cliente
-            response = await client.post(AIBANK_CALLBACK_URL, content=payload_json_str, headers=headers)
-            response.raise_for_status()
-            logger.info(f"BG TASK [{rnn_tx_id}]: Callback para AIBank enviado com sucesso. Resposta: {response.status_code}")
-            transactions_db[rnn_tx_id]["callback_status"] = f"sent_success_{response.status_code}"
-    except httpx.RequestError as e_req:
-        logger.error(f"BG TASK [{rnn_tx_id}]: Erro de REDE ao enviar callback para AIBank: {e_req}")
-        transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_network_error"
-    except httpx.HTTPStatusError as e_http:
-        logger.error(f"BG TASK [{rnn_tx_id}]: Erro HTTP do AIBank ao receber callback: {e_http.response.status_code} - {e_http.response.text[:200]}")
-        transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_http_error_{e_http.response.status_code}"
-    except Exception as e_cb_final:
-        logger.error(f"BG TASK [{rnn_tx_id}]: Erro INESPERADO ao enviar callback: {e_cb_final}", exc_info=True)
-        transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_unknown_error"
-
-
-import asyncio 
-import random  
-
-    
-
-# --- Endpoints da API ---
-@app.post("/api/invest",
-          response_model=InvestmentResponse,
-          dependencies=[Depends(verify_aibank_key)])
-async def initiate_investment(
-    request_data: InvestmentRequest,
-    background_tasks: BackgroundTasks
-):
-    """
-    Endpoint para o AIBank iniciar um ciclo de investimento.
-    Responde rapidamente e executa a lógica pesada em background.
-    """
-    logger.info(f"Requisição de investimento recebida para client_id: {request_data.client_id}, "
-                f"amount: {request_data.amount}, aibank_tx_token: {request_data.aibank_transaction_token}")
-
-    rnn_tx_id = str(uuid.uuid4())
-
-    # Armazena informações iniciais da transação DB real para ser mais robusto
-    transactions_db[rnn_tx_id] = {
-        "rnn_transaction_id": rnn_tx_id,
-        "aibank_transaction_token": request_data.aibank_transaction_token,
-        "client_id": request_data.client_id,
-        "initial_amount": request_data.amount,
-        "status": "pending_background_processing",
-        "received_at": datetime.utcnow().isoformat(),
-        "callback_status": "not_sent_yet"
-    }
-
-    # Adiciona a tarefa de longa duração ao background
-    background_tasks.add_task(
-        execute_investment_strategy_background,
-        rnn_tx_id,
-        request_data.client_id,
-        request_data.amount,
-        request_data.aibank_transaction_token
-    )
-
-    logger.info(f"Estratégia de investimento para rnn_tx_id: {rnn_tx_id} agendada para execução em background.")
-    return InvestmentResponse(
-        status="pending",
-        message="Investment request received and is being processed in the background. Await callback for results.",
-        rnn_transaction_id=rnn_tx_id
-    )
-
-@app.get("/api/transaction_status/{rnn_tx_id}", response_class=JSONResponse)
-async def get_transaction_status(rnn_tx_id: str):
-    """ Endpoint para verificar o status de uma transação (para debug/admin) """
-    transaction = transactions_db.get(rnn_tx_id)
-    if not transaction:
-        raise HTTPException(status_code=404, detail="Transaction not found")
-    return transaction
-
-
-# --- Dashboard (Existente, adaptado) ---
-# Setup para arquivos estáticos e templates
-
-try:
-    app.mount("/static", StaticFiles(directory="rnn/static"), name="static")
-    templates = Environment(loader=FileSystemLoader("rnn/templates"))
-except RuntimeError as e:
-    logger.warning(f"Não foi possível montar /static ou carregar templates: {e}. O dashboard pode não funcionar.")
-    templates = None # Para evitar erros se o loader falhar
-
-@app.get("/", response_class=HTMLResponse)
-async def index(request: Request):
-    if not templates:
-        return HTMLResponse("<html><body><h1>Dashboard indisponível</h1><p>Configuração de templates/estáticos falhou.</p></body></html>")
-    
-    agora = datetime.now()
-    agentes_simulados = [
-        # dados de agentes ...
-    ]
-    template = templates.get_template("index.html")
-    # Adicionar transações recentes ao contexto do template
-    recent_txs = list(transactions_db.values())[-5:] # Últimas 5 transações
-    return HTMLResponse(template.render(request=request, agentes=agentes_simulados, transactions=recent_txs))
-
-# --- Imports para Background Task ---
-import asyncio
-import random
-
-# Função de logger dummy 
-# class DummyLogger:
-#     def info(self, msg, *args, **kwargs): print(f"INFO: {msg}")
-#     def warning(self, msg, *args, **kwargs): print(f"WARNING: {msg}")
-#     def error(self, msg, *args, **kwargs): print(f"ERROR: {msg}", kwargs.get('exc_info'))
-
-# if __name__ == "__main__": # Para teste local
-#     # logger = DummyLogger() # se não tiver get_logger()
-#     # Configuração das variáveis de ambiente para teste local
-#     os.environ["AIBANK_API_KEY"] = "test_aibank_key_from_rnn_server"
-#     os.environ["AIBANK_CALLBACK_URL"] = "http://localhost:8001/api/rnn_investment_result_callback" # URL do aibank simulado
-#     os.environ["CALLBACK_SHARED_SECRET"] = "super_secret_for_callback_signing"
-#     # import uvicorn
+# rnn/app.py
+from agents.train_rl_portfolio_agent_from_app import model_ppo
+model_ppo() 
+
+import os
+import uuid
+import time
+import hmac
+import hashlib
+import json
+from datetime import datetime, timedelta
+from typing import Dict, Any, List, Optional
+from rnn.app.utils.ccxt_utils import get_ccxt_exchange, fetch_crypto_data
+
+import httpx # Para fazer chamadas HTTP assíncronas (para o callback)
+from fastapi import FastAPI, Request, HTTPException, Depends, Header, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from jinja2 import Environment, FileSystemLoader
+from pydantic import BaseModel, Field
+
+from rnn.app.model.rnn_predictor import RNNModelPredictor
+from rnn.app.utils.logger import get_logger 
+
+
+
+logger = get_logger()
+
+# --- Configuração Inicial e Variáveis de Ambiente (Secrets do Hugging Face) ---
+AIBANK_API_KEY = os.environ.get("AIBANK_API_KEY") # Chave que o aibank usa para chamar esta API RNN
+AIBANK_CALLBACK_URL = os.environ.get("AIBANK_CALLBACK_URL") # URL no aibank para onde esta API RNN enviará o resultado
+CALLBACK_SHARED_SECRET = os.environ.get("CALLBACK_SHARED_SECRET") # Segredo para assinar/verificar o payload do callback
+
+# Chaves para serviços externos 
+MARKET_DATA_API_KEY = os.environ.get("MARKET_DATA_API_KEY")
+EXCHANGE_API_KEY = os.environ.get("EXCHANGE_API_KEY")
+EXCHANGE_API_SECRET = os.environ.get("EXCHANGE_API_SECRET")
+
+if not AIBANK_API_KEY:
+    logger.warning("AIBANK_API_KEY não configurada. A autenticação para /api/invest falhou.")
+if not AIBANK_CALLBACK_URL:
+    logger.warning("AIBANK_CALLBACK_URL não configurada. O callback para o aibank falhou.")
+if not CALLBACK_SHARED_SECRET:
+    logger.warning("CALLBACK_SHARED_SECRET não configurado. A segurança do callback está comprometida.")
+
+
+
+
+app = FastAPI(title="ATCoin Neural Agents - Investment API")
+
+# --- Middlewares ---
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:3000",  # URL desenvolvimento local
+        "http://aibank.app.br",   # URL de produção 
+        "https://*.aibank.app.br", # subdomínios
+        "https://*.hf.space"      # HF Space
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Simulação de Banco de Dados de Transações DEV ---
+# Em produção  MongoDB
+transactions_db: Dict[str, Dict[str, Any]] = {}
+
+# --- Modelos Pydantic ---
+class InvestmentRequest(BaseModel):
+    client_id: str
+    amount: float = Field(..., gt=0) # Garante que o montante seja positivo
+    aibank_transaction_token: str # Token único gerado pelo aibank para rastreamento
+
+class InvestmentResponse(BaseModel):
+    status: str
+    message: str
+    rnn_transaction_id: str # ID da transação this.API
+
+class InvestmentResultPayload(BaseModel): # Payload para o callback para o aibank
+    rnn_transaction_id: str
+    aibank_transaction_token: str
+    client_id: str
+    initial_amount: float
+    final_amount: float
+    profit_loss: float
+    status: str #  "completed", "failed"
+    timestamp: datetime
+    details: str = ""
+
+
+# --- Dependência de Autenticação ---
+async def verify_aibank_key(authorization: str = Header(None)):
+    if not AIBANK_API_KEY: # Checagem se a chave do servidor está configurada
+        logger.error("CRITICAL: AIBANK_API_KEY (server-side) não está configurada nos Secrets.")
+        raise HTTPException(status_code=500, detail="Internal Server Configuration Error: Missing server API Key.")
+
+    if authorization is None:
+        logger.warning("Authorization header ausente na chamada do AIBank.")
+        raise HTTPException(status_code=401, detail="Authorization header is missing")
+
+    parts = authorization.split()
+    if len(parts) != 2 or parts[0].lower() != 'bearer':
+        logger.warning(f"Formato inválido do Authorization header: {authorization}")
+        raise HTTPException(status_code=401, detail="Authorization header must be 'Bearer <token>'")
+
+    token_from_aibank = parts[1]
+    if not hmac.compare_digest(token_from_aibank, AIBANK_API_KEY):
+        logger.warning(f"Chave de API inválida fornecida pelo AIBank. Token: {token_from_aibank[:10]}...")
+        raise HTTPException(status_code=403, detail="Invalid API Key provided by AIBank.")
+    logger.info("API Key do AIBank verificada com sucesso.")
+    return True
+
+
+# --- Lógica de Negócio Principal (Simulada e em Background) ---
+
+
+async def execute_investment_strategy_background(
+    rnn_tx_id: str,
+    client_id: str,
+    amount: float,
+    aibank_tx_token: str
+):
+    logger.info(f"BG TASK [{rnn_tx_id}]: Iniciando estratégia de investimento para cliente {client_id}, valor {amount}.")
+    transactions_db[rnn_tx_id]["status"] = "processing"
+    transactions_db[rnn_tx_id]["status_details"] = "Initializing investment cycle"
+    
+    final_status = "completed"
+    error_details = "" # Acumula mensagens de erro de várias etapas
+    calculated_final_amount = amount 
+
+    # Inicializa a exchange ccxt usando o utilitário
+    # O logger do app.py é passado para ccxt_utils para que os logs apareçam no mesmo stream
+    exchange = await get_ccxt_exchange(logger_instance=logger) # MODIFICADO
+
+    if not exchange:
+        # get_ccxt_exchange já loga o erro. Se a exchange é crucial, podemos falhar aqui.
+        logger.warning(f"BG TASK [{rnn_tx_id}]: Falha ao inicializar a exchange. A estratégia pode não funcionar como esperado para cripto.")
+        # Se as chaves CCXT foram fornecidas no ambiente mas a exchange falhou, considere isso um erro de config.
+        if os.environ.get("CCXT_API_KEY") and os.environ.get("CCXT_API_SECRET"):
+            error_details += "Failed to initialize CCXT exchange despite API keys being present; "
+            final_status = "failed_config" 
+            # (PULAR PARA CALLBACK - veja a seção de tratamento de erro crítico abaixo)
+    
+    # =========================================================================
+    # 1. COLETAR DADOS DE MERCADO
+    # =========================================================================
+    logger.info(f"BG TASK [{rnn_tx_id}]: Coletando dados de mercado...")
+    transactions_db[rnn_tx_id]["status_details"] = "Fetching market data"
+    market_data_results = {"crypto": {}, "stocks": {}, "other": {}}
+    critical_data_fetch_failed = False # Flag para falha crítica na coleta de dados
+
+    # --- Coleta de dados de Cripto via ccxt_utils ---
+    if exchange:
+        crypto_pairs_to_fetch = ["BTC/USDT", "ETH/USDT", "SOL/USDT"] # Mantenha configurável
+        
+        crypto_data, crypto_fetch_ok, crypto_err_msg = await fetch_crypto_data(
+            exchange, 
+            crypto_pairs_to_fetch, 
+            logger_instance=logger
+        )
+        market_data_results["crypto"] = crypto_data
+        if not crypto_fetch_ok:
+            error_details += f"Crypto data fetch issues: {crypto_err_msg}; "
+            # Decida se a falha na coleta de cripto é crítica
+            # Se for, defina critical_data_fetch_failed = True
+            if os.environ.get("CCXT_API_KEY"): # Se esperávamos dados de cripto
+                critical_data_fetch_failed = True 
+                logger.error(f"BG TASK [{rnn_tx_id}]: Falha crítica na coleta de dados de cripto.")
+    else:
+        logger.info(f"BG TASK [{rnn_tx_id}]: Instância da exchange ccxt não disponível. Pulando coleta de dados de cripto.")
+        if os.environ.get("CCXT_API_KEY"): # Se esperávamos dados de cripto mas a exchange não inicializou
+            error_details += "CCXT exchange not initialized, crypto data skipped; "
+            critical_data_fetch_failed = True
+
+
+    # --- Coleta de dados para outros tipos de ativos (ex: Ações com yfinance) ---
+    # (Sua lógica yfinance aqui, se aplicável, similarmente atualizando market_data_results["stocks"])
+    # try:
+    #     import yfinance as yf # Mova para o topo do app.py se for usar
+    #     # ... lógica yfinance ...
+    # except Exception as e_yf:
+    #     logger.warning(f"BG TASK [{rnn_tx_id}]: Falha ao buscar dados de ações com yfinance: {e_yf}")
+    #     error_details += f"YFinance data fetch failed: {str(e_yf)}; "
+    #     # Decida se isso é crítico: critical_data_fetch_failed = True
+
+    market_data_results["other"]['simulated_index_level'] = random.uniform(10000, 15000) # Mantém simulação
+    
+    transactions_db[rnn_tx_id]["market_data_collected"] = market_data_results
+    
+    # --- PONTO DE CHECAGEM PARA FALHA CRÍTICA NA COLETA DE DADOS ---
+    if critical_data_fetch_failed:
+        final_status = "failed_market_data"
+        logger.error(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado falhou criticamente. {error_details}")
+        # Pular para a seção de callback
+        # (A lógica de envio do callback precisa ser alcançada)
+    else:
+        logger.info(f"BG TASK [{rnn_tx_id}]: Coleta de dados de mercado concluída.")
+        transactions_db[rnn_tx_id]["status_details"] = "Processing RNN analysis"
+
+
+
+
+
+    # =========================================================================
+    # 2. ANÁLISE PELA RNN E TOMADA DE DECISÃO
+    # =========================================================================
+    investment_decisions: List[Dict[str, Any]] = [] 
+    total_usd_allocated_by_rnn = 0.0
+    loop = asyncio.get_running_loop() 
+
+    if final_status == "completed": 
+        logger.info(f"BG TASK [{rnn_tx_id}]: Executando análise RNN...")
+        transactions_db[rnn_tx_id]["status_details"] = "Running RNN model"
+        rnn_analysis_success = True
+        
+        # CORRIGIDO: Acessando app.state.rnn_predictor
+        predictor: Optional[RNNModelPredictor] = getattr(app.state, 'rnn_predictor', None)
+
+        try:
+                crypto_data_for_rnn = market_data_results.get("crypto", {})
+                candidate_assets = [
+                    asset_key for asset_key, data in crypto_data_for_rnn.items() 
+                    if data and not data.get("error") and data.get("ohlcv_1h") # Apenas com dados válidos
+                ]
+                
+                # --- Parâmetros de Gerenciamento de Risco e Alocação (AJUSTE FINO É CRUCIAL) ---
+                # Risco total do portfólio para este ciclo (ex: não usar mais que 50% do capital total em novas posições)
+                MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE = 0.75 # Usar até 75% do 'amount'
+                
+                # Risco por ativo individual (percentual do 'amount' TOTAL)
+                MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL = 0.15 # Ex: máx 15% do capital total em UM ativo
+                MIN_ALLOCATION_PER_ASSET_PCT_OF_TOTAL = 0.02 # Ex: mín 2% do capital total para valer a pena
+
+                MIN_USD_PER_ORDER = 25.00     # Mínimo de USD por ordem
+                MAX_CONCURRENT_POSITIONS = 4  # Máximo de posições abertas simultaneamente
+                
+                # Limiares de Confiança da RNN
+                CONFIDENCE_STRONG_BUY = 0.80 # Confiança para considerar uma alocação maior
+                CONFIDENCE_MODERATE_BUY = 0.65 # Confiança mínima para considerar uma alocação base
+                CONFIDENCE_WEAK_BUY = 0.55    # Confiança para uma alocação muito pequena ou nenhuma
+
+                allocated_capital_this_cycle = 0.0
+                
+                # Para diversificação, podemos querer limitar a avaliação ou dar pesos
+                # random.shuffle(candidate_assets) 
+
+                for asset_key in candidate_assets:
+                    if len(investment_decisions) >= MAX_CONCURRENT_POSITIONS:
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de {MAX_CONCURRENT_POSITIONS} posições concorrentes atingido.")
+                        break
+                    
+                    # Verifica se já usamos o capital máximo para o ciclo
+                    if allocated_capital_this_cycle >= amount * MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE:
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de capital para o ciclo ({MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE*100}%) atingido.")
+                        break
+
+                    asset_symbol = asset_key.replace("_", "/")
+                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN avaliando ativo: {asset_symbol}")
+                    
+                    signal, confidence_prob = await predictor.predict_for_asset(
+                        crypto_data_for_rnn[asset_key], 
+                        loop=loop
+                    )
+
+                    if signal == 1 and confidence_prob is not None: # Sinal de COMPRA e confiança válida
+                        target_usd_allocation = 0.0
+
+                        if confidence_prob >= CONFIDENCE_STRONG_BUY:
+                            # Alocação maior para sinais fortes
+                            # Ex: entre 60% e 100% da alocação máxima permitida por ativo
+                            alloc_factor = 0.6 + 0.4 * ((confidence_prob - CONFIDENCE_STRONG_BUY) / (1.0 - CONFIDENCE_STRONG_BUY + 1e-6))
+                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
+                            reason = f"RNN STRONG BUY signal (Conf: {confidence_prob:.3f})"
+                        elif confidence_prob >= CONFIDENCE_MODERATE_BUY:
+                            # Alocação base para sinais moderados
+                            # Ex: entre 30% e 60% da alocação máxima permitida por ativo
+                            alloc_factor = 0.3 + 0.3 * ((confidence_prob - CONFIDENCE_MODERATE_BUY) / (CONFIDENCE_STRONG_BUY - CONFIDENCE_MODERATE_BUY + 1e-6))
+                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
+                            reason = f"RNN MODERATE BUY signal (Conf: {confidence_prob:.3f})"
+                        elif confidence_prob >= CONFIDENCE_WEAK_BUY:
+                             # Alocação pequena para sinais fracos (ou nenhuma)
+                            alloc_factor = 0.1 + 0.2 * ((confidence_prob - CONFIDENCE_WEAK_BUY) / (CONFIDENCE_MODERATE_BUY - CONFIDENCE_WEAK_BUY + 1e-6))
+                            target_usd_allocation = (amount * MAX_ALLOCATION_PER_ASSET_PCT_OF_TOTAL) * alloc_factor
+                            reason = f"RNN WEAK BUY signal (Conf: {confidence_prob:.3f})"
+                        else:
+                            logger.info(f"BG TASK [{rnn_tx_id}]: Sinal COMPRA para {asset_symbol} mas confiança ({confidence_prob:.3f}) abaixo do limiar WEAK_BUY ({CONFIDENCE_WEAK_BUY}). Pulando.")
+                            continue
+                        
+                        # Garantir que a alocação não seja menor que a mínima permitida (percentual do total)
+                        target_usd_allocation = max(target_usd_allocation, amount * MIN_ALLOCATION_PER_ASSET_PCT_OF_TOTAL)
+
+                        # Garantir que não exceda o capital restante disponível neste CICLO
+                        capital_left_for_this_cycle = (amount * MAX_CAPITAL_DEPLOYMENT_PCT_THIS_CYCLE) - allocated_capital_this_cycle
+                        actual_usd_allocation = min(target_usd_allocation, capital_left_for_this_cycle)
+                        
+                        # Garantir que a ordem mínima em USD seja respeitada
+                        if actual_usd_allocation < MIN_USD_PER_ORDER:
+                            logger.info(f"BG TASK [{rnn_tx_id}]: Alocação final ({actual_usd_allocation:.2f}) para {asset_symbol} abaixo do mínimo de ordem ({MIN_USD_PER_ORDER}). Pulando.")
+                            continue
+                        
+                        # Adicionar à lista de decisões
+                        investment_decisions.append({
+                            "asset_id": asset_symbol, "type": "CRYPTO", "action": "BUY",
+                            "target_usd_amount": round(actual_usd_allocation, 2),
+                            "rnn_confidence": round(confidence_prob, 4),
+                            "reasoning": reason
+                        })
+                        allocated_capital_this_cycle += round(actual_usd_allocation, 2)
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Decisão: COMPRAR {actual_usd_allocation:.2f} USD de {asset_symbol}. {reason}")
+                    
+                    # ... (restante da lógica para signal 0 ou None) ...
+        except Exception as e: # Captura exceções da lógica da RNN
+                logger.error(f"BG TASK [{rnn_tx_id}]: Erro CRÍTICO durante análise/predição RNN: {str(e)}", exc_info=True)
+                rnn_analysis_success = False # Marca que a análise RNN falhou
+                error_details += f"Critical RNN analysis/prediction error: {str(e)}; "
+
+
+        total_usd_allocated_by_rnn = allocated_capital_this_cycle 
+      
+      
+        
+
+        if not predictor or not predictor.model: # Verifica se o preditor e o modelo interno existem
+            logger.warning(f"BG TASK [{rnn_tx_id}]: Instância do preditor RNN não disponível ou modelo interno não carregado. Pulando análise RNN.")
+            rnn_analysis_success = False 
+            error_details += "RNN model/predictor not available for prediction; "
+        else:
+            try:
+                # ... (lógica de iteração sobre `candidate_assets` e chamada a `predictor.predict_for_asset` como na resposta anterior)
+                # ... (lógica de alocação de capital como na resposta anterior)
+                # Garantir que toda essa lógica está dentro deste bloco 'else'
+                crypto_data_for_rnn = market_data_results.get("crypto", {})
+                candidate_assets = [
+                    asset_key for asset_key, data in crypto_data_for_rnn.items() 
+                    if data and not data.get("error") and data.get("ohlcv_1h")
+                ]
+                
+                MAX_RISK_PER_ASSET_PCT = 0.05 
+                MIN_USD_PER_ORDER = 20.00    
+                MAX_CONCURRENT_POSITIONS = 5 
+                CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC = 0.85 
+                CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC = 0.60 
+                BASE_ALLOCATION_PCT_OF_TOTAL_CAPITAL = 0.10 
+
+                allocated_capital_this_cycle = 0.0
+                
+                for asset_key in candidate_assets:
+                    if len(investment_decisions) >= MAX_CONCURRENT_POSITIONS:
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de posições concorrentes ({MAX_CONCURRENT_POSITIONS}) atingido.")
+                        break
+                    if allocated_capital_this_cycle >= amount * 0.90:
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Limite de capital do ciclo atingido.")
+                        break
+
+                    asset_symbol = asset_key.replace("_", "/")
+                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN avaliando ativo: {asset_symbol}")
+                    
+                    signal, confidence_prob = await predictor.predict_for_asset(
+                        crypto_data_for_rnn[asset_key], 
+                        loop=loop
+                        # window_size e expected_features serão os defaults de rnn_predictor.py
+                        # ou podem ser passados explicitamente se você quiser variar por ativo
+                    )
+
+                    if signal == 1: 
+                        if confidence_prob is None or confidence_prob < CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC:
+                            logger.info(f"BG TASK [{rnn_tx_id}]: Sinal COMPRA para {asset_symbol} mas confiança ({confidence_prob}) abaixo do mínimo {CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC}. Pulando.")
+                            continue
+
+                        confidence_factor = 0.5 
+                        if confidence_prob >= CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC:
+                            confidence_factor = 1.0
+                        elif confidence_prob > CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC: 
+                            confidence_factor = 0.5 + 0.5 * (
+                                (confidence_prob - CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC) /
+                                (CONFIDENCE_THRESHOLD_FOR_MAX_ALLOC - CONFIDENCE_THRESHOLD_FOR_MIN_ALLOC)
+                            )
+                        
+                        potential_usd_allocation = amount * BASE_ALLOCATION_PCT_OF_TOTAL_CAPITAL * confidence_factor
+                        potential_usd_allocation = min(potential_usd_allocation, amount * MAX_RISK_PER_ASSET_PCT)
+                        remaining_capital_for_cycle = amount - allocated_capital_this_cycle # Recalcula a cada iteração
+                        actual_usd_allocation = min(potential_usd_allocation, remaining_capital_for_cycle)
+
+                        if actual_usd_allocation < MIN_USD_PER_ORDER:
+                            logger.info(f"BG TASK [{rnn_tx_id}]: Alocação calculada ({actual_usd_allocation:.2f}) para {asset_symbol} abaixo do mínimo ({MIN_USD_PER_ORDER}). Pulando.")
+                            continue
+                        
+                        investment_decisions.append({
+                            "asset_id": asset_symbol, "type": "CRYPTO", "action": "BUY",
+                            "target_usd_amount": round(actual_usd_allocation, 2),
+                            "rnn_confidence": round(confidence_prob, 4) if confidence_prob is not None else None,
+                            "reasoning": f"RNN signal BUY for {asset_symbol} with confidence {confidence_prob:.2f}"
+                        })
+                        allocated_capital_this_cycle += round(actual_usd_allocation, 2)
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Decisão: COMPRAR {actual_usd_allocation:.2f} USD de {asset_symbol} (Conf: {confidence_prob:.2f})")
+                    
+                    elif signal == 0: 
+                        logger.info(f"BG TASK [{rnn_tx_id}]: RNN sinal NÃO COMPRAR para {asset_symbol} (Conf: {confidence_prob:.2f if confidence_prob is not None else 'N/A'})")
+                    else: 
+                        logger.warning(f"BG TASK [{rnn_tx_id}]: RNN não gerou sinal para {asset_symbol}.")
+                
+                if not investment_decisions:
+                    logger.info(f"BG TASK [{rnn_tx_id}]: RNN não gerou decisões de COMPRA válidas após avaliação e alocação.")
+            
+            except Exception as e: # Captura exceções da lógica da RNN
+                logger.error(f"BG TASK [{rnn_tx_id}]: Erro CRÍTICO durante análise/predição RNN: {str(e)}", exc_info=True)
+                rnn_analysis_success = False # Marca que a análise RNN falhou
+                error_details += f"Critical RNN analysis/prediction error: {str(e)}; "
+        
+        if not rnn_analysis_success: # Se a flag foi setada para False
+            final_status = "failed_rnn_analysis" 
+        
+        transactions_db[rnn_tx_id]["rnn_decisions"] = investment_decisions
+    
+    total_usd_allocated_by_rnn = allocated_capital_this_cycle 
+    transactions_db[rnn_tx_id]["status_details"] = "Preparing to execute orders"
+
+   
+   
+
+
+
+
+
+
+
+    # =========================================================================
+    # 3. EXECUÇÃO DE ORDENS (Só executa se a RNN não falhou e gerou ordens)
+    # =========================================================================
+    executed_trades_info: List[Dict[str, Any]] = []
+    current_portfolio_value = 0.0 # Valor dos ativos comprados, baseado no custo
+    cash_remaining_after_execution = amount # Começa com todo o montante
+    
+    if final_status == "completed" and investment_decisions and exchange:
+        logger.info(f"BG TASK [{rnn_tx_id}]: Executando {len(investment_decisions)} ordens...")
+        transactions_db[rnn_tx_id]["status_details"] = "Executing investment orders"
+        order_execution_overall_success = True
+
+        # Placeholder para LÓGICA REAL DE EXECUÇÃO DE ORDENS (CREATE_ORDER_PLACEHOLDER)
+        # Esta seção precisa ser preenchida com:
+        # 1. Iterar sobre `investment_decisions`.
+        # 2. Para cada decisão de "BUY":
+        #    a. Determinar o símbolo correto na exchange (ex: "BTC/USDT").
+        #    b. Obter o preço atual (ticker) para calcular a quantidade de ativo a comprar.
+        #       `amount_of_asset = target_usd_amount / current_price_of_asset`
+        #    c. Considerar saldo disponível na exchange (se estiver gerenciando isso).
+        #    d. Criar a ordem via `await exchange.create_market_buy_order(symbol, amount_of_asset)`
+        #       ou `create_limit_buy_order(symbol, amount_of_asset, limit_price)`.
+        #       Para ordens limite, a RNN precisaria fornecer o `limit_price`.
+        #    e. Tratar respostas da exchange (sucesso, falha, ID da ordem).
+        #       `ccxt.InsufficientFunds`, `ccxt.InvalidOrder`, etc.
+        #    f. Armazenar detalhes da ordem em `executed_trades_info`:
+        #       { "asset_id": ..., "order_id_exchange": ..., "type": "market/limit", "side": "buy",
+        #         "requested_usd_amount": ..., "asset_quantity_ordered": ..., 
+        #         "status_from_exchange": ..., "filled_quantity": ..., "average_fill_price": ...,
+        #         "cost_in_usd": ..., "fees_paid": ..., "timestamp": ... }
+        #    g. Atualizar `current_portfolio_value` com o `cost_in_usd` da ordem preenchida.
+        #    h. Deduzir `cost_in_usd` de `cash_remaining_after_execution`.
+        # 3. Para decisões de "SELL" (se sua RNN gerar):
+        #    a. Verificar se você possui o ativo (requer gerenciamento de portfólio).
+        #    b. Criar ordem de venda.
+        #    c. Atualizar `current_portfolio_value` e `cash_remaining_after_execution`.
+
+        # Simulação atual:
+        for decision in investment_decisions:
+            if decision.get("action") == "BUY" and decision.get("type") == "CRYPTO":
+                asset_symbol = decision["asset_id"]
+                usd_to_spend = decision["target_usd_amount"]
+                
+                # Simular pequena chance de falha na ordem
+                if random.random() < 0.05:
+                    logger.warning(f"BG TASK [{rnn_tx_id}]: Falha simulada ao executar ordem para {asset_symbol}.")
+                    executed_trades_info.append({
+                        "asset_id": asset_symbol, "status": "failed_simulated", 
+                        "requested_usd_amount": usd_to_spend, "error": "Simulated exchange rejection"
+                    })
+                    order_execution_overall_success = False # Marca que pelo menos uma falhou
+                    continue # Pula para a próxima decisão
+
+                # Simular slippage e custo
+                simulated_cost = usd_to_spend * random.uniform(0.995, 1.005) # +/- 0.5% slippage
+                
+                # Garantir que não estamos gastando mais do que o caixa restante
+                if simulated_cost > cash_remaining_after_execution:
+                    simulated_cost = cash_remaining_after_execution # Gasta apenas o que tem
+                    if simulated_cost < 1: # Se não há quase nada, não faz a ordem
+                        logger.info(f"BG TASK [{rnn_tx_id}]: Saldo insuficiente ({cash_remaining_after_execution:.2f}) para ordem de {asset_symbol}, pulando.")
+                        continue
+
+
+                if simulated_cost > 0:
+                    current_portfolio_value += simulated_cost
+                    cash_remaining_after_execution -= simulated_cost
+                    executed_trades_info.append({
+                        "asset_id": asset_symbol, "order_id_exchange": f"sim_ord_{uuid.uuid4()}",
+                        "type": "market", "side": "buy",
+                        "requested_usd_amount": usd_to_spend,
+                        "status_from_exchange": "filled", "cost_in_usd": round(simulated_cost, 2),
+                        "timestamp": datetime.utcnow().isoformat()
+                    })
+                    logger.info(f"BG TASK [{rnn_tx_id}]: Ordem simulada para {asset_symbol} (custo: {simulated_cost:.2f} USD) preenchida.")
+        
+        await asyncio.sleep(random.uniform(1, 2) * len(investment_decisions) if investment_decisions else 1)
+
+        if not order_execution_overall_success:
+            error_details += "One or more orders failed during execution; "
+            # Decida se isso torna o status final 'failed_order_execution' ou se 'completed_with_partial_failure'
+            # final_status = "completed_with_partial_failure" # Exemplo de um novo status
+    
+    elif not exchange and investment_decisions:
+        logger.warning(f"BG TASK [{rnn_tx_id}]: Decisões de investimento geradas, mas a exchange não está disponível para execução.")
+        error_details += "Exchange not available for order execution; "
+        final_status = "failed_order_execution" # Se a execução é crítica
+        cash_remaining_after_execution = amount # Nada foi gasto
+    
+    transactions_db[rnn_tx_id]["executed_trades"] = executed_trades_info
+    transactions_db[rnn_tx_id]["cash_after_execution"] = round(cash_remaining_after_execution, 2)
+    transactions_db[rnn_tx_id]["portfolio_value_after_execution"] = round(current_portfolio_value, 2)
+    
+
+    # =========================================================================
+    # 4. SIMULAÇÃO DO PERÍODO DE INVESTIMENTO E CÁLCULO DE LUCRO/PERDA (Só se não houve falha crítica antes)
+    # =========================================================================
+    value_of_investments_at_eod = current_portfolio_value # Começa com o valor de custo
+
+    if final_status == "completed": # Ou "completed_with_partial_failure"
+        transactions_db[rnn_tx_id]["status_details"] = "Simulating EOD valuation"
+        logger.info(f"BG TASK [{rnn_tx_id}]: Simulando valorização do portfólio no final do dia...")
+        await asyncio.sleep(random.uniform(3, 7)) 
+
+        if current_portfolio_value > 0:
+            # Simular mudança de valor do portfólio. A meta de 4.2% é sobre o capital INVESTIDO.
+            # O lucro/perda é aplicado ao `current_portfolio_value` (o que foi efetivamente comprado).
+            daily_return_factor = 0.042 # A meta
+            simulated_performance_factor = random.uniform(0.7, 1.3) # Variação em torno da meta (pode ser prejuízo)
+            # Para ser mais realista, o fator de performance deveria ser algo como:
+            # random.uniform(-0.05, 0.08) -> -5% a +8% de retorno diário sobre o investido (ainda alto)
+            # E não diretamente ligado à meta de 4.2%
+            
+            # Ajuste para uma simulação de retorno mais plausível (ainda agressiva)
+            # Suponha que o retorno diário real possa variar de -3% a +5% sobre o investido
+            actual_daily_return_on_portfolio = random.uniform(-0.03, 0.05) 
+            
+            profit_or_loss_on_portfolio = current_portfolio_value * actual_daily_return_on_portfolio
+            value_of_investments_at_eod = current_portfolio_value + profit_or_loss_on_portfolio
+            logger.info(f"BG TASK [{rnn_tx_id}]: Portfólio inicial: {current_portfolio_value:.2f}, Retorno simulado: {actual_daily_return_on_portfolio*100:.2f}%, "
+                        f"Lucro/Prejuízo no portfólio: {profit_or_loss_on_portfolio:.2f}, Valor EOD do portfólio: {value_of_investments_at_eod:.2f}")
+        else: 
+            logger.info(f"BG TASK [{rnn_tx_id}]: Nenhum portfólio para valorizar no EOD (nada foi comprado).")
+            value_of_investments_at_eod = 0.0
+        
+        # O calculated_final_amount é o valor dos investimentos liquidados + o caixa que não foi usado
+        calculated_final_amount = value_of_investments_at_eod + cash_remaining_after_execution
+    
+    else: # Se houve falha antes, o valor final é o que sobrou após a falha
+        calculated_final_amount = cash_remaining_after_execution + current_portfolio_value # current_portfolio_value pode ser 0 ou parcial
+        logger.warning(f"BG TASK [{rnn_tx_id}]: Ciclo de investimento não concluído normalmente ({final_status}). Valor final baseado no estado atual.")
+
+    transactions_db[rnn_tx_id]["eod_portfolio_value_simulated"] = round(value_of_investments_at_eod, 2)
+    transactions_db[rnn_tx_id]["final_calculated_amount"] = round(calculated_final_amount, 2)
+
+
+    # =========================================================================
+    # 5. TOKENIZAÇÃO / REGISTRO DA OPERAÇÃO (Só se não houve falha crítica antes)
+    # =========================================================================
+    if final_status not in ["failed_config", "failed_market_data", "failed_rnn_analysis"]: # Prossegue se ao menos tentou executar
+        transactions_db[rnn_tx_id]["status_details"] = "Finalizing transaction log (tokenization)"
+        logger.info(f"BG TASK [{rnn_tx_id}]: Registrando (tokenizando) operação detalhadamente...")
+        # Placeholder para LÓGICA REAL DE TOKENIZAÇÃO (TOKENIZATION_PLACEHOLDER)
+        # 1. Coletar todos os dados relevantes da transação de `transactions_db[rnn_tx_id]`
+        #    (market_data_collected, rnn_decisions, executed_trades, eod_portfolio_value_simulated, etc.)
+        # 2. Se for usar blockchain:
+        #    a. Preparar os dados para um contrato inteligente.
+        #    b. Interagir com o contrato (ex: web3.py para Ethereum).
+        #    c. Armazenar o hash da transação da blockchain.
+        # 3. Se for um registro interno avançado:
+        #    a. Assinar digitalmente os dados da transação.
+        #    b. Armazenar em um sistema de log imutável ou banco de dados com auditoria.
+        
+        # Simulação atual (hash dos dados da transação):
+        transaction_data_for_hash = {
+            "rnn_tx_id": rnn_tx_id, "client_id": client_id, "initial_amount": amount,
+            "final_amount_calculated": calculated_final_amount,
+            # Incluir resumos ou hashes dos dados coletados para não tornar o hash gigante
+            "market_data_summary_keys": list(transactions_db[rnn_tx_id].get("market_data_collected", {}).keys()),
+            "rnn_decisions_count": len(transactions_db[rnn_tx_id].get("rnn_decisions", [])),
+            "executed_trades_count": len(transactions_db[rnn_tx_id].get("executed_trades", [])),
+            "eod_portfolio_value": transactions_db[rnn_tx_id].get("eod_portfolio_value_simulated"),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        ordered_tx_data_str = json.dumps(transaction_data_for_hash, sort_keys=True)
+        proof_token_hash = hashlib.sha256(ordered_tx_data_str.encode('utf-8')).hexdigest()
+        
+        transactions_db[rnn_tx_id]["proof_of_operation_token"] = proof_token_hash
+        transactions_db[rnn_tx_id]["tokenization_method"] = "internal_summary_hash_proof"
+        await asyncio.sleep(0.5) # Simula tempo de escrita/hash
+        logger.info(f"BG TASK [{rnn_tx_id}]: Operação registrada. Prova (hash): {proof_token_hash[:10]}...")
+
+
+    # =========================================================================
+    # 6. PREPARAR E ENVIAR CALLBACK PARA AIBANK
+    # =========================================================================
+    if exchange and hasattr(exchange, 'close'):
+        try:
+            await exchange.close()
+            logger.info(f"BG TASK [{rnn_tx_id}]: Conexão ccxt fechada.")
+        except Exception as e_close: # Especificar o tipo de exceção se souber
+            logger.warning(f"BG TASK [{rnn_tx_id}]: Erro ao fechar conexão ccxt: {str(e_close)}")
+
+    if not AIBANK_CALLBACK_URL or not CALLBACK_SHARED_SECRET:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Configuração de callback ausente. Não é possível notificar o AIBank.")
+        transactions_db[rnn_tx_id]["callback_status"] = "config_missing_critical"
+        return 
+
+    # Certifique-se que `final_status` reflete o estado real da operação
+    # Se `error_details` não estiver vazio e `final_status` ainda for "completed", ajuste-o
+    if error_details and final_status == "completed":
+        final_status = "completed_with_warnings" # Ou um status mais apropriado
+
+    callback_payload_data = InvestmentResultPayload(
+        rnn_transaction_id=rnn_tx_id, aibank_transaction_token=aibank_tx_token, client_id=client_id,
+        initial_amount=amount, final_amount=round(calculated_final_amount, 2), # Arredonda para 2 casas decimais
+        profit_loss=round(calculated_final_amount - amount, 2),
+        status=final_status, timestamp=datetime.utcnow(),
+        details=error_details if error_details else "Investment cycle processed."
+    )
+    payload_json_str = callback_payload_data.model_dump_json() # Garante que está usando a string serializada
+    
+    signature = hmac.new(CALLBACK_SHARED_SECRET.encode('utf-8'), payload_json_str.encode('utf-8'), hashlib.sha256).hexdigest()
+    headers = {'Content-Type': 'application/json', 'X-RNN-Signature': signature}
+
+    logger.info(f"BG TASK [{rnn_tx_id}]: Enviando callback para AIBank ({AIBANK_CALLBACK_URL}) com status final '{final_status}'. Payload: {payload_json_str}")
+    transactions_db[rnn_tx_id]["callback_status"] = "sending"
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client: # Timeout global para o cliente
+            response = await client.post(AIBANK_CALLBACK_URL, content=payload_json_str, headers=headers)
+            response.raise_for_status()
+            logger.info(f"BG TASK [{rnn_tx_id}]: Callback para AIBank enviado com sucesso. Resposta: {response.status_code}")
+            transactions_db[rnn_tx_id]["callback_status"] = f"sent_success_{response.status_code}"
+    except httpx.RequestError as e_req:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro de REDE ao enviar callback para AIBank: {e_req}")
+        transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_network_error"
+    except httpx.HTTPStatusError as e_http:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro HTTP do AIBank ao receber callback: {e_http.response.status_code} - {e_http.response.text[:200]}")
+        transactions_db[rnn_tx_id]["callback_status"] = f"sent_failed_http_error_{e_http.response.status_code}"
+    except Exception as e_cb_final:
+        logger.error(f"BG TASK [{rnn_tx_id}]: Erro INESPERADO ao enviar callback: {e_cb_final}", exc_info=True)
+        transactions_db[rnn_tx_id]["callback_status"] = "sent_failed_unknown_error"
+
+
+import asyncio 
+import random  
+
+    
+
+# --- Endpoints da API ---
+@app.post("/api/invest",
+          response_model=InvestmentResponse,
+          dependencies=[Depends(verify_aibank_key)])
+async def initiate_investment(
+    request_data: InvestmentRequest,
+    background_tasks: BackgroundTasks
+):
+    """
+    Endpoint para o AIBank iniciar um ciclo de investimento.
+    Responde rapidamente e executa a lógica pesada em background.
+    """
+    logger.info(f"Requisição de investimento recebida para client_id: {request_data.client_id}, "
+                f"amount: {request_data.amount}, aibank_tx_token: {request_data.aibank_transaction_token}")
+
+    rnn_tx_id = str(uuid.uuid4())
+
+    # Armazena informações iniciais da transação DB real para ser mais robusto
+    transactions_db[rnn_tx_id] = {
+        "rnn_transaction_id": rnn_tx_id,
+        "aibank_transaction_token": request_data.aibank_transaction_token,
+        "client_id": request_data.client_id,
+        "initial_amount": request_data.amount,
+        "status": "pending_background_processing",
+        "received_at": datetime.utcnow().isoformat(),
+        "callback_status": "not_sent_yet"
+    }
+
+    # Adiciona a tarefa de longa duração ao background
+    background_tasks.add_task(
+        execute_investment_strategy_background,
+        rnn_tx_id,
+        request_data.client_id,
+        request_data.amount,
+        request_data.aibank_transaction_token
+    )
+
+    logger.info(f"Estratégia de investimento para rnn_tx_id: {rnn_tx_id} agendada para execução em background.")
+    return InvestmentResponse(
+        status="pending",
+        message="Investment request received and is being processed in the background. Await callback for results.",
+        rnn_transaction_id=rnn_tx_id
+    )
+
+@app.get("/api/transaction_status/{rnn_tx_id}", response_class=JSONResponse)
+async def get_transaction_status(rnn_tx_id: str):
+    """ Endpoint para verificar o status de uma transação (para debug/admin) """
+    transaction = transactions_db.get(rnn_tx_id)
+    if not transaction:
+        raise HTTPException(status_code=404, detail="Transaction not found")
+    return transaction
+
+
+# --- Dashboard (Existente, adaptado) ---
+# Setup para arquivos estáticos e templates
+
+try:
+    app.mount("/static", StaticFiles(directory="rnn/static"), name="static")
+    templates = Environment(loader=FileSystemLoader("rnn/templates"))
+except RuntimeError as e:
+    logger.warning(f"Não foi possível montar /static ou carregar templates: {e}. O dashboard pode não funcionar.")
+    templates = None # Para evitar erros se o loader falhar
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    if not templates:
+        return HTMLResponse("<html><body><h1>Dashboard indisponível</h1><p>Configuração de templates/estáticos falhou.</p></body></html>")
+    
+    agora = datetime.now()
+    agentes_simulados = [
+        # dados de agentes ...
+    ]
+    template = templates.get_template("index.html")
+    # Adicionar transações recentes ao contexto do template
+    recent_txs = list(transactions_db.values())[-5:] # Últimas 5 transações
+    return HTMLResponse(template.render(request=request, agentes=agentes_simulados, transactions=recent_txs))
+
+# --- Imports para Background Task ---
+import asyncio
+import random
+
+# Função de logger dummy 
+# class DummyLogger:
+#     def info(self, msg, *args, **kwargs): print(f"INFO: {msg}")
+#     def warning(self, msg, *args, **kwargs): print(f"WARNING: {msg}")
+#     def error(self, msg, *args, **kwargs): print(f"ERROR: {msg}", kwargs.get('exc_info'))
+
+# if __name__ == "__main__": # Para teste local
+#     # logger = DummyLogger() # se não tiver get_logger()
+#     # Configuração das variáveis de ambiente para teste local
+#     os.environ["AIBANK_API_KEY"] = "test_aibank_key_from_rnn_server"
+#     os.environ["AIBANK_CALLBACK_URL"] = "http://localhost:8001/api/rnn_investment_result_callback" # URL do aibank simulado
+#     os.environ["CALLBACK_SHARED_SECRET"] = "super_secret_for_callback_signing"
+#     # import uvicorn
 #     # uvicorn.run(app, host="0.0.0.0", port=8000)

ppo_deep_portfolio_tensorboard/PPO_1/events.out.tfevents.1750765461.verticalagent-X555LPB.73418.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7789699c28d5982a526892f3fd60ffb5200399a931f6212791cce45905096145
+size 88

scripts/gerador_de_grafico.py

@@ -0,0 +1,139 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+import pandas as pd
+import os
+
+# Criar pasta para salvar os gráficos
+output_dir = "graficos_tese"
+os.makedirs(output_dir, exist_ok=True)
+
+# ============================
+# Figura 1 – Endividamento vs. Inadimplência
+# ============================
+anos = list(range(2005, 2025))
+endividamento = [46, 49, 53, 56, 58, 59, 59.8, 61, 62.5, 64.3, 66.5, 68.1, 70, 71.4, 72.8, 74.3, 76.1, 77.9, 78.5, 78.5]
+inadimplencia = [6.2, 6.4, 6.8, 7.1, 7.3, 7.9, 8.1, 8.4, 9.1, 9.7, 10.3, 10.9, 11.3, 11.7, 12.1, 12.3, 12.4, 12.6, 12.7, 12.7]
+
+fig, ax1 = plt.subplots(figsize=(10, 6))
+ax1.plot(anos, endividamento, 'b-', label='Famílias Endividadas (%)')
+ax2 = ax1.twinx()
+ax2.plot(anos, inadimplencia, 'r-', label='Inadimplência (%)')
+
+ax1.set_xlabel('Ano')
+ax1.set_ylabel('Endividamento (%)', color='blue')
+ax2.set_ylabel('Inadimplência (%)', color='red')
+plt.title('Figura 1 – Evolução da Inadimplência e Endividamento (2005–2024)')
+fig.tight_layout()
+plt.savefig(f"{output_dir}/figura_1.png")
+plt.close()
+
+# ============================
+# Figura 2 – Comparativo Internacional de Spread Bancário
+# ============================
+spread_data = pd.DataFrame({
+    'País': ['Brasil', 'Chile', 'México', 'Índia', 'EUA'],
+    'Spread (%)': [30.2, 12.4, 9.8, 7.1, 3.5]
+})
+plt.figure(figsize=(8, 5))
+sns.barplot(x='Spread (%)', y='País', data=spread_data, palette='flare')
+plt.title('Figura 2 – Spread Bancário por País (2024)')
+plt.tight_layout()
+plt.savefig(f"{output_dir}/figura_2.png")
+plt.close()
+
+# ============================
+# Figura 3 – Comprometimento da Renda com Dívidas
+# ============================
+comp_renda = [18.2, 19.4, 20.6, 21.2, 22.5, 23.1, 24.4, 25.3, 26.7, 27.9, 28.7, 29.4, 30.1, 30.2, 30.5, 30.6, 30.6, 30.6, 30.6, 30.6]
+plt.figure(figsize=(9, 5))
+plt.plot(anos, comp_renda, color='darkgreen', marker='o')
+plt.title('Figura 3 – Comprometimento da Renda Familiar com Dívidas (2005–2024)')
+plt.xlabel('Ano')
+plt.ylabel('Comprometimento (%)')
+plt.grid(True)
+plt.tight_layout()
+plt.savefig(f"{output_dir}/figura_3.png")
+plt.close()
+
+# ============================
+# Figura 4 – SELIC, IPCA e Inadimplência
+# ============================
+df_macro = pd.DataFrame({
+    'Ano': [2010, 2015, 2020, 2022, 2024],
+    'SELIC (%)': [10.75, 14.25, 2.0, 13.75, 10.5],
+    'IPCA (%)': [5.91, 10.67, 4.52, 5.79, 5.8],
+    'Inadimplência (%)': [6.2, 8.1, 11.3, 12.1, 12.7]
+})
+df_macro.set_index('Ano', inplace=True)
+df_macro.plot(marker='o', figsize=(10, 6))
+plt.title('Figura 2 – SELIC, IPCA e Inadimplência no Brasil (2010–2024)')
+plt.ylabel('Percentual (%)')
+plt.grid(True)
+plt.tight_layout()
+plt.savefig(f"{output_dir}/figura_2.png")
+plt.close()
+
+# Você pode adicionar outros gráficos aqui com a mesma estrutura...
+
+print(f"✅ Gráficos salvos com sucesso em: ./{output_dir}/")
+
+
+
+
+import seaborn as sns
+import matplotlib.pyplot as plt
+import pandas as pd
+
+data = pd.DataFrame({
+    'País': ['Brasil', 'Chile', 'México', 'Índia', 'EUA'],
+    'Spread Bancário (%)': [30.2, 12.4, 9.8, 7.1, 3.5]
+})
+
+plt.figure(figsize=(8, 5))
+sns.barplot(x='Spread Bancário (%)', y='País', data=data, palette='flare')
+plt.title('Comparativo de Spread Bancário Internacional (2024)')
+plt.xlabel('Spread (%)')
+plt.tight_layout()
+plt.savefig(f"{output_dir}/figura_2.png")
+
+plt.show()
+plt.close()
+
+
+
+#------
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import os
+
+# Criar diretório para salvar
+output_dir = "graficos_tese"
+os.makedirs(output_dir, exist_ok=True)
+
+# Dados simulados com base em fontes públicas (ajuste conforme necessário)
+anos = list(range(2005, 2024))
+crescimento_credito = [15.2, 17.8, 20.1, 18.5, 16.3, 14.7, 13.2, 12.5, 11.1, 10.4, 9.8, 8.6, 7.9, 6.5, 5.2, 6.1, 7.4, 8.2, 9.1]
+crescimento_pib = [3.2, 4.0, 6.1, 5.2, -0.1, 7.5, 3.9, 1.9, 3.0, 0.5, -3.5, -3.3, 1.3, 1.8, 1.1, -4.1, 4.6, 2.9, 2.3]
+
+# Criar DataFrame
+df = pd.DataFrame({
+    'Ano': anos,
+    'Crescimento do Crédito (%)': crescimento_credito,
+    'Crescimento do PIB (%)': crescimento_pib
+})
+
+# Plotar gráfico
+plt.figure(figsize=(10, 6))
+plt.plot(df['Ano'], df['Crescimento do Crédito (%)'], label='Crescimento do Crédito (%)', marker='o', color='blue')
+plt.plot(df['Ano'], df['Crescimento do PIB (%)'], label='Crescimento do PIB (%)', marker='s', color='green')
+plt.title('Figura 3.1 – Correlação entre Crescimento do Crédito e PIB Real (2005–2023)')
+plt.xlabel('Ano')
+plt.ylabel('Variação (%)')
+plt.grid(True)
+plt.legend()
+plt.tight_layout()
+plt.savefig(f"{output_dir}/figura_3_1.png")
+plt.close()
+
+print(f"✅ Figura 3.1 salva com sucesso em: ./{output_dir}/figura_3_1.png")

scripts/train_rl_portfolio_agent.py

@@ -65,7 +65,7 @@ model_ppo = PPO("MlpLstmPolicy", env, verbose=1, tensorboard_log="./ppo_portfoli
 
 # 4. Treinar o Agente
 print("Iniciando treinamento do agente PPO...")
-model_ppo.learn(total_timesteps=50000, progress_bar=True) # Aumente timesteps para treino real
+model_ppo.learn(total_timesteps=1000000, progress_bar=True) # Aumente timesteps para treino real
 
 # 5. Salvar o Modelo Treinado
 model_ppo.save("rl_models/ppo_deep_portfolio_agent")