Tarea acabada

.gitignore

@@ -0,0 +1,36 @@
+# --- Bytecode de Python (Archivos temporales) ---
+__pycache__/
+*.py[cod]
+*$py.class
+
+# --- Entornos Virtuales (NUNCA se suben) ---
+# Nombres comunes para la carpeta del entorno
+venv/
+.venv/
+env/
+ENV/
+.env_folder/
+
+# --- Variables de Entorno y Secretos (SEGURIDAD CRÍTICA) ---
+# Esto evita que tu Token de Hugging Face se suba a Internet
+.env
+.env.*
+.secrets
+
+# --- Archivos de IDE (Configuraciones de tu editor) ---
+.vscode/
+.idea/
+*.swp
+
+# --- Archivos específicos de Gradio ---
+# Gradio crea esta carpeta si le das al botón "Flag" en la interfaz
+flagged/
+
+# --- Archivos del Sistema Operativo ---
+.DS_Store
+Thumbs.db
+
+# --- Distribución / Instaladores (si creas paquetes) ---
+dist/
+build/
+*.egg-info/

app_tran_empresa.py

@@ -0,0 +1,70 @@
+import gradio as gr
+from transformers import pipeline
+
+#Configuración del modelo
+modelo_sentimiento = "pysentimiento/robertuito-sentiment-analysis"
+
+print("Cargando modelo de sentimientos... (Esto es rápido)")
+
+try:
+    clasificador = pipeline("text-classification", model=modelo_sentimiento)
+    print("✅ Modelo cargado y listo.")
+except Exception as e:
+    print(f"❌ Error al cargar: {e}")
+    clasificador = None
+
+def analizar_texto(texto):
+    if clasificador is None:
+        return "Error: El modelo no está cargado."
+    
+    if not texto:
+        return "Escribe algo primero."
+    
+    try:
+        resultados = clasificador(texto)
+        
+        # Formateamos bonito el resultado
+        mejor_resultado = resultados[0]
+        etiqueta = mejor_resultado['label'] # POS, NEG, NEU
+        confianza = round(mejor_resultado['score'] * 100, 2)
+        
+        # Traducción de etiquetas para que se entienda mejor
+        traduccion = {
+            'POS': '😃 Positivo',
+            'NEG': '😡 Negativo',
+            'NEU': '😐 Neutro'
+        }
+        
+        resultado_texto = traduccion.get(etiqueta, etiqueta)
+        return f"{resultado_texto} (Confianza: {confianza}%)"
+
+    except Exception as e:
+        return f"Error al analizar: {str(e)}"
+
+# --- INTERFAZ GRÁFICA ---
+with gr.Blocks(theme=gr.themes.Base()) as demo:
+    gr.Markdown("# 🌡️ Termómetro de Opinión")
+    gr.Markdown("Escribe una frase, reseña o tweet y la IA detectará el tono emocional.")
+    
+    with gr.Row():
+        input_text = gr.Textbox(
+            label="Tu texto", 
+            placeholder="Ej: ¡Este producto es una maravilla, me encanta!",
+            lines=3
+        )
+        output_text = gr.Label(label="Sentimiento Detectado")
+    
+    btn = gr.Button("Analizar Sentimiento", variant="primary")
+    btn.click(fn=analizar_texto, inputs=input_text, outputs=output_text)
+    
+    gr.Examples(
+        examples=[
+            ["El servicio fue pésimo y la comida estaba fría."],
+            ["Es una película entretenida, aunque el final es un poco flojo."],
+            ["¡Estoy superfeliz con mi nueva compra!"]
+        ],
+        inputs=input_text
+    )
+
+if __name__ == "__main__":
+    demo.launch()

difuser_autismo.py

