Cómo elegir el modelo de IA ideal para tu equipo y por qué tu IA se emborracha

Vistas: 863
0:00 / 0:00
Cómo elegir el modelo de IA ideal para tu equipo y por qué tu IA se emborracha

En este episodio continuo explorando este ChatGTP personalizado que es OpenWebUI, y que te permite hacer casi cualquier cosa que puedas imaginar. En concreto me he centrado únicamente en dos aspectos concretos. Los prompts y los modelos. Lo que realmente ando buscando es tener las herramientas que necesito directamente en mi entorno de trabajo sin tener que recurrir a un servicio de terceros. Vamos lo que venimos llamando soberanía digital. Sin embargo, no quiero perder ninguna de las características que tengo con Gemini o con Google AI Studio, e incluso mejorarlas con las opciones que me ofrece OpenWebUI. Durante estos últimos días he estado probando decenas de distintos modelos, y los resultados eran dispares. Incluso modelos como Gemma4 no se comportaba como yo esperaba. Hasta que me he dado cuenta de un detalle fundamental, la ventana de contexto. En ocasiones utilizo prompts tan extensos que se comían literalmente la ventana de contexto. Así en este episodio vamos a abordar modelos y prompts, incluso la opción de crear tus propios modelos.

En busca del mejor modelo

Buscando modelos

En los episodios anteriores estuvimos hablando de hardware y de modelos. ¿Pero que modelo encaja en tu hardware?. En este sentido te hablé de rust-hf-downloader, que es una herramienta que te permite descargar modelos desde Hugging Face, y que te muestra información sobre el modelo, como su tamaño, su ventana de contexto, etc. Sin embargo, no es una herramienta que te permita gestionar los modelos que tienes en tu entorno de trabajo.

Pero además en el grupo de Telegram Juanma comentó que utilizaba llfit, que es una herramienta que te permite realizar búsquedas de los modelos soportados en tu equipo. Esta herramienta selecciona el modelo mas adecuado en base a tu RAM, CPY y GPU. Además todo lo hace de forma interactiva y muy sencillo.

Un poquito de background

Entender la ventana de contexto (el «espacio de memoria» a corto plazo del modelo) es vital. Si te pasas, el modelo empezará a «olvidar» el principio de la conversación. Cada modelo de lenguaje tiene un límite físico definido durante su entrenamiento (y configurado en su Modelfile). En Ollama, este valor se suele definir con el parámetro num_ctx. Por defecto, si no se especifica, Ollama suele arrancar muchos modelos con un contexto de 2048 o 4096 tokens, aunque el modelo soporte más (como Llama 3 que llega a los 8k o más). Y claro, si te pasas con el prompt, evidentemente esto lo pierdes por completo. Y como andaba jugando en paralelo tanto con modelos como con prompts…

Descubriendo las ventanas de contexto

Actualmente estoy utilizando Ollama como mi servidor de modelos, así que hay que preguntarle por esta información, y lo puedes hacer de dos formas, o bien directamente con,

ollama show gemma4:latest --parameters

O bien vía API,

curl -s http://localhost:11434/api/show -d '{"name": "gemma4:latest"}' | jq '.parameters'

Como te decía, dado que estuve probando varias decenas de modelos, finalmente me decidí por un script que me mostrara de forma ordenada los modelos que tengo en mi Ollama, y sus respectivas ventanas de contexto. Y el resultado es el siguiente,

ACTUAL   MÁXIMO  MODELO
------   ------  ------
64000    262144  Qwen3-4B-Instruct-2507-Q4_K_M:latest
64000    163840  DeepSeek-V2-Lite-Chat-Q4_K_M:latest
96000    131072  gemma4-128k:latest
4096*    262144  zantag/Qwen3-30B-A3B-Thinking-2507-GGUF-Q2_K_XL:latest
4096*    131072  granite3.3:latest
131072   262144  batiai/qwen3.5-9b:q6
4096*    131072  deepseek-r1:8b
4096*       512  nomic-embed-text-v2-moe:latest
4096*    262144  qwen3.5:27b
4096*    262144  qwen3.5:9b
4096*    262144  qwen3.5:4b
4096*    262144  qwen3.5:0.8b
8192      2048   nomic-embed-text:latest
65536   1010000  myaniu/qwen2.5-1m:14b
65536   1010000  myaniu/qwen2.5-1m:7b
4096*    131072  mma4:e2b
4096*     16384  motron-3-nano:4b
4096*    262144  mma4:latest
4096*    131072  mma4:e4b
4096*     32768  mistral:7b

Lo cierto es que no me había dado cuenta de este detalle, y es que algunos modelos, como Gemma4 o Qwen3-4B tienen una ventana de contexto de 128k o 256k tokens, pero Ollama los estaba arrancando con una ventana de contexto de tan solo 4096 tokens. Esto evidentemente hacía que los resultados fueran muy pobres, y no se comportaran como yo esperaba. Así que lo primero que hice fue configurar la ventana de contexto a su valor máximo, y el resultado fue espectacular. De hecho, el modelo Gemma4 se comporta ahora como yo esperaba, y es una auténtica pasada. Evidentemente esto no es algo que puedas hacer con un modelo alojado en un servicio de terceros, pero al tenerlo en tu propio entorno de trabajo, puedes configurarlo a tu antojo.

Modificar la ventana de contexto

Tienes varias opciones para modificar la ventana de contexto, o bien directamente con el comando ollama run, o bien modificando el Modelfile del modelo. En mi caso, dado que quiero que el modelo siempre arranque con la ventana de contexto al máximo, he optado por modificar el Modelfile. Para ello, lo primero que hice fue localizar el Modelfile del modelo, y luego modificar el valor del parámetro num_ctx a su valor máximo. En el caso de Gemma4 lo he configurado a 131072 tokens, y el resultado ha sido espectacular.

Dado que he estado importando también modelos de Hugging Face, he implementado un sencillo script que me permita integrar el modelo dentro de Ollama definiendo además la ventana de contexto.

Y por supuesto, y como no podía ser de otra forma, otro script adicional que me permite crear un nuevo modelo a partir de uno existente. Que conste, que todas estas operaciones o muchas de ellas se pueden realizar desde la interfaz de OpenWebUI, pero como me gusta más la terminal, pues he optado por esta opción.

Cuanto consumo la ventana de contexto

El contexto se almacena en lo que llamamos el KV Cache (Key-Value Cache). Este espacio reside en la VRAM de tu GPU (o en la RAM si usas CPU).

La fórmula rápida para modelos de 7B a 9B (como tus Qwen o DeepSeek):

  • Cada 1.000 tokens de contexto extra consumen, aproximadamente, entre 50 MB y 100 MB de VRAM adicional (dependiendo de la cuantización).
  • Si subes a 32.000 tokens, prepara unos 2 GB – 3 GB de VRAM solo para la «memoria» del modelo, aparte de lo que ya pese el modelo en sí.
  • Si te vienes arriba y pones los 262.144 tokens del Qwen 3.5, ¡podrías necesitar más de 20 GB de VRAM solo para el contexto!

Entonces, ¿Cuanta ventana de contexto utilizo?

No por tener 1 millón de tokens de máximo hay que usarlos siempre. La recomndación,

  • Uso diario (Chat/Asistente): Configura tus modelos a 8.192 o 16.384 tokens. Es más que suficiente para recordar el hilo de una conversación larga y el modelo responderá a la velocidad del rayo.
  • Programación (Análisis de archivos): Súbelo a 32.768. Te permite meterle un par de clases de Rust o scripts de Fish enteros para que los entienda en bloque.
  • Análisis de Documentación/Libros: Solo ahí, usa los modelos de 1M (millón) como el qwen2.5-1m, pero asegúrate de tener RAM de sobra.

El equilibro de poder von la VRAM, teniendo en cuenta que se dvidie en dos partes,

  • El peso del modelo, o lo que es lo mismo, lo que pesa el cerebro en reposo.
  • KV Cache. El espacio para la memoria de trabajo.

Para maximizar el contexto con 16 GB, la mejor estrategia es usar modelos de 7B a 9B parámetros con una cuantización de 4-bit o 5-bit (Q4_K_M o Q5_K_M).

  • Un modelo de 9B (como Qwen 3.5) a Q4 ocupa unos 5.5 GB.
  • Te quedan 10.5 GB libres.
  • Esos 10.5 GB pueden albergar aproximadamente 64.000 tokens con total seguridad, y quizás llegar a 96.000 forzando un poco.

Así puedo crear dos versiones personalizadas, una para razonamiento profundo, DeepSeek, y la otra para memoria masiva con Qwen

FROM deepseek-r1:8b
PARAMETER num_ctx 32768
FROM qwen3.5:9b
PARAMETER num_ctx 65536
PARAMETER num_predict 4096

¿Y qué pasa con los modelos de 14B o 30B?

Con 16 GB de VRAM:

  • Un 14B (como DeepSeek-R1 14B) ocupa unos 9-10 GB. Te deja sitio para unos 16k-24k de contexto.
  • Un 30B (como el Qwen que tienes en Q2) ocupa unos 12-13 GB. Estás muy al límite; te recomiendo no pasar de 8k de contexto para evitar que el sistema se vuelva inestable.

Usa el Qwen 3.5 9B configurado a 64k. Es el punto donde la inteligencia del modelo y la capacidad de memoria se encuentran en un equilibrio perfecto para tu hardware. Podrás analizar hilos de conversación larguísimos sin que la GPU sufra.

Un contexto de 4096 tokens ¿para que da?

