Upload 151 files

Commit others PPO

agents/AutomatedLendingPool.sol

@@ -0,0 +1,35 @@
+pragma solidity ^0.8.0;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./CreditOracle.sol";
+
+contract AutomatedLendingPool {
+    IERC20 public immutable token;
+    CreditOracle public immutable creditOracle;
+    
+    struct Loan {
+        uint256 amount;
+        uint256 interest;
+        uint256 dueDate;
+    }
+    
+    mapping(address => Loan) public loans;
+    
+    constructor(address _token, address _creditOracle) {
+        token = IERC20(_token);
+        creditOracle = CreditOracle(_creditOracle);
+    }
+    
+    function requestLoan(uint256 amount) external {
+        require(loans[msg.sender].amount == 0, "Existing loan must be repaid");
+        bytes32 requestId = creditOracle.requestCreditScore(msg.sender);
+        // Lógica para processar o empréstimo com base no score de crédito
+    }
+    
+    function repayLoan() external {
+        Loan storage loan = loans[msg.sender];
+        require(loan.amount > 0, "No active loan");
+        uint256 totalDue = loan.amount + loan.interest;
+        require(token.transferFrom(msg.sender, address(this), totalDue), "Transfer failed");
+        delete loans[msg.sender];
+    }
+}

agents/CreditOracle.sol

@@ -0,0 +1,27 @@
+pragma solidity ^0.8.0;
+import "@chainlink/contracts/src/v0.8/ChainlinkClient.sol";
+
+contract CreditOracle is ChainlinkClient {
+    using Chainlink for Chainlink.Request;
+    
+    address private oracle;
+    bytes32 private jobId;
+    uint256 private fee;
+    
+    constructor() {
+        setPublicChainlinkToken();
+        oracle = 0x...;  // Endereço do nó Chainlink
+        jobId = "...";   // ID do job Chainlink
+        fee = 0.1 * 10 ** 18; // 0.1 LINK
+    }
+    
+    function requestCreditScore(address user) public returns (bytes32 requestId) {
+        Chainlink.Request memory request = buildChainlinkRequest(jobId, address(this), this.fulfill.selector);
+        request.add("userId", uint256(uint160(user)));
+        return sendChainlinkRequestTo(oracle, request, fee);
+    }
+    
+    function fulfill(bytes32 _requestId, uint256 _creditScore) public recordChainlinkFulfillment(_requestId) {
+        // Lógica para atualizar o score de crédito do usuário
+    }
+}

agents/FuzzedDataProvider.js

@@ -0,0 +1,15 @@
+const { FuzzedDataProvider } = require('fuzzing-tools');
+
+function fuzzTest(data) {
+    const fuzz = new FuzzedDataProvider(data);
+    const amount = fuzz.consumeNumber();
+    const recipient = fuzz.consumeAddress();
+
+    try {
+        token.transfer(recipient, amount);
+    } catch (error) {
+        // Registrar e analisar erros
+    }
+}
+
+module.exports = { fuzzTest };

agents/ImeAtcoinGovernance.sol

