Gxhhfhdhdggggg

Sleeping

App Files Files Community

Yhhxhfh commited on Sep 22

Commit

f4907db

•

1 Parent(s): 77c2378

Update app.py

Browse files

Files changed (1) hide show

app.py +173 -128

app.py CHANGED Viewed

@@ -1,45 +1,50 @@
 import os
-import logging
-import asyncio
-import uvicorn
 import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-from fastapi import FastAPI, Query, HTTPException
 from fastapi.responses import HTMLResponse
-# Configuración de logging
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-# Inicializar la aplicación FastAPI
-app = FastAPI()
-# Diccionario para almacenar los modelos
-data_and_models_dict = {}
-# Lista para almacenar el historial de mensajes
-message_history = []
-# Función para cargar modelos
-async def load_models():
-    gpt_models = ["gpt2-medium", "gpt2-large", "gpt2"]
-    for model_name in gpt_models:
-        try:
-            model = AutoModelForCausalLM.from_pretrained(model_name)
-            tokenizer = AutoTokenizer.from_pretrained(model_name)
-            logger.info(f"Successfully loaded {model_name} model")
-            return model, tokenizer
-        except Exception as e:
-            logger.error(f"Failed to load GPT-2 model: {e}")
-    raise HTTPException(status_code=500, detail="Failed to load any models")
-# Función para descargar modelos
-async def download_models():
-    model, tokenizer = await load_models()
-    data_and_models_dict['model'] = (model, tokenizer)
 @app.get('/')
-async def main():
     html_code = """
     <!DOCTYPE html>
     <html lang="en">
@@ -48,151 +53,191 @@ async def main():
         <meta name="viewport" content="width=device-width, initial-scale=1.0">
         <title>ChatGPT Chatbot</title>
         <style>
-            body, html {
-                height: 100%;
                 margin: 0;
                 padding: 0;
-                font-family: Arial, sans-serif;
             }
             .container {
-                height: 100%;
-                display: flex;
-                flex-direction: column;
-                justify-content: center;
-                align-items: center;
             }
             .chat-container {
-                border-radius: 10px;
-                overflow: hidden;
                 box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
-                width: 100%;
-                height: 100%;
             }
             .chat-box {
-                height: calc(100% - 60px);
                 overflow-y: auto;
                 padding: 10px;
             }
             .chat-input {
-                width: calc(100% - 100px);
-                padding: 10px;
                 border: none;
-                border-top: 1px solid #ccc;
                 font-size: 16px;
             }
-            .input-container {
-                display: flex;
-                align-items: center;
-                justify-content: space-between;
-                padding: 10px;
-                background-color: #f5f5f5;
-                border-top: 1px solid #ccc;
-                width: 100%;
             }
-            button {
-                padding: 10px;
-                border: none;
-                cursor: pointer;
                 background-color: #007bff;
                 color: #fff;
-                font-size: 16px;
-            }
-            .user-message {
-                background-color: #cce5ff;
-                border-radius: 5px;
-                align-self: flex-end;
                 max-width: 70%;
-                margin-left: auto;
-                margin-right: 10px;
-                margin-bottom: 10px;
             }
             .bot-message {
-                background-color: #d1ecf1;
-                border-radius: 5px;
-                align-self: flex-start;
                 max-width: 70%;
                 margin-bottom: 10px;
             }
         </style>
     </head>
     <body>
         <div class="container">
-            <div class="chat-container">
                 <div class="chat-box" id="chat-box"></div>
-                <div class="input-container">
-                    <input type="text" class="chat-input" id="user-input" placeholder="Escribe un mensaje...">
-                    <button onclick="sendMessage()">Enviar</button>
-                </div>
             </div>
         </div>
         <script>
-            const chatBox = document.getElementById('chat-box');
-            const userInput = document.getElementById('user-input');
             function saveMessage(sender, message) {
                 const messageElement = document.createElement('div');
-                messageElement.textContent = `${sender}: ${message}`;
-                messageElement.classList.add(`${sender}-message`);
-                chatBox.appendChild(messageElement);
-                userInput.value = '';
             }
-            async function sendMessage() {
-                const userMessage = userInput.value.trim();
-                if (!userMessage) return;
-                saveMessage('user', userMessage);
-                await fetch(`/autocomplete?q=${userMessage}`)
-                    .then(response => response.text())
-                    .then(data => {
-                        saveMessage('bot', data);
-                        chatBox.scrollTop = chatBox.scrollHeight;
-                    })
-                    .catch(error => console.error('Error:', error));
             }
-            userInput.addEventListener("keyup", function(event) {
                 if (event.keyCode === 13) {
                     event.preventDefault();
                     sendMessage();
                 }
             });
         </script>
     </body>
     </html>
     """
     return HTMLResponse(content=html_code, status_code=200)
