Spaces:

asmhashenry12345
/

gpt2-text-generator

Running

App Files Files Community

sonyps1928 commited on 6 days ago

Commit

107fb80

1 Parent(s): 36fde64

update app22

Browse files

Files changed (2) hide show

app.py +225 -79
app1.txt +121 -0

app.py CHANGED Viewed

@@ -1,16 +1,21 @@
-import gradio as gr
 from transformers import GPT2LMHeadModel, GPT2Tokenizer
 import torch
-# 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
 def generate_text(prompt, max_length=100, temperature=0.7, top_p=0.9, top_k=50):
@@ -23,7 +28,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),  # Limit total length
                 temperature=temperature,
                 top_p=top_p,
                 top_k=top_k,
@@ -39,83 +44,224 @@ 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:
-        return f"Error generating text: {str(e)}"
-# 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")
-        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__":
-    demo.launch()

+import json
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
 from transformers import GPT2LMHeadModel, GPT2Tokenizer
 import torch
+import logging
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+# Load model and tokenizer globally
+logger.info("Loading GPT-2 model and tokenizer...")
+model_name = "gpt2"
+tokenizer = GPT2LMHeadModel.from_pretrained(model_name)
 model = GPT2LMHeadModel.from_pretrained(model_name)
 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):
         with torch.no_grad():
             outputs = model.generate(
                 inputs,
+                max_length=min(max_length + len(inputs[0]), 512),
                 temperature=temperature,
                 top_p=top_p,
                 top_k=top_k,
         return generated_text[len(prompt):].strip()
     except Exception as e:
+        logger.error(f"Error generating text: {str(e)}")
+        return f"Error: {str(e)}"
+class GPT2Handler(BaseHTTPRequestHandler):
+    def _set_headers(self, content_type='application/json'):
+        self.send_response(200)
+        self.send_header('Content-type', content_type)
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+        self.end_headers()
+    def _send_error(self, code, message):
+        self.send_response(code)
+        self.send_header('Content-type', 'application/json')
+        self.end_headers()
+        response = {'error': message}
+        self.wfile.write(json.dumps(response).encode())
+    def do_OPTIONS(self):
+        self._set_headers()
+    def do_GET(self):
+        parsed_path = urlparse(self.path)
+        if parsed_path.path == '/':
+            # Serve a simple HTML interface
+            self._set_headers('text/html')
+            html = '''
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <title>GPT-2 Text Generator</title>
+                <style>
+                    body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+                    .container { margin: 20px 0; }
+                    textarea, input, button { margin: 5px 0; padding: 8px; }
+                    textarea { width: 100%; height: 100px; }
+                    button { background: #007bff; color: white; border: none; padding: 10px 20px; cursor: pointer; }
+                    button:hover { background: #0056b3; }
+                    .output { background: #f8f9fa; padding: 15px; border-radius: 5px; min-height: 100px; }
+                    .controls { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; }
+                    label { font-weight: bold; }
+                </style>
+            </head>
+            <body>
+                <h1>GPT-2 Text Generator</h1>
+                <p>Enter a prompt and generate text using GPT-2</p>
+                <div class="container">
+                    <label for="prompt">Prompt:</label>
+                    <textarea id="prompt" placeholder="Enter your text prompt here...">Once upon a time in a distant galaxy,</textarea>
+                </div>
+                <div class="controls">
+                    <div>
+                        <label for="maxLength">Max Length: <span id="maxLengthValue">100</span></label>
+                        <input type="range" id="maxLength" min="10" max="200" value="100" step="10">
+                    </div>
+                    <div>
+                        <label for="temperature">Temperature: <span id="temperatureValue">0.7</span></label>
+                        <input type="range" id="temperature" min="0.1" max="2.0" value="0.7" step="0.1">
+                    </div>
+                    <div>
+                        <label for="topP">Top-p: <span id="topPValue">0.9</span></label>
+                        <input type="range" id="topP" min="0.1" max="1.0" value="0.9" step="0.1">
+                    </div>
+                    <div>
+                        <label for="topK">Top-k: <span id="topKValue">50</span></label>
+                        <input type="range" id="topK" min="1" max="100" value="50" step="1">
+                    </div>
+                </div>
+                <div class="container">
+                    <button onclick="generateText()" id="generateBtn">Generate Text</button>
+                </div>
+                <div class="container">
+                    <label>Generated Text:</label>
+                    <div id="output" class="output">Generated text will appear here...</div>
+                </div>
+                <script>
+                    // Update slider value displays
+                    document.getElementById('maxLength').oninput = function() {
+                        document.getElementById('maxLengthValue').textContent = this.value;
+                    }
+                    document.getElementById('temperature').oninput = function() {
+                        document.getElementById('temperatureValue').textContent = this.value;
+                    }
+                    document.getElementById('topP').oninput = function() {
+                        document.getElementById('topPValue').textContent = this.value;
+                    }
+                    document.getElementById('topK').oninput = function() {
+                        document.getElementById('topKValue').textContent = this.value;
+                    }
+                    async function generateText() {
+                        const btn = document.getElementById('generateBtn');
+                        const output = document.getElementById('output');
+                        btn.disabled = true;
+                        btn.textContent = 'Generating...';
+                        output.textContent = 'Generating text...';
+                        const data = {
+                            prompt: document.getElementById('prompt').value,
+                            max_length: parseInt(document.getElementById('maxLength').value),
+                            temperature: parseFloat(document.getElementById('temperature').value),
+                            top_p: parseFloat(document.getElementById('topP').value),
+                            top_k: parseInt(document.getElementById('topK').value)
+                        };
+                        try {
+                            const response = await fetch('/generate', {
+                                method: 'POST',
+                                headers: {'Content-Type': 'application/json'},
+                                body: JSON.stringify(data)
+                            });
+                            const result = await response.json();
+                            if (result.error) {
+                                output.textContent = 'Error: ' + result.error;
+                            } else {
+                                output.textContent = result.generated_text;
+                            }
+                        } catch (error) {
+                            output.textContent = 'Error: ' + error.message;
+                        }
+                        btn.disabled = false;
+                        btn.textContent = 'Generate Text';
+                    }
+                </script>
+            </body>
+            </html>
+            '''
+            self.wfile.write(html.encode())
+        elif parsed_path.path == '/health':
+            # Health check endpoint
+            self._set_headers()
+            response = {'status': 'healthy', 'model': model_name}
+            self.wfile.write(json.dumps(response).encode())
+        else:
+            self._send_error(404, 'Not found')
+    def do_POST(self):
+        if self.path == '/generate':
+            try:
+                # Get request body
+                content_length = int(self.headers['Content-Length'])
+                post_data = self.rfile.read(content_length)
+                data = json.loads(post_data.decode())
+                # Extract parameters
+                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:
+                    self._send_error(400, 'Prompt is required')
+                    return
+                # Generate text
+                logger.info(f"Generating text for prompt: {prompt[:50]}...")
+                generated_text = generate_text(prompt, max_length, temperature, top_p, top_k)
+                # Send response
+                self._set_headers()
+                response = {'generated_text': generated_text}
+                self.wfile.write(json.dumps(response).encode())
+            except json.JSONDecodeError:
+                self._send_error(400, 'Invalid JSON')
+            except Exception as e:
+                logger.error(f"Error in POST /generate: {str(e)}")
+                self._send_error(500, str(e))
+        else:
+            self._send_error(404, 'Not found')
+    def log_message(self, format, *args):
+        # Override to use our logger
+        logger.info(f"{self.address_string()} - {format % args}")
+def run_server(host='localhost', port=8000):
+    """Start the HTTP server"""
+    server_address = (host, port)
+    httpd = HTTPServer(server_address, GPT2Handler)
+    logger.info(f"Starting GPT-2 server on http://{host}:{port}")
+    logger.info(f"Web interface: http://{host}:{port}")
+    logger.info(f"API endpoint: http://{host}:{port}/generate")
+    logger.info(f"Health check: http://{host}:{port}/health")
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        logger.info("Shutting down server...")
+        httpd.shutdown()
 if __name__ == "__main__":
+    import sys
+    # Parse command line arguments
+    host = 'localhost'
+    port = 8000
+    if len(sys.argv) > 1:
+        port = int(sys.argv[1])
+    if len(sys.argv) > 2:
+        host = sys.argv[2]
+    run_server(host, port)

app1.txt ADDED Viewed

	@@ -0,0 +1,121 @@

+import gradio as gr
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
+import torch
+# 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
+def generate_text(prompt, max_length=100, temperature=0.7, top_p=0.9, top_k=50):
+    """Generate text using GPT-2"""
+    try:
+        # Encode input
+        inputs = tokenizer.encode(prompt, return_tensors="pt", max_length=512, truncation=True)
+        # Generate
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs,
+                max_length=min(max_length + len(inputs[0]), 512),  # Limit total length
+                temperature=temperature,
+                top_p=top_p,
+                top_k=top_k,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                num_return_sequences=1
+            )
+        # Decode output
+        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        # Return only the new generated part
+        return generated_text[len(prompt):].strip()
+    except Exception as e:
+        return f"Error generating text: {str(e)}"
+# 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")
+        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__":
+    demo.launch()