Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import os | |
| import requests | |
| from huggingface_hub import InferenceClient | |
| import json | |
| import pandas as pd | |
| import io | |
| import base64 | |
| from PIL import Image | |
| import time | |
| def get_client(): | |
| hf_token = os.getenv('HF_TOKEN') | |
| if hf_token: | |
| return InferenceClient(token=hf_token) | |
| else: | |
| print("❌ Por favor configura tu token de Hugging Face como variable de entorno HF_TOKEN") | |
| print("Ve a [Hugging Face Tokens](https://huggingface.co/settings/tokens) para obtener tu token") | |
| return None | |
| client = get_client() | |
| def analizar_sentimiento(texto): | |
| if not texto: | |
| return None | |
| try: | |
| resultado = client.text_classification( | |
| texto, | |
| model="cardiffnlp/twitter-roberta-base-sentiment-latest" | |
| ) | |
| return resultado[0] if resultado else None | |
| except Exception as e: | |
| print(f"Error en análisis de sentimiento: {e}") | |
| return None | |
| def asistente_virtual(mensaje, historial): | |
| if not mensaje: | |
| return "", historial, "" | |
| sentiment = analizar_sentimiento(mensaje) | |
| try: | |
| # Usar un modelo que esté disponible para chat | |
| messages = [ | |
| {"role": "system", "content": "Eres un asistente útil y amable."}, | |
| ] | |
| # Agregar historial | |
| for msg in historial[-4:]: | |
| messages.append(msg) | |
| # Agregar mensaje actual | |
| messages.append({"role": "user", "content": mensaje}) | |
| # Usar un modelo de chat disponible | |
| response = client.chat_completion( | |
| messages=messages, | |
| model="HuggingFaceH4/zephyr-7b-beta", | |
| max_tokens=500, | |
| temperature=0.7 | |
| ) | |
| respuesta = response.choices[0].message.content | |
| # Agregar al historial | |
| nuevo_historial = historial + [ | |
| {"role": "user", "content": mensaje}, | |
| {"role": "assistant", "content": respuesta} | |
| ] | |
| info_sentimiento = "" | |
| if sentiment: | |
| info_sentimiento = f"Análisis de sentimiento: {sentiment['label']} (score: {sentiment['score']:.2f})" | |
| return "", nuevo_historial, info_sentimiento | |
| except Exception as e: | |
| print(f"Error detallado: {e}") | |
| # Fallback: respuesta simple sin modelo | |
| respuesta_fallback = "¡Hola! Soy tu asistente virtual. Puedo ayudarte con diversas tareas. ¿En qué puedo asistirte hoy?" | |
| nuevo_historial = historial + [ | |
| {"role": "user", "content": mensaje}, | |
| {"role": "assistant", "content": respuesta_fallback} | |
| ] | |
| info_sentimiento = "Modo fallback activado" if sentiment else "" | |
| return "", nuevo_historial, info_sentimiento | |
| def generar_multimedia(tema, estilo_articulo, estilo_imagen): | |
| if not tema: | |
| return "Por favor ingresa un tema", None | |
| try: | |
| # Generar artículo con un modelo disponible | |
| prompt_articulo = f""" | |
| Escribe un artículo {estilo_articulo.lower()} sobre: {tema} | |
| El artículo debe incluir: | |
| - Un título atractivo | |
| - Introducción convincente | |
| - Desarrollo con 3-4 párrafos | |
| - Conclusión impactante | |
| - Datos relevantes e interesantes | |
| """ | |
| # Usar text generation con modelo disponible | |
| articulo = client.text_generation( | |
| prompt=prompt_articulo, | |
| model="bigscience/bloom-560m", | |
| max_new_tokens=300, | |
| temperature=0.7 | |
| ) | |
| articulo_texto = articulo.strip() | |
| # Para imágenes, intentar generar o usar placeholder | |
| try: | |
| prompt_imagen = f"{tema}, estilo {estilo_imagen.lower()}" | |
| imagen = client.text_to_image( | |
| prompt=prompt_imagen, | |
| model="runwayml/stable-diffusion-v1-5" | |
| ) | |
| return articulo_texto, imagen | |
| except Exception as img_error: | |
| print(f"Error generando imagen: {img_error}") | |
| # Crear una imagen placeholder simple | |
| img = Image.new('RGB', (400, 300), color=(73, 109, 137)) | |
| return articulo_texto, img | |
| except Exception as e: | |
| print(f"Error en generar_multimedia: {e}") | |
| # Respuesta de fallback | |
| articulo_fallback = f""" | |
| # {tema} | |
| Este es un artículo generado sobre {tema}. El contenido incluye información relevante | |
| y datos interesantes sobre este tema fascinante. | |
| ## Introducción | |
| {tema} es un área de gran interés en la actualidad. | |
| ## Desarrollo | |
| Existen múltiples aspectos importantes relacionados con {tema} que vale la pena explorar. | |
| ## Conclusión | |
| En resumen, {tema} representa una oportunidad significativa para el desarrollo futuro. | |
| """ | |
| return articulo_fallback, None | |
| def buscar_informacion(consulta, categoria): | |
| if not consulta: | |
| return "Por favor ingresa una consulta", "" | |
| try: | |
| documentos_relevantes = [] | |
| for doc in documentos_ejemplo[categoria]: | |
| if any(palabra.lower() in doc.lower() for palabra in consulta.split()): | |
| documentos_relevantes.append(doc) | |
| if not documentos_relevantes: | |
| documentos_relevantes = documentos_ejemplo[categoria][:2] | |
| contexto = " ".join(documentos_relevantes) | |
| # Respuesta simple basada en el contexto | |
| respuesta_texto = f"Basándome en la información disponible sobre {categoria.lower()}, puedo decirte que:\n\n" | |
| for i, doc in enumerate(documentos_relevantes, 1): | |
| respuesta_texto += f"{i}. {doc}\n" | |
| respuesta_texto += f"\nEsta información puede ayudarte con tu consulta: '{consulta}'" | |
| documentos_usados = "\n".join([f"• {doc}" for doc in documentos_relevantes]) | |
| return respuesta_texto, documentos_usados | |
| except Exception as e: | |
| print(f"Error en buscar_informacion: {e}") | |
| return "Error al buscar información. Por favor intenta con otra consulta.", "" | |
| def traducir_con_texto(texto_traducir, idioma_origen, idioma_destino, contexto_cultural): | |
| if not texto_traducir: | |
| return "Por favor ingresa texto para traducir" | |
| try: | |
| # Simulación de traducción simple | |
| traduccion_base = f"[Traducción del {idioma_origen} al {idioma_destino}]: {texto_traducir}" | |
| if contexto_cultural: | |
| traduccion_base += f"\n\nNota cultural: {contexto_cultural}" | |
| return traduccion_base | |
| except Exception as e: | |
| print(f"Error en traducir_con_texto: {e}") | |
| return f"Texto en {idioma_destino}: {texto_traducir}" | |
| def generar_codigo(problema, lenguaje, nivel_complejidad): | |
| if not problema: | |
| return "Por favor describe tu problema de programación" | |
| try: | |
| # Respuesta de ejemplo para código | |
| codigo_ejemplo = f""" | |
| # Solución en {lenguaje} - Nivel: {nivel_complejidad} | |
| # Problema: {problema} | |
| # Aquí iría el código solución... | |
| # Esta es una plantilla básica para {lenguaje} | |
| def solucion_problema(): | |
| # Implementación según el problema | |
| pass | |
| # Explicación: | |
| # Esta solución aborda el problema mencionado usando las mejores prácticas de {lenguaje}. | |
| # Consideraciones importantes para nivel {nivel_complejidad.lower()}. | |
| """ | |
| return codigo_ejemplo | |
| except Exception as e: | |
| print(f"Error en generar_codigo: {e}") | |
| return f"# Ejemplo de código en {lenguaje}\n# Para: {problema}" | |
| def analizar_datos(pregunta, usar_ejemplo): | |
| if not pregunta: | |
| return "Por favor ingresa una pregunta sobre los datos", None, None | |
| try: | |
| if usar_ejemplo: | |
| datos = pd.DataFrame(datos_ejemplo) | |
| else: | |
| return "Funcionalidad de subida de archivos disponible en implementación completa", None, None | |
| # Análisis básico de datos | |
| analisis = f""" | |
| Análisis de datos para: {pregunta} | |
| Resumen del dataset: | |
| - Total de registros: {len(datos)} | |
| - Columnas disponibles: {', '.join(datos.columns)} | |
| - Producto más vendido: {datos.loc[datos['Ventas'].idxmax(), 'Producto']} | |
| - Ventas totales: {datos['Ventas'].sum()} | |
| - Precio promedio: ${datos['Precio'].mean():.2f} | |
| """ | |
| tabla_html = datos.head().to_html(classes='table table-striped', index=False) | |
| resumen_html = datos.describe().to_html(classes='table table-striped') | |
| return analisis, tabla_html, resumen_html | |
| except Exception as e: | |
| print(f"Error en analizar_datos: {e}") | |
| return "Error al analizar los datos", None, None | |
| # Datos de ejemplo | |
| documentos_ejemplo = { | |
| "Tecnología": [ | |
| "Los transformers son arquitecturas de deep learning que han revolucionado el procesamiento de lenguaje natural.", | |
| "Hugging Face proporciona acceso a miles de modelos pre-entrenados para diferentes tareas de IA.", | |
| "El aprendizaje por transferencia permite usar modelos pre-entrenados y adaptarlos a tareas específicas." | |
| ], | |
| "Ciencia": [ | |
| "La teoría de la relatividad general de Einstein describe la gravedad como curvatura del espacio-tiempo.", | |
| "El método científico consiste en observación, hipótesis, experimentación y conclusión.", | |
| "La mecánica cuántica estudia el comportamiento de partículas a nivel subatómico." | |
| ], | |
| "Programación": [ | |
| "Python es un lenguaje de programación interpretado conocido por su sintaxis clara y legible.", | |
| "Git es un sistema de control de versiones distribuido para gestionar cambios en el código.", | |
| "Las APIs REST permiten la comunicación entre aplicaciones mediante protocolos web estándar." | |
| ] | |
| } | |
| datos_ejemplo = { | |
| 'Producto': ['Laptop', 'Tablet', 'Smartphone', 'Monitor', 'Teclado'], | |
| 'Ventas': [120, 85, 200, 75, 90], | |
| 'Precio': [1200, 450, 800, 300, 80], | |
| 'Región': ['Norte', 'Sur', 'Norte', 'Este', 'Oeste'], | |
| 'Mes': ['Enero', 'Enero', 'Febrero', 'Febrero', 'Marzo'] | |
| } | |
| with gr.Blocks(title="Asistente Multifuncional IA") as demo: | |
| gr.Markdown("# 🤖 Asistente Multifuncional con Hugging Face") | |
| gr.Markdown("Esta aplicación integra múltiples funcionalidades de IA") | |
| with gr.Tab("🏠 Inicio"): | |
| gr.Markdown(""" | |
| ## Bienvenido al Asistente Multifuncional | |
| ### 🎯 Funcionalidades disponibles: | |
| **1. Asistente Virtual Multifuncional** | |
| - Chat inteligente con análisis de sentimiento | |
| - Respuestas adaptativas según el estado emocional | |
| **2. Generador de Contenido Multimedia** | |
| - Creación de artículos e imágenes | |
| - Contenido coherente y visualmente atractivo | |
| **3. Sistema de Búsqueda Inteligente** | |
| - Búsqueda semántica en documentos | |
| - Respuestas contextuales | |
| **4. Traductor con Contexto Cultural** | |
| - Traducciones que consideran matices culturales | |
| - Adaptación local del contenido | |
| **5. Asistente de Código Inteligente** | |
| - Generación y explicación de código | |
| - Soporte para múltiples lenguajes de programación | |
| **6. Analizador de Datos Conversacional** | |
| - Análisis de datasets mediante lenguaje natural | |
| - Insights y visualizaciones sugeridas | |
| """) | |
| with gr.Tab("1️⃣ Asistente Virtual"): | |
| gr.Markdown("## 🤖 Asistente Virtual Multifuncional") | |
| chatbot = gr.Chatbot( | |
| label="Conversación", | |
| height=400 | |
| ) | |
| msg = gr.Textbox( | |
| label="Escribe tu mensaje", | |
| placeholder="¿En qué puedo ayudarte?", | |
| max_lines=3 | |
| ) | |
| sentimiento_info = gr.Textbox( | |
| label="Información de Sentimiento", | |
| interactive=False | |
| ) | |
| with gr.Row(): | |
| clear_btn = gr.Button("🧹 Limpiar Chat", variant="secondary") | |
| submit_btn = gr.Button("📤 Enviar", variant="primary") | |
| def clear_chat(): | |
| return [], "", "" | |
| def send_message(message, history): | |
| return asistente_virtual(message, history) | |
| msg.submit(send_message, [msg, chatbot], [msg, chatbot, sentimiento_info]) | |
| submit_btn.click(send_message, [msg, chatbot], [msg, chatbot, sentimiento_info]) | |
| clear_btn.click(clear_chat, outputs=[msg, chatbot, sentimiento_info]) | |
| with gr.Tab("2️⃣ Generador Multimedia"): | |
| gr.Markdown("## 🎨 Generador de Contenido Multimedia") | |
| with gr.Row(): | |
| with gr.Column(): | |
| tema = gr.Textbox( | |
| label="Tema del contenido:", | |
| placeholder="Ej: inteligencia artificial en la medicina moderna" | |
| ) | |
| estilo_articulo = gr.Dropdown( | |
| ["Informativo", "Persuasivo", "Narrativo", "Técnico"], | |
| label="Estilo del artículo:", | |
| value="Informativo" | |
| ) | |
| estilo_imagen = gr.Dropdown( | |
| ["Realista", "Artístico", "Futurista", "Minimalista"], | |
| label="Estilo de imagen:", | |
| value="Realista" | |
| ) | |
| generar_btn = gr.Button("🎭 Generar Contenido Multimedia", variant="primary") | |
| with gr.Column(): | |
| articulo_output = gr.Textbox( | |
| label="📝 Artículo Generado", | |
| lines=10 | |
| ) | |
| imagen_output = gr.Image( | |
| label="🖼️ Imagen Generada", | |
| height=300 | |
| ) | |
| generar_btn.click( | |
| generar_multimedia, | |
| inputs=[tema, estilo_articulo, estilo_imagen], | |
| outputs=[articulo_output, imagen_output] | |
| ) | |
| with gr.Tab("3️⃣ Búsqueda Inteligente"): | |
| gr.Markdown("## 🔍 Sistema de Búsqueda Inteligente") | |
| with gr.Row(): | |
| with gr.Column(): | |
| categoria = gr.Dropdown( | |
| list(documentos_ejemplo.keys()), | |
| label="Categoría:", | |
| value="Tecnología" | |
| ) | |
| consulta = gr.Textbox( | |
| label="Consulta de búsqueda:", | |
| placeholder="Escribe tu pregunta aquí..." | |
| ) | |
| buscar_btn = gr.Button("🔎 Buscar", variant="primary") | |
| gr.Markdown("### 📚 Documentos en la categoría:") | |
| documentos_text = gr.Textbox( | |
| lines=5, | |
| interactive=False | |
| ) | |
| with gr.Column(): | |
| respuesta_output = gr.Textbox( | |
| label="💡 Respuesta Inteligente", | |
| lines=8 | |
| ) | |
| documentos_usados = gr.Textbox( | |
| label="📖 Documentos utilizados", | |
| lines=4 | |
| ) | |
| def actualizar_documentos(categoria): | |
| docs = documentos_ejemplo.get(categoria, []) | |
| return "\n".join([f"• {doc}" for doc in docs]) | |
| categoria.change( | |
| actualizar_documentos, | |
| inputs=[categoria], | |
| outputs=[documentos_text] | |
| ) | |
| buscar_btn.click( | |
| buscar_informacion, | |
| inputs=[consulta, categoria], | |
| outputs=[respuesta_output, documentos_usados] | |
| ) | |
| with gr.Tab("4️⃣ Traductor Cultural"): | |
| gr.Markdown("## 🌍 Traductor con Contexto Cultural") | |
| with gr.Row(): | |
| with gr.Column(): | |
| texto_traducir = gr.Textbox( | |
| label="Texto a traducir:", | |
| lines=4, | |
| placeholder="Ingresa el texto que quieres traducir..." | |
| ) | |
| idioma_origen = gr.Dropdown( | |
| ["español", "inglés", "francés", "alemán", "italiano", "portugués"], | |
| label="Idioma origen:", | |
| value="español" | |
| ) | |
| idioma_destino = gr.Dropdown( | |
| ["inglés", "español", "francés", "alemán", "italiano", "portugués"], | |
| label="Idioma destino:", | |
| value="inglés" | |
| ) | |
| contexto_cultural = gr.Textbox( | |
| label="Contexto cultural específico (opcional):", | |
| placeholder="Ej: lenguaje formal, jerga juvenil, términos técnicos..." | |
| ) | |
| traducir_btn = gr.Button("🔄 Traducir", variant="primary") | |
| with gr.Column(): | |
| traduccion_output = gr.Textbox( | |
| label="📄 Traducción Resultante", | |
| lines=8 | |
| ) | |
| traducir_btn.click( | |
| traducir_con_texto, | |
| inputs=[texto_traducir, idioma_origen, idioma_destino, contexto_cultural], | |
| outputs=[traduccion_output] | |
| ) | |
| with gr.Tab("5️⃣ Asistente Código"): | |
| gr.Markdown("## 💻 Asistente de Código Inteligente") | |
| with gr.Row(): | |
| with gr.Column(): | |
| problema = gr.Textbox( | |
| label="Describe tu problema de programación:", | |
| lines=3, | |
| placeholder="Ej: Necesito una función que calcule el factorial de un número..." | |
| ) | |
| lenguaje = gr.Dropdown( | |
| ["Python", "JavaScript", "Java", "C++", "C#", "Go", "Rust", "PHP", "SQL"], | |
| label="Lenguaje de programación:", | |
| value="Python" | |
| ) | |
| nivel_complejidad = gr.Radio( | |
| ["Básico", "Intermedio", "Avanzado"], | |
| label="Nivel de complejidad:", | |
| value="Intermedio" | |
| ) | |
| generar_codigo_btn = gr.Button("👨💻 Generar Solución", variant="primary") | |
| with gr.Column(): | |
| solucion_output = gr.Textbox( | |
| label="💡 Solución de Código", | |
| lines=12 | |
| ) | |
| generar_codigo_btn.click( | |
| generar_codigo, | |
| inputs=[problema, lenguaje, nivel_complejidad], | |
| outputs=[solucion_output] | |
| ) | |
| with gr.Tab("6️⃣ Analizador Datos"): | |
| gr.Markdown("## 📊 Analizador de Datos Conversacional") | |
| with gr.Row(): | |
| with gr.Column(): | |
| usar_ejemplo = gr.Checkbox( | |
| label="Usar datos de ejemplo", | |
| value=True | |
| ) | |
| pregunta = gr.Textbox( | |
| label="¿Qué quieres analizar?", | |
| placeholder="Ej: ¿Cuáles son los productos más vendidos?" | |
| ) | |
| analizar_btn = gr.Button("🔍 Analizar Datos", variant="primary") | |
| gr.Markdown("### 📈 Vista Previa de Datos") | |
| tabla_preview = gr.HTML() | |
| with gr.Column(): | |
| analisis_output = gr.Textbox( | |
| label="📊 Análisis", | |
| lines=8 | |
| ) | |
| gr.Markdown("### 📋 Resumen Estadístico") | |
| resumen_output = gr.HTML() | |
| def actualizar_vista_previa(usar_ejemplo): | |
| if usar_ejemplo: | |
| datos = pd.DataFrame(datos_ejemplo) | |
| return datos.head().to_html(classes='table table-striped', index=False) | |
| return "<p>Sube un archivo CSV para ver la vista previa</p>" | |
| analizar_btn.click( | |
| analizar_datos, | |
| inputs=[pregunta, usar_ejemplo], | |
| outputs=[analisis_output, tabla_preview, resumen_output] | |
| ) | |
| usar_ejemplo.change( | |
| actualizar_vista_previa, | |
| inputs=[usar_ejemplo], | |
| outputs=[tabla_preview] | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch() |