@@ -0,0 +1,109 @@
+import gradio as gr
+import torch
+from diffusers import DiffusionPipeline
+
+# --- 1. CONFIGURACIÓN DEL MODELO (LCM para velocidad) ---
+print("🚀 Cargando modelo de difusión rápida (LCM)...")
+model_id = "SimianLuo/LCM_Dreamshaper_v7"
+
+try:
+    pipe = DiffusionPipeline.from_pretrained(model_id)
+    
+    pipe.to("cpu")
+    
+    pipe.safety_checker = None 
+    
+    print("✅ Modelo LCM cargado. Listo para generar imágenes rápidas.")
+except Exception as e:
+    print(f"❌ Error al cargar modelo: {e}")
+    pipe = None
+
+# --- 2. LÓGICA DE GENERACIÓN ---
+def generar_pictograma(texto_usuario, estilo):
+    if pipe is None:
+        return None
+    
+    prompt_base = f"{texto_usuario}, {estilo}, white background, centered, vector illustration, flat design, high contrast, minimal, simple shapes, no shadows"
+    prompt_negativo = "complex, realistic, photo, details, text, watermark, blurry, distorted, 3d render"
+
+    print(f"🎨 Generando: {texto_usuario}...")
+    
+    try:
+
+        imagen = pipe(
+            prompt=prompt_base,
+            negative_prompt=prompt_negativo,
+            num_inference_steps=4, 
+            guidance_scale=8.0,
+            width=512, 
+            height=512
+        ).images[0]
+        return imagen
+    except Exception as e:
+        print(f"Error generando: {e}")
+        return None
+
+# --- 3. INTERFAZ GRÁFICA ---
+css_accesible = """
+.gradio-container {background-color: #f0f8ff !important;}
+h1 {font-family: 'Arial', sans-serif; color: #2c3e50;}
+.boton-grande {font-size: 20px !important; height: 60px !important;}
+.texto-grande textarea {font-size: 24px !important; line-height: 1.5 !important;}
+.info-box {background-color: #e8f4f8; padding: 15px; border-radius: 10px; border: 2px solid #3498db;}
+"""
+
+with gr.Blocks(theme=gr.themes.Soft(), css=css_accesible) as demo:
+    
+    with gr.Row():
+        gr.Markdown("# 🗣️ PictoGen: Comunicación Visual")
+    
+    gr.Markdown(
+        """
+        <div class='info-box'>
+        <b>Herramienta de Accesibilidad:</b> Escribe lo que necesitas comunicar y la IA creará una tarjeta visual simple al instante.
+        Ideal para crear tableros de comunicación, agendas visuales o expresar necesidades.
+        </div>
+        """
+    )
+
+    with gr.Row():
+        # Columna Izquierda: Controles
+        with gr.Column(scale=1):
+            input_text = gr.Textbox(
+                label="¿Qué imagen necesitas?", 
+                placeholder="Ej: Comer manzana, Ir al baño, Jugar pelota...",
+                elem_classes="texto-grande"
+            )
+            
+            radio_style = gr.Radio(
+                ["icon style, thick lines", "cartoon style, colorful", "line art, black and white"],
+                label="Estilo Visual",
+                value="icon style, thick lines",
+                info="Selecciona el tipo de dibujo que mejor se entienda."
+            )
+            
+            btn = gr.Button("🎨 Crear Pictograma", variant="primary", elem_classes="boton-grande")
+
+        # Columna Derecha: Resultado
+        with gr.Column(scale=1):
+            output_image = gr.Image(
+                label="Tu Pictograma", 
+                type="pil", 
+                interactive=False,
+                height=512
+            )
+
+
+    btn.click(fn=generar_pictograma, inputs=[input_text, radio_style], outputs=output_image)
+
+    gr.Examples(
+        examples=[
+            ["Un vaso de agua", "icon style, thick lines"],
+            ["Sentirse feliz", "cartoon style, colorful"],
+            ["Autobús escolar", "icon style, thick lines"]
+        ],
+        inputs=[input_text, radio_style]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

difuser_empresa.py

@@ -0,0 +1,141 @@
+import gradio as gr
+import torch
+from diffusers import DiffusionPipeline
+import gc 
+
+
+print("💼 Iniciando BizSketch. Cargando motor gráfico ligero...")
+model_id = "SimianLuo/LCM_Dreamshaper_v7"
+
+try:
+
+    pipe = DiffusionPipeline.from_pretrained(model_id)
+    pipe.to("cpu", torch.float32)
+    pipe.safety_checker = None 
+    print("✅ Motor listo. Modo de bajo consumo activado.")
+
+except Exception as e:
+    print(f"❌ Error crítico al cargar el modelo: {e}\nAsegúrate de tener instalado: pip install diffusers transformers accelerate torch")
+    pipe = None
+
+def limpiar_memoria():
+    gc.collect()
+
+# --- 2. LÓGICA DE GENERACIÓN ---
+def generar_concepto(concepto_negocio, estilo_visual):
+    if pipe is None:
+        raise gr.Error("El modelo no se pudo cargar. Revisa la terminal.")
+    
+    if not concepto_negocio:
+         raise gr.Error("Por favor, escribe un concepto primero.")
+
+    prompt_base = f"{concepto_negocio}, {estilo_visual}, professional corporate illustration, clean background, minimal design, high quality, presentation ready"
+    
+    prompt_negativo = "blurry, messy, amateur, ugly, deformed hands, text, watermark, signature, low resolution, photograph"
+
+    print(f"📊 Generando concepto: {concepto_negocio}...")
+    
+    try:
+
+        imagen = pipe(
+            prompt=prompt_base,
+            negative_prompt=prompt_negativo,
+            num_inference_steps=5,  
+            guidance_scale=7.5,
+            width=512,                               
+            height=512
+        ).images[0]
+        
+        limpiar_memoria() 
+        return imagen
+    except Exception as e:
+        limpiar_memoria()
+        raise gr.Error(f"Error durante la generación: {e}")
+
+# --- 3. DISEÑO DE LA INTERFAZ (Layout Profesional) ---
+
+tema_negocio = gr.themes.Monochrome(
+    primary_hue="slate",
+    radius_size=gr.themes.sizes.radius_sm,
+    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"],
+)
+
+css_corporativo = """
+.container {max-width: 900px; margin: auto; padding-top: 20px;}
+#header-box {text-align: center; margin-bottom: 30px; border-bottom: 2px solid #e5e7eb; padding-bottom: 20px;}
+h1 {font-weight: 700; color: #1a202c;}
+.subtitle {color: #4b5563; font-size: 1.1rem;}
+#generate-btn {font-weight: bold; font-size: 1.1rem;}
+"""
+
+with gr.Blocks(theme=tema_negocio, css=css_corporativo, title="BizSketch App") as demo:
+    
+    with gr.Column(elem_classes="container"):
+        # Header
+        with gr.Column(elem_id="header-box"):
+            gr.Markdown("# 💼 BizSketch: Visualizador de Conceptos")
+            gr.Markdown("<span class='subtitle'>Genera ilustraciones rápidas para tus presentaciones y brainstorms.</span>")
+
+        with gr.Row(equal_height=False):
+            # --- Columna Izquierda: Inputs ---
+            with gr.Column(scale=2):
+                with gr.Group():
+                    gr.Markdown("### 1. Define tu idea")
+                    input_concept = gr.Textbox(
+                        label="Concepto de Negocio",
+                        placeholder="Ej: Crecimiento sostenible en mercados emergentes...",
+                        lines=3,
+                        show_label=False
+                    )
+                
+                with gr.Group():
+                     gr.Markdown("### 2. Elige el estilo visual")
+                     radio_style = gr.Radio(
+                        choices=[
+                            "clean line art sketch, blueprint style", 
+                            "flat vector illustration, modern tech style", 
+                            "isometric 3D render, soft colors",
+                            "watercolor sketch, business storyboard style"
+                        ],
+                        value="flat vector illustration, modern tech style",
+                        label="Estilo",
+                        show_label=False,
+                        interactive=True
+                    )
+
+                btn = gr.Button("🚀 Generar Visualización", variant="primary", elem_id="generate-btn")
+                
+                with gr.Accordion("💡 Consejos para mejores resultados", open=False):
+                    gr.Markdown("- Mantén los conceptos simples (ej: 'reunión de equipo exitosa' en vez de una descripción de 3 párrafos).")
+                    gr.Markdown("- El estilo 'Flat vector' suele ser el más limpio para presentaciones.")
+
+            # --- Columna Derecha: Output ---
+            with gr.Column(scale=3):
+                 gr.Markdown("### 🎯 Resultado")
+                 output_image = gr.Image(
+                    label="Visualización Generada",
+                    type="pil",
+                    interactive=False,
+                    #show_download_button=True,
+                    height=400
+                )
+
+        # --- Footer / Ejemplos ---
+        gr.Markdown("---")
+        gr.Markdown("### ⚡ Ejemplos Rápidos")
+        gr.Examples(
+            examples=[
+                ["Equipo diverso colaborando alrededor de una mesa con gráficos", "flat vector illustration, modern tech style"],
+                ["Innovación tecnológica y medio ambiente, bombilla con hoja", "clean line art sketch, blueprint style"],
+                ["Logística global, red de conexiones alrededor del mundo", "isometric 3D render, soft colors"]
+            ],
+            inputs=[input_concept, radio_style],
+            outputs=output_image,
+            fn=generar_concepto,
+            cache_examples=False 
+        )
+
+    btn.click(fn=generar_concepto, inputs=[input_concept, radio_style], outputs=output_image)
+
+if __name__ == "__main__":
+    demo.queue().launch()

inference_disc_visual.py

@@ -0,0 +1,65 @@
+import gradio as gr
+import requests
+import os
+from dotenv import load_dotenv
+
+# --- CONFIGURACIÓN ---
+load_dotenv()
+MI_TOKEN = os.getenv("HF_TOKEN") 
+
+MODELO = "Helsinki-NLP/opus-mt-es-en"
+
+API_URL = f"https://router.huggingface.co/hf-inference/models/{MODELO}"
+HEADERS = {"Authorization": f"Bearer {MI_TOKEN}"}
+
+def traducir_texto(texto):
+    if not texto:
+        return "Escribe algo..."
+
+    print(f"📡 Enviando a traducir ({MODELO})...")
+
+    payload = {"inputs": texto}
+
+    try:
+        response = requests.post(API_URL, headers=HEADERS, json=payload)
+        
+        # Leemos el resultado crudo
+        datos = response.json()
+        
+        if response.status_code == 200:      
+            if isinstance(datos, list) and len(datos) > 0:
+                return datos[0].get('translation_text', 'No se pudo traducir')
+            elif isinstance(datos, dict):
+                return datos.get('translation_text', str(datos))
+            else:
+                return str(datos)
+
+        elif response.status_code == 503:
+            return "⏳ El modelo está cargando (Cold Boot). Espera 20 segundos y reintenta."
+        
+        else:
+            return f"❌ Error {response.status_code}: {response.text}"
+
+    except Exception as e:
+        return f"Error de conexión: {e}"
+
+# Interfaz
+ui = gr.Interface(
+    fn=traducir_texto,
+    inputs=gr.Textbox(
+        label="Texto en Español", 
+        placeholder="Escribe aquí (ej: La accesibilidad es vital para la empresa)",
+        lines=3
+    ),
+    outputs=gr.Textbox(label="Traducción al Inglés (Modelo Helsinki-NLP)"),
+    title="🌍 Traductor Empresarial",
+    description="Herramienta de eliminación de barreras idiomáticas usando IA.",
+    examples=[
+        ["La inteligencia artificial transforma los negocios."],
+        ["Es necesario firmar el contrato antes del lunes."]
+    ],
+    flagging_mode="never"
+)
+
+if __name__ == "__main__":
+    ui.launch()

inference_incidencia.py

@@ -0,0 +1,94 @@
+import gradio as gr
+import requests
+import os
+from dotenv import load_dotenv
+
+# --- CONFIGURACIÓN ---
+load_dotenv()
+MI_TOKEN = os.getenv("HF_TOKEN") 
+
+MODELO = "facebook/bart-large-mnli"
+
+API_URL = f"https://router.huggingface.co/hf-inference/models/{MODELO}"
+HEADERS = {"Authorization": f"Bearer {MI_TOKEN}"}
+
+def clasificar_incidencia(mensaje):
+    if not mensaje:
+        return None
+
+    print(f"📡 Enviando incidencia: '{mensaje}'...")
+
+    # Departamentos (Etiquetas)
+    departamentos = [
+        "Soporte IT", 
+        "Mantenimiento", 
+        "Secretaría", 
+        "Seguridad", 
+        "Cafetería"
+    ]
+
+    # Configuración para clasificación
+    payload = {
+        "inputs": mensaje,
+        "parameters": {
+            "candidate_labels": departamentos,
+            "multi_label": False
+        }
+    }
+
+    try:
+        response = requests.post(API_URL, headers=HEADERS, json=payload)
+        datos = response.json()
+    
+        print(f"📦 DATOS RECIBIDOS: {datos}")
+
+        if response.status_code == 200:
+            
+            resultados_gradio = {}
+            
+            if isinstance(datos, list):
+                for item in datos:
+                    etiqueta = item.get('label')
+                    puntuacion = item.get('score')
+                    
+                    if etiqueta and puntuacion is not None:
+                        resultados_gradio[etiqueta] = puntuacion
+                
+                return resultados_gradio
+            
+            elif isinstance(datos, dict) and 'labels' in datos:
+                return {l: s for l, s in zip(datos['labels'], datos['scores'])}
+            
+            else:
+                return {"Error: Formato desconocido": 0.0}
+
+        elif response.status_code == 503:
+            return {"⏳ Cargando modelo... (Prueba en 10s)": 0.0}
+        
+        else:
+            return {f"Error {response.status_code}": 0.0}
+
+    except Exception as e:
+        return {f"Error técnico: {e}": 0.0}
+
+# Interfaz
+ui = gr.Interface(
+    fn=clasificar_incidencia,
+    inputs=gr.Textbox(
+        label="📝 Incidencia", 
+        placeholder="Ej: Se ha roto la silla del aula 4...",
+        lines=2
+    ),
+    outputs=gr.Label(num_top_classes=5, label="Clasificación IA"),
+    title="🏢 Smart Campus: Router IA",
+    description="Sistema de triaje inteligente para incidencias universitarias.",
+    examples=[
+        ["El proyector no enciende y tengo clase ahora."],
+        ["He perdido mi cartera en el pasillo."],
+        ["Necesito un certificado de notas para la beca."]
+    ],
+    flagging_mode="never"
+)
+
+if __name__ == "__main__":
+    ui.launch()

requirements.txt

@@ -0,0 +1,10 @@
+
+gradio
+requests
+pillow
+python-dotenv
+huggingface_hub
+transformers
+torch
+torchaudio
+numpy

tran_visual.py

@@ -0,0 +1,44 @@
+import gradio as gr
+from transformers import pipeline
+# --- CARGA DE LOS MODELOS ---
+# MODELO A: (Imagen -> Texto Inglés) BLIP Genera la descripción en inglés.
+captioner = pipeline("image-to-text", model="Salesforce/blip-image-captioning-base")
+
+# MODELO B:(Texto Inglés -> Texto Español) Traductor.
+translator = pipeline("translation", model="Helsinki-NLP/opus-mt-en-es")
+
+# MODELO C: Voz (Texto Español -> Audio) Crea audio en español.
+tts = pipeline("text-to-speech", model="facebook/mms-tts-spa")
+
+# --- LÓGICA  ---
+#Retornona texto y audio en español
+def procesar_imagen(imagen):
+    if imagen is None:
+        return "No hay imagen", None
+
+
+    texto_ingles = captioner(imagen)[0]['generated_text']
+    
+    texto_espanol = translator(texto_ingles)[0]['translation_text']
+
+    salida_audio = tts(texto_espanol)
+    
+    audio_data = salida_audio['audio'][0]
+    sampling_rate = salida_audio['sampling_rate']
+    
+    return texto_espanol, (sampling_rate, audio_data)
+
+# ---INTERFAZ ---
+interfaz = gr.Interface(
+    fn=procesar_imagen,
+    inputs=gr.Image(label="Sube una imagen", type="pil"),
+    outputs=[
+        gr.Textbox(label="Descripción en Español"),
+        gr.Audio(label="Audio")
+    ],
+    title="Asistente para Invidentes (Español)",
+    description="Sube una imagen y la aplicación te dirá qué contiene.",
+)
+
+if __name__ == "__main__":
+    interfaz.launch()