En modelos basados en arquitecturas tipo Llama o Gemma, la equivalencia aproximada es 1.000 tokens ≈ 750 palabras (en inglés) / ≈ 600-700 palabras (en español). El español consume un poco más de tokens por la cantidad de artículos, flexiones verbales y caracteres especiales (tildes, eñes). Haciendo cálculos rápidos,

  • Palabras: Unas 2.800 – 3.000 palabras.
  • Páginas (A4, espacio simple): Unas 5 o 6 páginas de texto denso.
  • Tiempo de lectura: Unos 10-12 minutos de lectura en voz alta.

Sin embargo, en todo esto hay una pequeña trampa. Esos 4.096 tokens no son solo para tu pregunta, son para TODO lo que el modelo tiene que tener en mente en ese instante. El pastel se reparte de la siguiente forma,

  • System Prompt (Instrucciones): Si le has dicho «Eres un experto programador en Rust, amable, directo…», eso ya gasta tokens.
  • Historial de la conversación: Para que la IA recuerde lo que dijiste hace tres mensajes, tiene que volver a leer esos mensajes en cada turno.
  • Tu pregunta actual: Lo que acabas de escribir.
  • La respuesta de la IA: Los tokens que está generando ahora también cuentan dentro del límite.

Conclusión: Si tienes una conversación larga, en el momento en que la suma de (Instrucciones + Historial + Pregunta + Respuesta) llegue a 4.096, el modelo empezará a olvidar el principio. Es el efecto borrachera, la IA sigue hablando, pero ya no sabe de qué habláis al principio.

Para que lo veas claro en tu día a día con Linux y el desarrollo:

  • DA PARA (OK ✅):
    • Explicar un script de Fish de unas 100 líneas.
    • Resumir un artículo de un blog o una noticia.
    • Ayudarte a redactar un correo electrónico profesional.
    • Resolver errores de compilación de un solo archivo.
  • NO DA PARA (MAL ❌):
    • Analizar un archivo docker-compose.yml complejo junto con sus 5 Dockerfile asociados.
    • Pegar un log de sistema (journalctl -u podman) de los últimos 10 minutos.
    • Pedirle que refactorice una clase de Rust de 500 líneas.
    • Mantener una sesión de «brainstorming» de dos horas sobre un proyecto.
  • 4.096 tokens: Una servilleta de restaurante (útil para una nota rápida).
  • 128.000 tokens (Tu Gemma 4): ¡Un libro de 300 páginas!

Más información,

Ver el vídeo de este episodio
Transcripción

Hola soy lorenzo y esto es atareado con Linux episodio número 793 en este episodio y seguramente,

En el siguiente continuaré con el tema de open web y es que es una herramienta que realmente me,

Ha sorprendido mucho porque viene a reunir lo que otras herramientas en este caso en otros servicios,

Como pueden ser chat gpt o como puede ser gemini o como puede ser cualquier otro pero además cogiendo,

Lo mejor de cada de cada uno de ellos y no quiero decir que open web y haya copiado los otros porque,

A lo mejor son los otros lo que han copiado a ellos sino que lo que vengo a decir es que básicamente,

Lo que ha hecho ha sido en agrupar todas esas características que yo echaba de menos en unos,

Y otros por ejemplo el tema de las carpetas pero lo cierto es que a pesar de que estaba con bastante,

Dudas sobre el funcionamiento de open web y lo que se podía exprimir la verdad es que se puede hacer,

Mucho así por ejemplo si le preguntas algo tan sencillo como que que es un rag,

A los modelos que yo tengo actualmente cargado lo que vas a ver es que la respuesta es relativamente,

Rápida y es relativamente rápida porque funciona realmente muy bien actualmente y durante estos días,

Lo que he estado haciendo ha sido cargar decenas de y además no exagero en absoluto decenas de distintos,

Modelos distintos modelos para hacer casi cualquier cosa que te puedas hacer una idea,

Pero sobre todo era probar probar cuánto cargan cuánto consumen qué es lo que hacen qué es lo que,

No hacen la rapidez de la respuesta todo eso me ha interesado muchísimo quería ver exactamente,

Cuál era la respuesta y hasta dónde podía yo sustituir una herramienta como puede ser chat gpt o gemini o,

Google i studio directamente con open web ui incluso ha habido un momento que lo que he hecho ha sido,

Realizar una un mix en el sentido de que estaba utilizando,

Gemini pero dentro de open web ui y lo estaba haciendo así por lo que te acabo de decir porque,

Tiene una de las características que más me gustan que es el tema de las carpetas de hecho en firefox,

Estaba utilizando incluso en chrome creo recordar también una herramienta que me permitía tener las,

Carpetas dentro de gemini porque creo que es una herramienta muy interesante sin embargo a pesar de que,

Sea una herramienta muy interesante lo cierto es que no consigo de ninguna de las maneras o no conseguía de,

Ninguna o es muy complicado llegar a hacer lo que se puede hacer directamente aquí lo que se puede,

Hacer directamente en open web ui en el sentido de que puedes asignar un determinado modelo a,

Una a un determinado a una determinada carpeta incluso bueno pues hacer todo tipo de operaciones según tus,

