app.py

import gradio as gr
import numpy as np
from bark import SAMPLE_RATE, generate_audio
from transformers import pipeline
from diffusers import DiffusionPipeline
import time
import torch
import random

device = "cuda" if torch.cuda.is_available() else "cpu"

generate_story_pipe = pipeline("text-generation", model="openai-community/gpt2")
image_pipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl-turbo", torch_dtype= torch.float16 if torch.cuda.is_available() else torch.float32)
image_pipe = image_pipe.to(device)

# Para medir el rendimiento de los métodos, voy a crear este decorador, que simplemente imprime en nuestra terminal el tiempo de ejecucion de los metodos que tengan los modelos y los usen, de esta manera podremos estudiar el tiempo que este cada modelo activo
def measure_performance(func):
    def wrapper(*args, **kwargs):
        print(f"Starting execution of '{func.__name__}' with 'args={args}, kwargs={kwargs}'")
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        duration = end - start
        print(f"Execution time of '{func.__name__}' with 'args={args}, kwargs={kwargs}': {duration:.4f} seconds")
        return result
    return wrapper

@measure_performance
def generate_story_text(theme):
    if generate_story_pipe.tokenizer.pad_token is None:
        generate_story_pipe.tokenizer.pad_token = generate_story_pipe.tokenizer.eos_token

    prompt = f"Tell me a storie about {theme}"
    story = generate_story_pipe(prompt, max_length=400, num_return_sequences=1, temperature=0.7, do_sample=True, repetition_penalty=3.0, eos_token_id=generate_story_pipe.model.config.eos_token_id, pad_token_id=generate_story_pipe.model.config.pad_token_id, truncation=True, padding=True)
    generated_story = story[0]["generated_text"]
    return generated_story

@measure_performance
def generate_tts(text):
    audio_arr = generate_audio(text, history_prompt="es_speaker_0")
    audio_arr = (audio_arr * 32767).astype(np.int16)
    return (SAMPLE_RATE, audio_arr)

@measure_performance
def generate_image(prompt):
    seed = random.randint(0, 1000)
    generator = torch.Generator().manual_seed(seed)

    image = image_pipe(
        prompt=prompt,
        num_inference_steps=2,
        width=256,
        height=256,
        generator=generator,
    ).images[0]

    return image

def generate_story(theme):
    story_text = generate_story_text(theme)
    return (generate_tts(story_text), generate_image(story_text))

def subtitle():
    gr.Markdown("""

                <a style="display:inline-block; margin-left: 1em" href="https://huggingface.co/spaces/RafaelJaime/SherezIAde"><img src="https://img.shields.io/badge/-Duplicate%20Space%20to%20skip%20the%20queue-blue?labelColor=white&style=flat&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAP5JREFUOE+lk7FqAkEURY+ltunEgFXS2sZGIbXfEPdLlnxJyDdYB62sbbUKpLbVNhyYFzbrrA74YJlh9r079973psed0cvUD4A+4HoCjsA85X0Dfn/RBLBgBDxnQPfAEJgBY+A9gALA4tcbamSzS4xq4FOQAJgCDwV2CPKV8tZAJcAjMMkUe1vX+U+SMhfAJEHasQIWmXNN3abzDwHUrgcRGmYcgKe0bxrblHEB4E/pndMazNpSZGcsZdBlYJcEL9Afo75molJyM2FxmPgmgPqlWNLGfwZGG6UiyEvLzHYDmoPkDDiNm9JR9uboiONcBXrpY1qmgs21x1QwyZcpvxt9NS09PlsPAAAAAElFTkSuQmCC&logoWidth=14" alt="Duplicate Space"></a>

                <p>Cuando se necesite dormir a los mas pequeños de la casa, podrá usar este espacio, en el cual se integrarán varias inteligencias artificiales diseñadas para contar historias de todo tipo, al estilo del libro Las mil y una noches.</p>

    """)

# Ejemplos que pondre debajo de la ventana
examples = [
    ["A love story"],
    ["An humor story"],
    ["A history about a vampire who dance Reggaeton"],
]

# Documentacion
def end_text():
    gr.Markdown("<h2>Documentación</h2>")
    gr.Markdown("""El problema que se busca solucionar es la dificultad que algunos padres enfrentan para contar historias a sus hijos a la hora de dormir, ya sea por falta de tiempo, cansancio o falta de inspiración. Este proyecto propone una solución que facilite este momento y lo haga más cómodo, ofreciendo una herramienta que narre historias personalizadas, permitiendo que los padres y sus hijos disfruten juntos de esta experiencia de una manera práctica y accesible.Este problema es muy flexible para este trabajo puesto que hay multitud de tipos de modelos que pueden añadirse, sin pensar mucho pues añadir generador de texto como base de todo a partir de un texto que ponga el usuario y de ahí partir a text-speech, image generator del texto generado, video generator, resúmenes de la historia, chat sobre la historia... Un monton de distintos tipos de modelos que se pueden añadir con el simple input de una cadena de texto que describa una historia""")
    gr.Markdown("""<h3>Input y Output</h3>

    <p><strong>Input:</strong> El programa espera un texto que describa la historia que quiere ser contada.</p>

    <p><strong>Output:</strong> Será un audio que cuente la historia relacionada con el input.</p>

    """)
    gr.Markdown("""<h3>Descripción del Modelo</h3>""")
    with gr.Row():
        with gr.Column():
            gr.Markdown("""<h4>Gpt2</h4>

            """)
            gr.Markdown("""

            Desarrollado por OpenAI, el modelo GPT-2 es una red neuronal de generación de texto que utiliza una arquitectura de transformador para producir texto coherente y continuo en función de un texto de entrada o "prompt". 

            Con una gran cantidad de parámetros, GPT-2 puede completar frases, responder preguntas, o incluso generar historias creativas a partir de una breve descripción inicial, proporcionando un flujo de texto que se asemeja al lenguaje humano.

            De todos los modelos text2text que he probado y compilado en mi maquina, hasta los mas grandes de 20 o 30 gb de tamaño, este era el que mejor ha funcionado de todos sin ninguna duda, habia buscado hasta uno especifico para [contar historias](https://huggingface.co/mooncakex/t5-story-generation) pero ninguno como este.



            **Componentes principales del modelo:**

            - Transformador: GPT-2 emplea una arquitectura de transformador que permite capturar dependencias a largo plazo en el texto, manteniendo coherencia en oraciones largas y proporcionando contexto a la narrativa.

            - Generación de texto fluida: Capacidad de generar párrafos completos con fluidez, manteniendo un tono y estilo consistentes según el prompt inicial.

            - Adaptabilidad temática: Ajuste a múltiples temas y estilos de escritura, lo que lo hace útil para aplicaciones de escritura creativa, generación de artículos, respuestas a preguntas, y más.



            **Limitaciones del modelo**:

            - Repetición y coherencia: En algunas situaciones, puede tender a repetir frases o perder coherencia en textos extensos.

            - Contenido de entrenamiento: Como está basado en datos previos a 2020, no tiene conocimientos sobre eventos recientes. Aunque en nuestro caso, no se haga una limitacion.

            - Sesgos en los datos: Dado que se entrenó en un amplio corpus de internet, puede presentar sesgos reflejados en esos datos, lo que debe ser considerado en aplicaciones que lo utilicen para generar texto. De nuevo, para contar cuentos, no importa que los datos sean fantasiosos, aunque puede llevar a historias sin logica.

            **Tiempo promedio**

            Bastante rapido, normalmente menos de 40 segudos, puedes revisar esto en el [example log](https://huggingface.co/spaces/RafaelJaime/SherezIAde/blob/main/logs/log1.txt).

            """)
        with gr.Column():
            gr.Markdown("""<h4>Bark</h4>

            """)
            gr.Markdown("""

            Desarrollado por **[Suno](https://huggingface.co/suno)**, es un modelo de texto a audio que permite generar voz humana realista en varios idiomas. 

            Además de la síntesis de voz, el modelo es capaz de generar otros tipos de audio, como música, sonidos ambientales y efectos sonoros simples.

            Este sistema crear audios de alta calidad a partir de texto, puedes hacerlo añadiendo tus propios audios para que el sistema lo replique o con los que ya tenga entrenado el propio modelo.

            He probado varios modelos de text to speech pero me parecía muy interesante esta manera que he tenido de implementarlo (como una librería normal de python) y me hace gracia el nombre. Otro ejemplo usando esta misma forma de implementación es [CoquiTTS](https://github.com/coqui-ai/TTS) que tiene hasta una clase con la que manejas todo como en este [ejemplo](https://huggingface.co/spaces/SoulAbi/text-to-voice).



            **Componentes principales del modelo:**

            - **Síntesis de voz multilingüe**: Generación de voces en varios idiomas, con capacidad para ajustar la entonación y ritmo.

            - **Generación de música y efectos sonoros**: Capacidad para crear composiciones musicales sencillas y sonidos de fondo.

            - **Enfoque multimodal**: Integración de diversos tipos de audio (voz, música, sonidos) en una salida coherente.



            **Limitaciones del modelo**:

            - Aunque es altamente preciso, puede generar una voz algo robótica en algunos contextos.

            - El uso comercial está restringido, y el contenido generado no está censurado.

            - No tiene todos los idiomas, debido a que requiere grandes volúmenes de datos de entrenamiento y puede tener dificultades con dialectos menos comunes o con datos limitados.

            - Genera audios cortos. No genera mas de 14 segundos, en hugging face al menos.

            **Tiempo promedio**

            Bastante mas lento que el otro, puede llegar a mas o menos 60 segundos cada segundo de audio, puedes revisar esto en el [example log](https://huggingface.co/spaces/RafaelJaime/SherezIAde/blob/main/logs/log1.txt) donde se estarán generando audios de 14 segundos, por lo que tendrá más o menos unos 800 segundos.

            """)
    with gr.Row():
        with gr.Column():
            gr.Markdown("""<h4>sdxl-turbo</h4>

            """)
            gr.Markdown("""

            Desarrollado por [Stability AI](https://huggingface.co/stabilityai), el modelo SDXL-Turbo es una versión avanzada y optimizada de la arquitectura de generadores de imágenes y texto que utiliza transformadores y redes neuronales profundas para generar contenido visual y textual con alta calidad. Es una herramienta de última generación diseñada para proporcionar respuestas rápidas, coherentes y visualmente atractivas, especialmente útil en aplicaciones que requieren generación de imágenes de alta resolución, adaptabilidad temática, y generación de textos creativos o técnicos.



            **Componentes principales del modelo:**

            - **Arquitectura de transformador avanzada**: SDXL-Turbo emplea una arquitectura de transformador especialmente afinada para generar imágenes y textos con un alto nivel de detalle y coherencia, capturando las relaciones espaciales y semánticas a través de modelos multimodales. Esto permite una integración fluida entre las tareas de texto e imagen.

            - **Generación de imágenes de alta resolución**: Capaz de producir imágenes de alta calidad a partir de descripciones textuales detalladas, el modelo ofrece resultados visuales sorprendentes, lo que lo hace ideal para proyectos creativos, diseño gráfico y generación de contenido visual para medios interactivos.

            - **Optimización de rendimiento**: La versión Turbo de SDXL está diseñada para ser más eficiente en términos de velocidad de generación, sin comprometer la calidad de los resultados. Esto lo hace adecuado para aplicaciones que requieren tiempos de respuesta rápidos, como la generación en tiempo real de contenido visual y textual para juegos, aplicaciones de diseño o chatbots.

            - **Generación de texto creativo y técnico**: Al igual que GPT-2, el modelo tiene la capacidad de generar texto fluido, ya sea para narrativas complejas, artículos, respuestas a preguntas o incluso guiones. Sin embargo, se distingue por su capacidad para adaptarse también a contenidos de alta complejidad técnica, lo que lo hace útil en aplicaciones que requieran un entendimiento preciso de terminología especializada.



            **Limitaciones del modelo**:

            - Dependencia de datos visuales y textuales: Aunque el modelo ha sido entrenado en un amplio corpus de datos, algunos resultados pueden reflejar los sesgos presentes en las imágenes o textos utilizados para su entrenamiento, lo que puede influir en la calidad o en la diversidad de los contenidos generados.

            - Generación inconsistente en escenas complejas: Aunque el modelo es altamente efectivo, puede encontrar dificultades al generar imágenes extremadamente complejas que requieren detalles muy finos o al mantener la coherencia entre una narrativa escrita y una imagen generada de manera simultánea.

            - Sensibilidad a prompts ambiguos: Al igual que otros modelos de IA, la claridad y precisión del prompt son clave. Instrucciones vagas o ambiguas pueden resultar en contenido menos relevante o difícil de interpretar, tanto en el aspecto visual como textual.



            **Tiempo promedio**

            Bastante rapido, normalmente algo más de 70 segundos, puedes revisar esto en el [example log](https://huggingface.co/spaces/RafaelJaime/SherezIAde/blob/main/logs/log1.txt).

            """)
    gr.Markdown("""<h3>Links consultados</h3>""")
    gr.Markdown("[Git, bark](https://github.com/suno-ai/bark/)")
    gr.Markdown("[huggingface, bark space](https://huggingface.co/spaces/suno/bark/)")
    gr.Markdown("[thepythoncode, transformers text generation guide](https://thepythoncode.com/article/text-generation-with-transformers-in-python)")
    gr.Markdown("[sdxl-turbo](https://huggingface.co/stabilityai/sdxl-turbo)")

