Update utils.py

utils.py

@@ -270,16 +270,30 @@ def predict_prices(data, model, tokenizer, prediction_days=30):
         # Tokenize the input
         input_sequence = prices[-context_length:]
         
+        # --- CRITICAL FIX: Simulate Quantization ---
+        # 1. Normalize prices (0 to 1)
+        price_min = np.min(input_sequence)
+        price_max = np.max(input_sequence)
+        
+        if price_max == price_min:
+             normalized_sequence = np.zeros_like(input_sequence)
+        else:
+             normalized_sequence = (input_sequence - price_min) / (price_max - price_min)
+
+        # 2. Scale to a token space (max vocab size 4096) and convert to Long
+        VOCAB_SIZE = 4096 
+        # Convert to Long/Int to satisfy model embedding layer
+        token_indices = (normalized_sequence * (VOCAB_SIZE - 1)).astype(np.long) 
+        
         # Create prediction input
-        # CRITICAL FIX: Revert to float, but use max_new_tokens for generation.
-        # This forces the model's custom generation logic to handle the raw floats, 
-        # as manual quantization/token mapping is impossible without the Chronos tokenizer.
-        prediction_input = torch.tensor(input_sequence).unsqueeze(0).float().to(model.device)
+        # Pass tokens to the model
+        prediction_input = torch.tensor(token_indices).unsqueeze(0).to(model.device)
+        # --- END CRITICAL FIX ---
         
         # Generate predictions
         with torch.no_grad():
-            # CRITICAL FIX: Use max_new_tokens, which is standard for Seq2Seq generation length.
-            # Removed prediction_length keyword and added do_sample to align with typical Chronos usage.
+            # Use max_new_tokens for generation length.
+            # do_sample is necessary for generating probabilistic time-series forecasts
             forecast = model.generate(
                 prediction_input,
                 max_new_tokens=prediction_days, 
@@ -287,13 +301,15 @@ def predict_prices(data, model, tokenizer, prediction_days=30):
             )
         
         # Handle complex Chronos output: [batch_size, num_samples, prediction_length]
-        
-        # 1. Get the actual tensor from the tuple/list if necessary
         output_tensor = forecast[0] if isinstance(forecast, (tuple, list)) else forecast
         
-        # 2. Average across the samples (dim=1) and convert to a simple 1D numpy array
-        # output_tensor shape: [1, num_samples, prediction_length] (If sampling, the float values are the predictions)
-        predictions = output_tensor.float().mean(dim=1).squeeze().cpu().numpy()
+        # Average across the samples and convert to a simple 1D numpy array
+        # Note: The output is still in TOKEN SPACE. We must INVERSE-SCALE it back to PRICE SPACE.
+        predictions_tokens = output_tensor.float().mean(dim=1).squeeze().cpu().numpy()
+        
+        # --- CRITICAL INVERSE-SCALE FIX ---
+        # Inverse normalize the predicted tokens back to the price range
+        predictions = (predictions_tokens / (VOCAB_SIZE - 1)) * (price_max - price_min) + price_min
         
         # Handle case where predictions is a single scalar (convert to array for safety)
         if predictions.ndim == 0:
@@ -321,7 +337,7 @@ def predict_prices(data, model, tokenizer, prediction_days=30):
             'mean_30d': predicted_mean,
             'change_pct': change_pct,
             'summary': f"""
-AI Model: Amazon Chronos-Bolt
+AI Model: Amazon Chronos-Bolt (Simulated Quantization)
 Prediction Period: {pred_len} days
 Expected Change: {change_pct:.2f}%
 Confidence: Medium (based on historical patterns)