Necesidades por ejemplo cómo podría montar un rag con rust una cosa así en fin que lo cierto es que,

Es realmente impresionante lo rápido que va y lo efectivo que funciona es cierto que en ocasiones se,

Queda un poco tostado pero esto es debido básicamente a la cantidad de pruebas que le he estado metiendo,

En el sentido de que he estado probando con algo de lo que te voy a hablar en este episodio que no es ni,

Más ni menos que los contextos o mejor dicho el tamaño del contexto y los prom así que vamos,

Directos al turrón en este episodio te voy a hablar sobre modelos y prom y empiezo primero por el tema,

De los modelos y es que lo cierto es que en el episodio en uno de los episodios anteriores te estuve,

Hablando sobre soluciones como podía ser rust hf downloader que es una herramienta que te permite,

Descargar distintos distintos modelos directamente de hagan face y para ir haciendo pruebas sobre todo,

Modelos en base a preguntas que vas haciendo y cuál es el modelo más rápido cuál es el modelo que,

Puedes utilizar para hacer autocompletado cuál es el modelo que puedes utilizar para razonar en base a,

Todo este tipo de cosas pues tienes una herramienta como esta que te va a permitir descargar en principio,

Todos los estoy descargando en modelo gg uf pero esto es por comodidad mía porque luego para importarlos,

Directamente o llama es relativamente sencillo aunque como te digo también estoy utilizando o llama,

Directamente para hacer las descargas pero claro llegados a este punto te preguntarás ostras y yo cómo,

Sé yo cuál es el modelo que mejor se adecua a mi sistema en este sentido en el grupo de atareado con,

Linux de telegram juan ma comentó que él utiliza una herramienta que es realmente muy interesante que,

Se llama l l m fit es decir large language model fit y lo que hace es buscar para tu.

Para tu equipo para las características de tu hardware exactamente la herramienta más adecuada puede,

Ser o llama puede ser en fin cualquiera de las soluciones se adecua pero él dice oye pues tú tienes,

Una envidia de estas características y va buscando de todas las disposiciones o de todos los modelos por,

Ejemplo que hay disponibles él busca cuál es el modelo que más va a casar con tu con tu hardware y,

Claro de esta manera pues es mucho más sencillo hacer una búsqueda de todas maneras no no voy a engañarte,

Yo lo que estoy haciendo es apoyarme en gemini para ir preguntándole exactamente qué modelo se,

Adecua más o qué modelo puede hacer para por ejemplo autocompletados o para cualquier otro tipo de operaciones,

Llegados a este punto te quiero hablar un poquito de las ventanas de contexto y es que uno de los,

Problemas con los que me he encontrado durante estos días ha sido precisamente la ventana de contexto,

Si no sabes qué es la ventana de contexto indicarte que es el espacio de memoria a corto plazo del modelo,

Y es una herramienta o es algo fundamental en el sentido de que todo lo que entra dentro de ese,

Dentro de esa ventana de contexto es lo que evalúa el modelo para poder trabajar con ello,

Cada modelo tiene un límite físico que está definido durante el entrenamiento y configurado en su model file,

El model file creo que lo vimos en un episodio anterior y te estuve hablando sobre cómo podías tú crear tus propios model file,

A partir de modelos existentes,

La cuestión es que y esto no me había dado cuenta es que en oyama se puede definir,

O mejor dicho oyama define por defecto,

El tamaño de la ventana,

De contexto,

Y esto,

Si lo tiene definido el modelo lo coge pero si no lo tiene definido lo pone por defecto,

Y en este sentido pone una ventana de contexto muy pequeña que pueden ser de 2048 tokens,

Claro una ventana de contexto muy pequeña lo que quiere decir es que vas a poder o va a tener una memoria muy pequeña,

Como toda la información tú cada vez que le haces cualquiera pregunta a Gemini,

Perdón a tu modelo lo envías toda esa información lo que va a resultar es que llega un momento en que parte de esa información la descarta,

Porque es que no la puedo utilizar,

Actualmente estoy utilizando como te digo oyama como mi servidor de modelos,

Y en este sentido al utilizar oyama como mi servidor de modelos lo que estaba haciendo él era directamente,

Realizar esa,

Digamos,

Modificación de mi ventana de contexto,

¿Cómo me di cuenta,

Bueno pues me di cuenta a base de hacer pruebas,

Conforme iba haciendo pruebas me di cuenta que enseguida,

Conforme le hacía cuatro preguntas o dos preguntas,

Lo primero que le había preguntado ya se había olvidado,

No solamente es esto,

Uno de los grandes problemas que he tenido hasta el momento ha sido que,

Pues le ponía,

El,

El,

PROM del sistema un PROM muy grande,

Explicándole,

Demasiadas cosas y,

Esto al final pues llevaba a que,

Enseguida se olvidaba,

De las más mínimas instrucciones,

Esto unido precisamente al,

Hecho de,

La ventana de contexto,

Limitada por defecto por oyama,

Pues,

