update app

app.py

@@ -1,23 +1,16 @@
-from flask import Flask, request, jsonify
+import gradio as gr
 from transformers import GPT2LMHeadModel, GPT2Tokenizer
 import torch
-import logging
-import os
 
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
 
-# Initialize Flask app
-app = Flask(__name__)
-
-# Load model and tokenizer globally
-logger.info("Loading GPT-2 model and tokenizer...")
-model_name = "gpt2"
+# Load model and tokenizer (using smaller GPT-2 for free tier)
+model_name = "gpt2"  # You can also use "gpt2-medium" if it fits in memory
 tokenizer = GPT2Tokenizer.from_pretrained(model_name)
 model = GPT2LMHeadModel.from_pretrained(model_name)
+
+
+# Set pad token
 tokenizer.pad_token = tokenizer.eos_token
-logger.info("Model loaded successfully!")
 
 
 def generate_text(prompt, max_length=100, temperature=0.7, top_p=0.9, top_k=50):
@@ -30,7 +23,7 @@ def generate_text(prompt, max_length=100, temperature=0.7, top_p=0.9, top_k=50):
         with torch.no_grad():
             outputs = model.generate(
                 inputs,
-                max_length=min(max_length + len(inputs[0]), 512),
+                max_length=min(max_length + len(inputs[0]), 512),  # Limit total length
                 temperature=temperature,
                 top_p=top_p,
                 top_k=top_k,
@@ -46,150 +39,83 @@ def generate_text(prompt, max_length=100, temperature=0.7, top_p=0.9, top_k=50):
         return generated_text[len(prompt):].strip()
     
     except Exception as e:
-        logger.error(f"Error generating text: {str(e)}")
-        return f"Error: {str(e)}"
-
-
-@app.route('/')
-def root():
-    """API information endpoint"""
-    return jsonify({
-        "message": "GPT-2 Text Generation API",
-        "model": model_name,
-        "endpoints": {
-            "/": "API information",
-            "/health": "Health check",
-            "/generate": "POST - Generate text"
-        },
-        "example_request": {
-            "url": "/generate",
-            "method": "POST",
-            "headers": {"Content-Type": "application/json"},
-            "body": {
-                "prompt": "Once upon a time",
-                "max_length": 100,
-                "temperature": 0.7,
-                "top_p": 0.9,
-                "top_k": 50
-            }
-        }
-    })
+        return f"Error generating text: {str(e)}"
 
 
-@app.route('/health')
-def health():
-    """Health check endpoint"""
-    return jsonify({
-        'status': 'healthy', 
-        'model': model_name,
-        'framework': 'flask',
-        'endpoints_available': ['/health', '/generate', '/']
-    })
-
-
-@app.route('/generate', methods=['POST'])
-def generate():
-    """Text generation API endpoint"""
-    try:
-        # Log the request
-        logger.info(f"Received generate request from {request.remote_addr}")
-        
-        data = request.get_json()
-        
-        if not data:
-            logger.warning("No JSON data provided")
-            return jsonify({'error': 'No JSON data provided', 'received_content_type': request.content_type}), 400
-        
-        # Extract parameters with defaults
-        prompt = data.get('prompt', '')
-        max_length = data.get('max_length', 100)
-        temperature = data.get('temperature', 0.7)
-        top_p = data.get('top_p', 0.9)
-        top_k = data.get('top_k', 50)
-        
-        if not prompt:
-            logger.warning("Empty prompt provided")
-            return jsonify({'error': 'Prompt is required and cannot be empty'}), 400
-        
-        # Validate and clamp parameters
-        max_length = max(10, min(200, int(max_length)))
-        temperature = max(0.1, min(2.0, float(temperature)))
-        top_p = max(0.1, min(1.0, float(top_p)))
-        top_k = max(1, min(100, int(top_k)))
-        
-        logger.info(f"Generating text for prompt: '{prompt[:50]}...' with params: max_length={max_length}, temperature={temperature}")
-        
-        # Generate text
-        generated_text = generate_text(prompt, max_length, temperature, top_p, top_k)
-        
-        result = {
-            'generated_text': generated_text,
-            'prompt': prompt,
-            'parameters': {
-                'max_length': max_length,
-                'temperature': temperature,
-                'top_p': top_p,
-                'top_k': top_k
-            }
-        }
-        
-        logger.info("Text generation successful")
-        return jsonify(result)
+# Create Gradio interface
+with gr.Blocks(title="GPT-2 Text Generator") as demo:
+    gr.Markdown("# GPT-2 Text Generation Server")
+    gr.Markdown("Enter a prompt and generate text using GPT-2. Free tier optimized!")
+    
+    with gr.Row():
+        with gr.Column():
+            prompt_input = gr.Textbox(
+                label="Prompt",
+                placeholder="Enter your text prompt here...",
+                lines=3
+            )
+            
+            with gr.Row():
+                max_length = gr.Slider(
+                    minimum=10,
+                    maximum=200,
+                    value=100,
+                    step=10,
+                    label="Max Length"
+                )
+                temperature = gr.Slider(
+                    minimum=0.1,
+                    maximum=2.0,
+                    value=0.7,
+                    step=0.1,
+                    label="Temperature"
+                )
+            
+            with gr.Row():
+                top_p = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.9,
+                    step=0.1,
+                    label="Top-p"
+                )
+                top_k = gr.Slider(
+                    minimum=1,
+                    maximum=100,
+                    value=50,
+                    step=1,
+                    label="Top-k"
+                )
+            
+            generate_btn = gr.Button("Generate Text", variant="primary")
         
