RL training in NN working

NN/models/simple_cnn.py

@@ -13,10 +13,9 @@ logger = logging.getLogger(__name__)
 
 class CNNModelPyTorch(nn.Module):
     """
-    CNN model for trading signals
-    Simplified version for RL training
+    CNN model for trading with multiple timeframes
     """
-    def __init__(self, window_size: int, num_features: int, output_size: int, timeframes: List[str]):
+    def __init__(self, window_size, num_features, output_size, timeframes):
         super(CNNModelPyTorch, self).__init__()
         
         self.window_size = window_size
@@ -24,12 +23,33 @@ class CNNModelPyTorch(nn.Module):
         self.output_size = output_size
         self.timeframes = timeframes
         
+        # Calculate total input features across all timeframes
+        self.total_features = num_features * len(timeframes)
+        
         # Device configuration
         self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
         logger.info(f"Using device: {self.device}")
         
-        # Build model
-        self.build_model()
+        # Convolutional layers
+        self.conv1 = nn.Conv1d(self.total_features, 64, kernel_size=3, padding=1)
+        self.bn1 = nn.BatchNorm1d(64)
+        
+        self.conv2 = nn.Conv1d(64, 128, kernel_size=3, padding=1)
+        self.bn2 = nn.BatchNorm1d(128)
+        
+        self.conv3 = nn.Conv1d(128, 256, kernel_size=3, padding=1)
+        self.bn3 = nn.BatchNorm1d(256)
+        
+        # Calculate size after convolutions
+        conv_output_size = window_size * 256
+        
+        # Fully connected layers
+        self.fc1 = nn.Linear(conv_output_size, 512)
+        self.fc2 = nn.Linear(512, 256)
+        
+        # Advantage and Value streams (Dueling DQN architecture)
+        self.fc3 = nn.Linear(256, output_size)  # Advantage stream
+        self.value_fc = nn.Linear(256, 1)  # Value stream
         
         # Initialize optimizer and scheduler
         self.optimizer = optim.Adam(self.parameters(), lr=0.001)
@@ -40,36 +60,6 @@ class CNNModelPyTorch(nn.Module):
         # Move model to device
         self.to(self.device)
         
-    def build_model(self):
-        """Build the CNN architecture"""
-        # First Convolutional Layer
-        self.conv1 = nn.Conv1d(
-            in_channels=self.num_features * len(self.timeframes),
-            out_channels=32,
-            kernel_size=3,
-            padding=1
-        )
-        self.bn1 = nn.BatchNorm1d(32)
-        
-        # Second Convolutional Layer
-        self.conv2 = nn.Conv1d(32, 64, kernel_size=3, padding=1)
-        self.bn2 = nn.BatchNorm1d(64)
-        
-        # Third Convolutional Layer
-        self.conv3 = nn.Conv1d(64, 128, kernel_size=3, padding=1)
-        self.bn3 = nn.BatchNorm1d(128)
-        
-        # Calculate size after convolutions
-        conv_out_size = self.window_size * 128
-        
-        # Fully connected layers
-        self.fc1 = nn.Linear(conv_out_size, 512)
-        self.fc2 = nn.Linear(512, 256)
-        self.fc3 = nn.Linear(256, self.output_size)
-        
-        # Additional output for value estimation
-        self.value_fc = nn.Linear(256, 1)
-    
     def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
         """Forward pass through the network"""
         # Ensure input is on the correct device