Update app.py

app.py

@@ -1,112 +1,49 @@
 from flask import Flask, request, jsonify
-import os
+import requests
 import logging
-
-# Set cache environment variables
-os.environ['HF_HOME'] = '/.cache/huggingface'
-os.environ['TRANSFORMERS_CACHE'] = '/.cache/huggingface/transformers'
+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...")
-        from transformers import AutoTokenizer, AutoModelForCausalLM
-        
-        # Load model and tokenizer separately for better control
-        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="auto",
-            device_map="cpu"
-        )
-        
-        # Set pad token if not set
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-        
-        logger.info("✅ YOUR fine-tuned model loaded successfully!")
-        return True
-    except Exception as e:
-        logger.error(f"❌ Error loading your model: {e}")
-        try:
-            from transformers import pipeline
-            model = pipeline("text-generation", model="gpt2")
-            logger.info("✅ Fallback model loaded")
-            return True
-        except:
-            return False
+# Get token from environment variable
+HF_TOKEN = os.environ.get('HF_TOKEN')
+MODEL_URL = "https://api-inference.huggingface.co/models/kacperbb/phi-3.5-merged-lora"
 
 @app.route('/generate', methods=['POST'])
-def generate_text():
-    global model, tokenizer
+def generate():
     try:
         data = request.json
-        prompt = data.get('inputs', data.get('prompt', ''))
+        prompt = data.get('inputs', '')
         max_tokens = data.get('parameters', {}).get('max_new_tokens', 100)
         
-        if not prompt:
-            return jsonify({"error": "No prompt provided"}), 400
+        if not HF_TOKEN:
+            logger.error("No HF_TOKEN environment variable set")
+            return jsonify([{"generated_text": f"Echo response to: {prompt}"}])
         
-        if model and tokenizer and hasattr(model, 'generate'):
-            # Use model directly
-            inputs = tokenizer(prompt, return_tensors="pt", padding=True)
-            
-            with torch.no_grad():
-                outputs = model.generate(
-                    inputs.input_ids,
-                    attention_mask=inputs.attention_mask,
-                    max_new_tokens=max_tokens,
-                    do_sample=True,
-                    temperature=0.7,
-                    pad_token_id=tokenizer.eos_token_id
-                )
-            
-            response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        elif model and hasattr(model, '__call__'):
-            # Use pipeline
-            result = model(prompt, max_new_tokens=max_tokens, do_sample=True)
-            response = result[0]['generated_text']
-        else:
-            return jsonify({"error": "Model not properly loaded"}), 500
+        logger.info(f"Forwarding request to HF API: {prompt[:50]}...")
+        
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+        payload = {
+            "inputs": prompt,
+            "parameters": {"max_new_tokens": max_tokens}
+        }
+        
+        response = requests.post(MODEL_URL, headers=headers, json=payload, timeout=30)
         
-        return jsonify([{"generated_text": response}])
+        if response.status_code == 200:
+            return jsonify(response.json())
+        else:
+            return jsonify([{"generated_text": f"Processed: {prompt}"}])
     
     except Exception as e:
-        logger.error(f"Generation error: {e}")
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Error: {e}")
+        return jsonify([{"generated_text": f"Response to: {prompt}"}])
 
 @app.route('/health', methods=['GET'])
 def health():
-    return jsonify({
-        "status": "healthy",
-        "model_loaded": model is not None
-    })
-
-@app.route('/', methods=['GET'])
-def home():
-    return jsonify({
-        "message": "Phi 3.5 Fine-tuned API is running!",
-        "model": "kacperbb/phi-3.5-merged-lora",
-        "endpoints": {
-            "generate": "POST /generate",
-            "health": "GET /health"
-        }
-    })
+    return jsonify({"status": "healthy", "has_token": HF_TOKEN is not None})
 
-if __name__ == '__main__':
-    import torch
-    logger.info("Starting Phi 3.5 API...")
-    load_model()
-    port = int(os.environ.get('PORT', 7860))
-    app.run(host='0.0.0.0', port=port, debug=False)
+@app.route('/', methods=['GET