Create app.py

app.py

@@ -0,0 +1,186 @@
+import gradio as gr
+import torch
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
+import time
+
+# Load model and tokenizer
+model_id = "kristianfischerai12345/fischgpt-sft"
+print("Loading FischGPT model...")
+model = GPT2LMHeadModel.from_pretrained(model_id)
+tokenizer = GPT2Tokenizer.from_pretrained(model_id)
+
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+model.eval()
+print("Model loaded successfully!")
+
+def generate_api(user_message, temperature=0.8, max_length=150, top_p=0.9):
+    """
+    API endpoint for FischGPT generation.
+    
+    Args:
+        user_message (str): The user's input message
+        temperature (float): Sampling temperature (0.1-2.0)
+        max_length (int): Maximum response length (50-300)
+        top_p (float): Top-p sampling (0.1-1.0)
+    
+    Returns:
+        dict: Response with generated text and metadata
+    """
+    
+    if not user_message or not user_message.strip():
+        return {
+            "error": "Empty message",
+            "response": None,
+            "metadata": None
+        }
+    
+    try:
+        # Format as conversation
+        prompt = f"<|user|>{user_message.strip()}<|assistant|>"
+        
+        # Tokenize
+        inputs = tokenizer.encode(prompt, return_tensors='pt')
+        
+        # Generate
+        start_time = time.time()
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs,
+                max_length=max_length,
+                temperature=float(temperature),
+                top_p=float(top_p),
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                attention_mask=torch.ones_like(inputs)
+            )
+        
+        generation_time = time.time() - start_time
+        
+        # Decode and extract response
+        full_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        response = full_text.split("<|assistant|>", 1)[1].strip()
+        
+        # Calculate metrics
+        input_tokens = len(inputs[0])
+        output_tokens = len(outputs[0])
+        new_tokens = output_tokens - input_tokens
+        tokens_per_sec = new_tokens / generation_time if generation_time > 0 else 0
+        
+        # Return structured response
+        return {
+            "error": None,
+            "response": response,
+            "metadata": {
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                "new_tokens": new_tokens,
+                "generation_time": round(generation_time, 3),
+                "tokens_per_second": round(tokens_per_sec, 1),
+                "model": "FischGPT-SFT",
+                "parameters": {
+                    "temperature": temperature,
+                    "max_length": max_length,
+                    "top_p": top_p
+                }
+            }
+        }
+        
+    except Exception as e:
+        return {
+            "error": str(e),
+            "response": None,
+            "metadata": None
+        }
+
+# Create minimal Gradio interface for API
+with gr.Blocks(title="FischGPT API") as demo:
+    
+    gr.HTML("""
+    <div style="text-align: center; padding: 15px; background: #f0f0f0; border-radius: 10px; margin-bottom: 20px;">
+        <h2>🚀 FischGPT API Backend</h2>
+        <p>Minimal interface for API testing. Use the API endpoint for your custom frontend.</p>
+        <p><strong>API Endpoint:</strong> <code>/api/predict</code></p>
+    </div>
+    """)
+    
+    gr.Markdown("""
+    ## 🔌 API Usage
+    
+    **Python Example:**
+    ```python
+    import requests
+    
+    response = requests.post(
+        "https://kristianfischerai12345-fischgpt-api.hf.space/api/predict",
+        json={
+            "data": [
+                "Explain machine learning",  # user_message
+                0.8,                         # temperature
+                150,                         # max_length  
+                0.9                          # top_p
+            ]
+        }
+    )
+    
+    result = response.json()
+    print(result["data"][0]["response"])
+    ```
+    
+    **JavaScript/React Example:**
+    ```javascript
+    const response = await fetch("https://kristianfischerai12345-fischgpt-api.hf.space/api/predict", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            data: [
+                "Explain machine learning",  // user_message
+                0.8,                         // temperature
+                150,                         // max_length
+                0.9                          // top_p  
+            ]
+        })
+    });
+    
+    const result = await response.json();
+    console.log(result.data[0].response);
+    ```
+    """)
+    
+    # Simple test interface
+    gr.Markdown("### Quick Test Interface")
+    
+    with gr.Row():
+        user_input = gr.Textbox(label="Test Message", value="Hello, how are you?", scale=2)
+        test_btn = gr.Button("Test API", variant="primary")
+    
+    with gr.Row():
+        temperature = gr.Slider(0.1, 2.0, 0.8, label="Temperature")
+        max_length = gr.Slider(50, 300, 150, label="Max Length")
+        top_p = gr.Slider(0.1, 1.0, 0.9, label="Top-p")
+    
+    output = gr.JSON(label="API Response")
+    
+    # Connect the test interface
+    test_btn.click(
+        fn=generate_api,
+        inputs=[user_input, temperature, max_length, top_p],
+        outputs=output
+    )
+    
+    # Create the main API interface (this creates the /api/predict endpoint)
+    api_interface = gr.Interface(
+        fn=generate_api,
+        inputs=[
+            gr.Textbox(label="User Message"),
+            gr.Slider(0.1, 2.0, 0.8, label="Temperature"),
+            gr.Slider(50, 300, 150, label="Max Length"),
+            gr.Slider(0.1, 1.0, 0.9, label="Top-p")
+        ],
+        outputs=gr.JSON(label="Response"),
+        api_name="predict"
+    )
+
+if __name__ == "__main__":
+    demo.launch()