Update app.py

app.py

@@ -1,69 +1,65 @@
+import os
 import torch
 import numpy as np
 from fastapi import FastAPI, Request
 from chronos import ChronosPipeline
+import uvicorn
 
 app = FastAPI()
 
-# Pipeline initialization with the corrected 'dtype'
-pipeline = ChronosPipeline.from_pretrained(
-    "amazon/chronos-t5-small",
-    device_map="auto",
-    dtype=torch.bfloat16, 
-)
+# Global variable for the model
+pipeline = None
+
+@app.on_event("startup")
+def load_model():
+    global pipeline
+    print("Loading Chronos model...")
+    # Using 'tiny' first to ensure it fits in RAM. 
+    # Swap to 'amazon/chronos-t5-small' if you have confirmed 16GB+ RAM
+    pipeline = ChronosPipeline.from_pretrained(
+        "amazon/chronos-t5-tiny", 
+        device_map="auto",
+        dtype=torch.bfloat16
+    )
+    print("Model loaded successfully.")
+
+@app.get("/")
+def home():
+    return {"status": "Model is running", "info": "Send POST to /predict"}
 
 @app.post("/predict")
 async def get_forecast(request: Request):
-    # 1. Receive data from your backend
     body = await request.json()
     history = body.get("history", [])
-    user_rr = body.get("rr_ratio", 2.0)  # Default to 2:1 if not provided
+    user_rr = float(body.get("rr_ratio", 2.0))
     
     if not history:
-        return {"error": "No history data provided"}
+        return {"error": "History array is empty"}
 
-    # 2. Convert history to tensor (No length limit - uses your 2-3 year data)
-    context = torch.tensor(history)
-    
-    # 3. Predict (Defaulting to 12 steps ahead)
-    # Chronos returns (num_samples, prediction_length)
+    # Chronos prediction logic
+    context = torch.tensor(history, dtype=torch.float32)
     forecast = pipeline.predict(context, prediction_length=12)
     
-    # 4. Extract Quantiles for Bounds
-    # P10 = Lower Bound, P50 = Median (Prediction), P90 = Upper Bound
-    low_bound = np.percentile(forecast.numpy(), 10, axis=0)
-    median_pred = np.percentile(forecast.numpy(), 50, axis=0)
-    high_bound = np.percentile(forecast.numpy(), 90, axis=0)
+    forecast_np = forecast.numpy()[0]
+    low_bound = np.percentile(forecast_np, 10, axis=0)
+    median_pred = np.percentile(forecast_np, 50, axis=0)
+    high_bound = np.percentile(forecast_np, 90, axis=0)
 
-    # 5. Trading System Logic
-    entry_price = history[-1]
-    next_move = median_pred[0]
+    entry_price = float(history[-1])
+    sl = float(low_bound[0])
+    if sl >= entry_price: sl = entry_price * 0.98
     
-    # Stop Loss (SL) based on the model's P10 (statistical support)
-    # We ensure SL is actually below entry; if not, we use a 2% buffer
-    sl = min(low_bound[0], entry_price * 0.98)
-    
-    # Calculate Take Profit (TP) based on User RR Ratio
-    risk_amount = entry_price - sl
-    tp = entry_price + (risk_amount * user_rr)
-
-    # 6. Verdict Engine
-    if next_move > entry_price * 1.01:
-        verdict = "Entry Confirmed: Upward momentum detected."
-    elif next_move < entry_price * 0.99:
-        verdict = "Wait: Potential pullback or downward trend."
-    else:
-        verdict = "Neutral: Sideways movement expected. Wait for breakout."
+    tp = entry_price + ((entry_price - sl) * user_rr)
 
-    # 7. Response to Backend
     return {
-        "status": "success",
-        "entry": float(entry_price),
         "prediction": median_pred.tolist(),
         "upper_bound": high_bound.tolist(),
         "lower_bound": low_bound.tolist(),
-        "suggested_sl": round(float(sl), 2),
-        "suggested_tp": round(float(tp), 2),
-        "verdict": verdict,
-        "rr_applied": f"{user_rr}:1"
-    }
+        "suggested_sl": round(sl, 4),
+        "suggested_tp": round(tp, 4),
+        "verdict": "Entry Confirmed" if median_pred[0] > entry_price else "Wait"
+    }
+
+if __name__ == "__main__":
+    # CRITICAL: Hugging Face requires port 7860
+    uvicorn.run(app, host="0.0.0.0", port=7860)