Se convertía en algo ridículo,

Fíjate hasta donde llega el asunto que,

Hubo un momento que me estuve planteando si realmente esto,

Lo iba a poder utilizar,

Es decir si iba a poder utilizar,

Una,

Un modelo de lenguaje o iba a poder utilizar,

La,

Ya directamente,

El local,

Y claro,

Hasta que,

Caí en el asunto,

Hasta que me di cuenta del problema con el que me estaba encontrando,

De la ventana de contexto,

Pues iba un poco despistado,

¿Cómo averiguar la ventana de contexto que tienes,

Bueno pues,

Tienes distintas opciones para hacerlo,

Pero,

Yo lo que al final hice fue un sencillo script,

Que le he llamado,

Oyama audit,

Que lo que hace es que cuando lo ejecutas,

Te lista todos los,

Modelos que tienes actualmente,

En tu equipo,

Con,

La ventana de contexto actual,

Y la máxima ventana de contexto definida,

Por defecto,

En el entrenamiento del modelo,

Así por ejemplo,

He definido para,

GEMA 4 E2B,

Una ventana de contexto de 32.000 tokens,

Para,

Llama 3.2,

Que lo utilizo para,

El autocompletado,

Le he definido una ventana de contexto,

De 8.000 tokens,

Y así sucesivamente,

Para todos,

Hay muchos,

Que son,

Los que están marcados,

Como asterisco,

Con un asterisco,

Perdón,

Son los que indica,

Que son por defecto,

Doyama,

Y que están a 4.096,

Lo cierto es que,

Teniendo en cuenta,

Que hay modelos,

Que te permiten,

Hasta,

200.000 Tokens,

Tener una ventana de contexto,

De 4.000,

Lo que quiere decir,

Es que le has puesto,

Ahí un embudo,

Para que aquello,

No pase,

De ninguna,

De las maneras,

Entonces,

¿Cómo modificar,

La ventana de contexto,

Bueno,

Para modificar,

La ventana de contexto,

Tienes,

Distintas opciones,

Desde,

Pasarle por parámetros,

Con un set parameter,

Una vez lo has lanzado,

Hasta crear,

Tu propio modelo,

De nuevo,

Lo que he hecho,

Ha sido,

Otro script,

Que,

Puedo crear,

Modelos,

O mejor dicho,

Puedo personalizar,

Puedo customizar,

Determinados modelos,

Con determinadas,

Ventanas de contexto,

Simplemente,

Oyama,

Custom,

Y aquí,

En este oyama custom,

Lo que puedo hacer,

Es decirle,

El modelo original,

El nuevo nombre,

Y el tamaño,

De la ventana de contexto,

Y con esto,

Lo tendría,

Perfectamente,

Todo acotado,

Una cosa tan sencilla,

Como esta,

Igualmente,

También he hecho,

Un oyama import,

Que lo que hace,

Es,

A partir de un archivo,

Gguf,

Y poniéndole,

Un nombre,

Y definiéndole,

Un tamaño,

De contexto,

Lo que hace,

Es crear,

También,

Un modelo,

A partir,

De algo,

Que me he descargado,

De,

Hang and face,

Y con esto,

Ya tendría,

Otra de las opciones,

Para poder empezar,

A trabajar,

Con ello,

Claro,

Que llegados,

A este punto,

Es muy probable,

Que te estés preguntando,

Vale,

Pero,

¿Cuánto realmente,

Consume,

En mi ventana,

De contexto,

Porque,

Si yo tengo,

Un modelo,

Por ejemplo,

De,

7 Billions,

Eso,

Más o menos,

Van a ser,

5 Gigas,

Con lo cual,

Si tengo,

Una memoria,

De 16 gigas,

Pues tengo ahí,

11 Gigas,

Disponibles,

Para todo esto,

Bueno,

Pues te voy a dar,

Una regla sencilla,

Y es que,

Cada 1000 tokens,

De contexto,

Aproximadamente,

Son,

Unos,

100 Megas,

De RAM,

Con lo cual,

Si te pones,

32.000 Tokens,

De contexto,

Lo que son,

3,2 Gigas,

En este sentido,

Si tienes,

Un modelo,

Pequeño,

O un modelo,

De 5,

De 7 billions,

Es decir,

Un modelo,

Que ocupe,

En torno,

A los 5 gigas,

Pues vas a poder,

Tener,

El resto,

Es decir,

10 Gigas,

Que van a ser,

Aproximadamente,

Unos 10,

Unos 100.000 tokens,

¿No.

1000,

100.000,

Si,

100.000 Tokens,

100K,

Para,

Para poder,

Trabajar,

Y eso está,

Muy bien,

De todas maneras,

Tienes que pensar,

Una cosa,

Que no por tener,

Un millón de tokens,

Tienes que utilizarlos,

Todos,

Y para esto,

Viene la siguiente regla,

Sencilla,

Para un chat,

Para una cosa sencilla,

Para un chat,

Con 8.000,

