app.py

import gradio as gr
import tensorflow as tf
from transformers import pipeline
import os

# Cargar tus modelos de clasificación (asumiendo que están en la raíz del proyecto)
try:
    model_transformer_encoder = tf.keras.models.load_model('stacked_transformer_encoder.keras')
    model_transformer_positional_encoding = tf.keras.models.load_model('transformer_encoder_pos.keras')
    model_simple_rnn = tf.keras.models.load_model('model_simple_rnn.keras')
    model_lstm = tf.keras.models.load_model('model_lstm.keras')
    print("Modelos de clasificación cargados correctamente.")
except Exception as e:
    print(f"Error al cargar los modelos de clasificación: {e}")
    model_transformer_encoder = None
    model_transformer_positional_encoding = None
    model_simple_rnn = None
    model_lstm = None

# Cargar el pipeline de traducción de Hugging Face (inglés a español)
try:
    translator_en_es = pipeline("translation", model="Helsinki-NLP/opus-mt-en-es")
except Exception as e:
    print(f"Error al cargar el modelo de traducción (inglés a español): {e}")
    translator_en_es = None

def clasificar_noticia(texto, modelo_seleccionado):
    """Función para clasificar el texto usando el modelo seleccionado."""
    modelo_a_usar = None
    if modelo_seleccionado == "Transformer Encoder Apilado" and model_transformer_encoder is not None:
        modelo_a_usar = model_transformer_encoder
    elif modelo_seleccionado == "Transformer Positional Encoding" and model_transformer_positional_encoding is not None:
        modelo_a_usar = model_transformer_positional_encoding
    elif modelo_seleccionado == "Simple RNN" and model_simple_rnn is not None:
        modelo_a_usar = model_simple_rnn
    elif modelo_seleccionado == "LSTM" and model_lstm is not None:
        modelo_a_usar = model_lstm

    if modelo_a_usar:
        # *** IMPORTANTE: Implementa aquí la lógica de preprocesamiento del texto ***
        # para que coincida con la entrada esperada por el modelo.
        # Esto incluye tokenización, padding, etc.
        prediction = modelo_a_usar.predict([texto])
        # *** IMPORTANTE: Interpreta la salida del modelo para obtener la clase predicha. ***
        # Esto dependerá de cómo entrenaste tu modelo.
        return f"Clase predicha ({modelo_seleccionado}): {prediction}"
    else:
        return f"El modelo '{modelo_seleccionado}' no está disponible."

def traducir_texto_en_es(texto_en):
    """Función para traducir texto de inglés a español."""
    if translator_en_es:
        result = translator_en_es(texto_en)[0]['translation_text']
        return result
    else:
        return "El modelo de traducción (inglés a español) no está disponible."

def main():
    with gr.Blocks() as demo:
        gr.Markdown("# Aplicación de Clasificación y Traducción")

        with gr.TabbedInterface([
            gr.TabItem(
                [
                    gr.Markdown("## Clasificación de Noticias"),
                    gr.Textbox(label="Ingresa la noticia aquí:", elem_id="input_texto_clasificacion"),
                    gr.Dropdown(
                        ["Transformer Encoder Apilado", "Transformer Positional Encoding", "Simple RNN", "LSTM"],
                        label="Selecciona el modelo:",
                        elem_id="modelo_seleccion"
                    ),
                    gr.Button("Clasificar", elem_id="boton_clasificar"),
                    gr.Textbox(label="Resultado de la clasificación:", elem_id="output_clasificacion")
                ],
                label="Clasificación de Noticias"
            ),
            gr.TabItem(
                [
                    gr.Markdown("## Traducción de Inglés a Español"),
                    gr.Textbox(label="Ingresa el texto en inglés:", elem_id="input_texto_traduccion"),
                    gr.Button("Traducir", elem_id="boton_traducir"),
                    gr.Textbox(label="Texto traducido al español:", elem_id="output_traduccion")
                ],
                label="Traducción (Inglés a Español)"
            )
        ]) as tabs:
            input_texto_clasificacion = gr.get_component("input_texto_clasificacion")
            modelo_seleccion = gr.get_component("modelo_seleccion")
            output_clasificacion = gr.get_component("output_clasificacion")
            boton_clasificar = gr.get_component("boton_clasificar")
            boton_clasificar.click(fn=clasificar_noticia, inputs=[input_texto_clasificacion, modelo_seleccion], outputs=output_clasificacion)

            input_texto_traduccion = gr.get_component("input_texto_traduccion")
            output_traduccion = gr.get_component("output_traduccion")
            boton_traducir = gr.get_component("boton_traducir")
            boton_traducir.click(fn=traducir_texto_en_es, inputs=input_texto_traduccion, outputs=output_traduccion)

    demo.launch()

if __name__ == "__main__":
    main()