Update app.py

app.py

@@ -6,7 +6,6 @@ import tempfile
 import pandas as pd
 import requests
 from bs4 import BeautifulSoup
-from transformers import AutoModelForCausalLM, AutoTokenizer
 import torch
 import whisper
 from moviepy.editor import VideoFileClip
@@ -16,6 +15,11 @@ import docx
 import yt_dlp
 from functools import lru_cache
 import gc
+import time
+from huggingface_hub import login
+from transformers import AutoTokenizer, BitsAndBytesConfig
+from unsloth import FastLanguageModel
+import tqdm
 
 # Configure logging
 logging.basicConfig(
@@ -24,6 +28,11 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# Login to Hugging Face Hub if token is available
+HUGGINGFACE_TOKEN = os.environ.get('HUGGINGFACE_TOKEN')
+if HUGGINGFACE_TOKEN:
+    login(token=HUGGINGFACE_TOKEN)
+
 class ModelManager:
     _instance = None
     
@@ -37,127 +46,126 @@ class ModelManager:
         if not self._initialized:
             self.tokenizer = None
             self.model = None
-            self.news_generator = None
             self.whisper_model = None
             self._initialized = True
+            self.last_used = time.time()
     
-    @spaces.GPU(duration=120)
-    def initialize_models(self):
-        """Initialize models with ZeroGPU compatible settings"""
+    @spaces.GPU()
+    def initialize_llm(self):
+        """Initialize LLM model with unsloth optimization"""
         try:
-            import torch
-            from transformers import AutoModelForCausalLM, AutoTokenizer
+            MODEL_NAME = "meta-llama/Llama-2-7b-chat-hf"
             
-            HUGGINGFACE_TOKEN = os.environ.get('HUGGINGFACE_TOKEN')
-            if not HUGGINGFACE_TOKEN:
-                raise ValueError("HUGGINGFACE_TOKEN environment variable not set")
-
-            logger.info("Starting model initialization...")
-            model_name = "meta-llama/Llama-2-7b-chat-hf"
-
-            # Load tokenizer
             logger.info("Loading tokenizer...")
             self.tokenizer = AutoTokenizer.from_pretrained(
-                model_name,
+                MODEL_NAME,
                 token=HUGGINGFACE_TOKEN,
                 use_fast=True,
-                model_max_length=512
             )
             self.tokenizer.pad_token = self.tokenizer.eos_token
-
-            # Initialize model with ZeroGPU compatible settings
-            logger.info("Loading model...")
-            self.model = AutoModelForCausalLM.from_pretrained(
-                model_name,
+            
+            # Configure 4-bit quantization
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=torch.float16,
+                bnb_4bit_use_double_quant=True
+            )
+            
+            logger.info("Loading and optimizing model with unsloth...")
+            # Use unsloth to load and optimize the model
+            self.model, self.tokenizer = FastLanguageModel.from_pretrained(
+                model_name=MODEL_NAME,
                 token=HUGGINGFACE_TOKEN,
-                device_map="auto",
-                torch_dtype=torch.float16,
-                low_cpu_mem_usage=True,
-                use_safetensors=True,
-                # ZeroGPU specific settings
-                max_memory={0: "6GB"},
-                offload_folder="offload",
-                offload_state_dict=True
+                quantization_config=bnb_config,
+                max_seq_length=2048,
+                device_map="auto"
             )
-
-            # Create pipeline with minimal settings
-            logger.info("Creating pipeline...")
-            from transformers import pipeline
-            self.news_generator = pipeline(
-                "text-generation",
-                model=self.model,
-                tokenizer=self.tokenizer,
-                device_map="auto",
-                torch_dtype=torch.float16,
-                max_new_tokens=512,
-                do_sample=True,
-                temperature=0.7,
-                top_p=0.95,
-                repetition_penalty=1.2,
-                num_return_sequences=1,
-                early_stopping=True
+            
+            # Optimize with unsloth
+            self.model = FastLanguageModel.get_peft_model(
+                self.model,
+                r=16,
+                target_modules=["q_proj", "k_proj", "v_proj", "o_proj", 
+                               "gate_proj", "up_proj", "down_proj"],
+                lora_alpha=16,
+                lora_dropout=0,
+                bias="none",
+                use_gradient_checkpointing=True,
+                random_state=3407
             )
+            
+            logger.info("LLM initialized successfully")
+            self.last_used = time.time()
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error initializing LLM: {str(e)}")
+            raise
 
-            # Load Whisper model with minimal settings
+    @spaces.GPU()
+    def initialize_whisper(self):
+        """Initialize Whisper model for audio transcription"""
+        try:
             logger.info("Loading Whisper model...")
+            # Using tiny model for efficiency but can be changed based on needs
             self.whisper_model = whisper.load_model(
                 "tiny",
                 device="cuda" if torch.cuda.is_available() else "cpu",
                 download_root="/tmp/whisper"
             )
-
-            logger.info("All models initialized successfully")
+            logger.info("Whisper model initialized successfully")
+            self.last_used = time.time()
             return True
-
         except Exception as e:
-            logger.error(f"Error during model initialization: {str(e)}")
-            self.reset_models()
+            logger.error(f"Error initializing Whisper: {str(e)}")
             raise
 
-    def reset_models(self):
-        """Reset all models and clear memory"""
-        try:
-            if hasattr(self, 'model') and self.model is not None:
-                self.model.cpu()
-                del self.model
-            
-            if hasattr(self, 'tokenizer') and self.tokenizer is not None:
-                del self.tokenizer
+    def check_llm_initialized(self):
+        """Check if LLM is initialized and initialize if needed"""
+        if self.tokenizer is None or self.model is None:
+            logger.info("LLM not initialized, initializing...")
+            self.initialize_llm()
+        self.last_used = time.time()
+    
+    def check_whisper_initialized(self):
+        """Check if Whisper model is initialized and initialize if needed"""
+        if self.whisper_model is None:
+            logger.info("Whisper model not initialized, initializing...")
+            self.initialize_whisper()
+        self.last_used = time.time()
+    
+    def reset_models(self, force=False):
+        """Reset models to free memory if they haven't been used recently"""
+        current_time = time.time()
+        # Only reset if forced or models haven't been used for 10 minutes
+        if force or (current_time - self.last_used > 600):  
+            try:
+                logger.info("Resetting models to free memory...")
                 
-            if hasattr(self, 'news_generator') and self.news_generator is not None:
-                del self.news_generator
+                if hasattr(self, 'model') and self.model is not None:
+                    del self.model
+                    
+                if hasattr(self, 'tokenizer') and self.tokenizer is not None:
+                    del self.tokenizer
+                    
+                if hasattr(self, 'whisper_model') and self.whisper_model is not None:
+                    del self.whisper_model
                 
-            if hasattr(self, 'whisper_model') and self.whisper_model is not None:
-                if hasattr(self.whisper_model, 'cpu'):
-                    self.whisper_model.cpu()
-                del self.whisper_model
-            
-            self.tokenizer = None
-            self.model = None
-            self.news_generator = None
-            self.whisper_model = None
-            
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-                torch.cuda.synchronize()
-            
-            import gc
-            gc.collect()
-            
-        except Exception as e:
-            logger.error(f"Error during model reset: {str(e)}")
-
-    def check_models_initialized(self):
-        """Check if all models are properly initialized"""
-        if None in (self.tokenizer, self.model, self.news_generator, self.whisper_model):
-            logger.warning("Models not initialized, attempting to initialize...")
-            self.initialize_models()
-
-    def get_models(self):
-        """Get initialized models, initializing if necessary"""
-        self.check_models_initialized()
-        return self.tokenizer, self.model, self.news_generator, self.whisper_model
-        
+                self.tokenizer = None
+                self.model = None
+                self.whisper_model = None
+                
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    torch.cuda.synchronize()
+                
+                gc.collect()
+                logger.info("Models reset successfully")
+                
+            except Exception as e:
+                logger.error(f"Error resetting models: {str(e)}")
+
 # Create global model manager instance
 model_manager = ModelManager()
 
@@ -188,7 +196,7 @@ def convert_video_to_audio(video_file):
     try:
         video = VideoFileClip(video_file)
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_file:
-            video.audio.write_audiofile(temp_file.name)
+            video.audio.write_audiofile(temp_file.name, verbose=False, logger=None)
             logger.info(f"Video converted to audio: {temp_file.name}")
             return temp_file.name
     except Exception as e:
@@ -208,30 +216,40 @@ def preprocess_audio(audio_file):
         logger.error(f"Error preprocessing audio: {str(e)}")
         raise
 
-@spaces.GPU(duration=120)
+@spaces.GPU()
 def transcribe_audio(file):
     """Transcribe an audio or video file."""
     try:
-        _, _, _, whisper_model = model_manager.get_models()
+        model_manager.check_whisper_initialized()
         
         if isinstance(file, str) and file.startswith('http'):
             file_path = download_social_media_video(file)
         elif isinstance(file, str) and file.lower().endswith(('.mp4', '.avi', '.mov', '.mkv')):
             file_path = convert_video_to_audio(file)
+        elif file is not None:  # Handle file object from Gradio
+            file_path = preprocess_audio(file.name)
         else:
-            file_path = preprocess_audio(file)
+            return ""  # Return empty string for None input
 
         logger.info(f"Transcribing audio: {file_path}")
         if not os.path.exists(file_path):
             raise FileNotFoundError(f"Audio file not found: {file_path}")
 
         with torch.inference_mode():
-            result = whisper_model.transcribe(file_path)
+            result = model_manager.whisper_model.transcribe(file_path)
             if not result:
                 raise RuntimeError("Transcription failed to produce results")
                 
         transcription = result.get("text", "Error in transcription")
         logger.info(f"Transcription completed: {transcription[:50]}...")
+        
+        # Clean up temp file
+        try:
+            if os.path.exists(file_path):
+                os.remove(file_path)
+        except Exception as e:
+            logger.warning(f"Could not remove temp file {file_path}: {str(e)}")
+            
         return transcription
     except Exception as e:
         logger.error(f"Error transcribing: {str(e)}")
@@ -247,7 +265,7 @@ def read_document(document_path):
         elif document_path.endswith(".docx"):
             doc = docx.Document(document_path)
             return "\n".join([paragraph.text for paragraph in doc.paragraphs])
-        elif document_path.endswith(".xlsx"):
+        elif document_path.endswith((".xlsx", ".xls")):
             return pd.read_excel(document_path).to_string()
         elif document_path.endswith(".csv"):
             return pd.read_csv(document_path).to_string()
@@ -260,17 +278,42 @@ def read_document(document_path):
 @lru_cache(maxsize=32)
 def read_url(url):
     """Read the content of a URL."""
+    if not url or url.strip() == "":
+        return ""
+        
     try:
-        response = requests.get(url)
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        response = requests.get(url, headers=headers, timeout=15)
         response.raise_for_status()
         soup = BeautifulSoup(response.content, 'html.parser')
-        return soup.get_text()
+        
+        # Remove non-content elements
+        for element in soup(["script", "style", "meta", "noscript", "iframe", "header", "footer", "nav"]):
+            element.extract()
+            
+        # Extract main content
+        main_content = soup.find("main") or soup.find("article") or soup.find("div", class_=["content", "main", "article"])
+        if main_content:
+            text = main_content.get_text(separator='\n', strip=True)
+        else:
+            text = soup.get_text(separator='\n', strip=True)
+            
+        # Clean up whitespace
+        lines = [line.strip() for line in text.split('\n') if line.strip()]
+        text = '\n'.join(lines)
+        
+        return text[:10000]  # Limit to 10k chars to avoid huge inputs
     except Exception as e:
         logger.error(f"Error reading URL: {str(e)}")
         return f"Error reading URL: {str(e)}"
 
 def process_social_content(url):
     """Process social media content."""
+    if not url or url.strip() == "":
+        return None
+        
     try:
         text_content = read_url(url)
         try:
@@ -287,11 +330,20 @@ def process_social_content(url):
         logger.error(f"Error processing social content: {str(e)}")
         return None
 
-@spaces.GPU(duration=120)
+@spaces.GPU()
 def generate_news(instructions, facts, size, tone, *args):
+    """Generate a news article based on provided data"""
     try:
-        tokenizer, _, news_generator, _ = model_manager.get_models()
+        # Ensure size is integer
+        if isinstance(size, float):
+            size = int(size)
+        elif not isinstance(size, int):
+            size = 250  # Default size
+            
+        # Check if models are initialized
+        model_manager.check_llm_initialized()
         
+        # Prepare data structure for inputs
         knowledge_base = {
             "instructions": instructions,
             "facts": facts,
@@ -301,78 +353,123 @@ def generate_news(instructions, facts, size, tone, *args):
             "social_content": []
         }
 
+        # Define the indices for parsing args
         num_audios = 5 * 3
         num_social_urls = 3 * 3
         num_urls = 5
 
+        # Parse arguments
         audios = args[:num_audios]
         social_urls = args[num_audios:num_audios+num_social_urls]
         urls = args[num_audios+num_social_urls:num_audios+num_social_urls+num_urls]
         documents = args[num_audios+num_social_urls+num_urls:]
 
+        # Process URLs with progress reporting
+        logger.info("Processing URLs...")
         for url in urls:
-            if url:
+            if url and isinstance(url, str) and url.strip():
                 content = read_url(url)
                 if content and not content.startswith("Error"):
                     knowledge_base["url_content"].append(content)
 
+        # Process documents
+        logger.info("Processing documents...")
         for document in documents:
             if document is not None:
                 content = read_document(document.name)
                 if content and not content.startswith("Error"):
                     knowledge_base["document_content"].append(content)
 
+        # Process audio/video files
+        logger.info("Processing audio/video files...")
         for i in range(0, len(audios), 3):
-            audio_file, name, position = audios[i:i+3]
-            if audio_file is not None:
-                knowledge_base["audio_data"].append({
-                    "audio": audio_file,
-                    "name": name,
-                    "position": position
-                })
-
-        for i in range(0, len(social_urls), 3):
-            social_url, social_name, social_context = social_urls[i:i+3]
-            if social_url:
-                social_content = process_social_content(social_url)
-                if social_content:
-                    knowledge_base["social_content"].append({
-                        "url": social_url,
-                        "name": social_name,
-                        "context": social_context,
-                        "text": social_content["text"],
-                        "video": social_content["video"]
+            if i+2 < len(audios):  # Ensure we have complete set of 3 elements
+                audio_file, name, position = audios[i:i+3]
+                if audio_file is not None:
+                    knowledge_base["audio_data"].append({
+                        "audio": audio_file,
+                        "name": name or "Unknown",
+                        "position": position or "Not specified"
                     })
 
+        # Process social media content
+        logger.info("Processing social media content...")
+        for i in range(0, len(social_urls), 3):
+            if i+2 < len(social_urls):  # Ensure we have complete set of 3 elements
+                social_url, social_name, social_context = social_urls[i:i+3]
+                if social_url and isinstance(social_url, str) and social_url.strip():
+                    social_content = process_social_content(social_url)
+                    if social_content:
+                        knowledge_base["social_content"].append({
+                            "url": social_url,
+                            "name": social_name or "Unknown",
+                            "context": social_context or "Not specified",
+                            "text": social_content.get("text", ""),
+                            "video": social_content.get("video", "")
+                        })
+
+        # Prepare transcriptions text
         transcriptions_text = ""
         raw_transcriptions = ""
 
+        # Process audio data transcriptions
+        logger.info("Transcribing audio...")
         for idx, data in enumerate(knowledge_base["audio_data"]):
             if data["audio"] is not None:
                 transcription = transcribe_audio(data["audio"])
-                if not transcription.startswith("Error"):
-                    transcriptions_text += f'"{transcription}" - {data["name"]}, {data["position"]}\n'
+                if transcription and not transcription.startswith("Error"):
+                    transcriptions_text += f'"{transcription}" - {data["name"]}, {data["position"]}\n\n'
                     raw_transcriptions += f'[Audio/Video {idx + 1}]: "{transcription}" - {data["name"]}, {data["position"]}\n\n'
 
-        for data in knowledge_base["social_content"]:
+        # Process social media content transcriptions
+        for idx, data in enumerate(knowledge_base["social_content"]):
             if data["text"] and not str(data["text"]).startswith("Error"):
-                transcriptions_text += f'[Social media text]: "{data["text"][:200]}..." - {data["name"]}, {data["context"]}\n'
-                raw_transcriptions += transcriptions_text + "\n\n"
+                # Truncate long texts for the prompt
+                text_excerpt = data["text"][:500] + "..." if len(data["text"]) > 500 else data["text"]
+                social_text = f'[Social media {idx+1} - text]: "{text_excerpt}" - {data["name"]}, {data["context"]}\n\n'
+                transcriptions_text += social_text
+                raw_transcriptions += social_text
+                
             if data["video"] and not str(data["video"]).startswith("Error"):
-                video_transcription = f'[Social media video]: "{data["video"]}" - {data["name"]}, {data["context"]}\n'
+                video_transcription = f'[Social media {idx+1} - video]: "{data["video"]}" - {data["name"]}, {data["context"]}\n\n'
                 transcriptions_text += video_transcription
-                raw_transcriptions += video_transcription + "\n\n"
-
-        document_content = "\n\n".join(knowledge_base["document_content"])
-        url_content = "\n\n".join(knowledge_base["url_content"])
-
+                raw_transcriptions += video_transcription
+
+        # Combine document content and URL content (with truncation for very long content)
+        document_summaries = []
+        for idx, doc in enumerate(knowledge_base["document_content"]):
+            # Truncate long documents
+            if len(doc) > 1000:
+                doc_excerpt = doc[:1000] + "... [document continues]"
+            else:
+                doc_excerpt = doc
+            document_summaries.append(f"[Document {idx+1}]: {doc_excerpt}")
+        
+        document_content = "\n\n".join(document_summaries)
+        
+        url_summaries = []
+        for idx, url_content in enumerate(knowledge_base["url_content"]):
+            # Truncate long URL content
+            if len(url_content) > 1000:
+                url_excerpt = url_content[:1000] + "... [content continues]"
+            else:
+                url_excerpt = url_content
+            url_summaries.append(f"[URL {idx+1}]: {url_excerpt}")
+            
+        url_content = "\n\n".join(url_summaries)
 
-        prompt = f"""[INST] You are a professional news writer. Write a news article based on the following information:
+        # Create prompt for the model
+        prompt = f"""<s>[INST] You are a professional news writer. Write a news article based on the following information:
 
 Instructions: {knowledge_base["instructions"]}
+
 Facts: {knowledge_base["facts"]}
-Additional content from documents: {document_content}
-Additional content from URLs: {url_content}
+
+Additional content from documents: 
+{document_content}
+
+Additional content from URLs: 
+{url_content}
 
 Use these transcriptions as direct and indirect quotes:
 {transcriptions_text}
@@ -380,7 +477,7 @@ Use these transcriptions as direct and indirect quotes:
 Follow these requirements:
 - Write a title
 - Write a 15-word hook that complements the title
-- Write the body with {size} words
+- Write the body with approximately {size} words
 - Use a {tone} tone
 - Answer the 5 Ws (Who, What, When, Where, Why) in the first paragraph
 - Use at least 80% direct quotes (in quotation marks)
@@ -388,27 +485,41 @@ Follow these requirements:
 - Do not invent information
 - Be rigorous with the provided facts [/INST]"""
 
-        # Optimize size and max tokens
-        max_tokens = min(int(size * 1.5), 512)
+        # Optimize for requested size
+        max_new_tokens = min(int(size * 2.5), 1024)  # Increased limit for better quality
 
-        # Generate article with optimized settings
+        # Generate response using optimized unsloth model
         with torch.inference_mode():
             try:
-                news_article = news_generator(
-                    prompt,
-                    max_new_tokens=max_tokens,
-                    num_return_sequences=1,
+                logger.info("Generating news article...")
+                # Use unsloth's optimized generate method
+                inputs = model_manager.tokenizer(
+                    prompt, 
+                    return_tensors="pt", 
+                    add_special_tokens=False
+                ).to(model_manager.model.device)
+                
+                # Generate with optimized settings
+                outputs = model_manager.model.generate(
+                    **inputs,
+                    max_new_tokens=max_new_tokens,
                     do_sample=True,
                     temperature=0.7,
                     top_p=0.95,
                     repetition_penalty=1.2,
-                    early_stopping=True
+                    pad_token_id=model_manager.tokenizer.eos_token_id,
+                    use_cache=True
+                )
+                
+                # Decode the generated text
+                generated_text = model_manager.tokenizer.decode(
+                    outputs[0][inputs.input_ids.shape[1]:], 
+                    skip_special_tokens=True
                 )
                 
-                # Process the generated text
-                if isinstance(news_article, list):
-                    news_article = news_article[0]['generated_text']
-                news_article = news_article.replace('[INST]', '').replace('[/INST]', '').strip()
+                # Clean up the generated text
+                news_article = generated_text.strip()
+                logger.info(f"News generation completed: {len(news_article)} chars")
                 
             except Exception as gen_error:
                 logger.error(f"Error in text generation: {str(gen_error)}")
@@ -419,122 +530,173 @@ Follow these requirements:
     except Exception as e:
         logger.error(f"Error generating news: {str(e)}")
         try:
-            # Attempt to recover by resetting and reinitializing models
-            model_manager.reset_models()
-            model_manager.initialize_models()
-            logger.info("Models reinitialized successfully after error")
-        except Exception as reinit_error:
-            logger.error(f"Failed to reinitialize models: {str(reinit_error)}")
-        return f"Error generating the news article: {str(e)}", ""
+            # Reset models to recover from errors
+            model_manager.reset_models(force=True)
+        except Exception as reset_error:
+            logger.error(f"Failed to reset models: {str(reset_error)}")
+        return f"Error generando la noticia: {str(e)}", "Error procesando las transcripciones."
 
 def create_demo():
-    with gr.Blocks() as demo:
-        gr.Markdown("## Generador de noticias todo en uno")
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 📰 NewsIA - Generador de Noticias IA")
+        gr.Markdown("Crea noticias profesionales a partir de múltiples fuentes de información.")
         
         with gr.Row():
             with gr.Column(scale=2):
                 instrucciones = gr.Textbox(
                     label="Instrucciones para la noticia",
+                    placeholder="Escribe instrucciones específicas para la generación de tu noticia",
                     lines=2
                 )
                 hechos = gr.Textbox(
-                    label="Describe los hechos de la noticia",
+                    label="Hechos principales",
+                    placeholder="Describe los hechos más importantes que debe incluir la noticia",
                     lines=4
                 )
-                tamaño = gr.Number(
-                    label="Tamaño del cuerpo de la noticia (en palabras)",
-                    value=100
-                )
-                tono = gr.Dropdown(
-                    label="Tono de la noticia",
-                    choices=["serio", "neutral", "divertido"],
-                    value="neutral"
-                )
+                
+                with gr.Row():
+                    tamaño = gr.Slider(
+                        label="Longitud aproximada (palabras)",
+                        minimum=100,
+                        maximum=500,
+                        value=250,
+                        step=50
+                    )
+                    tono = gr.Dropdown(
+                        label="Tono de la noticia",
+                        choices=["serio", "neutral", "divertido", "formal", "informal", "urgente"],
+                        value="neutral"
+                    )
 
             with gr.Column(scale=3):
                 inputs_list = [instrucciones, hechos, tamaño, tono]
 
                 with gr.Tabs():
-                    for i in range(1, 6):
-                        with gr.TabItem(f"Audio/Video {i}"):
-                            file = gr.File(
-                                label=f"Audio/Video {i}",
-                                file_types=["audio", "video"]
-                            )
-                            nombre = gr.Textbox(
-                                label="Nombre",
-                                placeholder="Nombre del entrevistado"
-                            )
-                            cargo = gr.Textbox(
-                                label="Cargo",
-                                placeholder="Cargo o rol"
-                            )
-                            inputs_list.extend([file, nombre, cargo])
-
-                    for i in range(1, 4):
-                        with gr.TabItem(f"Red Social {i}"):
-                            social_url = gr.Textbox(
-                                label=f"URL de red social {i}",
-                                placeholder="https://..."
-                            )
-                            social_nombre = gr.Textbox(
-                                label=f"Nombre de persona/cuenta {i}"
-                            )
-                            social_contexto = gr.Textbox(
-                                label=f"Contexto del contenido {i}",
-                                lines=2
-                            )
-                            inputs_list.extend([social_url, social_nombre, social_contexto])
-
-                    for i in range(1, 6):
-                        with gr.TabItem(f"URL {i}"):
+                    with gr.TabItem("📝 Documentos"):
+                        for i in range(1, 4):  # Reduced to 3 for better UX
+                            with gr.Row():
+                                documento = gr.File(
+                                    label=f"Documento {i}",
+                                    file_types=["pdf", "docx", "xlsx", "csv"],
+                                    file_count="single"
+                                )
+                                inputs_list.append(documento)
+                        
+                        # Add empty inputs to match the original expected array length
+                        for i in range(4, 6):
+                            inputs_list.append(None)
+
+                    with gr.TabItem("🔊 Audio/Video"):
+                        for i in range(1, 4):  # Reduced to 3 for better UX
+                            with gr.Group():
+                                gr.Markdown(f"**Fuente {i}**")
+                                file = gr.File(
+                                    label=f"Audio/Video {i}",
+                                    file_types=["audio", "video"]
+                                )
+                                with gr.Row():
+                                    nombre = gr.Textbox(
+                                        label="Nombre",
+                                        placeholder="Nombre del entrevistado"
+                                    )
+                                    cargo = gr.Textbox(
+                                        label="Cargo/Rol",
+                                        placeholder="Cargo o rol"
+                                    )
+                                inputs_list.extend([file, nombre, cargo])
+                        
+                        # Add empty inputs to match the original expected array length
+                        for i in range(4, 6):
+                            inputs_list.extend([None, None, None])
+
+                    with gr.TabItem("🌐 URLs"):
+                        for i in range(1, 4):  # Reduced to 3 for better UX
                             url = gr.Textbox(
                                 label=f"URL {i}",
                                 placeholder="https://..."
                             )
                             inputs_list.append(url)
-
-                    for i in range(1, 6):
-                        with gr.TabItem(f"Documento {i}"):
-                            documento = gr.File(
-                                label=f"Documento {i}",
-                                file_types=["pdf", "docx", "xlsx", "csv"],
-                                file_count="single"
-                            )
-                            inputs_list.append(documento)
-
-        gr.Markdown("---")
-
-        with gr.Row():
-            transcripciones_output = gr.Textbox(
-                label="Transcripciones",
-                lines=10,
-                show_copy_button=True
-            )
-
-        gr.Markdown("---")
+                        
+                        # Add empty inputs to match the original expected array length
+                        for i in range(4, 6):
+                            inputs_list.append(None)
+
+                    with gr.TabItem("📱 Redes Sociales"):
+                        for i in range(1, 3):  # Reduced to 2 for better UX
+                            with gr.Group():
+                                gr.Markdown(f"**Red Social {i}**")
+                                social_url = gr.Textbox(
+                                    label=f"URL",
+                                    placeholder="https://..."
+                                )
+                                with gr.Row():
+                                    social_nombre = gr.Textbox(
+                                        label=f"Nombre/Cuenta",
+                                        placeholder="Nombre de la persona o cuenta"
+                                    )
+                                    social_contexto = gr.Textbox(
+                                        label=f"Contexto",
+                                        placeholder="Contexto relevante"
+                                    )
+                                inputs_list.extend([social_url, social_nombre, social_contexto])
+                        
+                        # Add empty inputs to match the original expected array length
+                        for i in range(3, 4):
+                            inputs_list.extend([None, None, None])
 
         with gr.Row():
-            generar = gr.Button("Generar borrador")
-        
-        with gr.Row():
-            noticia_output = gr.Textbox(
-                label="Borrador generado",
-                lines=20,
-                show_copy_button=True
-            )
+            generar = gr.Button("✨ Generar Noticia", variant="primary")
+            reset = gr.Button("🔄 Limpiar Todo")
+
+        with gr.Tabs():
+            with gr.TabItem("📄 Noticia Generada"):
+                noticia_output = gr.Textbox(
+                    label="Borrador de la noticia",
+                    lines=15,
+                    show_copy_button=True
+                )
+            
+            with gr.TabItem("🎙️ Transcripciones"):
+                transcripciones_output = gr.Textbox(
+                    label="Transcripciones de fuentes",
+                    lines=10,
+                    show_copy_button=True
+                )
 
+        # Set up event handlers
         generar.click(
             fn=generate_news,
             inputs=inputs_list,
             outputs=[noticia_output, transcripciones_output]
         )
+        
+        # Reset functionality to clear all inputs
+        def reset_all():
+            output = []
+            for _ in range(len(inputs_list)):
+                output.append(None)
+            output.append("")
+            output.append("")
+            return output
+        
+        reset.click(
+            fn=reset_all,
+            inputs=[],
+            outputs=inputs_list + [noticia_output, transcripciones_output]
+        )
 
     return demo
 
 if __name__ == "__main__":
+    # Initialize models on startup to reduce first request latency
+    try:
+        model_manager.initialize_whisper()
+        model_manager.initialize_llm()
+    except Exception as e:
+        logger.warning(f"Initial model loading failed: {str(e)}")
+    
     demo = create_demo()
-    demo.queue()
+    demo.queue(concurrency_count=1, max_size=5)
     demo.launch(
         share=True,
         server_name="0.0.0.0",