Ú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.

Los modelos de lenguaje (vamos a centrarnos en ellos en este artículo, aunque lo aquí visto aplica al resto de los modelos) empiezan a verse cada vez en más usos y no solo la IA privada, también la IA local con despliegues de sistemas en los servidores propios de muchas empresas. Las ventajas de tener modelos propios son claras: mayor control, mayor personalización, mayor privacidad. Pero también tiene sus riesgos de seguridad .Sin embargo se suele hablar poco de ellos:

• Vulnerabilidades y Bugs: Los modelos de lenguaje necesitan un software para que los «ejecute» (realice la inferencia). Este software está sujeto a bugs y vulnerabilidades. Cómo con cualquier software hay que mantenerlo actualizado y estar atento a posibles vulnerabilidades.
• Marcado de textos: Un modelo puede marcar en secreto el texto que genera. Esto permitiría saber para que usas el modelo y rastrear su uso. Puedes saber más sobre este tema en el siguiente enlace: https://youtu.be/bc_bQeAY9-M
• Modelos trampa para extraer datos del finetunig: si tu plan es entrenar un modelo con datos propios de tu empresa, se ha logrado preparar modelos trampa que permiten recuperar parte de los datos usados como finetuning. En caso de usar RAG hay bastantes técnicas para recuperar los datos de los argumentos usados como fuente de información en el RAG.
• Agentes durmientes: suena a película de espías pero es posible tener LLMs con comportamientos ocultos que solo se activen en ciertas condiciones. Por ejemplo, generar código con bugs solo cuando detecte que se trabaja en ciertos proyectos.
• Mal uso de herramientas: últimamente los modelos de lenguaje están ganando la capacidad de usar herramientas. Una muy habitual es permitirles ejecutar código Python. Sin embargo los modelos podrían usar esta capacidad para enviar información al exterior o abrir conexiones a nuestro equipo desde el exterior. Combinado con el caso anterior podría ser realmente peligroso.

Más información en el vídeo de mi canal de YouTube:

Hace poco vivimos un caso en que liberaron una nueva IA(en teoría revolucionaria). Sin embargo en cuanto la gente comenzó a chatear con ella no tardó en descubrir que realmente era otra IA con un poco de magia en el prompt. ¿Cómo podemos distinguir qué modelo es simplemente conversando con el?

Realmente no hay ninguna prueba definitiva, hay que intentar realizar tantas pruebas cómo sea posible y ver si el peso de las pruebas indica un modelo en concreto. Con los modelos libres hay que tener en cuenta que pueden haber sufrido un fine-tuning, lo que puede complicar la cosa.

Veamos que pistas tenemos:

• Preguntarle al propio modelo. Es lo más básico pero puede funcionar. Cómo se le puede convencer, via prompt del sistema, de que mienta. Se pueden usar métodos más taimados como decirle que proponga palabras que rimen con su nombre, una adivinanza o una poesía donde cada línea empiece por una letra de su nombre
• Verificar si está censurado y sobre que temas. La mayoría de los modelos que se lanzan tienen censura. Si no la tiene podría señalar que es un finetunig. También podemos ver sobre que temas responde y compararlos con los modelos conocidos
• Ver cómo responde a temas censurados  Las respuestas a temas censurados suelen ser muy similares dentro del mismo modelo. Lo que puede ser una pista comparando sus negativas con las de otros modelos.
• Problemas límites del modelo. Hay problemas que solo algunos modelos pueden responder, incluso que depende cómo se le pregunte. Reunir varias de estas cuestiones y ver cómo las responde puede delimitar de que lenguaje se trata.
• Lenguas e idiomas. No todos los modelos entienden todos los lenguajes o idiomas. Puede ser una gran pista ver cuáles entiende.
• El tokenizador. La forma en que cada familia de modelos divide las palabras (genera los tokens) es diferente. Aquí el problema está en como ver esos tokens en una conversación. No es algo que se pueda ver de forma directa y requiere trucos que no siempre es seguro si están funcionando.

Puedes ver el tema desarrollado en este vídeo de mi canal de Youtube: