Kokoro-82M es un nuevo modelo de texto a voz que permite fácilmente y con pocos recursos convertir de texto a voz en varios idiomas:

🇪🇸 ‘e’ => Spanish es
🇫🇷 ‘f’ => French fr-fr
🇮🇳 ‘h’ => Hindi hi
🇮🇹 ‘i’ => Italian it
🇧🇷 ‘p’ => Brazilian Portuguese pt-br
🇺🇸 ‘a’ => American English
🇬🇧 ‘b’ => British English
🇯🇵 ‘j’ => Japanese
🇨🇳 ‘z’ => Mandarin Chinese

Entre ellos el español, lo cual no es tan habitual como cabria esperarse por su número de hablantes.

Su uso es realmente sencill, para instalarlo basta con seguir los siguientes pasos.

Lo primero es instalar kokoro y soundfile:

pip install  kokoro soundfile

También necesitaremos instalar espeak-ng, la forma de instarlo variará según el sistema operativo que tengamos:

• Para Windows podemos descargar la última versión aquí
• Para Linux eligen según tu distribución:

sudo apt-get install espeak-ng

sudo yum install espeak-ng

sudo pacman -S espeak-ng

Ahora nos queda escribir un poco de código en Python

from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='es') # lang_code del idioma

text = 'Hola, bienvenidos a construyendo a Chispas.'

# Voces:
# ef_dora Femenino
# em_alex Masculino
# em_santa Masculino
generator = pipeline(
    text, voice='em_santa', # cambia la voz aqui
    speed=1, split_pattern=r'\n+'
)

for i, (gs, ps, audio) in enumerate(generator):
    print(i)    # indice
    print(gs) # grafemas (texto)
    print(ps) # fonemas    
    sf.write(f'{i}.wav', audio, 24000)

También permite generar el audio desde los fonemas:

from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='es') # lang_code del idioma

phonemes = "ˈola, bjˌembenˈiðos a kˌonstɾujjˈɛndo a ʧˈispas."

# Voces:
# ef_dora Femenino
# em_alex Masculino
# em_santa Masculino
generator = pipeline.generate_from_tokens(
    tokens=phonemes,
    voice="ef_dora",
    speed=1.0
)

for i, (gs, ps, audio) in enumerate(generator):
    print(i)    # indice
    print(gs) # grafemas (texto)
    print(ps) # fonemas    
    sf.write(f'{i}.wav', audio, 24000)

¿Cómo es posible que un modelo tan pequeño funcione relativamente bien? Puedes verlo en el siguiente vídeo.

Realmente no tenemos existe una definición formal de que es la AGI así que no tenemos un objetivo claro para llegar a ella. La forma en que actualmente tratamos de aproximarnos a ella es a través de los benchmarks (que como ya vimos que tiene sus propios problemas). Cada vez que se supera un benchmark aparece otro que sube el listón.

De hecho ya han sido varias las pruebas superadas que se suponía nos llevaban a la AGI:

• Ganar al ajedrez
• Ganar al go
• Superar el test de Turing
• Demostraciones matemáticas
• …

Y aquí seguimos sin nada que podamos considerar AGI.

Principalmente hay tres caminos que se mezclan:

• Agentes: combinar varios modelos de lenguajes expertos en diferentes tareas.
• LLM + entrenamiento: entrenar a un modelo de lenguaje para mejorar sus capacidades de razonamiento.
• LLM + algoritmos clásicos: el modelo de lenguaje genera múltiples caminos de razonamiento y se usan algoritmos clásicos para elegir cual se desarrolla.

No son tres caminos independientes si no que se pueden combinar para mejorar el sistema.

Además estos modelos pueden usar las siguientes

• Ingeniería de prompts.
• RAG
• Uso de herramientas (function calling)
• Generación y ejecución de código

No basta con conseguir la AGI, no todo es inteligencia:

• Comprensibles. No basta con que la respuesta sea correcta, tiene que estar claramente explicada para que sea comprensible. Por como funcionan los modelos de lenguaje esta explicación debe de producirse durante la generación de la respuesta. No puede producirse a posteriori. Ahora mismo lo que hay es un galimatías caótico. (un ejemplo clásico es ¿Cuál es el secreto de la vida el universo y todo lo demás?)
• Confiables. Tenemos que poder confiar en la respuesta de estos modelos, ahora mismo las alucinaciones hacen que no podamos confiar en ellos plenamente. Está relacionado con el punto anterior ya que si podemos comprender el “porqué” de la respuesta podemos aprender a detectar las respuestas erróneas.
• Razonamiento general: Es capaz de enfrentar problemas de todo tipo y crear estrategias para resolverlos. Un ser humano inteligente no es aquel que sabe la solución a un problema, es el que puede usar sus recursos para hallarla o aproximarse.
• Coste asumible: Estos modelos tienen que funcionar en una escala realista. Se estima que a O3 superar el test ARC-AGI le costó más de un millón de dólares. Por mucho menos puedes contratar a un grupo de expertos humanos. La necesidad de potencia de cálculo, recursos como la RAM y tiempo puede disparar el precio de estos modelos.

Agentes:

Como ingeniero es mi solución favorita.

En lugar de un único modelo usa varios modelos diferentes colaborando en un flujo de trabajo para hallar la solución. Esto permite modelos más pequeños especializados en ciertas tareas.

Pueden lanzarse varios flujos de trabajo en paralelo afrontando el problema desde distintos puntos de vista.

Ventajas:

• Modelos especializados y más pequeños
• Modelos más fáciles de entrenar
• Es fácil integrar diversas fuentes de datos y herramientas
• Es más entendible.
• Muy flexible.
• No es necesario entrenar todas sus partes solo la que necesites mejorar.
• Es fácil incluir “humanos” en el proceso

Problemas:

• Un fallo en un agente puede propagarse a los demás.
• Puedes usar agentes que verifican las respuestas. ¿Pero quién verifica al verificador?
• Comunicar a los agentes entre si. Usar lenguaje natural puede no ser la mejor opción.
• Requiere mucho trabajo y tiempo ir creando los diversos flujos de trabajo

LLM + entrenamiento:

Como fan de la ciencia ficción es mi solución favorita. Es la que más se aproxima a la idea que tenemos de IA inteligente.

Un modelo único capaz de generar respuestas inteligentes.

Ventajas:

• La idea es simple

Problemas:

• Requiere grandes modelos difíciles y caros de entrenar
• Grandes cantidades de datos de calidad. Es difícil encontrar buenos ejemplos de razonamiento.
• Ahora mismo su “razonamiento” no es muy entendible. A veces incluso llega a la respuesta correcta y la ignora.
• Caros de usar

Ejemplos:

O1, O3, DeepSeek V3, QwQ 32B

LLM + algoritmos clásicos:

Como desarrollador de software es mi solución favorita. Combina el razonamiento de los modelos de lenguaje con pasos intermedios que ayudan a guiar este razonamiento hacia las mejores ideas.

Ventajas:

• Se puede aplicar a modelos de lenguaje no entrenados para razonar.
• Reduce los costes de razonamiento

Problemas:

• ¿Cómo saber lo buena qué es una idea?. Generalmente se usan LLM entrenados para ello, pero no son buenos cuantificando las ideas.

Ejemplos:

Marco-O1

Problemas del transformer:

Los actuales LLM usan diferentes modificaciones de un transformer, una arquitectura de red neuronal que pese a sus buenos resultados impone serias limitaciones.

Para nuestro caso nos afectan principalmente dos:

• El contexto tiene un tamaño limitado. Pasado de cierto punto el modelo “pierde el hilo” del texto que está generando. Lo cual limita el tamaño del “razonamiento” que puede generar.
• El modelo de lenguaje no predice una palabra, predice una distribución de probabilidad de que cada una de las palabras (realmente, tokens) que conoce sea el siguiente. Pero de ese resultado elegimos solo una y esa información se pierde. Por lo que el modelo de lenguaje pierde toda la información entre cada palabra.

Últimamente se ha puesto de moda un nuevo paradigma de modelo de lenguaje. Aquellos entrenados para razonar.

Básicamente son modelos que se plantean la resolución de un problema paso a paso. Y luego recorren esos pasos aprovechando que los LLM son recursivos.

Derpthougt 8B funciona así, eso no es una novedad. El cambio viene en la idea de como plantea el razonamiento. Lo hace de forma estructurada usando JSON. Eso nos permite manipular su razonamiento fácilmente, interfiriendo en sus «pensamientos».

A diferencia de lo habitual en los LLM. Para funcionar necesita como mínimo dos llamadas al modelo.