-    except ValueError as e:
-        logger.error(f"Parameter validation error: {str(e)}")
-        return jsonify({'error': f'Invalid parameter: {str(e)}'}), 400
-    except Exception as e:
-        logger.error(f"Error in /generate: {str(e)}")
-        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
-
-
-@app.route('/generate', methods=['GET'])
-def generate_get():
-    """GET endpoint for /generate with usage information"""
-    return jsonify({
-        'error': 'Method not allowed',
-        'message': 'This endpoint only accepts POST requests',
-        'usage': 'Send a POST request with JSON body containing "prompt" field',
-        'example': {
-            'method': 'POST',
-            'headers': {'Content-Type': 'application/json'},
-            'body': {'prompt': 'Once upon a time', 'max_length': 100}
-        }
-    }), 405
-
-
-@app.errorhandler(404)
-def not_found(error):
-    return jsonify({
-        'error': 'Not found',
-        'available_endpoints': ['/', '/health', '/generate'],
-        'message': 'Check the available endpoints above'
-    }), 404
-
-
-@app.errorhandler(405)
-def method_not_allowed(error):
-    return jsonify({
-        'error': 'Method not allowed',
-        'message': 'Check the allowed methods for this endpoint'
-    }), 405
-
-
-@app.errorhandler(500)
-def internal_error(error):
-    return jsonify({'error': 'Internal server error'}), 500
+        with gr.Column():
+            output_text = gr.Textbox(
+                label="Generated Text",
+                lines=10,
+                placeholder="Generated text will appear here..."
+            )
+    
+    # Examples
+    gr.Examples(
+        examples=[
+            ["Once upon a time in a distant galaxy,"],
+            ["The future of artificial intelligence is"],
+            ["In the heart of the ancient forest,"],
+            ["The detective walked into the room and noticed"],
+        ],
+        inputs=prompt_input
+    )
+    
+    # Connect the function with explicit API endpoint name
+    generate_btn.click(
+        fn=generate_text,
+        inputs=[prompt_input, max_length, temperature, top_p, top_k],
+        outputs=output_text,
+        api_name="/predict"  # Explicit API endpoint for external calls
+    )
 
 
+# Launch the app
 if __name__ == "__main__":
-    # For Hugging Face Spaces
-    port = int(os.environ.get("PORT", 7860))
-    host = "0.0.0.0"
-    
-    logger.info(f"Starting GPT-2 API server on {host}:{port}")
-    logger.info("Available endpoints:")
-    logger.info("  GET  / - API information")
-    logger.info("  GET  /health - Health check")
-    logger.info("  POST /generate - Text generation")
-    
-    app.run(host=host, port=port, debug=False)
+    demo.launch()

requirements.txt

@@ -1,3 +1,4 @@
-flask==2.3.3
-transformers==4.35.0
-torch==2.1.0
+gradio>=3.50.0
+transformers>=4.30.0
+torch>=2.0.0
+tokenizers>=0.13.0