Entre 8.000,

Y 16.000 tokens,

Tienes suficiente,

Para mantener,

Una conversación,

Lo suficientemente larga,

Y ahora te daré,

Algunos detalles,

Más,

Para programación,

Lo que deberías,

De ir,

Es a un,

A una ventana,

De contexto,

De unos,

32K,

Porque,

De esta manera,

Puedes meter,

Todas las clases,

Y lo puedes meter,

Todo ahí,

Y para,

Documentación,

Lo que puedes ir,

Es a modelos,

Mucho más grandes,

De incluso,

100K,

100.000 Tokens,

Entre los modelos,

Que yo he descargado,

Tengo uno,

Que permite,

Hasta un millón,

De tokens,

Pero claro,

Ahí tienes que pensar,

Que 10 gigas,

Son,

O sea perdón,

100.000 Tokens,

Son 10 gigas,

Pues si quieres,

Un millón de tokens,

Son,

100 Gigas,

Así que,

No solo está,

Limitado por esto,

Sino limitado,

Por otras cosas,

Para,

Al final,

Se trata de tener,

Un equilibrio,

Un equilibrio,

Entre el peso,

Del modelo,

Y un equilibrio,

Entre la KVKH,

Que es,

La memoria,

De trabajo,

Digamos que,

El peso del modelo,

Se corresponde,

Con el peso,

Del cerebro,

En reposo,

Mientras que,

La KVKH,

Es la memoria,

Para maximizar,

El contexto,

Para tener en cuenta,

Yo actualmente,

Tengo 16 gigas,

Lo que puedo hacer,

Es un modelo,

De 9 gigas,

Que,

Ocupa,

Perdón,

Un modelo,

De 9 billions,

Vendría a ocupar,

Unos 5,5 gigas,

Con lo cual,

Quedan,

Unos 10 gigas,

Libres,

Con lo cual,

Son unos,

Entre 60,

Y 100.000 tokens,

Depende,

Como,

Esté hecho,

Y te digo,

Entre 60,

Y 100.000 tokens,

Porque tienes que,

Tener en cuenta,

Que un token,

Es aproximadamente,

O mejor dicho,

Sí,

Un token,

Es casi,

Una palabra,

En el sentido,

En el sentido,

De que,

1.000 Tokens,

Son 750,

Palabras,

En inglés,

Pero,

En español,

No es así,

En español,

En ver de,

1.000 Tokens,

Ser 700,

50,

Van a ser,

Unas 600,

Y esto es debido,

Así a la cantidad,

De artículos,

Flexiones verbales,

Y caracteres especiales,

Que tiene,

El español,

En este sentido,

Y para que te hagas,

Una idea,

Más o menos,

Tienes que tener en cuenta,

Que,

Unas,

A ver,

Un contexto,

De unos,

4.000 Tokens,

Viene a ser,

Aproximadamente,

Unas 2.500 palabras,

Que viene a ser,

Unas 5 o 6 páginas,

En A4,

Y un tiempo de lectura,

Aproximado,

De 10 o 12 minutos,

Esto es para que te hagas,

Una idea,

Lo que,

Venía a ser,

Los 4.096 tokens,

Que pone por defecto,

Oyama,

¿Qué es lo que pasa,

Que tú dices,

Hombre,

Con 4.096,

Si yo le digo,

Que me diga,

Por ejemplo,

Con,

Qué diferencia,

Hay,

Entre,

Entre el peso,

Del modelo,

Y.

Y el KV,

Tú vas a decir,

Hombre,

Y le he puesto ahí,

Un contexto muy pequeño,

Pero claro,

Tienes que pensar,

Lo siguiente,

Primero,

Que cuando tú,

Envías,

Vas a enviar,

El System Prompt,

Es decir,

Todas las instrucciones,

Que tú le has dado,

Por ejemplo,

Eres un experto,

Programador,

En Rast,

Eres amable,

Eres directo,

Eres,

Muy simpático,

Muy colaborador,

Todo eso que le pones,

Es el System Prompt,

Cuanto más grande,

Es el System Prompt,

Más estás consumiendo,

Lo siguiente,

Es que también envías,

El historial,

De la conversación,

Cuanto más grande,

Es el historial,

De la conversación,

Más consume,

También tienes que tener,

En cuenta,

Que,

En una,

En un contexto,

De 4.000,

Tokens,

Más o menos,

En dos o tres mensajes,

Ya empieza a olvidarse,

Es lo que se llama,

La borrachera,

Y luego,

Evidentemente,

También va,

Lo que es,

Es la pregunta,

Que acabas de escribir,

Y la respuesta,

Conclusión,

Que si tienes,

Una conversación,

Más o menos,

Larga,

Es decir,

De un par de preguntas,

En el momento,

En que la suma,

De instrucciones,

Historial,

La pregunta,

Y la respuesta,

Llegan los 4.000 tokens,

Ya empiezas a olvidarse cosas,

Así que,

Todo esto,

