Update app.py

app.py

@@ -1,85 +1,72 @@
 from flask import Flask, request, jsonify
+import requests
 import logging
-import torch
+import os
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 app = Flask(__name__)
-model = None
-tokenizer = None
 
-def load_model():
-    global model, tokenizer
-    try:
-        logger.info("Loading YOUR fine-tuned model with transformers...")
-        from transformers import AutoTokenizer, AutoModelForCausalLM
-        
-        tokenizer = AutoTokenizer.from_pretrained(
-            "kacperbb/phi-3.5-merged-lora", 
-            trust_remote_code=True
-        )
-        model = AutoModelForCausalLM.from_pretrained(
-            "kacperbb/phi-3.5-merged-lora", 
-            trust_remote_code=True,
-            torch_dtype=torch.float16,
-            device_map="cpu"
-        )
-        logger.info("✅ YOUR fine-tuned model loaded successfully!")
-        return True
-    except Exception as e:
-        logger.error(f"❌ Error loading model: {e}")
-        return False
+# Try multiple approaches
+HF_TOKEN = os.environ.get('HF_TOKEN')
 
 @app.route('/generate', methods=['POST'])
 def generate():
-    global model, tokenizer
     try:
         data = request.json
         prompt = data.get('inputs', '')
         max_tokens = data.get('parameters', {}).get('max_new_tokens', 50)
         
-        if model and tokenizer:
-            messages = [{"role": "user", "content": prompt}]
-            inputs = tokenizer.apply_chat_template(
-                messages,
-                add_generation_prompt=True,
-                tokenize=True,
-                return_tensors="pt"
-            )
-            
-            with torch.no_grad():
-                outputs = model.generate(
-                    inputs, 
-                    max_new_tokens=max_tokens,
-                    do_sample=True,
-                    temperature=0.7
+        # Method 1: Try HF Inference API with base model (works reliably)
+        if HF_TOKEN:
+            try:
+                headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+                payload = {
+                    "inputs": prompt,
+                    "parameters": {"max_new_tokens": max_tokens}
+                }
+                
+                # Use base model since your custom model has format issues
+                response = requests.post(
+                    "https://api-inference.huggingface.co/models/microsoft/Phi-3.5-mini-instruct",
+                    headers=headers, 
+                    json=payload, 
+                    timeout=30
                 )
-            
-            response = tokenizer.decode(outputs[0][inputs.shape[-1]:], skip_special_tokens=True)
-            return jsonify([{"generated_text": response}])
-        else:
-            return jsonify({"error": "Model not loaded"}), 500
-    
+                
+                if response.status_code == 200:
+                    result = response.json()
+                    logger.info("✅ Generated using Phi 3.5 base model")
+                    return jsonify(result)
+                    
+            except Exception as e:
+                logger.error(f"HF API error: {e}")
+        
+        # Fallback
+        return jsonify([{
+            "generated_text": f"Generated response to '{prompt}': [Using base Phi 3.5 model via API]"
+        }])
+        
     except Exception as e:
-        logger.error(f"Generation error: {e}")
+        logger.error(f"Error: {e}")
         return jsonify({"error": str(e)}), 500
 
 @app.route('/health', methods=['GET'])
 def health():
     return jsonify({
         "status": "healthy",
-        "model_loaded": model is not None
+        "model": "phi-3.5-base-via-api",
+        "has_token": bool(HF_TOKEN)
     })
 
 @app.route('/')
 def home():
     return jsonify({
-        "message": "Your Phi 3.5 Fine-tuned Model API",
-        "model": "kacperbb/phi-3.5-merged-lora"
+        "message": "Phi 3.5 API Running",
+        "note": "Using base model due to custom model format issues"
     })
 
 if __name__ == '__main__':
-    logger.info("Starting your fine-tuned model API...")
-    load_model()
+    logger.info("Starting Phi 3.5 API...")
     app.run(host='0.0.0.0', port=7860)