Vamos a empezar a ver cómo funciona. Un aviso importante, el modelo es muy estricto con los prompts. Hay que respetarlos lo más estrictamente posible.

Para la prueba vamos a usar llamacpp con la versión cuantizada Q8.

./llama-server -m ./deepthought-8b-llama-v0.01-alpha-Q8_0.gguf

El prompt inicial es el siguiente:

<|im_start|>system
You are a superintelligent AI system, capable of comprehensive reasoning. When provided with <reasoning>, you must provide your logical reasoning chain to solve the user query. Be verbose with your outputs.<|im_end|>
<|im_start|>user
{{User Query}}<|im_end|>
<|im_start|>reasoning
<reasoning>
[
  {
    "step": 1,

Podéis ver qué se usa el truco de comenzar la respuesta del modelo de lenguaje para obligar al modelo de lenguaje a seguirla.

En este primer paso genera el razonamiento, siguiendo cada paso la siguiente estructura JSON:

  {
    "step": 1,
    "type": "problem_understanding",
    "thought": "I need to count the number of times the letter 'r' appears.
  }

Una vez tenemos el razonamiento en formato JSON lo volvemos a pasar con este prompt.

<|im_start|>reasoning
<reasoning>
{{Steps JSON}}
</reasoning>|im_end|>
<|im_start|>assistant

Y obtenemos la respuesta.

Veamos un ejemplo con la tipica pregunta de cuantas letras «r» tiene «Straberrry» (tiene una R de más a proposito)

El primer prompt

<|im_start|>system
You are a superintelligent AI system, capable of comprehensive reasoning. When provided with <reasoning>, you must provide your logical reasoning chain to solve the user query. Be verbose with your outputs.<|im_end|>
<|im_start|>user
How many letters "r" does the word strawberrry have?<|im_end|>
<|im_start|>reasoning
<reasoning>
[
  {
    "step": 1,

Y luego el segundo prompt con todos los pasos del razonamiento:

<|im_start|>reasoning
<reasoning>
[
  {
    "step": 1,
    "type": "problem_understanding",
    "thought": "I need to count the number of times the letter 'r' appears in the word 'straberrry'."
  },
  {
    "step": 2,
    "type": "data_gathering",
    "thought": "The word to analyze is 'straberrry'. I'll need to examine each character in this word."
  },
  {
    "step": 3,
    "type": "hypothesis_formation",
    "thought": "Based on a quick glance, I hypothesize that there are 3 'r's in the word 'straberrry'."
  },
  {
    "step": 4,
    "type": "analysis",
    "thought": "I'll go through the word character by character: s (not r), t (not r), r (count: 1), a (not r), b (not r), e (not r), r (count: 2), r (count: 3), r (count: 4), y (not r)."
  },
  {
    "step": 5,
    "type": "calculation",
    "thought": "After analyzing each character, I've counted 4 occurrences of the letter 'r'."
  },
  {
    "step": 6,
    "type": "verification",
    "thought": "To verify, I'll recount: s-t-r-a-b-e-r-r-r-y. This confirms 4 'r's."
  },
  {
    "step": 7,
    "type": "error_checking",
    "thought": "I'll double-check for any missed 'r's or counting errors. No errors found."
  },
  {
    "step": 8,
    "type": "conclusion_drawing",
    "thought": "The letter 'r' appears 4 times in the word 'straberrry'."
  },
  {
    "step": 9,
    "type": "reflection",
    "thought": "My initial hypothesis was close but not exact. This reminds me to be careful about quick estimates and to always verify."
  },
  {
    "step": 10,
    "type": "implementation",
    "thought": "The final response should be the number 4, as this is the correct count of 'r's in 'straberrry'."
  }
]</reasoning>|im_end|>
<|im_start|>assistant

El código Python para ejecutar esto contra el servidor de llama.cpp:

import requests
import json

llamaURL = "http://127.0.0.1:8080" 

def instruct(prompt, n_predict, temperature):
    #print("Asking llama.cpp")
    #print(prompt)
    
    response = requests.post(llamaURL+"/completion", json={
        'prompt': prompt,
        'n_predict': n_predict,
        'temperature': temperature,
        'cache_prompt': True
    })
    
    if response.status_code == 200:
        #print("Response llama.cpp")
        #print(response.json().get('content'))
        return response.json().get('content')
    else:
        raise Exception(f"Request failed with status code {response.status_code}")

def promptResolve(steps):
    return '''<|im_start|>reasoning
<reasoning>
[
  {
    "step": 1,
'''+steps+'''<|im_end|>
<|im_start|>assistant'''

def promptSteps(query):
    return '''<|im_start|>system
You are a superintelligent AI system, capable of comprehensive reasoning. When provided with <reasoning>, you must provide your logical reasoning chain to solve the user query. Be verbose with your outputs.<|im_end|>
<|im_start|>user
'''+query+'''<|im_end|>
<|im_start|>reasoning
<reasoning>
[
  {
    "step": 1,'''


try:
    query = '''How many letters "r" does the word strawberrry have?'''    

    steps = instruct(promptSteps(query), 8000, 0.5)    
    result = instruct(promptResolve(steps), 8000, 0.5)
    print(promptResolve(steps))
    print(result)
except Exception as e:
    print(e)

Controlando el razonamiento:

Para controlar el razonamiento hemos de interferir en la creación de pasos. Eso lo haremos usando el token «}» como «stop token». De esta forma después de cada paso de razonamiento (en JSON, os recuerdo) el modelo de lenguaje retornará el control a nuestro código, pudiendo nosotros modificar el paso recién añadido o el siguiente paso que le pasaremos al modelo

En este caso añado un ejemplo para controlar el número de pasos que va generar el modelo.

import requests
import json

llamaURL = "http://127.0.0.1:8080" 

def instruct(prompt, n_predict, temperature):
    #print("Asking llama.cpp")
    #print(prompt)
    
    response = requests.post(llamaURL+"/completion", json={
        'prompt': prompt,
        'n_predict': n_predict,
        'temperature': temperature,
        'cache_prompt': True
    })
    
    if response.status_code == 200:
        #print("Response llama.cpp")
        #print(response.json().get('content'))
        return response.json().get('content')
    else:
        raise Exception(f"Request failed with status code {response.status_code}")


def generateStep(prompt, n_predict, temperature):
    #print("Asking llama.cpp")
    #print(prompt)
    
    response = requests.post(llamaURL+"/completion", json={
        'prompt': prompt,
        'n_predict': n_predict,
        'temperature': temperature,
        'cache_prompt': True,
        'stop': ['}']
    })
    
    if response.status_code == 200:
        #print("Response llama.cpp")
        #print(response.json().get('content'))
        return response.json().get('content')
    else:
        raise Exception(f"Request failed with status code {response.status_code}")


def promptStep(query, steps):
    return '''<|im_start|>system
You are a superintelligent AI system, capable of comprehensive reasoning. When provided with <reasoning>, you must provide your logical reasoning chain to solve the user query. Be verbose with your outputs.<|im_end|>
<|im_start|>user
'''+query+'''<|im_end|>
<|im_start|>reasoning
<reasoning>
'''+steps

def promptResolve(steps):
    return '''<|im_start|>reasoning
<reasoning>
'''+steps+'''
<reasoning><|im_end|>
<|im_start|>assistant'''

def openStep(i):
    return '''    {
    "step": '''+str(i)+''',
'''

def closeStep():
    return "},"


try:
    query = '''How many letters "r" does the word strawberry have?'''
    
    stepByStep = '''[
'''
    for i in range(1,11):
        stepByStep += openStep(i)
        stepByStep += generateStep(promptStep(query, stepByStep), 8000, 0.5)
        stepByStep += closeStep()

    stepByStep += ''']'''    
    result = instruct(promptResolve(stepByStep), 8000, 0.5)
    print(promptResolve(stepByStep))
    print(result)
except Exception as e:
    print(e)

Algunas ideas que se pueden hacer con esto:

• Controlar el número de pasos
• Controlar el tiempo de ejecución
• Eliminar pasos
• Añadir pasos
• Crear un árbol de razonamiento

Puede lo que aquí se explica en el siguiente vídeo:

La OSI presento hace poco una definición de modelo de IA abierta, el equivalente del «Open Source» para los modelos de lenguajes. Antes de entrar en detalles con lo que ha definido la OSI vamos a hablar de los diferentes aspectos que se pueden «liberar» Grosso modo:

• API: dar acceso al modelo a través de una API pública.
• Pesos: el modelo propiamente dicho. Junto con el modelo se libera información de aspectos técnicos cómo información sobre cómo ejecutarlo o cuál es el formato de los prompts
• Pesos destilados: es una versión reducida del modelo de lenguaje obtenidos a partir de «refinar» el modelo original. Es más cerrado puesto que complica el generar modelos derivados. Por ejemplo el finetuning del modelo.
• Documentación de cómo usarlo: no basta con los pesos, hay que saber cómo usarlos. La arquitectura del modelo, el formato del prompt, …
• Cómo replicar el modelo: generalmente tiene la forma de «el paper» del modelo. Dónde se explica cómo se ha creado el modelo y permite duplicarlo. No siempre es tan exhausto, últimamente hay muchos casos que parecen más un documento de marketing que de investigación.
• El código de entrenamiento: el código necesario para entrenar tu propio modelo «igual» que el proporcionado
• Descripción del dataset: un resumen indicando el tipo de datos y su origen. Por lo general se mezclan dataset públicos, privados y datos sintéticos.
• Dataset: los datos usados para el entrenamiento. Es la parte más difícil que sea liberada ya que es lo más valioso y complicado de conseguir.

Por lo general las licencias suelen restringir algunas de las siguientes libertades:

• Usar el modelo de forma comercial. Muchos modelos solo permiten su uso no comercial.
• Usar el modelo de forma libre sin limitaciones. Es habitual que las empresas limiten los usos del modelo. La más habitual es que prohíban usarlo para entrenar otros modelos.
• Modificar/reentrenar el modelo. Algunas empresas prohíben modificar sus modelos.

Para cumplir con la OSI es necesario que la licencia del modelo no tenga restricciones.

Para más información puedes ver el siguiente vídeo de mi canal:

Speculative Decoding es un técnica (realmente un conjunto de ellas) para acelerar un modelo de lenguaje usando un «oraculo» que genera un borrador tratando de adivinar lo que el modelo va a generar. En este caso usaremos Qwen-2.5-coder-0.5B como oraculo para generar el borrador.

Para esta prueba usaremos un ejemplo que viene con Llama.cpp. Pero antes de poder usarlo hay que cambiar en el fichero examples/speculative/speculative.cpp el valor de la constante SPEC_VOCAB_MAX_SIZE_DIFFERENCE de 100 a 200.

#define SPEC_VOCAB_MAX_SIZE_DIFFERENCE  200

Una vez hecho esto hay que volver a compilarlo y ya se puede probar con el comando:

./llama-speculative
  -m models/Qwen2.5.1-Coder-7B-Instruct-Q8_0.gguf 
  -md models/Qwen2.5-coder-0.5b-instruct-q4_k_m.gguf
  -c 4000 --draft 8 --color
  --sampling-seq k --top-k 10 --temp 0.7
  -p "Generate a tetris game using JS and HTML in one HTML file"
  -ngl 99 -ngld 99

Puedes verlo en funcionamientos en el siguiente vídeo (así como la explicación de cada parámetro):

Hace no mucho Google sacó una herramienta que permite crear podcasts donde dos IAs discuten sobre el texto que les pasas. Meta no hace mucho sacó su propia versión usando Llama que se puede usar en local. Aquí presento mi idea, con código para que podáis jugar vosotros.

Podéis ver el vídeo con más detalles en mi canal de YouTube:

El proceso tiene varias partes:

Extraer el texto: 

El documento de origen puede tener una gran cantidad de formatos, para que funcione con la IA es necesario pasarlo a texto plano (txt). En este caso esa parte del trabajo os lo dejo a vosotros.

Limpiar el texto: 

Es posible que el texto extraído tenga «ruido», caracteres no válidos o que no forman parte del texto principal (cabeceras, notas de pie, número de página). Los resultados son mejores si le pedimos a una IA que limpie el texto.

Resumir el texto:

Su utilidad no es solo tener un podcast más corto y «concentrado». También sirve para lograr que el texto «quepa» dentro del contexto del modelos del lenguaje.

Generar el guión del podcast: 

En este caso se generará como si hablaran dos personas. Alice y Bob. Para ello pediremos al modelo de lenguaje que genere un podcast 

Generar el audio:

Aquí surge el problema de cómo generar audio con dos voces. En principio con Piper podemos fácilmente usar el parámetro –json-input y un fichero en formato json, indicando la voz usada en cada línea (es necesario un fichero de voz con múltiples voces). Por desgracia es necesario crear tu propia compilación de Piper. Así que haremos algo más simple: dividiremos el texto en líneas aprovechando que cada una va precedida de la voz que lo dice (el uso de [Alice] y [Bob] no es accidental). Y generamos un fichero wav independiente para cada línea. Luego tendremos que unirlos. En mi caso uso la herramienta sox.

const fetch = require('sync-fetch')
const fs = require("fs");
const { execSync } = require('child_process');

const llamaURL = "http://127.0.0.1:8080/completion";
const tokenizerURL = "http://127.0.0.1:8080/tokenize";
const inputFilename = "./text.txt";

//Llama a llama.cpp
function CallIA(prompt, n_predict, temperature) {
	console.log("Asking llama.cpp");
	
	let response = fetch(llamaURL, {
		method: 'POST',
		body: JSON.stringify({
			prompt,
			n_predict: n_predict,
			temperature: temperature,
			cache_prompt: true
		})
	}).json().content;

	return response;
}

//Consulta el tamaño en tokens del texto
function callTokenizer(text) {
	console.log("Asking llama.cpp");    

	let response = fetch(tokenizerURL, {
		method: 'POST',
		body: JSON.stringify({
            text,
            add_special: true
        })    
    }).json();

    console.log(response.tokens);
	return response.tokens.length;
}

//Limpiar texto
function generatePromptClean(text){
    return "<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n<|im_start|>user\nRepite el texto que te voy a pasar, limpia los caracteres extraños y corrige los posibles errores\n"+text+"\n<|im_end|>\n<|im_start|>assistant\n";
}  
//Resumir texto
function generatePromptSumarize(text){
    return "<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n<|im_start|>user\nResume el texto que te voy a pasar, extrae las partes más interesantes y curiosas de él\n"+text+"\n<|im_end|>\n<|im_start|>assistant\n";    
}   
//Generar guion
function generatePromptDialog(text){
    return "<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n<|im_start|>user\nConvierte el siguiente texto en una conversacion, en español, animada y divertida entre dos personas: Alice y Bob. Indica cada usuario poniendo delante [Alice] o [Bob].Comienza Alice\n"+text+"\n<|im_end|>\n<|im_start|>assistant\n[Alice]";    
}   

function generateAudio(text){
    //Almacena listado de ficheros para concatenar con sox
    var concatSox = ""; 

    //Se separa cada linea que empieza por [
    var podcastWithVoices = podcast.split("[");
    for(var i = 0; i < podcastWithVoices.length; i++){
        var line = podcastWithVoices[i].trim();
        //Elegimos la voz Alice/Bob
        var speaker;
        if(line.startsWith("Alice")){
            speaker = 1;
        } else {
            speaker = 0;
        }

        //Eliminamos el nombre para que no lo lea
        line = line.replace("Alice]", "").replace("Bob]", "");
        
        //Llamamos a Piper para generar el audio en un fichero .wav
        execSync(`echo '${line}' | piper --model ./models/es_ES-sharvard-medium.onnx --speaker ${speaker} --output_file podcast${i}.wav`, { encoding: 'utf-8' });

        //Añadimos el fichero a la lista para concatenar
        concatSox += "podcast"+i+".wav ";
    }

    //Unimos todos los ficheros .wav
    console.log(`sox ${concatSox} podcast.wav`);
    execSync(`sox ${concatSox} podcast.wav`);
}

//Leer fichero de texto
var text = fs.readFileSync(inputFilename, 'utf8');

//Tokenizador calcula cuantos tokens ocupa el texto (no he logrado que funcione)
//callTokenizer(text);

//Limpiamos el texto
//text = callIA(generatePromptClean(text), 8000, 0.2)

//Resumimos el texto
//text = callIA(generatePromptSumarize(text), 8000, 0.2)

//Generamos el dialogo
//Es necesario añadir [Alice] 
var podcast = "[Alice]"+CallIA(generatePromptDialog(text), 8000, 0.2);
console.log(podcast);

//Limpiamos el texto generado por la IA
podcast = podcast.replace(/(\r\n|\n|\r)/gm, "");

//Llama a piper para generar el audio linea a linea
generateAudio(podcast);

Si queréis ver (bueno, oir) el resultado, tenéis un ejemplo al final del vídeo.