@@ -0,0 +1,59 @@
+pragma solidity ^0.8.0;
+import "@openzeppelin/contracts/governance/Governor.sol";
+import "@openzeppelin/contracts/governance/extensions/GovernorSettings.sol";
+import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
+import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
+import "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
+import "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";
+
+contract ImeAtcoinGovernance is Governor, GovernorSettings, GovernorCountingSimple, GovernorVotes, GovernorVotesQuorumFraction, GovernorTimelockControl {
+    constructor(IVotes _token, TimelockController _timelock)
+        Governor("ImeAtcoinGovernance")
+        GovernorSettings(1 /* 1 block */, 45818 /* 1 week */, 0)
+        GovernorVotes(_token)
+        GovernorVotesQuorumFraction(4)
+        GovernorTimelockControl(_timelock)
+    {}
+
+    function votingDelay() public view override(IGovernor, GovernorSettings) returns (uint256) {
+        return super.votingDelay();
+    }
+
+    function votingPeriod() public view override(IGovernor, GovernorSettings) returns (uint256) {
+        return super.votingPeriod();
+    }
+
+    function quorum(uint256 blockNumber) public view override(IGovernor, GovernorVotesQuorumFraction) returns (uint256) {
+        return super.quorum(blockNumber);
+    }
+
+    function state(uint256 proposalId) public view override(Governor, GovernorTimelockControl) returns (ProposalState) {
+        return super.state(proposalId);
+    }
+
+    function propose(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, string memory description)
+        public override(Governor, IGovernor) returns (uint256)
+    {
+        return super.propose(targets, values, calldatas, description);
+    }
+
+    function _execute(uint256 proposalId, address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)
+        internal override(Governor, GovernorTimelockControl)
+    {
+        super._execute(proposalId, targets, values, calldatas, descriptionHash);
+    }
+
+    function _cancel(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)
+        internal override(Governor, GovernorTimelockControl) returns (uint256)
+    {
+        return super._cancel(targets, values, calldatas, descriptionHash);
+    }
+
+    function _executor() internal view override(Governor, GovernorTimelockControl) returns (address) {
+        return super._executor();
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view override(Governor, GovernorTimelockControl) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+}

agents/ImeAtcoinPayment.js

@@ -0,0 +1,15 @@
+class ImeAtcoinPayment {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+
+    async createPayment(amount, currency) {
+        // Lógica para criar um pagamento
+    }
+
+    async verifyPayment(paymentId) {
+        // Lógica para verificar um pagamento
+    }
+}
+
+module.exports = ImeAtcoinPayment;

agents/MarketMaker.py

@@ -0,0 +1,30 @@
+import ccxt
+
+class MarketMaker:
+    def __init__(self, exchange, symbol, spread=0.01):
+        self.exchange = ccxt.exchange({'apiKey': '...', 'secret': '...'})
+        self.symbol = symbol
+        self.spread = spread
+
+    def place_orders(self):
+        ticker = self.exchange.fetch_ticker(self.symbol)
+        mid_price = (ticker['bid'] + ticker['ask']) / 2
+
+        bid_price = mid_price * (1 - self.spread / 2)
+        ask_price = mid_price * (1 + self.spread / 2)
+
+        self.exchange.create_limit_buy_order(self.symbol, 1, bid_price)
+        self.exchange.create_limit_sell_order(self.symbol, 1, ask_price)
+
+    def run(self):
+        while True:
+            try:
+                self.place_orders()
+                time.sleep(60)  # Atualiza ordens a cada minuto
+            except Exception as e:
+                print(f"Error: {e}")
+                time.sleep(60)
+
+if __name__ == "__main__":
+    market_maker = MarketMaker("binance", "I*****ME/USDT")
+    market_maker.run()

agents/PrivateTransactions.sol

@@ -0,0 +1,23 @@
+pragma solidity ^0.8.0;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./ZkSnarkVerifier.sol";
+
+contract PrivateTransactions {
+    IERC20 public immutable token;
+    ZkSnarkVerifier public immutable verifier;
+
+    constructor(address _token, address _verifier) {
+        token = IERC20(_token);
+        verifier = ZkSnarkVerifier(_verifier);
+    }
+
+    function privateTransfer(
+        uint256[2] memory a,
+        uint256[2][2] memory b,
+        uint256[2] memory c,
+        uint256[3] memory input
+    ) external {
+        require(verifier.verifyProof(a, b, c, input), "Invalid zk-SNARK proof");
+        // Executar a transferência privada
+    }
+}

agents/README.md

@@ -0,0 +1,12 @@
+---
+title: Aibank Token
+emoji: 🐠
+colorFrom: yellow
+colorTo: pink
+sdk: static
+pinned: false
+license: other
+short_description: Token aibank
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agents/RewardSystem.sol

@@ -0,0 +1,22 @@
+pragma solidity ^0.8.0;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract RewardSystem {
+    IERC20 public immutable token;
+    mapping(address => uint256) public rewards;
+
+    constructor(address _token) {
+        token = IERC20(_token);
+    }
+
+    function addReward(address user, uint256 amount) external {
+        rewards[user] += amount;
+    }
+
+    function claimReward() external {
+        uint256 amount = rewards[msg.sender];
+        require(amount > 0, "No rewards to claim");
+        rewards[msg.sender] = 0;
+        require(token.transfer(msg.sender, amount), "Transfer failed");
+    }
+}

agents/agents/DeepPortfolioAgent.py

@@ -0,0 +1,361 @@
+
+# rnn/agents/deep_portfolio.py (ou onde você tem DeepPortfolioAI / DeepPortfolioAgentNetwork)
+import numpy as np
+from tensorflow.keras import regularizers
+import tensorflow as tf
+from tensorflow.keras.layers import (
+    Input, Conv1D, LSTM, Dense, Dropout, 
+    MultiHeadAttention, Reshape, Concatenate,
+    TimeDistributed, GlobalAveragePooling1D, LayerNormalization
+)
+from tensorflow.keras.models import Model
+from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
+# Comente as importações do transformers se não for testar o sentimento agora para simplificar
+# from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
+
+# --- DEFINIÇÕES DE CONFIGURAÇÃO (COPIE OU IMPORTE DO SEU CONFIG.PY) ---
+# Se você não importar do config.py, defina-as aqui para o teste
+WINDOW_SIZE_CONF = 60
+NUM_ASSETS_CONF = 4  # Ex: ETH, BTC, ADA, SOL
+NUM_FEATURES_PER_ASSET_CONF = 26 # Número de features calculadas para CADA ativo
+                                 # (open_div_atr, ..., buy_condition_v1, etc.)
+L2_REG = 0.0001 # Exemplo, use o valor do seu config
+
+# (Cole as classes AssetProcessor e DeepPortfolioAgentNetwork aqui se estiver em um novo script)
+# Ou, se estiver no mesmo arquivo, elas já estarão definidas.
+
+# ... (Definição das classes AssetProcessor e DeepPortfolioAgentNetwork como na resposta anterior) ...
+# Certifique-se que a classe DeepPortfolioAgentNetwork está usando estas constantes:
+# num_assets=NUM_ASSETS_CONF, 
+# sequence_length=WINDOW_SIZE_CONF, 
+# num_features_per_asset=NUM_FEATURES_PER_ASSET_CONF
+
+class AssetProcessor(tf.keras.Model):
+    def __init__(self, sequence_length, num_features, cnn_filters1=32, cnn_filters2=64, lstm_units1=64, lstm_units2=32, dropout_rate=0.2, name="single_asset_processor_module", **kwargs): # Adicionado **kwargs
+        super(AssetProcessor, self).__init__(name=name, **kwargs) # Adicionado **kwargs
+        self.sequence_length = sequence_length
+        self.num_features = num_features
+        self.cnn_filters1 = cnn_filters1 # Salvar para get_config
+        self.cnn_filters2 = cnn_filters2
+        self.lstm_units1 = lstm_units1
+        self.lstm_units2 = lstm_units2
+        self.dropout_rate = dropout_rate
+        
+        self.conv1 = Conv1D(filters=cnn_filters1, kernel_size=3, activation='relu', padding='same', name="asset_cnn1")
+        self.dropout_cnn1 = Dropout(dropout_rate, name="asset_cnn1_dropout")
+        self.conv2 = Conv1D(filters=cnn_filters2, kernel_size=3, activation='relu', padding='same', name="asset_cnn2")
+        self.dropout_cnn2 = Dropout(dropout_rate, name="asset_cnn2_dropout")
+        self.lstm1 = LSTM(lstm_units1, return_sequences=True, name="asset_lstm1")
+        self.dropout_lstm1 = Dropout(dropout_rate, name="asset_lstm1_dropout")
+        self.lstm2 = LSTM(lstm_units2, return_sequences=False, name="asset_lstm2_final")
+        self.dropout_lstm2 = Dropout(dropout_rate, name="asset_lstm2_dropout")
+
+    def call(self, inputs, training=False):
+        x = self.conv1(inputs)
+        x = self.dropout_cnn1(x, training=training)
+        x = self.conv2(x)
+        x = self.dropout_cnn2(x, training=training)
+        x = self.lstm1(x, training=training)
+        x = self.dropout_lstm1(x, training=training)
+        x = self.lstm2(x, training=training)
+        x_processed_asset = self.dropout_lstm2(x, training=training)
+        return x_processed_asset
+
+    def get_config(self):
+        config = super().get_config()
+        config.update({
+            "sequence_length": self.sequence_length,
+            "num_features": self.num_features,
+            "cnn_filters1": self.cnn_filters1,
+            "cnn_filters2": self.cnn_filters2,
+            "lstm_units1": self.lstm_units1,
+            "lstm_units2": self.lstm_units2,
+            "dropout_rate": self.dropout_rate,
+        })
+        return config
+
+class DeepPortfolioAgentNetwork(tf.keras.Model):
+    def __init__(self, 
+                 num_assets=int(NUM_ASSETS_CONF), 
+                 sequence_length=int(WINDOW_SIZE_CONF), 
+                 num_features_per_asset=int(NUM_FEATURES_PER_ASSET_CONF),
+                 asset_cnn_filters1=32, asset_cnn_filters2=64, 
+                 asset_lstm_units1=64, asset_lstm_units2=32, asset_dropout=0.2,
+                 mha_num_heads=4, mha_key_dim_divisor=2, # key_dim será asset_lstm_units2 // mha_key_dim_divisor
+                 final_dense_units1=128, final_dense_units2=64, final_dropout=0.3,
+                 use_sentiment_analysis=True, 
+                 output_latent_features=False, **kwargs): # Adicionado **kwargs
+        super(DeepPortfolioAgentNetwork, self).__init__(name="deep_portfolio_agent_network", **kwargs) # Adicionado **kwargs
+        
+
+        print(f"DPN __init__ > num_assets ENTRADA: {num_assets}, tipo: {type(num_assets)}")
+
+        # Tentar extrair o valor escalar se for um tensor/variável ou TrackedDict
+        def get_int_value(param_name, val):
+            if isinstance(val, (tf.Tensor, tf.Variable)):
+                if val.shape == tf.TensorShape([]): # Escalar
+                    print(f"DPN __init__: Convertendo {param_name} (Tensor/Variable escalar) para int.")
+                    return int(val.numpy())
+                else:
+                    raise ValueError(f"{param_name} é um Tensor/Variable mas não é escalar. Shape: {val.shape}")
+            elif isinstance(val, dict): # Pode ser um TrackedDict
+                # TrackedDict pode se comportar como um dict. Se o valor real está "escondido",
+                # precisamos descobrir como acessá-lo.
+                # Por agora, vamos tentar a conversão direta, e se falhar, o erro será mais claro.
+                # Se for um dict simples com uma chave específica, você precisaria dessa chave.
+                # O erro 'KeyError: value' sugere que ['value'] não é a forma correta.
+                # Geralmente, para hiperparâmetros, o TrackedDict deve conter o valor diretamente
+                # se o SB3 o passou corretamente.
+                print(f"DPN __init__: Tentando converter {param_name} (dict-like) para int.")
+                try:
+                    return int(val) # Tentar conversão direta
+                except TypeError:
+                     # Se TrackedDict se comporta como um tensor quando usado em ops TF,
+                     # tf.get_static_value pode funcionar, ou apenas o uso direto
+                     # em operações TF (mas range() não é uma op TF).
+                     # Se for um tensor TF "disfarçado", .numpy() pode funcionar.
+                     # Se for um dict com uma chave específica, essa chave seria necessária.
+                     # O erro mostra que ['value'] não funcionou.
+                     print(f"DPN __init__: Conversão direta de {param_name} (dict-like) para int falhou. Investigar TrackedDict.")
+                     # Para depuração, você pode tentar imprimir os itens do dict:
+                     # if isinstance(val, collections.abc.Mapping): # Checa se é um dict-like
+                     #    for k, v_item in val.items():
+                     #        print(f"   {param_name} item: {k} -> {v_item}")
+                     raise TypeError(f"{param_name} é {type(val)} e não pôde ser convertido para int diretamente. Valor: {val}")
+            else: # Tenta conversão direta para outros tipos
+                return int(val)
+
+        try:
+            self.num_assets = get_int_value("num_assets", num_assets)
+            self.sequence_length = get_int_value("sequence_length", sequence_length)
+            self.num_features_per_asset = get_int_value("num_features_per_asset", num_features_per_asset)
+            self.asset_lstm_output_dim = get_int_value("asset_lstm_units2", asset_lstm_units2) # Do kwargs
+            
+            # Faça o mesmo para TODOS os outros parâmetros que devem ser inteiros e são passados
+            # para construtores de camadas Keras (cnn_filters, lstm_units, mha_num_heads, etc.)
+            # Exemplo:
+            # self.asset_cnn_filters1_val = get_int_value("asset_cnn_filters1", kwargs.get("asset_cnn_filters1"))
+
+        except Exception as e_conv:
+            print(f"ERRO CRÍTICO DE CONVERSÃO DE TIPO no __init__ da DeepPortfolioAgentNetwork: {e_conv}")
+            raise
+
+        print(f"DPN __init__ > self.num_assets APÓS conversão: {self.num_assets}, tipo: {type(self.num_assets)}")
+        
+
+
+
+
+
+        self.num_assets = num_assets
+        self.sequence_length = sequence_length
+        self.num_features_per_asset = num_features_per_asset
+        self.asset_lstm_output_dim = asset_lstm_units2
+
+        self.asset_processor = AssetProcessor(
+            sequence_length=self.sequence_length, num_features=self.num_features_per_asset,
+            cnn_filters1=asset_cnn_filters1, cnn_filters2=asset_cnn_filters2,
+            lstm_units1=asset_lstm_units1, lstm_units2=asset_lstm_units2,
+            dropout_rate=asset_dropout
+        )
+        
+        # Ajustar key_dim para ser compatível com a dimensão de entrada e num_heads
+        # key_dim * num_heads deve ser idealmente igual a asset_lstm_output_dim se for auto-atenção direta,
+        # ou o MHA projeta internamente. Para simplificar, vamos fazer key_dim ser divisível.
+        # Se asset_lstm_output_dim não for divisível por num_heads, key_dim pode ser diferente.
+        # Vamos definir key_dim explicitamente. Se asset_lstm_output_dim = 32 e num_heads = 4, key_dim pode ser 8.
+        # Ou deixar o MHA lidar com a projeção se key_dim for diferente.
+        # Para maior clareza, calculamos uma key_dim sensata.
+        calculated_key_dim = self.asset_lstm_output_dim // mha_key_dim_divisor 
+        if calculated_key_dim == 0: # Evitar key_dim zero
+            calculated_key_dim = self.asset_lstm_output_dim # Fallback se for muito pequeno
+            print(f"AVISO: asset_lstm_output_dim ({self.asset_lstm_output_dim}) muito pequeno para mha_key_dim_divisor ({mha_key_dim_divisor}). Usando key_dim = {calculated_key_dim}")
+
+        self.attention = MultiHeadAttention(num_heads=mha_num_heads, key_dim=calculated_key_dim, dropout=0.1, name="multi_asset_attention")
+        self.attention_norm = LayerNormalization(epsilon=1e-6, name="attention_layernorm")
+        self.global_avg_pool_attention = GlobalAveragePooling1D(name="gap_after_attention")
+
+        self.use_sentiment = use_sentiment_analysis # Desabilitado por padrão para este teste
+        self.sentiment_embedding_size = 3 
+        if self.use_sentiment:
+            try:
+                self.tokenizer = AutoTokenizer.from_pretrained('ProsusAI/finbert')
+                self.sentiment_model = TFAutoModelForSequenceClassification.from_pretrained('ProsusAI/finbert', from_pt=True)
+                print("Modelo FinBERT carregado para análise de sentimento.")
+            except Exception as e:
+                print(f"AVISO: Falha ao carregar FinBERT: {e}. Análise de sentimento será desabilitada.")
+                self.use_sentiment = False
+
+        
+        dense_input_dim = self.use_sentiment
+        #if self.use_sentiment: dense_input_dim += self.sentiment_embedding_size
+        
+        self.dense1 = Dense(final_dense_units1, activation='relu', kernel_regularizer=regularizers.l2(L2_REG), name="final_dense1")
+        self.dropout1 = Dropout(final_dropout, name="final_dropout1")
+        self.dense2 = Dense(final_dense_units2, activation='relu', kernel_regularizer=regularizers.l2(L2_REG), name="final_dense2")
+        self.dropout2 = Dropout(final_dropout, name="final_dropout2")
+        self.output_allocation = Dense(self.num_assets, activation='softmax', name="portfolio_allocation_output")
+
+    def call(self, inputs, training=False):
+        market_data_flat = inputs 
+        
+        print(type(self.num_assets))
+        asset_representations_list = []
+        for i in range(self.num_assets):
+            start_idx = i * self.num_features_per_asset
+            end_idx = (i + 1) * self.num_features_per_asset
+            current_asset_data = market_data_flat[:, :, start_idx:end_idx]
+            processed_asset_representation = self.asset_processor(current_asset_data, training=training)
+            asset_representations_list.append(processed_asset_representation)
+            
+        stacked_asset_features = tf.stack(asset_representations_list, axis=1)
+        
+        # Para MHA, query, value, key são (batch_size, Tq, dim), (batch_size, Tv, dim)
+        # Aqui, T = num_assets, dim = asset_lstm_output_dim
+        attention_output = self.attention(
+            query=stacked_asset_features, value=stacked_asset_features, key=stacked_asset_features,
+            training=training
+        )
+        attention_output = self.attention_norm(stacked_asset_features + attention_output) 
+        
+        context_vector_from_attention = self.global_avg_pool_attention(attention_output)
+        
+        current_features_for_dense = context_vector_from_attention
+        # if self.use_sentiment: ... (lógica de concatenação)
+
+        x = self.dense1(current_features_for_dense)
+        x = self.dropout1(x, training=training)
+        x = self.dense2(x)
+        x = self.dropout2(x, training=training)
+        
+        portfolio_weights = self.output_allocation(x)
+        return portfolio_weights
+
+    def get_config(self): # Necessário se você quiser salvar/carregar o modelo que usa este sub-modelo
+        config = super().get_config()
+        config.update({
+            "num_assets": self.num_assets,
+            "sequence_length": self.sequence_length,
+            "num_features_per_asset": self.num_features_per_asset,
+            # Adicione outros args do __init__ aqui para todas as camadas e sub-modelos
+            "asset_lstm_output_dim": self.asset_lstm_output_dim,
+            # ... e os parâmetros passados para AssetProcessor e MHA, etc.
+        })
+        return config
+    
+    # @classmethod
+    # def from_config(cls, config): # Necessário para carregar com sub-modelo customizado
+    #    # Extrair config do AssetProcessor se necessário
+    #    return cls(**config)
+
+
+if __name__ == '__main__':
+    print("Testando o Forward Pass do DeepPortfolioAgentNetwork...")
+
+    # 1. Definir Parâmetros para o Teste (devem corresponder ao config.py)
+    batch_size_test = 2 # Um batch pequeno para teste
+    seq_len_test = WINDOW_SIZE_CONF
+    num_assets_test = NUM_ASSETS_CONF
+    num_features_per_asset_test = NUM_FEATURES_PER_ASSET_CONF
+    total_features_flat = num_assets_test * num_features_per_asset_test
+
+    print(f"Configuração do Teste:")
+    print(f"  Batch Size: {batch_size_test}")
+    print(f"  Sequence Length (Window): {seq_len_test}")
+    print(f"  Number of Assets: {num_assets_test}")
+    print(f"  Features per Asset: {num_features_per_asset_test}")
+    print(f"  Total Flat Features per Timestep: {total_features_flat}")
+
+    # 2. Criar Tensor de Input Mockado
+    # Shape: (batch_size, sequence_length, num_assets * num_features_per_asset)
+    mock_market_data_flat = tf.random.normal(
+        shape=(batch_size_test, seq_len_test, total_features_flat)
+    )
+    print(f"Shape do Input Mockado (market_data_flat): {mock_market_data_flat.shape}")
+
+    # 3. Instanciar o Modelo
+    # Use os mesmos hiperparâmetros que você definiria no config.py para a rede
+    print("\nInstanciando DeepPortfolioAgentNetwork...")
+    agent_network = DeepPortfolioAgentNetwork(
+        num_assets=num_assets_test,
+        sequence_length=seq_len_test,
+        num_features_per_asset=num_features_per_asset_test,
+        # Você pode variar os próximos parâmetros para testar diferentes configs
+        asset_cnn_filters1=32, asset_cnn_filters2=64,
+        asset_lstm_units1=64, asset_lstm_units2=32, # asset_lstm_units2 define asset_lstm_output_dim
+        asset_dropout=0.1,
+        mha_num_heads=4, mha_key_dim_divisor=4, # Ex: 32 // 4 = 8 para key_dim
+        final_dense_units1=64, final_dense_units2=32, final_dropout=0.2,
+        use_sentiment_analysis=False # Testar sem sentimento primeiro
+    )
+
+    # Para construir o modelo e ver o summary, você pode chamar com o input mockado
+    # ou explicitamente chamar model.build() se souber o input shape completo
+    # Chamar com input mockado é mais fácil para construir.
+    print("\nConstruindo o modelo com input mockado (primeira chamada)...")
+    try:
+        # É uma boa prática fazer a primeira chamada dentro de um tf.function para otimizar
+        # ou apenas chamar diretamente para teste.
+        _ = agent_network(mock_market_data_flat) # Chamada para construir as camadas
+        print("\n--- Summary da Rede Principal (DeepPortfolioAgentNetwork) ---")
+        agent_network.summary()
+        
+        # O summary do asset_processor já foi impresso no __init__ do DeepPortfolioAgentNetwork
+        # se você descomentar as linhas de build/summary lá.
+        # Ou você pode imprimir aqui:
+        print("\n--- Summary do AssetProcessor (Sub-Modelo) ---")
+        agent_network.asset_processor.summary()
+
+
+    except Exception as e:
+        print(f"Erro ao construir a rede principal: {e}", exc_info=True)
+        exit()
+
+    # 4. Chamar model(mock_input) para o Forward Pass
+    print("\nExecutando Forward Pass...")
+    try:
+        predictions = agent_network(mock_market_data_flat, training=False) # Passar training=False para inferência
+        print("Forward Pass concluído com sucesso!")
+    except Exception as e:
+        print(f"Erro durante o Forward Pass: {e}", exc_info=True)
+        exit()
+
+    # 5. Verificar o Shape da Saída
+    print(f"\nShape da Saída (predictions): {predictions.shape}")
+    expected_output_shape = (batch_size_test, num_assets_test)
+    if predictions.shape == expected_output_shape:
+        print(f"Shape da Saída está CORRETO! Esperado: {expected_output_shape}")
+    else:
+        print(f"ERRO: Shape da Saída INCORRETO. Esperado: {expected_output_shape}, Obtido: {predictions.shape}")
+
+    # Verificar se a saída é uma distribuição de probabilidade (softmax)
+    if hasattr(predictions, 'numpy'): # Se for um EagerTensor
+        output_sum = tf.reduce_sum(predictions, axis=-1).numpy()
+        print(f"Soma das probabilidades de saída por amostra no batch (deve ser próximo de 1): {output_sum}")
+        if np.allclose(output_sum, 1.0):
+            print("Saída Softmax parece CORRETA (soma 1).")
+        else:
+            print("AVISO: Saída Softmax pode NÃO estar correta (soma diferente de 1).")
+    
+    print("\nExemplo das primeiras predições (pesos do portfólio):")
+    print(predictions.numpy()[:min(5, batch_size_test)]) # Imprime até 5 predições do batch
+
+    # Teste com sentimento (se implementado e FinBERT carregado)
+    # agent_network.use_sentiment = True # Ativar para teste
+    # if agent_network.use_sentiment and hasattr(agent_network, 'tokenizer'):
+    #     print("\nTestando Forward Pass COM SENTIMENTO...")
+    #     mock_news_batch = ["positive news for asset 1", "market is very volatile today"] # Exemplo
+    #     # A forma como você passa 'news' para o call() precisa ser definida.
+    #     # Se for um dicionário:
+    #     # mock_inputs_with_news = {"market_data": mock_market_data_flat, "news_data": mock_news_batch}
+    #     # predictions_with_sentiment = agent_network(mock_inputs_with_news, training=False)
+    #     # print(f"Shape da Saída com Sentimento: {predictions_with_sentiment.shape}")
+    # else:
+    #     print("\nTeste com sentimento pulado (use_sentiment=False ou FinBERT não carregado).")
+
+    print("\nTeste do Forward Pass Concluído!")
+
+
+
+
+

agents/agents/app/model/model2.h5

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

agents/agents/app/model/model3.zip

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

agents/agents/app/model/ppo_custom_deep_portfolio_agent.zip

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

agents/agents/config.md

@@ -0,0 +1,13 @@
+# EXPECTED_FEATURES_ORDER define como as colunas DEVEM ESTAR no DataFrame
+# que entra na função create_sequences, APÓS o escalonamento e ANTES do sufixo _scaled.
+# E também como o rnn_predictor.py espera as features ANTES de aplicar os scalers.
+# Se rnn_predictor.py vai aplicar scalers separados, ele precisa dos nomes originais (ou _div_atr).
+# O script de treino vai criar colunas com sufixo _scaled para alimentar o modelo.
+# A lista EXPECTED_FEATURES_ORDER no config.py não é diretamente usada no train_rnn_model.py
+# da forma como está agora, mas é CRUCIAL para alinhar com rnn_predictor.py.
+# Fazer o train_rnn_model.py funcionar e depois alinhar o rnn_predictor.py.
+# Importante que as NUM_FEATURES e o input_shape do modelo estejam corretos.
+
+# Esta variável será usada para nomear as colunas escaladas que vão para o modelo
+# e deve corresponder ao que o rnn_predictor.py espera encontrar como features escaladas.
+# Os nomes aqui devem ser as colunas de BASE_FEATURE_COLS com "_scaled" no final.

agents/agents/config.py

@@ -0,0 +1,126 @@
+# config.py
+
+# --- Parâmetros de Dados ---
+SYMBOL = 'ETH/USDT'  # Ativo principal para o modelo de classificação (se ainda usar)
+MULTI_ASSET_SYMBOLS = { # Para o agente de portfólio RL
+    'eth': 'ETH-USD',  # Chave amigável: ticker_yfinance
+    'btc': 'BTC-USD',
+    'ada': 'ADA-USD',
+    'sol': 'SOL-USD'
+}
+NUM_ASSETS_PORTFOLIO = len(MULTI_ASSET_SYMBOLS) # Número de ativos no portfólio
+NUM_ASSETS=4
+TIMEFRAME = '1h' # Usado tanto para yfinance quanto para ccxt (se adaptar)
+DAYS_OF_DATA_TO_FETCH = 365 * 2
+LIMIT_PER_FETCH = 1000 # Para ccxt
+
+# --- Parâmetros de Features e Janela ---
+WINDOW_SIZE = 60
+
+# BASE_FEATURE_COLS: Colunas calculadas para CADA ativo ANTES do escalonamento final para o modelo.
+# Estas são as features que seu data_handler_multi_asset.py DEVE produzir para cada ativo.
+# O rnn_predictor.py (ou a parte de features da DeepPortfolioAgentNetwork) também as calculará.
+BASE_FEATURES_PER_ASSET_INPUT = [ # Renomeado para clareza
+    'open_div_atr', 'high_div_atr', 'low_div_atr', 'close_div_atr', 'volume_div_atr',
+    'log_return', 'rsi_14', 'atr', 'bbp', 'cci_37', 'mfi_37',
+    'body_size_norm_atr', 'body_vs_avg_body', 'macd', 'sma_10_div_atr',
+    'adx_14', 'volume_zscore', 'buy_condition_v1'
+    # Se 'cond_compra_v1' for diferente de 'buy_condition_v1', adicione aqui.
+    # Se for igual, remova a redundância. Assumindo que 'buy_condition_v1' é a correta.
+]
+# Nomes das colunas de preço/volume (normalizadas por ATR) que usarão o price_vol_scaler
+API_PRICE_VOL_COLS = ['open_div_atr', 'high_div_atr', 'low_div_atr', 'close_div_atr', 'volume_div_atr', 'body_size_norm_atr']
+# Nomes das colunas de indicadores (e outras) que usarão o indicator_scaler
+API_INDICATOR_COLS = [col for col in BASE_FEATURES_PER_ASSET_INPUT if col not in API_PRICE_VOL_COLS]
+
+# Número de features que CADA ativo terá após todos os cálculos e ANTES do escalonamento final.
+NUM_FEATURES_PER_ASSET = len(BASE_FEATURES_PER_ASSET_INPUT)
+
+# Nomes das colunas escaladas que o modelo RNN/RL efetivamente verá como entrada.
+# Esta é a ordem que deve ser mantida após o escalonamento no data_handler e no rnn_predictor.
+# E também o que o create_sequences espera.
+EXPECTED_SCALED_FEATURES_FOR_MODEL = [f"{col}_scaled" for col in BASE_FEATURES_PER_ASSET_INPUT]
+# NUM_FEATURES_MODEL_INPUT será len(EXPECTED_SCALED_FEATURES_FOR_MODEL), que é igual a NUM_FEATURES_PER_ASSET
+
+# --- Parâmetros do Alvo da Predição (Para o Modelo de Classificação Supervisionado, se ainda usar) ---
+PREDICTION_HORIZON = 5
+PRICE_CHANGE_THRESHOLD = 0.0075
+
+# --- Parâmetros da Rede Neural (DeepPortfolioAgentNetwork e seu AssetProcessor) ---
+# Para AssetProcessor (processamento individual de ativo)
+ASSET_CNN_FILTERS1 = 32
+ASSET_CNN_FILTERS2 = 64
+ASSET_LSTM_UNITS1 = 64
+ASSET_LSTM_UNITS2 = 32  # Saída do AssetProcessor, se torna a dimensão da feature latente por ativo
+ASSET_DROPOUT = 0.2
+
+# Para DeepPortfolioAgentNetwork (camadas após processamento individual)
+MHA_NUM_HEADS = 4
+# key_dim da MHA será ASSET_LSTM_UNITS2 // MHA_KEY_DIM_DIVISOR
+MHA_KEY_DIM_DIVISOR = 2 # Ex: 32 // 2 = 16. Garanta que ASSET_LSTM_UNITS2 seja divisível. Se não, ajuste.
+
+# Camadas densas FINAIS DENTRO da DeepPortfolioAgentNetwork, ANTES da saída de features latentes
+# ou da camada de alocação softmax (se não estiver retornando features latentes).
+# `FINAL_DENSE_UNITS2_EXTRACTOR` será a dimensão das features que o extrator cospe para o SB3.
+DPN_FINAL_DENSE1_UNITS = 64 # "DPN" para DeepPortfolioNetwork
+DPN_LATENT_FEATURE_DIM = 32 # Saída da DPN quando output_latent_features=True. IGUAL A ASSET_LSTM_UNITS2 se não houver mais camadas após GAP.
+                            # Se você adicionou Dense(final_dense_units1) e Dense(final_dense_units2) APÓS a atenção
+                            # no DeepPortfolioAgentNetwork, então DPN_LATENT_FEATURE_DIM seria final_dense_units2.
+                            # No nosso último design, era a saída do global_avg_pool_attention, então ASSET_LSTM_UNITS2.
+                            # Vamos assumir que a saída do GAP é usada como feature latente por enquanto.
+                            # DPN_LATENT_FEATURE_DIM = ASSET_LSTM_UNITS2
+
+# Ajustando com base no seu código de `deep_portfolio.py` onde você tinha `final_dense_units1` e `final_dense_units2`
+# após a atenção e antes do output de alocação.
+# Estas são as camadas que produzem as features latentes para SB3.
+DPN_SHARED_HEAD_DENSE1_UNITS = 128 # Corresponde a final_dense_units1 na sua DeepPortfolioAgentNetwork
+DPN_SHARED_HEAD_LATENT_DIM = 64   # Corresponde a final_dense_units2, que será o self.features_dim do extrator
+DPN_SHARED_HEAD_DROPOUT = 0.3
+
+DEFAULT_EXTRACTOR_KWARGS=DPN_SHARED_HEAD_DENSE1_UNITS
+
+# Para as cabeças de Política (Ator) e Valor (Crítico) no Stable-Baselines3 (APÓS o extrator)
+# Se vazias, a saída do extrator é usada diretamente para as camadas finais de ação/valor.
+POLICY_HEAD_NET_ARCH = [64]  # Ex: [64, 32] ou [] se não quiser camadas extras
+VALUE_HEAD_NET_ARCH = [64]   # Ex: [64, 32] ou []
+
+# --- Parâmetros Gerais do Modelo (se aplicável a ambos os tipos de modelo) ---
+MODEL_DROPOUT_RATE = 0.3      # Você usou 0.3 na última rodada de classificação bem-sucedida
+MODEL_L2_REG = 0.0001         # Você usou 0.0001 ou 0.0005
+
+L2_REG = 0.0001 
+
+# --- Parâmetros de Treinamento ---
+# Para o modelo de classificação supervisionado (se ainda usar)
+SUPERVISED_LEARNING_RATE = 0.0005
+SUPERVISED_BATCH_SIZE = 128
+SUPERVISED_EPOCHS = 100
+LEARNING_RATE=0.0005
+
+# Para o agente RL (PPO)
+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.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%)
+# REWARD_WINDOW_SHARPE = 252 * 1 # Ex: Janela de 1 ano de dados horários para Sharpe (252 dias * 24h)
+                               # Ou uma janela menor como 60 ou 120 passos.
+INITIAL_BALANCE = 100000
+TRANSACTION_COST_PCT = 0.001 # 0.1%
+
+# --- Caminhos para Salvar ---
+MODEL_ROOT_DIR = "app/model" # Diretório raiz para todos os modelos e scalers
+# Para modelo de classificação supervisionado (se mantiver)
+SUPERVISED_MODEL_NAME = "classification_model.h5"
+SUPERVISED_PV_SCALER_NAME = "supervisor_pv_scaler.joblib"
+SUPERVISED_IND_SCALER_NAME = "supervisor_ind_scaler.joblib"
+# Para modelo RL (agente PPO salvo pelo SB3)
+RL_AGENT_MODEL_NAME = "ppo_deep_portfolio_agent" # SB3 adiciona .zip
+# Scalers usados para preparar dados para o DeepPortfolioAgentNetwork (que é o extrator do RL)
+RL_PV_SCALER_NAME = "rl_price_volume_atr_norm_scaler.joblib" # Seus nomes descritivos
+RL_INDICATOR_SCALER_NAME = "rl_other_indicators_scaler.joblib"
+FINAL_DENSE_UNITS1_EXTRACTOR=DEFAULT_EXTRACTOR_KWARGS
+USE_SENTIMENT_CONFIG=True

agents/agents/custom_policies.py

@@ -0,0 +1,99 @@
+# 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
+import torch
+
+class CustomTFMlpExtractor(tf.keras.layers.Layer):
+    def __init__(self, feature_dim, net_arch, activation_fn=tf.nn.relu):
+        super().__init__()
+        self.net = tf.keras.Sequential()
+        for units in net_arch:
+            self.net.add(tf.keras.layers.Dense(units))
+            self.net.add(tf.keras.layers.Activation(activation_fn))
+
+    def call(self, inputs, training=False):
+        return self.net(inputs, training=training)
+
+
+
+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 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
+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 CustomPolicy(ActorCriticPolicy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mlp_extractor = CustomTFMlpExtractor(
+            input_dim=self.observation_space.shape[0],
+            net_arch=[64, 64],  # Exemplo de arquitetura
+            activation_fn=nn.ReLU,
+            device=self.device
+        )
+
+from torch import nn
+
+class CustomPortfolioPolicySB3(ActorCriticPolicy):
+    def __init__(
+        self,
+        observation_space: gym.spaces.Space,
+        action_space: gym.spaces.Space,
+        lr_schedule,
+        net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None,
+        activation_fn: Type[nn.Module] = nn.ReLU,  # Use PyTorch ReLU
+        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        if features_extractor_kwargs is None:
+            features_extractor_kwargs = {}
+        features_extractor_kwargs.setdefault("features_dim", ASSET_LSTM_UNITS2_POLICY)
+
+        super().__init__(
+            observation_space,
+            action_space,
+            lr_schedule,
+            net_arch=net_arch,
+            activation_fn=activation_fn,  # Passando nn.ReLU
+            features_extractor_class=PortfolioFeaturesExtractorTorch,
+            features_extractor_kwargs=features_extractor_kwargs,
+            **kwargs,
+        )

agents/agents/data_handler_multi_asset.py

@@ -0,0 +1,448 @@
+# rnn/data_handler_multi_asset.py (NOVO ARQUIVO)
+
+
+import pandas as pd
+import numpy as np
+import yfinance as yf # Ou ccxt, dependendo da sua preferência de fonte de dados
+import pandas_ta as ta
+from datetime import datetime, timedelta, timezone
+from typing import List, Dict, Optional
+
+WINDOW_SIZE = 60
+
+# Importar do seu config.py
+# Assumindo que config.py está em ../config.py ou rnn/config.py
+# Ajuste o import conforme sua estrutura.
+# Se train_rnn_model.py e este data_handler estiverem na mesma pasta 'scripts',
+# e config.py estiver um nível acima:
+# from ..app/config.py import (
+#     MULTI_ASSET_LIST, TIMEFRAME, DAYS_OF_DATA_TO_FETCH, 
+#     # etc. para features a serem calculadas
+# )
+# Por agora, vamos definir aqui para exemplo:
+
+# EXEMPLO DE CONFIGURAÇÃO (Mova para config.py depois)
+MULTI_ASSET_SYMBOLS = {
+    'eth': 'ETH-USD', 
+    'btc': 'BTC-USD',
+    'ada': 'ADA-USD',
+    'sol': 'SOL-USD' 
+} # Use os tickers corretos para yfinance ou ccxt
+TIMEFRAME_YFINANCE = '1h' # yfinance suporta '1m', '2m', '5m', '15m', '30m', '60m', '90m', '1h', '1d', '5d', '1wk', '1mo', '3mo'
+# Para '1h', yfinance só retorna os últimos 730 dias. Para mais dados, use '1d'.
+# Se usar ccxt, TIMEFRAME = '1h' como antes.
+DAYS_TO_FETCH = 365 * 2 # 2 anos
+
+# Lista das features base que você quer calcular para CADA ativo
+# (as 19 que definimos antes)
+INDIVIDUAL_ASSET_BASE_FEATURES = [
+    'open', 'high', 'low', 'close', 'volume', # OHLCV originais são necessários para os cálculos
+    'sma_10', 'rsi_14', 'macd', 'macds', 'atr', 'bbp', 'cci_37', 'mfi_37', 'adx_14',
+    'volume_zscore', 'body_size', 'body_size_norm_atr', 'body_vs_avg_body',
+    'log_return', 'buy_condition_v1',
+    'open_div_atr', 'high_div_atr', 
+    'low_div_atr', 
+    'close_div_atr', 
+    'volume_div_atr',
+    'sma_10_div_atr' # 'sma_50' é calculada dentro de buy_condition_v1
+    # As colunas _div_atr serão criadas a partir destas
+]
+
+# Features que serão normalizadas pelo ATR
+COLS_TO_NORM_BY_ATR = ['open', 'high', 'low', 'close', 'volume', 'sma_10', 'macd', 'body_size']
+#----------------------------------
+# -- New get multi asset data for rl
+# ... (imports e outras funções como antes) ...
+
+def get_multi_asset_data_for_rl(
+    asset_symbols_map: Dict[str, str], 
+    timeframe_yf: str, 
+    days_to_fetch: int,
+    logger_instance # Adicionar logger como parâmetro
+) -> Optional[pd.DataFrame]: # Adicionar logger como parâmetro
+
+    all_asset_features_list: List[pd.DataFrame] = [] # Tipagem para clareza
+    min_data_length = float('inf')
+    print(all_asset_features_list)
+    
+    #logger_instance.info(f"Iniciando get_multi_asset_data_for_rl para: {list(asset_symbols_map.keys())}")
+
+    for asset_key, yf_ticker in asset_symbols_map.items():
+        #logger_instance.info(f"\n--- Processando {asset_key} ({yf_ticker}) ---")
+        # ... (lógica de fetch_single_asset_ohlcv_yf como antes) ...
+        single_asset_ohlcv = fetch_single_asset_ohlcv_yf(yf_ticker, period=f"{days_to_fetch}d", interval=timeframe_yf) # Passar logger se a função aceitar
+
+        # if single_asset_ohlcv.empty:
+        #     logger_instance.warning(f"Sem dados OHLCV para {yf_ticker}, pulando.")
+        #     continue
+            
+        single_asset_features = calculate_all_features_for_single_asset(single_asset_ohlcv)#, logger_instance) 
+        
+        if single_asset_features is None or single_asset_features.empty:
+            logger_instance.warning(f"Sem features calculadas para {yf_ticker}, pulando.")
+            continue
+        
+        #logger_instance.info(f"Features para {asset_key} shape: {single_asset_features.shape}, Index Min: {single_asset_features.index.min()}, Index Max: {single_asset_features.index.max()}")
+        
+        # Garantir que o índice é DatetimeIndex e UTC para todos antes de adicionar prefixo e à lista
+        if not isinstance(single_asset_features.index, pd.DatetimeIndex):
+            single_asset_features.index = pd.to_datetime(single_asset_features.index)
+        if single_asset_features.index.tz is None:
+            single_asset_features.index = single_asset_features.index.tz_localize('UTC')
+        else:
+            single_asset_features.index = single_asset_features.index.tz_convert('UTC')
+
+        single_asset_features = single_asset_features.add_prefix(f"{asset_key}_")
+        all_asset_features_list.append(single_asset_features)
+        min_data_length = min(min_data_length, len(single_asset_features))
+
+    if not all_asset_features_list:
+        logger_instance.error("Nenhum DataFrame de feature de ativo foi adicionado à lista.")
+        return None
+
+    if min_data_length == float('inf') or min_data_length < WINDOW_SIZE: # Adicionada checagem de WINDOW_SIZE
+        logger_instance.error(f"min_data_length inválido ({min_data_length}) ou menor que WINDOW_SIZE ({WINDOW_SIZE}). Não é possível truncar/usar.")
+        return None
+
+    #logger_instance.info(f"Menor número de linhas de dados encontrado (min_data_length): {min_data_length}")
+    
+    # Truncar para garantir que todos os DFs tenham o mesmo comprimento ANTES do concat
+    # E que tenham pelo menos min_data_length.
+    # É importante que os ÍNDICES de data/hora se sobreponham para o join='inner' funcionar.
+    # Apenas pegar o .tail() pode não alinhar os timestamps se os DFs tiverem começos diferentes.
+    
+    # Melhor abordagem: encontrar o índice comum mais recente e o mais antigo.
+    if not all_asset_features_list: # Checagem se a lista não ficou vazia por algum motivo
+        logger_instance.error("all_asset_features_list está vazia antes do alinhamento de índice.")
+        return None
+    print(all_asset_features_list)
+    # Alinhar DataFrames por um índice comum antes de concatenar
+    # 1. Encontrar o primeiro timestamp comum a todos
+    # 2. Encontrar o último timestamp comum a todos
+    # Ou, mais simples, confiar no join='inner' do concat, mas garantir que os DFs são válidos.
+
+    # Vamos simplificar e manter o truncamento pelo tail, mas com mais logs
+    # e garantir que são DataFrames.
+    
+    truncated_asset_features_list = []
+    for i, df_asset in enumerate(all_asset_features_list):
+        if isinstance(df_asset, pd.DataFrame) and len(df_asset) >= min_data_length:
+            truncated_df = df_asset.tail(min_data_length)
+            #logger_instance.info(f"  DF truncado {i} ({df_asset.columns[0].split('_')[0]}): shape {truncated_df.shape}, ")
+                                 #f"Index Min: {truncated_df.index.min()}, Max: {truncated_df.index.max()}")
+            truncated_asset_features_list.append(truncated_df)
+        else:
+            asset_name_debug = df_asset.columns[0].split('_')[0] if isinstance(df_asset, pd.DataFrame) and not df_asset.empty else f"DF_{i}"
+            logger_instance.warning(f"  DF {asset_name_debug} inválido ou muito curto (len: {len(df_asset) if isinstance(df_asset, pd.DataFrame) else 'N/A'}) para truncamento. Pulando.")
+
+    if not truncated_asset_features_list:
+        #ogger_instance.error("Nenhum DataFrame válido restou após truncamento para concatenar.")
+        return None
+    
+    # Se houver apenas UM DataFrame na lista, não precisa concatenar, apenas retorna ele.
+    if len(truncated_asset_features_list) == 1:
+        #logger_instance.info("Apenas um DataFrame de ativo processado, retornando-o diretamente.")
+        combined_df = truncated_asset_features_list[0]
+    else:
+        #logger_instance.info(f"Concatenando {len(truncated_asset_features_list)} DataFrames de ativos com join='inner'...")
+        try:
+            combined_df = pd.concat(truncated_asset_features_list, axis=1, join='outer')
+            print(combined_df)
+        except Exception as e_concat:
+            logger_instance.error(f"ERRO CRÍTICO durante pd.concat: {e_concat}", exc_info=True)
+            return None
+        
+
+    combined_df.fillna(method='ffill', inplace=True)
+    # Depois do ffill, ainda pode haver NaNs no início se algum ativo começar depois dos outros.
+    if not combined_df.empty:
+        #logger_instance.info(f"Shape após ffill: {combined_df.shape}. Buscando primeiro/último índice válido...")
+        first_valid_index = combined_df.first_valid_index()
+        last_valid_index = combined_df.last_valid_index()
+
+    if pd.isna(first_valid_index) or pd.isna(last_valid_index):
+        print("Não foi possível determinar first/last_valid_index após ffill.")
+        return None
+    
+    print(f"Primeiro índice válido: {first_valid_index}, Último índice válido: {last_valid_index}")
+    combined_df = combined_df.loc[first_valid_index:last_valid_index]
+    print(f"Shape após fatiar por first/last valid index: {combined_df.shape}")
+    
+    # Um dropna final pode ser necessário se o ffill não pegou tudo (improvável, mas seguro)
+    combined_df.dropna(inplace=True) 
+    print(f"Shape após dropna final (pós-fatiamento): {combined_df.shape}")
+    print("Imprimindo DF_COMBINED com index ")
+    print(combined_df)
+
+    #logger_instance.info(f"Tipo de combined_df após concat: {type(combined_df)}")
+    if not isinstance(combined_df, pd.DataFrame):
+        logger_instance.error(f"combined_df NÃO é um DataFrame após concat. Tipo: {type(combined_df)}")
+        return None
+    
+
+    return combined_df
+    # if combined_df.empty:
+                              
+    #     logger_instance.error("DataFrame combinado está VAZIO após concatenação e join='inner'. "
+    #                           "Isso geralmente significa que não há timestamps comuns entre TODOS os ativos processados.")
+    #     # Adicionar mais depuração aqui se isso acontecer:
+    #     # for i, df_trunc_debug in enumerate(truncated_asset_features_list):
+    #     #     logger_instance.info(f"Debug DF {i} - Head:\n{df_trunc_debug.head(3)}")
+    #     #     logger_instance.info(f"Debug DF {i} - Tail:\n{df_trunc_debug.tail(3)}")
+    #     #     logger_instance.info(f"DataFrame combinado ANTES do dropna final, shape: {combined_df.shape}")
+    #     print(combined_df.head()) # Descomente para depuração pesada
+    # return None
+        
+    
+    
+    
+# ... 
+#----------------------------------
+
+# def get_multi_asset_data_for_rl(
+#     asset_symbols_map: Dict[str, str], 
+#     timeframe_yf: str, 
+#     days_to_fetch: int
+# ) -> Optional[pd.DataFrame]:
+#     """
+#     Busca, processa e combina dados de múltiplos ativos em um DataFrame achatado.
+#     """
+#     all_asset_features_list = []
+#     # min_data_length = float('inf') # Inicializar com um valor alto
+#     # Vamos inicializar com 0 e pegar o len do primeiro DF válido
+#     min_data_length = 0 
+#     first_valid_df_processed = False
+
+#     for asset_key, yf_ticker in asset_symbols_map.items():
+#         print(f"\n--- Processando {asset_key} ({yf_ticker}) ---")
+#         period_yf = f"{days_to_fetch}d"
+#         if timeframe_yf == '1h' and days_to_fetch > 730:
+#             print(f"AVISO: Para {timeframe_yf}, buscando no máximo 730 dias com yfinance para {yf_ticker}.")
+#             period_yf = "730d" 
+        
+#         single_asset_ohlcv = fetch_single_asset_ohlcv_yf(yf_ticker, period=period_yf, interval=timeframe_yf)
+#         if single_asset_ohlcv.empty:
+#             print(f"AVISO: Sem dados OHLCV para {yf_ticker}, pulando este ativo.")
+#             continue
+            
+#         single_asset_features = calculate_all_features_for_single_asset(single_asset_ohlcv) # Passar logger se tiver
+#         if single_asset_features is None or single_asset_features.empty:
+#             print(f"AVISO: Sem features calculadas para {yf_ticker}, pulando este ativo.")
+#             continue
+        
+#         single_asset_features = single_asset_features.add_prefix(f"{asset_key}_")
+#         all_asset_features_list.append(single_asset_features)
+        
+#         # Atualizar min_data_length de forma mais segura
+#         if not first_valid_df_processed:
+#             min_data_length = len(single_asset_features)
+#             first_valid_df_processed = True
+#         else:
+#             min_data_length = min(min_data_length, len(single_asset_features))
+
+#     if not all_asset_features_list: # Se nenhum ativo foi processado com sucesso
+#         print("ERRO: Nenhum dado de feature de ativo foi processado com sucesso para a lista `all_asset_features_list`.")
+#         return None # Retorna None, que não tem '.empty' mas será checado por 'is None'
+
+#     if min_data_length == 0 : # Checagem adicional se algo deu muito errado
+#         print("ERRO: min_data_length é zero após processar ativos, não é possível truncar DataFrames.")
+#         return None
+
+#     print(f"Menor número de linhas de dados encontrado entre os ativos (min_data_length): {min_data_length}")
+#     truncated_asset_features_list = [df.tail(min_data_length) for df in all_asset_features_list if not df.empty and len(df) >= min_data_length]
+
+#     # Verificar se a lista de DFs truncados não está vazia ANTES de concatenar
+#     if not truncated_asset_features_list:
+#         print("ERRO: Nenhum DataFrame válido restou após o truncamento. Não é possível concatenar.")
+#         return None
+
+#     print(f"Concatenando {len(truncated_asset_features_list)} DataFrames de ativos...")
+#     try:
+#         combined_df = pd.concat(truncated_asset_features_list, axis=1, join='inner')
+#     except Exception as e_concat:
+#         print(f"ERRO durante pd.concat: {e_concat}")
+#         return None # Retorna None em caso de erro na concatenação
+
+#     # Agora, combined_df DEVE ser um DataFrame (mesmo que vazio se o join falhar)
+#     if not isinstance(combined_df, pd.DataFrame):
+#         print(f"ERRO: pd.concat não retornou um DataFrame. Tipo retornado: {type(combined_df)}")
+#         return None
+
+#     if combined_df.empty: # Esta checagem agora deve funcionar ou ser desnecessária se o anterior já retornou None
+#         print("ERRO: DataFrame combinado está vazio após concatenação e join. Verifique os dados dos ativos e o alinhamento de datas.")
+#         return None
+        
+#     combined_df.dropna(inplace=True)
+    
+#     if combined_df.empty: # Checagem final após dropna
+#         print("ERRO: DataFrame combinado está vazio após dropna final.")
+#         return None
+
+#     print(f"\nDataFrame multi-ativo final gerado com shape: {combined_df.shape}")
+#     return combined_df
+
+
+
+
+def fetch_single_asset_ohlcv_yf(ticker_symbol: str, period: str = "2y", interval: str = "1h") -> pd.DataFrame:
+    """ Adaptação da sua função fetch_historical_ohlcv de financial_data_agent.py """
+    print(f"Buscando dados para {ticker_symbol} com yfinance (period: {period}, interval: {interval})...")
+    try:
+        ticker = yf.Ticker(ticker_symbol)
+        # Para dados horários, o período máximo é geralmente 730 dias com yfinance
+        # Se precisar de mais, considere '1d' e depois reamostre, ou use ccxt para cripto.
+        if interval == '1h' and period.endswith('y') and int(period[:-1]) * 365 > 730:
+             print(f"AVISO: yfinance pode limitar dados horários a 730 dias. Buscando 'max' para {interval} e depois fatiando.")
+             data = ticker.history(interval=interval, period="730d") # Pega o máximo possível
+        elif interval == '1d' and period.endswith('y'):
+             data = ticker.history(period=period, interval=interval)
+        else: # Para períodos menores ou outros intervalos
+            data = ticker.history(period=period, interval=interval)
+
+        if data.empty:
+            print(f"Nenhum dado encontrado para {ticker_symbol}.")
+            return pd.DataFrame()
+        
+        data.rename(columns={
+            "Open": "open", "High": "high", "Low": "low", 
+            "Close": "close", "Volume": "volume", "Adj Close": "adj_close"
+        }, inplace=True)
+        
+        # Selecionar apenas as colunas OHLCV e garantir que o índice é DatetimeIndex UTC
+        data = data[['open', 'high', 'low', 'close', 'volume']]
+        if data.index.tz is None:
+            data.index = data.index.tz_localize('UTC')
+        else:
+            data.index = data.index.tz_convert('UTC')
+
+        # Para dados horários, yfinance pode retornar dados do fim de semana (sem volume)
+        # e o último candle pode estar incompleto.
+        # if interval == '1h':
+        #     data = data[data['volume'] > 0] # Remover candles sem volume
+            # data = data[:-1] # Remover o último candle que pode estar incompleto
+
+        print(f"Dados coletados para {ticker_symbol}: {len(data)} linhas.")
+        return data
+    except Exception as e:
+        print(f"Erro ao buscar dados para {ticker_symbol} com yfinance: {e}")
+        return pd.DataFrame()
+
+
+def calculate_all_features_for_single_asset(ohlcv_df: pd.DataFrame) -> Optional[pd.DataFrame]:
+    """Calcula todas as features base para um único ativo."""
+    if ohlcv_df.empty: return None
+    df = ohlcv_df.copy()
+    print(f"Calculando features para ativo (shape inicial: {df.shape})...")
+
+    # GARANTIR que a coluna 'close' original será preservada no DataFrame final
+    if 'close' in df.columns:
+        df['close'] = df['close']  # redundante, mas deixa explícito que não será sobrescrita
+
+    if ta:
+        df.ta.sma(length=10, close='close', append=True, col_names=('sma_10',))
+        df.ta.rsi(length=14, close='close', append=True, col_names=('rsi_14',))
+        macd_out = df.ta.macd(close='close', append=False)
+        if macd_out is not None and not macd_out.empty:
+            df['macd'] = macd_out.iloc[:,0]
+            df['macds'] = macd_out.iloc[:,2] # Linha de sinal para buy_condition
+        df.ta.atr(length=14, append=True, col_names=('atr',))
+        df.ta.bbands(length=20, close='close', append=True, col_names=('bbl', 'bbm', 'bbu', 'bbb', 'bbp'))
+        df.ta.cci(length=37, append=True, col_names=('cci_37',))
+        df['volume'] = df['volume'].astype(float) 
+        df.ta.mfi(length=37, close='close', high='high', low='low', volume='volume', append=True, col_names=('mfi_37',))
+        df.ta.mfi(length=37, append=True, col_names=('mfi_37',))
+        adx_out = df.ta.adx(length=14, append=False)
+        if adx_out is not None and not adx_out.empty:
+             df['adx_14'] = adx_out.iloc[:,0]
+        
+        rolling_vol_mean = df['volume'].rolling(window=20).mean()
+        rolling_vol_std = df['volume'].rolling(window=20).std()
+        df['volume_zscore'] = (df['volume'] - rolling_vol_mean) / (rolling_vol_std + 1e-9)
+
+        df['body_size'] = abs(df['close'] - df['open'])
+        
+        # ATR precisa existir para as próximas. Drop NaNs do ATR primeiro.
+        df.dropna(subset=['atr'], inplace=True)
+        df_atr_valid = df[df['atr'] > 1e-9].copy()
+        if df_atr_valid.empty:
+            print("AVISO: ATR inválido para todas as linhas restantes, features _div_atr e body_size_norm_atr podem ser todas NaN ou vazias.")
+            # Criar colunas com NaN para manter a estrutura
+            df['body_size_norm_atr'] = np.nan
+            for col in COLS_TO_NORM_BY_ATR:
+                df[f'{col}_div_atr'] = np.nan
+        else:
+            df['body_size_norm_atr'] = df['body_size'] / df['atr'] # ATR já filtrado para > 1e-9
+            for col in COLS_TO_NORM_BY_ATR:
+                if col in df.columns:
+                    df[f'{col}_div_atr'] = df[col] / (df['atr'] + 1e-9) # Adicionar 1e-9 aqui também por segurança
+                else:
+                    df[f'{col}_div_atr'] = np.nan
+
+
+        df['body_vs_avg_body'] = df['body_size'] / (df['body_size'].rolling(window=20).mean() + 1e-9)
+        df['log_return'] = np.log(df['close'] / df['close'].shift(1))
+        
+        sma_50_series = df.ta.sma(length=50, close='close', append=False)
+        if sma_50_series is not None: df['sma_50'] = sma_50_series
+        else: df['sma_50'] = np.nan
+        
+        if all(col in df.columns for col in ['macd', 'macds', 'rsi_14', 'close', 'sma_50']):
+            df['buy_condition_v1'] = ((df['macd'] > df['macds']) & (df['rsi_14'] > 50) & (df['close'] > df['sma_50'])).astype(int)
+        else:
+            df['buy_condition_v1'] = 0
+        
+        # Selecionar apenas as colunas que realmente usaremos como features base para o modelo
+        # (incluindo as _div_atr e as originais que não foram normalizadas por ATR)
+        # Esta lista de features é a que será passada para os scalers no script de treino.
+        # E também as colunas que o rnn_predictor.py precisará ter antes de aplicar seus scalers.
+        # Esta lista deve vir do config.py (BASE_FEATURE_COLS)
+        
+        # Exemplo:
+        # final_feature_columns = [
+        #    'open_div_atr', 'high_div_atr', 'low_div_atr', 'close_div_atr', 'volume_div_atr', 
+        #    'log_return', 'rsi_14', 'atr', 'bbp', 'cci_37', 'mfi_37', 
+        #    'body_size_norm_atr', 'body_vs_avg_body', 'macd', 'sma_10_div_atr', 
+        #    'adx_14', 'volume_zscore', 'buy_condition_v1'
+        # ] # Esta é a BASE_FEATURE_COLS do seu config.py
+
+        # Verificar se todas as colunas em INDIVIDUAL_ASSET_BASE_FEATURES existem
+        # (INDIVIDUAL_ASSET_BASE_FEATURES deve ser igual a config.BASE_FEATURE_COLS)
+        current_feature_cols = [col for col in INDIVIDUAL_ASSET_BASE_FEATURES if col in df.columns]
+        missing_cols = [col for col in INDIVIDUAL_ASSET_BASE_FEATURES if col not in df.columns]
+        if missing_cols:
+            print(f"AVISO: Colunas de features ausentes após cálculo: {missing_cols}. Usando apenas as disponíveis: {current_feature_cols}")
+        # GARANTIR que 'close' (preço original) está presente nas features finais
+        if 'close' not in current_feature_cols and 'close' in df.columns:
+            current_feature_cols.append('close')
+        
+        df_final_features = df[current_feature_cols].copy()
+        df_final_features.dropna(inplace=True)
+        print(f"Features calculadas. Shape após dropna: {df_final_features.shape}. Colunas: {df_final_features.columns.tolist()}")
+        return df_final_features
+    else:
+        print("pandas_ta não está disponível.")
+        return None
+
+
+if __name__ == '__main__':
+    print("Testando data_handler_multi_asset.py...")
+    # Substitua pelos tickers yfinance reais que você quer usar
+    test_assets = {
+        'eth': 'ETH-USD', 
+        'btc': 'BTC-USD',
+        # 'aapl': 'AAPL' # Exemplo de ação
+    }
+    multi_asset_data = get_multi_asset_data_for_rl(
+        test_assets, 
+        timeframe_yf='1h', # Para teste rápido, período menor
+        days_to_fetch=90   # Para teste rápido, período menor
+    )
+
+    if multi_asset_data is not None and not multi_asset_data.empty:
+        print("\n--- Exemplo do DataFrame Multi-Ativo Gerado ---")
+        print(multi_asset_data.head())
+        print(f"\nShape: {multi_asset_data.shape}")
+        print(f"\nInfo:")
+        multi_asset_data.info()
+    else:
+        print("\nFalha ao gerar DataFrame multi-ativo.")

agents/agents/dataset_update_agent.py

@@ -0,0 +1,9 @@
+# agents/dataset_update_agent.py
+import pandas as pd
+from datetime import datetime
+
+def update_dataset(path="data/sp500_news.csv", new_data=pd.DataFrame()):
+    df = pd.read_csv(path)
+    combined = pd.concat([df, new_data]).drop_duplicates().reset_index(drop=True)
+    combined.to_csv(path, index=False)
+    print(f"Dataset atualizado: {path}")

agents/agents/deep_portfolio.py

@@ -0,0 +1,104 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.layers import LSTM, Dense, Conv1D, MultiHeadAttention
+from transformers import AutoTokenizer, TFAutoModelForSequenceClassification # Changed here
+import gymnasium as gym
+from gymnasium import spaces
+
+class DeepPortfolioAI(tf.keras.Model):
+    def __init__(self, num_assets, sequence_length=60):
+        super(DeepPortfolioAI, self).__init__()
+        
+        # Parâmetros do modelo
+        self.num_assets = num_assets
+        self.sequence_length = sequence_length
+        
+        # CNN para análise de padrões técnicos
+        self.conv1 = Conv1D(64, 3, activation='relu')
+        self.conv2 = Conv1D(128, 3, activation='relu')
+        
+        # LSTM para análise temporal
+        self.lstm1 = LSTM(128, return_sequences=True)
+        self.lstm2 = LSTM(64)
+        
+        # Attention para correlações entre ativos
+        self.attention = MultiHeadAttention(num_heads=8, key_dim=64)
+        
+        # Camadas densas para decisão final
+        self.dense1 = Dense(256, activation='relu')
+        self.dense2 = Dense(128, activation='relu')
+        self.output_layer = Dense(num_assets, activation='softmax')
+        
+        # Inicializar tokenizer e modelo de sentimento
+        self.tokenizer = AutoTokenizer.from_pretrained('ProsusAI/finbert')
+        self.sentiment_model = TFAutoModelForSequenceClassification.from_pretrained('ProsusAI/finbert') # Changed here
+
+    def call(self, inputs):
+        market_data, news_data = inputs
+        
+        # Análise técnica com CNN
+        x_technical = self.conv1(market_data)
+        x_technical = self.conv2(x_technical)
+        
+        # Análise temporal com LSTM
+        x_temporal = self.lstm1(x_technical)
+        x_temporal = self.lstm2(x_temporal)
+        
+        # Attention para correlações
+        x_attention = self.attention(x_temporal, x_temporal, x_temporal)
+        
+        # Combinar com análise de sentimento
+        sentiment_embeddings = self._process_news(news_data)
+        x_combined = tf.concat([x_attention, sentiment_embeddings], axis=-1)
+        
+        # Camadas densas finais
+        x = self.dense1(x_combined)
+        x = self.dense2(x)
+        return self.output_layer(x)
+    
+    def _process_news(self, news_data):
+        inputs = self.tokenizer(news_data, return_tensors="pt", padding=True, truncation=True)
+        sentiment_scores = self.sentiment_model(**inputs).logits
+        return tf.convert_to_tensor(sentiment_scores.detach().numpy())
+
+class PortfolioEnvironment(gym.Env):
+    def __init__(self, data, initial_balance=100000):
+        super(PortfolioEnvironment, self).__init__()
+        
+        self.data = data
+        self.initial_balance = initial_balance
+        self.current_step = 0
+        
+        # Define espaços de ação e observação
+        self.action_space = spaces.Box(
+            low=0, high=1, shape=(len(data.columns),), dtype=np.float32)
+        self.observation_space = spaces.Box(
+            low=-np.inf, high=np.inf, shape=(60, len(data.columns)), dtype=np.float32)
+        
+    def reset(self):
+        self.current_step = 0
+        self.balance = self.initial_balance
+        self.portfolio = np.zeros(len(self.data.columns))
+        return self._get_observation()
+    
+    def step(self, action):
+        # Implementar lógica de negociação
+        current_prices = self.data.iloc[self.current_step]
+        next_prices = self.data.iloc[self.current_step + 1]
+        
+        # Calcular retorno
+        returns = (next_prices - current_prices) / current_prices
+        reward = np.sum(action * returns)
+        
+        # Atualizar portfolio
+        self.portfolio = action
+        self.balance *= (1 + reward)
+        
+        # Incrementar step
+        self.current_step += 1
+        done = self.current_step >= len(self.data) - 1
+        
+        return self._get_observation(), reward, done, {}
+    
+    def _get_observation(self):
+        return self.data.iloc[self.current_step-60:self.current_step].values

agents/agents/deep_portfolio_torch.py

@@ -0,0 +1,80 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class SingleAssetProcessor(nn.Module):
+    def __init__(self, sequence_length, num_features_per_asset, cnn_filters1, cnn_filters2, lstm_units):
+        super().__init__()
+        self.conv1 = nn.Conv1d(num_features_per_asset, cnn_filters1, kernel_size=3, padding=1)
+        self.conv2 = nn.Conv1d(cnn_filters1, cnn_filters2, kernel_size=3, padding=1)
+        self.lstm = nn.LSTM(input_size=cnn_filters2, hidden_size=lstm_units, batch_first=True)
+
+    def forward(self, x):
+        # x: (batch, seq_len, num_features_per_asset)
+        x = x.transpose(1, 2)  # (batch, num_features_per_asset, seq_len)
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = x.transpose(1, 2)  # (batch, seq_len, cnn_filters2)
+        _, (h_n, _) = self.lstm(x)  # h_n: (1, batch, lstm_units)
+        return h_n.squeeze(0)  # (batch, lstm_units)
+
+class DeepPortfolioAgentNetworkTorch(nn.Module):
+    def __init__(self, num_assets, sequence_length, num_features_per_asset,
+                 asset_cnn_filters1=32, asset_cnn_filters2=64,
+                 asset_lstm_units1=64, asset_lstm_units2=32,
+                 final_dense_units1=128, final_dense_units2=32,
+                 final_dropout=0.3, mha_num_heads=4, mha_key_dim_divisor=2,
+                 output_latent_features=True, use_sentiment_analysis=False):
+        super().__init__()
+        self.num_assets = num_assets
+        self.sequence_length = sequence_length
+        self.num_features_per_asset = num_features_per_asset
+        self.output_latent_features = output_latent_features
+        self.use_sentiment_analysis = use_sentiment_analysis
+
+        # Processador individual de ativos
+        self.asset_processor = SingleAssetProcessor(
+            sequence_length, num_features_per_asset,
+            asset_cnn_filters1, asset_cnn_filters2, asset_lstm_units1
+        )
+        # Atenção multi-cabeça
+        self.attention = nn.MultiheadAttention(
+            embed_dim=asset_lstm_units1,
+            num_heads=mha_num_heads,
+            batch_first=True
+        )
+        # Pooling global
+        self.global_avg_pool = nn.AdaptiveAvgPool1d(1)
+        # Camadas densas finais
+        self.dense1 = nn.Linear(asset_lstm_units1, final_dense_units1)
+        self.dropout1 = nn.Dropout(final_dropout)
+        self.dense2 = nn.Linear(final_dense_units1, final_dense_units2)
+        self.dropout2 = nn.Dropout(final_dropout)
+        self.output_allocation = nn.Linear(final_dense_units2, num_assets)
+
+    def forward(self, x):
+        # x: (batch, seq_len, num_assets * num_features_per_asset)
+        batch_size = x.size(0)
+        # Separar cada ativo
+        asset_representations = []
+        for i in range(self.num_assets):
+            start = i * self.num_features_per_asset
+            end = (i + 1) * self.num_features_per_asset
+            asset_data = x[:, :, start:end]  # (batch, seq_len, num_features_per_asset)
+            asset_repr = self.asset_processor(asset_data)  # (batch, lstm_units1)
+            asset_representations.append(asset_repr)
+        # Empilhar ativos: (batch, num_assets, lstm_units1)
+        stacked = torch.stack(asset_representations, dim=1)
+        # Atenção multi-cabeça
+        attn_output, _ = self.attention(stacked, stacked, stacked)
+        # Pooling global sobre ativos (num_assets)
+        pooled = self.global_avg_pool(attn_output.transpose(1,2)).squeeze(-1)  # (batch, lstm_units1)
+        # Camadas densas finais
+        x = F.relu(self.dense1(pooled))
+        x = self.dropout1(x)
+        x = F.relu(self.dense2(x))
+        x = self.dropout2(x)
+        if self.output_latent_features:
+            return x  # (batch, final_dense_units2)
+        else:
+            return F.softmax(self.output_allocation(x), dim=-1)  # (batch, num_assets)

agents/agents/financial_data_agent.py

@@ -0,0 +1,76 @@
+# agents/financial_data_agent.py
+import yfinance as yf
+import pandas as pd
+from agno.agent import Agent # Commented out
+from agno.models.anthropic import Claude # Commented out
+from agno.tools.yfinance import YFinanceTools # Commented out
+
+def get_stock_report(ticker="NVDA"): # Commented out
+    agent = Agent(
+        model=Claude(id="claude-3-7-sonnet-latest"),
+        tools=[
+            YFinanceTools(
+                stock_price=True,
+                analyst_recommendations=True,
+                company_info=True,
+                company_news=True,
+            )
+        ],
+        instructions=[
+            "Use tables to display data",
+            "Only output the report, no other text",
+        ],
+        markdown=True,
+    )
+    return agent.get_response(f"Write a financial report on {ticker}")
+
+def fetch_historical_ohlcv(ticker_symbol: str, period: str = "1y", interval: str = "1d") -> pd.DataFrame:
+    """
+    Fetches historical OHLCV data for a given ticker symbol.
+
+    Args:
+        ticker_symbol (str): The stock ticker symbol (e.g., "AAPL" for Apple on NASDAQ,
+                             "PETR4.SA" for Petrobras on B3, "000001.SS" for SSE Composite Index).
+        period (str): The period for which to download data (e.g., "1d", "5d", "1mo", "3mo", "6mo", "1y", "2y", "5y", "10y", "ytd", "max").
+        interval (str): The interval of data points (e.g., "1m", "2m", "5m", "15m", "30m", "60m", "90m", "1h", "1d", "5d", "1wk", "1mo", "3mo").
+
+    Returns:
+        pd.DataFrame: A pandas DataFrame containing the OHLCV data, or an empty DataFrame if an error occurs.
+    """
+    try:
+        ticker = yf.Ticker(ticker_symbol)
+        data = ticker.history(period=period, interval=interval)
+        if data.empty:
+            print(f"No data found for {ticker_symbol} for the given period/interval.")
+            return pd.DataFrame()
+        # Ensure column names are consistent (Yahoo Finance sometimes uses 'Adj Close')
+        data.rename(columns={"Adj Close": "Adj_Close"}, inplace=True)
+        return data
+    except Exception as e:
+        print(f"Error fetching data for {ticker_symbol}: {e}")
+        return pd.DataFrame()
+
+if __name__ == '__main__':
+    # Example usage:
+    # NASDAQ
+    aapl_data = fetch_historical_ohlcv("AAPL", period="1mo", interval="1d")
+    if not aapl_data.empty:
+        print("\nAAPL Data (NASDAQ):")
+        print(aapl_data.head())
+
+    # B3 (Brazilian Stock Exchange) - Example: Petrobras
+    petr4_data = fetch_historical_ohlcv("PETR4.SA", period="1mo", interval="1d")
+    if not petr4_data.empty:
+        print("\nPETR4.SA Data (B3):")
+        print(petr4_data.head())
+
+    # Asian Market - Example: Samsung Electronics (Korea Exchange)
+    samsung_data = fetch_historical_ohlcv("005930.KS", period="1mo", interval="1d")
+    if not samsung_data.empty:
+        print("\n005930.KS Data (Samsung - KRX):")
+        print(samsung_data.head())
+    
+    # Example for a non-existent ticker or error
+    error_data = fetch_historical_ohlcv("NONEXISTENTTICKER", period="1d")
+    if error_data.empty:
+        print("\nSuccessfully handled non-existent ticker.")

agents/agents/investment_agent.py

@@ -0,0 +1,7 @@
+# agents/investment_agent.py
+def execute_investment(prediction, threshold=0.8):
+    if prediction > threshold:
+        print("Comprar ativos com probabilidade:", prediction)
+        # chamada API para execução real
+    else:
+        print("Não investir. Probabilidade baixa:", prediction)

agents/agents/portfolio_environment.py

@@ -0,0 +1,246 @@
+# agents/portfolio_environment.py (ou atcoin_env.py)
+
+from typing import List
+import numpy as np
+import pandas as pd
+import gymnasium as gym
+from gymnasium import spaces
+from collections import deque
+
+# Importar do config.py
+# from ..config import WINDOW_SIZE # Ajuste o import
+WINDOW_SIZE_ENV = 60 # Exemplo, pegue do config
+NUM_ASSETS=4
+WINDOW_SIZE=60
+
+NUM_FEATURES_PER_ASSET=26
+
+
+
+
+
+
+class PortfolioEnv(gym.Env): # Renomeado para seguir convenção de Gymnasium (Opcional)
+    metadata = {'render_modes': ['human'], 'render_fps': 30}
+
+    def __init__(self, df_multi_asset_features: pd.DataFrame, 
+                 asset_symbols_list: List[str], # Lista de chaves dos ativos ex: ['crypto_eth', 'stock_aapl']
+                 initial_balance=100000, 
+                 window_size=WINDOW_SIZE_ENV,
+                 transaction_cost_pct=0.001,
+                 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__()
+        
+        self.df = df_multi_asset_features.copy() # DataFrame ACHATADO com todas as features de todos os ativos
+        self.asset_keys = asset_symbols_list # Usado para identificar colunas de preço de fechamento
+        self.num_assets = len(asset_symbols_list)
+        self.initial_balance = initial_balance
+        self.window_size = window_size
+        self.transaction_cost_pct = transaction_cost_pct
+        self.reward_window_size = reward_window_size
+        # Cálculo automático da taxa livre de risco por passo se não for passada
+        RISK_FREE_RATE_ANNUAL = 0.02 # 2% ao ano
+        TRADING_DAYS_PER_YEAR = 252
+        HOURS_PER_DAY_TRADING = 24
+        if risk_free_rate_per_step is None:
+            self.risk_free_rate_per_step = RISK_FREE_RATE_ANNUAL / (TRADING_DAYS_PER_YEAR * HOURS_PER_DAY_TRADING)
+        else:
+            self.risk_free_rate_per_step = risk_free_rate_per_step
+        self.portfolio_returns_history = deque(maxlen=self.reward_window_size) # Armazena retorenos do portifólio por passos
+        
+        self.current_step = 0
+        self.balance = self.initial_balance
+        self.portfolio_weights = np.full(self.num_assets, 1.0 / self.num_assets if self.num_assets > 0 else 0) # Pesos iniciais iguais
+        self.portfolio_value = self.initial_balance
+        self.total_steps = len(self.df) - self.window_size -2 # -1 para ter um next_prices
+
+        # Espaço de Ação: pesos do portfólio para cada ativo (devem somar 1, via Softmax da rede)
+        # A rede neural vai outputar pesos que somam 1 (softmax).
+        self.action_space = spaces.Box(low=0, high=1, shape=(NUM_ASSETS,), dtype=np.float32)
+        
+        # Espaço de Observação: janela de N features para M ativos (achatado)
+        # O número de colunas no df é num_assets * num_features_per_asset
+        num_total_features = self.df.shape[1]
+        self.observation_space = spaces.Box(
+            low=-np.inf, high=np.inf, 
+            shape=(WINDOW_SIZE, NUM_ASSETS * NUM_FEATURES_PER_ASSET), 
+            dtype=np.float32
+        )
+
+
+        
+        
+        self.current_prices_cols = [f"{key}_close" for key in self.asset_keys] # Assumindo que 'close' é uma das features base
+        # Se você usa 'close_div_atr', então seria f"{key}_close_div_atr"
+        # É importante ter uma coluna de preço de fechamento *original* (não escalada, não normalizada por ATR)
+        # para calcular os retornos reais do portfólio. Se não estiver no df, precisará ser adicionada/mantida.
+        # Por agora, vamos assumir que o df passado já tem as colunas de preço de fechamento originais,
+        # ou você precisará de um df separado só com os preços para o cálculo de retorno.
+        # VOU ASSUMIR QUE VOCÊ ADICIONA COLUNAS DE PREÇO DE FECHAMENTO ORIGINAIS AO `df_multi_asset_features`
+        # com nomes como `eth_orig_close`, `ada_orig_close` etc.
+        self.orig_close_price_cols = [f"{asset_prefix}_close" for asset_prefix in self.asset_keys] # Ex: 'crypto_eth_close'
+
+        # Verificar se as colunas de preço de fechamento original existem
+        missing_price_cols = [col for col in self.orig_close_price_cols if col not in self.df.columns]
+        if missing_price_cols:
+            raise ValueError(f"Colunas de preço de fechamento original ausentes no DataFrame do ambiente: {missing_price_cols}. "
+                             "Adicione-as ao DataFrame com prefixo do ativo (ex: 'crypto_eth_close').")
+
+
+    def _get_observation(self):
+        # Pega as features da janela atual
+        # O DataFrame self.df já deve estar achatado e conter TODAS as features de TODOS os ativos
+        start = self.current_step
+        end = start + self.window_size
+        obs = self.df.iloc[start:end].values
+        return obs.astype(np.float32)
+
+    def _get_current_prices(self):
+        # Pega os preços de fechamento originais do passo atual para cálculo de retorno
+        # O índice é window_size - 1 dentro da observação atual, que corresponde a self.current_step + self.window_size -1 no df original.
+        # Mas para o cálculo de PnL, precisamos do preço no início do step e no final do step.
+        # Preço no início do step (t)
+        return self.df[self.orig_close_price_cols].iloc[self.current_step + self.window_size -1].values
+
+    def _get_next_prices(self):
+        # Preço no final do step (t+1)
+        return self.df[self.orig_close_price_cols].iloc[self.current_step + self.window_size].values
+
+    def reset(self, seed=None, options=None): # Assinatura atualizada do Gymnasium
+        super().reset(seed=seed) # Importante para Gymnasium
+        self.current_step = 0 # Inicia do primeiro ponto onde uma janela completa pode ser formada
+        self.balance = self.initial_balance
+        self.portfolio_value = self.initial_balance
+        self.portfolio_weights = np.full(self.num_assets, 1.0 / self.num_assets if self.num_assets > 0 else 0)
+        self.portfolio_returns_history.clear()
+
+        observation = self._get_observation()
+        info = self._get_info() # Informações adicionais (opcional)
+        return observation, info
+    
+    def _calculate_sharpe_ratio(self) -> float:
+        """Calcula o Sharpe Ratio anualizado a partir do histórico de retornos por passo."""
+        if len(self.portfolio_returns_history) < self.reward_window_size / 2: # Precisa de um mínimo de dados
+            return 0.0 # Ou uma pequena penalidade por não ter histórico suficiente
+
+        returns_array = np.array(self.portfolio_returns_history)
+        
+        # Média dos retornos por passo
+        mean_return_per_step = np.mean(returns_array)
+        # Desvio padrão dos retornos por passo
+        std_return_per_step = np.std(returns_array)
+
+        print(f"    DEBUG Sharpe: mean_ret_step={mean_return_per_step:.6f}, std_ret_step={std_return_per_step:.6f}, risk_free_step={self.risk_free_rate_per_step:.8f}")
+
+        if std_return_per_step < 1e-9: # Evitar divisão por zero se não houver volatilidade
+            print("    DEBUG Sharpe: Std dev muito baixo, retornando 0.")
+            return 0.0 
+
+        # Sharpe Ratio por passo
+        sharpe_per_step = (mean_return_per_step - self.risk_free_rate_per_step) / std_return_per_step
+        
+        # Anualizar o Sharpe Ratio (assumindo passos horários e ~252 dias de negociação * 24 horas)
+        annualization_factor = np.sqrt(252 * 24) # Ajuste se seu timeframe for diferente
+        
+        annualized_sharpe = sharpe_per_step * annualization_factor
+        print(f"    DEBUG Sharpe: sharpe_per_step={sharpe_per_step:.4f}, annualized_sharpe={annualized_sharpe:.4f}")
+        return annualized_sharpe
+
+
+    def step(self, action_weights: np.ndarray): # Ação são os pesos do portfólio
+        current_portfolio_value_before_rebalance = self.portfolio_value
+
+        # Normalizar pesos da ação se não somarem 1 (saída softmax da rede já deve fazer isso)
+
+        if not np.isclose(np.sum(action_weights), 1.0):
+            action_weights = action_weights / (np.sum(action_weights) + 1e-9)
+        action_weights = np.clip(action_weights, 0, 1) # Garantir que os pesos estão entre 0 e 1 # Normaliza
+        
+        # Calcular custo de transação para rebalancear
+        # Valor de cada ativo ANTES do rebalanceamento
+        current_asset_values = self.portfolio_weights * current_portfolio_value_before_rebalance
+        # Valor de cada ativo DEPOIS do rebalanceamento (com base nos novos pesos)
+        target_asset_values = action_weights * current_portfolio_value_before_rebalance # Valor do portfólio ainda não mudou por preço
+
+        # Volume negociado (absoluto) para cada ativo
+        trade_volume_per_asset = np.abs(target_asset_values - current_asset_values)
+        total_trade_volume = np.sum(trade_volume_per_asset)
+        transaction_costs = total_trade_volume * self.transaction_cost_pct
+        
+        # Deduzir custos do valor do portfólio
+        current_portfolio_value_after_costs = current_portfolio_value_before_rebalance - transaction_costs
+        
+        # Atualizar os pesos do portfólio
+        self.portfolio_weights = action_weights
+        
+        # Pegar preços atuais (t) e próximos (t+1)
+        prices_t = self._get_current_prices()
+        self.current_step += 1 # Avançar para o próximo estado
+        prices_t_plus_1 = self._get_next_prices()
+
+        # Calcular retornos dos ativos
+        asset_returns_on_step = (prices_t_plus_1 - prices_t) / (prices_t + 1e-9)
+        
+        # Calcular retorno do portfólio neste passo, APÓS custos e com os NOVOS pesos
+        portfolio_return_on_step = np.sum(self.portfolio_weights * asset_returns_on_step)
+        
+        # Atualizar valor do portfólio
+        self.portfolio_value = current_portfolio_value_after_costs * (1 + portfolio_return_on_step)
+        
+        # Adicionar retorno do passo ao histórico
+        self.portfolio_returns_history.append(portfolio_return_on_step)
+        
+        # Calcular Recompensa (Sharpe Ratio)
+        # Pode ser o Sharpe Ratio incremental ou o Sharpe Ratio da janela inteira
+        # Para RL, uma recompensa mais frequente é geralmente melhor.
+        # Usar o retorno do passo como recompensa imediata pode ser mais estável para PPO.
+        # Ou, podemos dar o Sharpe Ratio da janela como recompensa a cada N passos, ou no final.
+        # Por agora, vamos usar o retorno do passo como recompensa principal, e o Sharpe pode ser parte do 'info'.
+        # Se quisermos o Sharpe Ratio *como* recompensa, ele seria calculado aqui.
+        
+        # Opção A: Recompensa = Retorno do Passo (mais simples e denso)
+        # ultima iteração   --  reward = portfolio_return_on_step   
+
+        #Opção B: Recompensa = Sharpe Ratio da Janela (mais complexo, pode ser esparso se calculado raramente)
+        # Em PortfolioEnv.step()
+# reward = portfolio_return_on_step # Recompensa atual
+
+# NOVA RECOMPENSA (Opção B da nossa discussão anterior):
+        REWARD_SCALE_FACTOR_SHARPE = 0.1  # Ou 0.01, experimente
+        if len(self.portfolio_returns_history) >= self.reward_window_size:
+            current_sharpe = self._calculate_sharpe_ratio()
+            reward = np.clip(current_sharpe, -5, 5) * REWARD_SCALE_FACTOR_SHARPE
+            print(f"  Sharpe Ratio Calculado: {current_sharpe:.4f}, Recompensa (Sharpe escalado): {reward:.6f}")
+        elif len(self.portfolio_returns_history) > 1:
+            reward = portfolio_return_on_step * 0.1
+            print(f"  Retorno Simples como Recompensa (escalado): {reward:.6f}")
+        else:
+            reward = 0.0
+
+        terminated = self.current_step >= self.total_steps 
+        truncated = False 
+
+        observation = self._get_observation()
+        info = self._get_info() # Adicionar Sharpe Ratio ao info
+
+        return observation, reward, terminated, truncated, info
+
+
+    def _get_info(self): # Opcional, para retornar métricas
+        current_sharpe = self._calculate_sharpe_ratio() if len(self.portfolio_returns_history) > 1 else 0.0
+        return {
+            "current_step": self.current_step,
+            "portfolio_value": self.portfolio_value,
+            "balance": self.balance, # Se você rastrear cash separadamente
+            "portfolio_weights": self.portfolio_weights.tolist(),
+            "last_step_return": self.portfolio_returns_history[-1] if self.portfolio_returns_history else 0.0,
+            "sharpe_ratio_window": current_sharpe
+        }
+
+    def render(self, mode='human'):
+        if mode == 'human':
+            print(f"Step: {self.current_step}, Portfolio Value: {self.portfolio_value:.2f}, Weights: {self.portfolio_weights}")
+
+    def close(self):
+        pass # Limpar recursos se necessário

agents/agents/portfolio_features_extractor_torch.py

@@ -0,0 +1,35 @@
+import torch
+import torch.nn as nn
+from stable_baselines3.common.torch_layers import BaseFeaturesExtractor
+from deep_portfolio_torch import DeepPortfolioAgentNetworkTorch
+
+class PortfolioFeaturesExtractorTorch(BaseFeaturesExtractor):
+    def __init__(self, observation_space, features_dim=32,
+                 num_assets=4, sequence_length=60, num_features_per_asset=26,
+                 asset_cnn_filters1=32, asset_cnn_filters2=64,
+                 asset_lstm_units1=64, asset_lstm_units2=32,
+                 final_dense_units1=128, final_dense_units2=32,
+                 final_dropout=0.3, mha_num_heads=4, mha_key_dim_divisor=2,
+                 output_latent_features=True, use_sentiment_analysis=False):
+        super().__init__(observation_space, features_dim)
+        self.network = DeepPortfolioAgentNetworkTorch(
+            num_assets=num_assets,
+            sequence_length=sequence_length,
+            num_features_per_asset=num_features_per_asset,
+            asset_cnn_filters1=asset_cnn_filters1,
+            asset_cnn_filters2=asset_cnn_filters2,
+            asset_lstm_units1=asset_lstm_units1,
+            asset_lstm_units2=asset_lstm_units2,
+            final_dense_units1=final_dense_units1,
+            final_dense_units2=final_dense_units2,
+            final_dropout=final_dropout,
+            mha_num_heads=mha_num_heads,
+            mha_key_dim_divisor=mha_key_dim_divisor,
+            output_latent_features=output_latent_features,
+            use_sentiment_analysis=use_sentiment_analysis
+        )
+        self._features_dim = features_dim
+
+    def forward(self, observations):
+        # observations: (batch, seq_len, num_assets * num_features_per_asset)
+        return self.network(observations)

agents/agents/ppo_deep_portfolio_tensorboard/PPO_1/events.out.tfevents.1750287361.verticalagent-X555LPB.89910.0

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

agents/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/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/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/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/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/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/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/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/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