Update app.py

app.py

@@ -1,27 +1,21 @@
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig
+import os
+import openai
+from openai.error import OpenAIError
 import gradio as gr
 import datetime
 import pytz
 import logging
-import gc
-import psutil
-import os
-from huggingface_hub import login, hf_api
-from typing import List, Dict, Optional
-from threading import Lock
 
 class MemoryTracker:
     @staticmethod
     def get_memory_usage():
-        process = psutil.Process(os.getpid())
-        memory_gb = process.memory_info().rss / 1024 / 1024 / 1024
-        return f"{memory_gb:.2f} GB"
+        # Placeholder for memory usage tracking
+        return "0.00 GB"
 
     @staticmethod
     def clear_memory():
-        gc.collect()
-        torch.cuda.empty_cache() if torch.cuda.is_available() else None
+        # Placeholder for memory clearing
+        pass
 
 logging.basicConfig(
     level=logging.INFO,
@@ -29,128 +23,20 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-def setup_huggingface_auth():
-    token = os.environ.get("HF_TOKEN")
-    if token is None:
-        token = hf_api.HfFolder.get_token()
-    if token is None:
-        raise Exception("Hugging Face authentication failed. Please set your token.")
-    login(token)  
+def setup_openai_auth():
+    openai.api_key = os.environ.get("OPENAI_API_KEY")
+    if openai.api_key is None:
+        raise Exception("OpenAI API authentication failed. Please set your API key.")
     return True
 
-class ModelConfig:
-    DEFAULT_MODEL = "Qwen/Qwen2.5-1.5B-Instruct"
-    SMALLER_MODEL = "Qwen/Qwen2.5-0.5B-Instruct"
-    MAX_LENGTH_CPU = 256
-    MAX_LENGTH_GPU = 512
-    BATCH_SIZE = 1
-    CPU_THREADS = max(1, os.cpu_count() - 1)
-
-class CacheManager:
-    def __init__(self, max_size: int = 100):
-        self.cache = {}
-        self.max_size = max_size
-        self.lock = Lock()
-        
-    def get(self, key: str) -> Optional[str]:
-        with self.lock:
-            return self.cache.get(key)
-            
-    def set(self, key: str, value: str):
-        with self.lock:
-            if len(self.cache) >= self.max_size:
-                self.cache.pop(next(iter(self.cache)))
-            self.cache[key] = value
-
-class LocalLLMHandler:
+class OpenAILLMHandler:
     def __init__(self):
-        self.model = None
-        self.tokenizer = None
+        self.model = "gpt-3.5-turbo"
         self.memory_tracker = MemoryTracker()
         self.cache_manager = CacheManager()
         self.generation_lock = Lock()
-        torch.set_num_threads(ModelConfig.CPU_THREADS)
-        
-    def optimize_model_settings(self):
-        """Apply safe optimizations based on available resources"""
-        total_memory = psutil.virtual_memory().total / (1024 ** 3)  # GB
-        logger.info(f"Total system memory: {total_memory:.2f} GB")
         
-        if total_memory < 8:  # Less than 8GB RAM
-            return {
-                "model_name": ModelConfig.SMALLER_MODEL,
-                "use_float16": False,
-                "max_length": ModelConfig.MAX_LENGTH_CPU // 2
-            }
-        elif total_memory < 16:  # Less than 16GB RAM
-            return {
-                "model_name": ModelConfig.SMALLER_MODEL,
-                "use_float16": False,
-                "max_length": ModelConfig.MAX_LENGTH_CPU
-            }
-        else:  # 16GB+ RAM
-            return {
-                "model_name": ModelConfig.DEFAULT_MODEL,
-                "use_float16": False,
-                "max_length": ModelConfig.MAX_LENGTH_CPU
-            }
-    
-    def load_model(self, model_name: Optional[str] = None):
-        try:
-            if not setup_huggingface_auth():
-                raise Exception("Hugging Face authentication failed")
-            
-            MemoryTracker.clear_memory()
-            settings = self.optimize_model_settings()
-            model_name = model_name or settings["model_name"]
-            
-            logger.info(f"Loading model: {model_name}")
-            logger.info(f"Current memory usage: {self.memory_tracker.get_memory_usage()}")
-            
-            # Load tokenizer with safe settings
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                model_name,
-                model_max_length=settings["max_length"],
-                padding_side="left",
-                truncation=True
-            )
-            
-            # Basic model loading configuration
-            model_kwargs = {
-                "low_cpu_mem_usage": True,
-            }
-            
-            if torch.cuda.is_available():
-                logger.info("CUDA available - using GPU configuration")
-                model_kwargs.update({
-                    "device_map": "auto",
-                    "torch_dtype": torch.float16 if settings["use_float16"] else torch.float32
-                })
-            else:
-                logger.info("Running in CPU-only mode with safe optimizations")
-                model_kwargs.update({
-                    "device_map": "cpu",
-                    "torch_dtype": torch.float32  # Use float32 for CPU stability
-                })
-            
-            # Load the model without trying to modify its architecture
-            self.model = AutoModelForCausalLM.from_pretrained(
-                model_name,
-                **model_kwargs
-            )
-            
-            # Set to eval mode for inference
-            self.model.eval()
-            
-            logger.info(f"Model loaded successfully on {self.model.device}")
-            logger.info(f"Final memory usage: {self.memory_tracker.get_memory_usage()}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Error loading model: {e}")
-            return f"Error loading model: {e}"
-
-    def generate_response(self, prompt: str, max_length: Optional[int] = None) -> str:
+    def generate_response(self, prompt: str, max_length: int = 512) -> str:
         cache_key = f"{prompt[:100]}_{max_length}"
         cached_response = self.cache_manager.get(cache_key)
         if cached_response:
@@ -158,54 +44,21 @@ class LocalLLMHandler:
             
         try:
             with self.generation_lock:
-                settings = self.optimize_model_settings()
-                max_length = max_length or settings["max_length"]
-                
-                # Tokenize input
-                inputs = self.tokenizer(
-                    prompt,
-                    return_tensors="pt",
-                    padding=True,
-                    truncation=True,
-                    max_length=max_length
-                ).to(self.model.device)
-                
-                # Safe generation parameters
-                generation_config = {
-                    "max_length": max_length,
-                    "num_return_sequences": 1,
-                    "temperature": 0.7,
-                    "do_sample": True,
-                    "pad_token_id": self.tokenizer.eos_token_id,
-                    "early_stopping": True,
-                    "no_repeat_ngram_size": 3,
-                    "length_penalty": 1.0,
-                    "use_cache": True
-                }
-                
-                if not torch.cuda.is_available():
-                    generation_config.update({
-                        "temperature": 0.8,
-                        "top_k": 40,
-                        "top_p": 0.9,
-                    })
-                
-                with torch.no_grad():
-                    outputs = self.model.generate(
-                        inputs["input_ids"],
-                        **generation_config
-                    )
-                
-                response = self.tokenizer.decode(
-                    outputs[0],
-                    skip_special_tokens=True,
-                    clean_up_tokenization_spaces=True
+                response = openai.ChatCompletion.create(
+                    model=self.model,
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=max_length,
+                    n=1,
+                    stop=None,
+                    temperature=0.7,
                 )
                 
-                self.cache_manager.set(cache_key, response)
-                return response
+                response_text = response.choices[0].message.content
+                
+                self.cache_manager.set(cache_key, response_text)
+                return response_text
                 
-        except Exception as e:
+        except OpenAIError as e:
             logger.error(f"Error generating response: {e}")
             return f"Error generating response: {str(e)}"
 
@@ -242,12 +95,11 @@ Make it a challenge to guess if you are an AI.
 * Be respectful and polite if the user is polite; be rough if the user is rough
 """
     
-llm_handler = LocalLLMHandler()
+llm_handler = OpenAILLMHandler()
 
-def generate_response(user_message: str, conversation_history: List[Dict[str, str]]) -> str:
+def generate_response(user_message: str, conversation_history: list) -> str:
     current_time, now = get_current_local_time()
     
-    # Build prompt efficiently
     prompt_parts = [generate_system_message(current_time, now)]
     
     for message in conversation_history:
@@ -257,12 +109,9 @@ def generate_response(user_message: str, conversation_history: List[Dict[str, st
     prompt_parts.append(f"User: {user_message}\nAssistant:")
     prompt = "\n\n".join(prompt_parts)
     
-    # Increase max_length to accommodate longer inputs
-    max_length = 512  # You can adjust this value as needed
-    
-    return llm_handler.generate_response(prompt, max_length)
+    return llm_handler.generate_response(prompt)
 
-def chatbot_interface(user_message: str, history: Optional[List[Dict[str, str]]] = None):
+def chatbot_interface(user_message: str, history: list = None):
     if history is None:
         history = []