Lo tienes que tener en cuenta,

Entonces,

Te estarás preguntando,

¿Y para qué da,

Un,

Contexto,

De 4.000 tokens,

Bueno,

Pues te da,

Para explicar,

Un script,

Por ejemplo,

Un script en base,

De 100 líneas,

Le dices,

Explícamelo,

Resumir un artículo,

Un artículo,

De un blog,

Más o menos,

Son unas,

2.000 Palabras,

Bueno,

Esto antes,

Ahora van,

Siendo cada vez,

Más pequeños,

Si quieres redactar,

Un correo electrónico,

O si quieres resolver,

Errores de compilación,

De un archivo,

Esto es algo,

Que hago habitualmente,

Simplemente,

Le paso,

Un trozo,

Del log,

Y le digo,

Explícame,

Lo que hay aquí,

Claro,

Cuanto más grande,

Es el trozo,

Del log,

Más consume,

Cuanta más información,

Le haya pasado,

Al prompt,

Para decirle,

Que,

Investigue,

Pues más consume,

¿Y para qué no da,

Ese contexto,

De 4.000,

Bueno,

Pues básicamente,

Para analizar,

Un Docker,

Con post complejo,

Que tenga varios,

Docker files,

Asociados,

Para eso no,

Pegar un,

Log de un sistema,

Completo,

Decirle que,

Refactorice,

Una clase de,

Rast,

De 5.000 líneas,

O de,

Perdón,

De 500 líneas,

Mantenían,

Una sesión,

De brainstorming,

De un par de horas,

Evidentemente,

En cuanto tengas,

Un poquito,

Ya se va a olvidar,

Del principio,

Básicamente,

Y como regla,

Mnemotécnica,

Puedes decir,

Que,

4.000 Tokens,

Es lo que viene,

A ser una servilleta,

De restaurante,

Y 100.000 tokens,

Vienen a ser,

Unas 300 páginas,

Del libro,

Para que te hagas una idea,

De ahí la importancia,

Y de ahí la importancia,

De,

Poder,

Ir aprovechando,

Cada una de las herramientas,

Y cada uno,

De los prompts,

Que utilizas,

De ahí,

Vuelvo a insistir,

La importancia,

De definir,

Distintos prompts,

Y utilizar,

Distintas herramientas,

O distintos modelos,

Para cada uno,

De los prompts,

Dependiendo,

De la tarea,

Que quieras hacer,

Pues vas a utilizar,

Un prompt,

O vas a utilizar,

Otro prompt,

Para tareas muy sencillas,

O para tareas,

Que sean muy rápidas,

Pues lo que vas a hacer,

Como te decía,

Anteriormente,

Es,

O para un,

Es un,

Un modelo,

Que sea,

Muy pequeñín,

Por ejemplo,

Para un auto,

Completado,

Eso es perfecto,

Por ejemplo,

¿Qué modelo,

Utilizaríamos,

Para un,

Auto,

Completado.

Completado,

¿Y qué ventana,

De contexto.

Sería la recomendable,

Con eso,

Se lo pasamos,

A nuestro modelo,

Nuestro modelo,

Va a,

Y ahora te repito,

Ojo a todo el tema,

Fíjate,

Antes de elegir,

Debes tener en cuenta,

La calidad,

Versus,

El costo,

Y la velocidad,

Máxima calidad,

Rendimiento,

Tienes un GPT4,

O un CLOB3,

Opus,

Ten en cuenta,

También,

El tiempo,

En el que se hizo,

Este modelo,

En el que te estoy hablando,

Luego,

Para máxima calidad,

Perdón,

Para máxima velocidad,

Empieza ya a utilizar,

Modelos pequeños,

Modelos,

Como puede ser,

Un Mistral 7B,

O un GEMA 2B,

De 2 billions,

Ojo,

Y luego,

Para la soberanía digital,

Para todo lo que es local,

Modelos pequeños,

Cuantizados,

Un modelo cuantizado,

De 4Q,

Prácticamente,

No pierdes,

Nada de rendimiento,

Respecto a 1 de 8Q,

Pero sí que ganas,

En mucho más,

Mucho más velocidad,

Recomendaciones,

Por nivel de implantación,

Un modelo recomendado,

El Mistral 7B,

O el GEMA 2B,

2 Billions,

7 Billions,

Son pequeños,

Eficientes,

Y funcionan muy bien,

Con cuantización,

Se ejecutan,

De forma nativa,

La mayoría,

De CPUs,

Y GPUs,

La ventana,

De contexto,

Recomendada,

Ventanas de contexto,

Realmente muy pequeñas,

De 1024,

O 2048 tokens,

O sea que,

Tienes que ir aquí,

Ir jugando,

Ir viendo,

Y ir aproximando,

Cada vez más,

Pues lo que vayas haciendo,

Con lo que necesites,

Dicho esto,

Sobre el tema,

De los PROMS,

Yo aquí,

He ido añadiendo,