-# Ruta para la generación de respuestas
 @app.get('/autocomplete')
-async def autocomplete(q: str = Query(...)):
-    global data_and_models_dict, message_history
-    # Verificar si hay modelos cargados
-    if 'model' not in data_and_models_dict:
-        await download_models()
-    # Obtener el modelo
-    model, tokenizer = data_and_models_dict['model']
-    # Guardar el mensaje del usuario en el historial
-    message_history.append(q)
-    # Generar una respuesta utilizando el modelo
-    input_ids = tokenizer.encode(q, return_tensors="pt")
-    output = model.generate(input_ids, max_length=50, num_return_sequences=1)
-    response_text = tokenizer.decode(output[0], skip_special_tokens=True)
-    # Guardar la respuesta en el historial
-    message_history.append(response_text)
-    return response_text
-# Función para ejecutar la aplicación sin reiniciarla
-def run_app():
-    asyncio.run(download_models())
-    uvicorn.run(app, host='0.0.0.0', port=7860)
-# Ejecutar la aplicación
-if __name__ == "__main__":
-    run_app()

 import os
+import sys
 import torch
+import uvicorn
+from fastapi import FastAPI, Query
 from fastapi.responses import HTMLResponse
+from starlette.middleware.cors import CORSMiddleware
+from transformers import AutoTokenizer, pipeline, GPT2LMHeadModel
+from loguru import logger
+sys.path.append('..')
+# Use finetuned GPT model
+current_dir = os.path.dirname(os.path.realpath(__file__))
+text_file_path = os.path.join(current_dir, 'xfa.txt')
+with open(text_file_path, 'r') as file:
+    model_names = [line.strip() for line in file.readlines()]
+models_dict = {}
+# Detect and load necessary models
+for name in model_names:
+    try:
+        model = GPT2LMHeadModel.from_pretrained(name)
+        tokenizer = AutoTokenizer.from_pretrained(name)
+        models_dict[name] = {
+            'model': model,
+            'tokenizer': tokenizer
+        }
+    except Exception as e:
+        logger.error(f"Error loading model {name}: {e}")
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"]
+)
+# Global variable to store the messages history
+message_history = []
 @app.get('/')
