Update modeling_omegacode.py with latest corrections

modeling_omegacode.py

@@ -9,7 +9,7 @@ class HolographicMasterCodeTransformer(nn.Module):
         super().__init__()
         self.d_model = d_model
         self.n_harmonics = n_harmonics
-        self.alpha_0 = 1.0 / 137.035
+        self.alpha_0 = torch.tensor(1.0 / 137.035) # Convert to tensor during initialization
         
         self.input_proj = nn.Linear(input_dim, d_model)
         
@@ -30,19 +30,31 @@ class HolographicMasterCodeTransformer(nn.Module):
         )
         
     def forward(self, x, alpha=None):
+        # Ensure alpha_0 is on the correct device
+        if self.alpha_0.device != x.device:
+            self.alpha_0 = self.alpha_0.to(x.device)
+
         if alpha is None:
             alpha = self.alpha_0
+        else:
+            # Convert alpha to a tensor if it's not already, and move to the correct device
+            alpha = torch.tensor(alpha, device=x.device, dtype=x.dtype) if not isinstance(alpha, torch.Tensor) else alpha.to(x.device)
+            
         h = self.input_proj(x)
         h = h.unsqueeze(1)
         h = self.transformer(h)
         h = h.squeeze(1)
         
+        # All operands for arithmetic operations should be tensors now
+        alpha_diff = alpha - self.alpha_0
+        
         psi = torch.zeros_like(h)
         for n in range(self.n_harmonics):
-            phase = 2 * torch.pi * (n + 1) * (alpha - self.alpha_0) * 800.0
+            # Ensure phase calculation uses tensors
+            phase = 2 * torch.pi * (n + 1) * alpha_diff * 800.0
             psi += self.harmonic_weights[n] * torch.cos(h * (n + 1) + phase)
         
-        alpha_dev = torch.abs(alpha - self.alpha_0)
+        alpha_dev = torch.abs(alpha_diff) # Now alpha_diff is guaranteed to be a tensor
         security_factor = torch.exp(-300.0 * alpha_dev)
         
         h = h + 0.35 * psi * security_factor