Update model_handler.py

model_handler.py

@@ -1,62 +1,44 @@
-import torch
 import numpy as np
-from transformers import AutoTokenizer, AutoConfig
-from huggingface_hub import hf_hub_download
-import json
-import os
+import torch
+# Menggunakan ChronosPipeline untuk pemuatan dan inferensi yang efisien
+from chronos import ChronosPipeline
 
 class ModelHandler:
     def __init__(self):
-        self.model_name = "amazon/chronos-t5-small"  # Using smaller model for CPU
-        self.tokenizer = None
-        self.model = None
-        self.device = "cpu"
+        # Mengganti model lama dengan Chronos-2 yang lebih canggih
+        self.model_name = "amazon/chronos-2" 
+        self.pipeline = None
+        # Penentuan device: "cuda" jika ada GPU, jika tidak "cpu"
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
         self.load_model()
     
     def load_model(self):
-        """Load Chronos model optimized for CPU"""
+        """Load Chronos-2 model optimized for CPU/GPU"""
         try:
-            print(f"Loading {self.model_name}...")
-            
-            # Download config
-            config_path = hf_hub_download(
-                repo_id=self.model_name,
-                filename="config.json"
-            )
-            
-            with open(config_path, 'r') as f:
-                config = json.load(f)
-            
-            # Initialize tokenizer
-            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            print(f"Loading {self.model_name} on {self.device}...")
             
-            # For CPU optimization, use TorchScript if available
-            model_path = hf_hub_download(
-                repo_id=self.model_name,
-                filename="model.safetensors"
+            # ChronosPipeline menangani semua proses tokenisasi dan pemuatan arsitektur
+            self.pipeline = ChronosPipeline.from_pretrained(
+                self.model_name,
+                device_map=self.device,
             )
-            
-            # Load model state dict
-            from safetensors.torch import load_file
-            state_dict = load_file(model_path)
-            
-            # Create model from config (simplified for CPU)
-            # In production, would load full model architecture
-            print("Model loaded successfully (optimized for CPU)")
+            print("Chronos-2 pipeline loaded successfully.")
             
         except Exception as e:
-            print(f"Error loading model: {e}")
+            print(f"Error loading Chronos-2 model: {e}")
             print("Using fallback prediction method")
-            self.model = None
+            self.pipeline = None
     
     def predict(self, data, horizon=10):
-        """Generate predictions using Chronos or fallback"""
+        """Generate predictions using Chronos-2 or fallback"""
         try:
-            if data is None or len(data['values']) < 20:
+            # Menggunakan data['original'] yang merupakan harga aktual riil
+            if data is None or len(data['original']) < 20:
                 return np.array([0] * horizon)
             
-            if self.model is None:
-                # Fallback: Use simple trend extrapolation for CPU efficiency
+            if self.pipeline is None:
+                # --- Fallback Logic ---
+                # Logic ekstrapolasi tren lama tetap dipertahankan jika model Deep Learning gagal dimuat
                 values = data['original']
                 recent_trend = np.polyfit(range(len(values[-20:])), values[-20:], 1)[0]
                 
@@ -64,18 +46,27 @@ class ModelHandler:
                 last_value = values[-1]
                 
                 for i in range(horizon):
-                    # Add trend with some noise
                     next_value = last_value + recent_trend * (i + 1)
-                    # Add realistic market noise
                     noise = np.random.normal(0, data['std'] * 0.1)
                     predictions.append(next_value + noise)
                 
                 return np.array(predictions)
             
-            # In production, would implement full Chronos inference
-            # For now, return fallback
-            return self.predict(data, horizon)  # Recursive call to fallback
+            # --- Chronos-2 Inference ---
+            # Input: numpy array dari harga Close historis yang riil
+            predictions_samples = self.pipeline.predict(
+                data['original'],
+                prediction_length=horizon,
+                # Mengambil 20 sampel prediksi untuk mendapatkan prediksi probablistik
+                num_samples=20 
+            )
+            
+            # Untuk chart (garis tunggal), ambil nilai rata-rata (mean) dari semua sampel.
+            mean_predictions = np.mean(predictions_samples, axis=0)
+            
+            return mean_predictions
             
         except Exception as e:
             print(f"Prediction error: {e}")
+            # Mengembalikan array nol jika ada error saat inferensi Chronos
             return np.array([0] * horizon)