+async def index():
     html_code = """
     <!DOCTYPE html>
     <html lang="en">
         <meta name="viewport" content="width=device-width, initial-scale=1.0">
         <title>ChatGPT Chatbot</title>
         <style>
+            body {
+                font-family: Arial, sans-serif;
                 margin: 0;
                 padding: 0;
+                background-color: #f4f4f4;
             }
             .container {
+                max-width: 800px;
+                margin: auto;
+                padding: 20px;
             }
             .chat-container {
+                background-color: #fff;
+                border-radius: 8px;
                 box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+                overflow: hidden;
+                margin-bottom: 20px;
+                animation: fadeInUp 0.5s ease forwards;
             }
             .chat-box {
+                height: 300px;
                 overflow-y: auto;
                 padding: 10px;
             }
             .chat-input {
+                width: calc(100% - 20px);
                 border: none;
+                border-top: 1px solid #ddd;
+                padding: 10px;
                 font-size: 16px;
+                outline: none;
             }
+            .chat-input:focus {
+                border-top: 1px solid #007bff;
             }
+            .user-message {
+                margin-bottom: 10px;
+                padding: 8px 12px;
+                border-radius: 8px;
                 background-color: #007bff;
                 color: #fff;
                 max-width: 70%;
+                word-wrap: break-word;
+                align-self: flex-end;
             }
             .bot-message {
+                margin-bottom: 10px;
+                padding: 8px 12px;
+                border-radius: 8px;
+                background-color: #4CAF50;
+                color: #fff;
                 max-width: 70%;
+                word-wrap: break-word;
+            }
+            .toggle-history {
+                text-align: center;
+                cursor: pointer;
+                color: #007bff;
                 margin-bottom: 10px;
             }
+            .history-container {
+                display: none;
+            }
+            .history-container.show {
+                display: block;
+            }
+            .history-container .history-content {
+                max-height: 200px;
+                overflow-y: auto;
+            }
+            @keyframes fadeInUp {
+                from {
+                    opacity: 0;
+                    transform: translateY(20px);
+                }
+                to {
+                    opacity: 1;
+                    transform: translateY(0);
+                }
+            }
         </style>
     </head>
     <body>
         <div class="container">
+            <h1 style="text-align: center;">ChatGPT Chatbot</h1>
+            <div class="chat-container" id="chat-container">
                 <div class="chat-box" id="chat-box"></div>
+                <input type="text" class="chat-input" id="user-input" placeholder="Type your message...">
+                <button onclick="retryLastMessage()">Retry Last Message</button>
+            </div>
+            <div class="toggle-history" onclick="toggleHistory()">Toggle History</div>
+            <div class="history-container" id="history-container">
+                <h2>Chat History</h2>
+                <div class="history-content" id="history-content"></div>
             </div>
         </div>
         <script>
+            function toggleHistory() {
+                const historyContainer = document.getElementById('history-container');
+                historyContainer.classList.toggle('show');
+            }
             function saveMessage(sender, message) {
+                const historyContent = document.getElementById('history-content');
                 const messageElement = document.createElement('div');
+                messageElement.className = `${sender}-message`;
+                messageElement.innerText = message;
+                historyContent.appendChild(messageElement);
             }
+            function appendMessage(sender, message) {
+                const chatBox = document.getElementById('chat-box');
+                const messageElement = document.createElement('div');
+                messageElement.className = `${sender}-message`;
+                messageElement.innerText = message;
+                chatBox.appendChild(messageElement);
             }
+            const userInput = document.getElementById('user-input');
+            userInput.addEventListener('keyup', function(event) {
                 if (event.keyCode === 13) {
                     event.preventDefault();
                     sendMessage();
                 }
             });
+            function sendMessage() {
+                const userMessage = userInput.value.trim();
+                if (userMessage === '') return;
+                saveMessage('user', userMessage);
+                appendMessage('user', userMessage);
+                userInput.value = '';
+                fetch(`/autocomplete?q=${encodeURIComponent(userMessage)}`)
+                .then(response => response.json())
+                .then(data => {
+                    const botMessages = data.result;
+                    botMessages.forEach(message => {
+                        saveMessage('bot', message);
+                        appendMessage('bot', message);
+                    });
+                })
+                .catch(error => {
+                    console.error('Error:', error);
+                });
+            }
+            function retryLastMessage() {
+                const lastUserMessage = document.querySelector('.user-message:last-of-type');
+                if (lastUserMessage) {
+                    userInput.value = lastUserMessage.innerText;
+                }
+            }
         </script>
     </body>
     </html>
     """
     return HTMLResponse(content=html_code, status_code=200)
 @app.get('/autocomplete')
+async def autocomplete(q: str = Query(..., title='query')):
+    global message_history
+    message_history.append(('user', q))
+    try:
+        # Use combined models for responses
+        generated_responses = []
+        for model_name, model_info in models_dict.items():
+            model = model_info['model']
+            tokenizer = model_info['tokenizer']
+            text_generation_pipeline = pipeline("text-generation", model=model, tokenizer=tokenizer, device=0 if torch.cuda.is_available() else -1)
+            generated_response = text_generation_pipeline(q, do_sample=True, num_return_sequences=5)
+            generated_responses.extend([response['generated_text'] for response in generated_response])
+            message_history.extend([('bot', response['generated_text']) for response in generated_response])
+        logger.debug(f"Successfully autocomplete, q:{q}, res:{generated_responses}")
+        # Find the response closest to the question
+        closest_response = min(generated_responses, key=lambda x: abs(len(x) - len(q)))
+        return {"result": [closest_response]}
+    except Exception as e:
+        logger.error(f"Ignored error in autocomplete: {e}")
+if __name__ == '__main__':
+    uvicorn.run(app=app, host='0.0.0.0', port=int(os.getenv("PORT", 8001)))