Update app.py

app.py

@@ -1,130 +1,120 @@
 import gradio as gr
-import torch
-from transformers import MarianMTModel, MarianTokenizer
+from transformers import pipeline
+import pandas as pd
 import logging
-import json
 
-# ---------------- LOGGING ----------------
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-logger = logging.getLogger("FrenchTitleApp")
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-# ---------------- MODEL CLASS ----------------
 class FrenchTitleGenerator:
-    def __init__(self, model_name="Helsinki-NLP/opus-mt-en-fr"):
-        logger.info(f"Loading model: {model_name}")
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    def __init__(self):
         try:
-            self.tokenizer = MarianTokenizer.from_pretrained(model_name)
-            self.model = MarianMTModel.from_pretrained(model_name).to(self.device)
-            logger.info("Model loaded successfully")
+            # Load your fine-tuned model from Hugging Face
+            # Replace with your actual model name after training
+            self.generator = pipeline(
+                "translation",
+                model="sufya12/french-title-model",  # Change this to your model
+                tokenizer="sufya12/french-title-model"
+            )
+            logger.info("✅ Model loaded successfully from Hugging Face")
         except Exception as e:
-            logger.error(f"Error loading model: {e}")
-            raise
+            logger.error(f"❌ Error loading model: {e}")
+            self.generator = None
 
-    def generate(self, year, city, original_title, max_length=50, temperature=0.8):
+    def generate_title(self, year, city, event_description, temperature=0.8, max_length=60):
+        if not self.generator:
+            return "Error: Model not loaded. Please check the logs."
+        
         try:
-            # Clean and prepare input
-            year = str(year).strip()
-            city = str(city).strip()
-            original_title = str(original_title).strip()
+            # Create input prompt
+            input_text = f"Generate French title: Year: {year} City: {city} Event: {event_description}"
             
-            if not original_title:
-                return {"error": "Please enter an event description."}
+            # Generate title
+            result = self.generator(
+                input_text,
+                max_length=max_length,
+                num_beams=3,
+                temperature=temperature,
+                do_sample=True,
+                early_stopping=True
+            )
             
-            input_text = f"Translate to French: {original_title}"
+            return result[0]['translation_text']
             
-            inputs = self.tokenizer(input_text, return_tensors="pt", padding=True, truncation=True, max_length=512).to(self.device)
+        except Exception as e:
+            return f"Error generating title: {str(e)}"
 
-            with torch.no_grad():
-                outputs = self.model.generate(
-                    inputs["input_ids"],
-                    attention_mask=inputs["attention_mask"],
-                    max_length=int(max_length),
-                    do_sample=True,
-                    temperature=float(temperature),
-                    num_beams=3,
-                    early_stopping=True
-                )
+# Initialize the generator
+title_generator = FrenchTitleGenerator()
+
+# Gradio interface
+def generate_french_title(year, city, event_description, temperature, max_length):
+    return title_generator.generate_title(year, city, event_description, temperature, max_length)
 
-            result = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+# Create the interface
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🇫🇷 French Event Title Generator")
+    gr.Markdown("Generate professional French event titles using AI!")
+    
+    with gr.Row():
+        with gr.Column():
+            year_input = gr.Textbox(
+                label="Year",
+                placeholder="e.g., 2025",
+                value="2025"
+            )
+            city_input = gr.Textbox(
+                label="City", 
+                placeholder="e.g., Paris",
+                value="Paris"
+            )
+            event_input = gr.Textbox(
+                label="Event Description",
+                placeholder="Describe your event in English...",
+                lines=3
+            )
             
-            # Clean up the result
-            result = result.replace("'", "").strip()
+            with gr.Row():
+                temperature_slider = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.5,
+                    value=0.8,
+                    step=0.1,
+                    label="Creativity Level"
+                )
+                max_length_slider = gr.Slider(
+                    minimum=20,
+                    maximum=100,
+                    value=60,
+                    step=5,
+                    label="Title Length"
+                )
             
-            # Add context if needed
-            if year and city:
-                final_result = f"{result} - {city} {year}"
-            elif city:
-                final_result = f"{result} - {city}"
-            elif year:
-                final_result = f"{result} - {year}"
-            else:
-                final_result = result
-
-            return {
-                "success": True,
-                "french_title": final_result,
-                "input_used": {
-                    "year": year,
-                    "city": city,
-                    "original_title": original_title,
-                    "temperature": temperature,
-                    "max_length": max_length
-                }
-            }
-
-        except Exception as e:
-            logger.error(f"Error during generation: {e}")
-            return {"error": f"Error generating title: {str(e)}"}
-
-# ---------------- INIT MODEL ----------------
-try:
-    generator = FrenchTitleGenerator()
-    model_loaded = True
-    logger.info("Application started successfully")
-except Exception as e:
-    logger.error(f"Failed to initialize model: {e}")
-    generator = None
-    model_loaded = False
-
-# ---------------- GRADIO APP ----------------
-def generate_title(year, city, original_title, temperature=0.8, max_length=50):
-    if not model_loaded:
-        return "Error: Model failed to load. Please check the logs."
+            generate_btn = gr.Button("Generate Title 🚀", variant="primary")
+        
+        with gr.Column():
+            output_text = gr.Textbox(
+                label="Generated French Title",
+                lines=4,
+                show_copy_button=True
+            )
     
-    result = generator.generate(year, city, original_title, max_length, temperature)
+    # Examples
+    gr.Examples(
+        examples=[
+            ["2025", "Paris", "Summer Jazz Festival in the Park"],
+            ["2024", "Lyon", "International Food and Wine Exhibition"],
+            ["2025", "Nice", "Beach Music Concert and Party"]
+        ],
+        inputs=[year_input, city_input, event_input]
+    )
     
-    if "error" in result:
-        return result["error"]
-    else:
-        return result["french_title"]
-
-# Create interface
-iface = gr.Interface(
-    fn=generate_title,
-    inputs=[
-        gr.Textbox(label="Year", placeholder="e.g. 2025", value=""),
-        gr.Textbox(label="City", placeholder="e.g. Paris", value=""),
-        gr.Textbox(
-            label="Event Description", 
-            placeholder="e.g. Jazz Festival in the City Park",
-            lines=2
-        ),
-        gr.Slider(0.1, 1.5, value=0.8, step=0.1, label="Creativity (Temperature)"),
-        gr.Slider(20, 100, value=50, step=5, label="Max Title Length")
-    ],
-    outputs=gr.Textbox(
-        label="Generated French Title"
-    ),
-    title="🇫🇷 French Event Title Generator",
-    description="Generate elegant French titles for your events based on year, city, and description.",
-    allow_flagging="never",
-    api_name="predict"
-)
+    generate_btn.click(
+        fn=generate_french_title,
+        inputs=[year_input, city_input, event_input, temperature_slider, max_length_slider],
+        outputs=output_text
+    )
 
 if __name__ == "__main__":
-    iface.launch(
-        server_name="0.0.0.0", 
-        server_port=7860,
-        share=False
-    )
+    demo.launch()