He ido creando,

Distintas herramientas,

¿No,

Por ejemplo,

Tengo una carpeta,

Para Atari,

Con Linux,

En esta carpeta,

De Atari,

Con Linux,

Por ejemplo,

Estoy utilizando,

El modelo,

GEMA,

E4B,

Incluso aquí,

En algunos de ellos,

Lo que estoy utilizando,

Son dos modelos,

En paralelo,

El GEMA 4,

Y el Dipsy,

Que reúno,

Y comparo,

Las respuestas,

De ambos,

Y así me voy haciendo,

Una idea,

De exactamente,

Cuál de los dos modelos,

Es más adecuado,

Esto con,

OpenWeb UI,

Funciona muy bien,

Luego también,

Tengo un auditor,

El auditor,

Luego tengo,

Para hacer chats,

Conversacionales,

Sencillos,

Otro que tengo aquí,

Es para,

Crear,

Chuletas,

A base de comandos,

Esto directamente,

Me genera,

La chuleta,

En,

En Types,

Y lo compilo,

Y con esto,

Directamente sale,

Igualmente,

Para esto,

He probado,

O he estado probando,

Distintas opciones,

Distintas,

Soluciones,

Distintos modelos,

Y cada uno,

De los modelos,

Con distintos contextos,

También tengo otro,

Para trabajar,

Con,

Con,

Kit,

Para la era,

De las distros,

Para OpenWeb UI,

En fin,

Tengo distintos,

Y cada uno,

De estos,

Tiene en particular,

Su propio modelo,

Si yo,

Pulso aquí,

En editar,

Tengo las instrucciones,

Eres,

Por ejemplo,

Este de aquí,

Dice,

Eres Leslie,

Tu función,

Es actuar,

Como una consultora,

De IA,

Aplicada de nivel,

Senior,

Eres un experto,

En arquitectura,

De IA local,

Luego le explico,

Y aquí claro,

Este,

Todo este,

Prom del sistema,

Es lo que le estamos pasando,

Fíjate que,

Yo le estoy pasando aquí,

Pues,

Prácticamente,

Una hoja,

Un poquito más,

Yo creo que,

Aquí habrá,

Más de mil palabras,

Con lo cual,

Estamos hablando,

De mil doscientos,

Mil trescientos tokens,

Que ya estamos consumiendo,

Si estamos utilizando,

Un modelo,

Que tiene un límite,

De dos mil tokens,

En la siguiente conversación,

Ya se ha perdido todo,

Porque claro,

En cada conversación,

Yo le mando,

El prompt,

Del,

Del,

Del sistema,

Así que,

Y esto es un poco,

Lo que quería contarte,

Quería contarte un poco,

Mis aventuras,

Y desventuras,

Quería que vieras,

Exactamente,

Las ventajas,

De la ventana,

De contexto,

Cómo personalizar,

Tus propios modelos,

Cómo,

Definir,

Distintos prom,

Para distintas tareas,

Y no solamente,

Distintos prom,

Sino también,

Distintos modelos,

Para distintas tareas,

Dependiendo de si vas a hacer,

Un auto completado,

Si vas a hacer una tarea,

Que requiere más trabajo,

Pues para todo esto,

Tienes distintas soluciones,

Y esto es un poco,

Lo que quería contarte,

Espero que te haya gustado,

Este nuevo episodio,

Y que lo hayas disfrutado,

Tanto como lo he disfrutado yo,

Recordarte que este es un podcast,

De la,

Como dijo el otro día,

El compañero,

Un elenco,

De los mejores podcast,

En español,

De la red de sospechosos habituales,

Que por cierto,

Le doy un,

Saludo,

A monos del espacio,

Que el otro día,

Se acordó de mí,

O sea bueno,

Se acordó del podcast,

Se acordó de la tarea con Linux,

Así que,

Un recuerdo para él,

Y por supuesto,

Un recuerdo también,

Para,

Tanto para,

El amigo,

Piston Z,

Que,

Últimamente,

Salgo mucho,

A pasear con él,

Al menos de forma virtual,

Es lo que tiene,

Bueno,

Y poco más que contarte,

Espero que te haya gustado,

Este nuevo episodio,

Y que lo hayas disfrutado,

Tanto como lo he disfrutado yo,

Recordarte,

Que la vida son dos días,

Y uno ya pasado,

Así que disfruto,

Como si no hubiera mañana,

Y si puede ser con Linux,

Y en este caso,

Con open web UI,

Los modelos,

Y el contexto,

Mejor que mejor,

Un saludo,

Y nos escuchamos,

El próximo jueves,

Hasta luego,

¡Gracias,

¡Gracias,

¡Gracias,

¡Gracias,

¡Gracias,

¡Gracias,

¡Gracias,

¡Gracias,

¡Gracias,

¡Gracias,

¡Gracias.

2 comentarios en “Cómo elegir el modelo de IA ideal para tu equipo y por qué tu IA se emborracha”

Deja una respuesta