css = """

h1 { text-align: center; font-family: Arial, sans-serif;}

.gradio-container {font-family: Arial, sans-serif; padding: 20px;}

textarea, input {width: 100%; padding: 10px; margin: 10px 0;}

"""

with gr.Blocks(css=css) as block:
    gr.Markdown("<h1>SherezIAde</h1>")
    subtitle()

    # input and outputs
    with gr.Row():
        with gr.Column():
            story_theme = gr.Textbox(label="Escribe de que quieres que vaya la historai", placeholder="Introduce la descripción de la historia aquí...")
        with gr.Column():
            audio_out = gr.Audio(label="Generated Audio", type="numpy", elem_id="audio_out")
            image_out = gr.Image(label="Generated image", show_label=False)
    run_button = gr.Button("Cuéntame la historia")
    run_button.click(fn=lambda: gr.update(visible=False), inputs=None, outputs=None, queue=False).then(
        fn=generate_story, inputs=[story_theme], outputs=[audio_out, image_out], queue=True).then(
        fn=lambda: gr.update(visible=True), inputs=None, outputs=None, queue=False)


    gr.Examples(examples=examples, fn=generate_story, inputs=[story_theme],
                outputs=[audio_out, image_out], cache_examples=True)
    end_text()

block.queue()
block.launch()