Crear un Modelfile para Ollama

Los hacks de hacks4geeks son minitutoriales rápidos pensados para geeks con conocimiento informático avanzado. Si no entiendes o no consigues ejecutar un hack de esta web considera suscribirte a Premium para solicitar asistencia sobre el mismo.

Crear un Modelfile para Ollama

Un Modelfile es el archivo que usamos en Ollama para crear una variante personalizada de un modelo. No estamos reentrenando el modelo desde cero, lo que hacemos es definir qué modelo base queremos usar, qué parámetros de ejecución tendrá, qué mensaje de sistema recibirá, qué plantilla de prompt usará y, si hace falta, qué adaptador LoRA se aplicará.

La estructura básica de un Modelfile es muy simple:
```
INSTRUCCION argumentos
```
Las instrucciones principales que podemos usar son:
```
FROM
PARAMETER
TEMPLATE
SYSTEM
ADAPTER
LICENSE
MESSAGE
REQUIRES
```
La única instrucción obligatoria es FROM, porque indica desde qué modelo base se va a crear nuestro modelo personalizado.

Crear un Modelfile básico

Podemos crear un archivo llamado Modelfile con este contenido:
```
FROM llama3.2

PARAMETER temperature 0.7
PARAMETER num_ctx 4096

SYSTEM """
Eres un asistente técnico especializado en GNU/Linux, redes y ciberseguridad.
Respondes de forma directa, práctica y sin relleno.
"""
```
Con esto le estamos diciendo a Ollama que cree un modelo basado en llama3.2, con una temperatura de 0.7, una ventana de contexto de 4096 tokens y un mensaje de sistema fijo.

Después lo creamos con:
```
ollama create asistente-linux -f ./Modelfile
```
Y lo ejecutamos con:
```
ollama run asistente-linux
```
Ver el Modelfile de un modelo existente

Una forma práctica de aprender es ver cómo está definido un modelo que ya tenemos instalado:
```
ollama show --modelfile llama3.2
```
Ese comando nos muestra el Modelfile generado por Ollama. A partir de ahí podemos copiarlo, modificarlo y crear una variante propia.

FROM: elegir el modelo base

La instrucción FROM define el modelo base. Puede apuntar a un modelo ya disponible en Ollama:
```
FROM llama3.2
```
También puede apuntar a un archivo GGUF local:
```
FROM ./modelo.gguf
```
O a una ruta absoluta:
```
FROM /home/usuario/Modelos/modelo.gguf
```
Si usamos un GGUF local, la ruta puede ser absoluta o relativa a la ubicación del Modelfile.

PARAMETER: ajustar el comportamiento del modelo

La instrucción PARAMETER nos permite definir cómo se comportará el modelo durante la generación.

Ejemplo:
```
PARAMETER temperature 0.7
PARAMETER num_ctx 8192
PARAMETER top_p 0.9
PARAMETER top_k 40
PARAMETER repeat_penalty 1.1
```
Los parámetros más útiles son:
- temperature: controla la creatividad. Cuanto más alto, más impredecible. Cuanto más bajo, más conservador.
- num_ctx: define el tamaño de la ventana de contexto. Si queremos que el modelo tenga en cuenta conversaciones o textos más largos, aumentamos este valor.
- top_k: limita la selección de tokens candidatos. Valores bajos hacen que el modelo sea más conservador.
- top_p: filtra tokens por probabilidad acumulada. También influye en la variedad de la respuesta.
- repeat_penalty: penaliza repeticiones. Es útil cuando el modelo empieza a repetir frases o estructuras.
- seed: permite hacer la generación más reproducible.
- num_predict: limita cuántos tokens puede generar el modelo.
- stop: define cadenas que harán que el modelo deje de generar texto.
Ejemplo con varias secuencias de parada:
```
PARAMETER stop "<|im_start|>"
PARAMETER stop "<|im_end|>"
```
SYSTEM: definir el comportamiento del asistente

La instrucción SYSTEM define el mensaje de sistema. Es una de las partes más útiles del Modelfile porque nos permite fijar el rol del modelo. Ejemplo:
```
SYSTEM """
Eres un asistente experto en Debian.
Siempre das comandos compatibles con Debian estable.
Evitas soluciones cerradas si existe una alternativa OpenSource razonable.
"""
```
Esto no cambia los pesos internos del modelo. No estamos haciendo fine-tuning. Estamos definiendo instrucciones persistentes que Ollama inyectará al usar ese modelo.

TEMPLATE: controlar cómo se construye el prompt

La instrucción TEMPLATE define la plantilla completa que se enviará al modelo. Es importante porque cada familia de modelos puede usar tokens especiales distintos. Una plantilla simple podría ser:
```
TEMPLATE """
{{ if .System }}Sistema:
{{ .System }}
{{ end }}

Usuario:
{{ .Prompt }}

Asistente:
{{ .Response }}
"""
```
Las variables principales son:
- {{ .System }}: contiene el mensaje de sistema.
- {{ .Prompt }}: contiene el mensaje del usuario.
- {{ .Response }}: marca el punto donde debe empezar la respuesta del modelo.
En modelos instruct modernos conviene respetar la plantilla original del modelo, porque muchos modelos fueron entrenados con formatos concretos. Si rompemos la plantilla, el modelo puede responder peor, mezclar roles o no respetar bien las instrucciones.

MESSAGE: añadir ejemplos de conversación

La instrucción MESSAGE permite añadir historial de conversación de ejemplo. Es útil cuando queremos guiar el estilo de respuesta con ejemplos concretos.
```
MESSAGE user ¿Debian usa apt?
MESSAGE assistant Sí. Debian usa apt como gestor de paquetes de alto nivel.

MESSAGE user ¿Debo usar pacman en Debian?
MESSAGE assistant No. pacman es propio de Arch Linux y derivadas. En Debian usamos apt.
```
Esto puede servir para reforzar patrones de respuesta, pero no sustituye a un buen mensaje de sistema ni a un modelo adecuado.

ADAPTER: aplicar un LoRA

La instrucción ADAPTER permite aplicar un adaptador LoRA o QLoRA al modelo base.
```
FROM llama3.2
ADAPTER ./adaptador-lora.gguf
```
El punto importante: el adaptador debe corresponder al mismo modelo base para el que fue entrenado. Si aplicamos un LoRA entrenado para otro modelo distinto, el comportamiento puede ser errático.

LICENSE: añadir licencia

La instrucción LICENSE permite incluir el texto de licencia del modelo personalizado.
```
LICENSE """
Texto de la licencia aquí.
"""
```
Esto es especialmente importante si vamos a compartir el modelo con otras personas o publicarlo.

REQUIRES: exigir una versión mínima de Ollama

La instrucción REQUIRES sirve para indicar una versión mínima de Ollama.
```
REQUIRES 0.14.0
```
Es útil cuando usamos opciones que dependen de versiones recientes.

Ejemplo práctico: modelo técnico para Debian

Este sería un Modelfile práctico para crear un asistente técnico orientado a Debian:
```
FROM llama3.2

PARAMETER temperature 0.4
PARAMETER num_ctx 8192
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1.15

SYSTEM """
Eres un asistente técnico especializado en Debian GNU/Linux.
Das respuestas directas, prácticas y verificables.
Cuando propongas comandos, deben funcionar en Debian estable.
No recomiendas Docker si puede resolverse de forma nativa o con LXC.
No inventas paquetes, rutas ni comandos.
"""
```
Lo creamos así:
```
ollama create debian-tech -f ./Modelfile
```
Y lo probamos:
```
ollama run debian-tech
```
Ejemplo práctico: modelo con respuestas más creativas

Si queremos un modelo más creativo, podemos subir la temperatura:
```
FROM llama3.2

PARAMETER temperature 1
PARAMETER top_p 0.95
PARAMETER top_k 80

SYSTEM """
Eres un asistente creativo.
Propones ideas originales, comparaciones y alternativas.
"""
```
Este tipo de configuración puede servir para lluvia de ideas, escritura creativa o generación de nombres, pero no es lo ideal para tareas técnicas donde necesitamos precisión.

Ejemplo práctico: modelo más determinista

Para tareas técnicas, generación de comandos o respuestas repetibles, nos conviene bajar la temperatura:
```
FROM llama3.2

PARAMETER temperature 0.2
PARAMETER top_p 0.8
PARAMETER seed 42

SYSTEM """
Eres un asistente técnico.
Respondes con precisión y evitas adornos.
"""
```
Esto no garantiza que el modelo sea perfecto, pero reduce la variabilidad.

Errores comunes al crear un Modelfile

Un error típico es escribir instrucciones que Ollama no reconoce. Las instrucciones válidas son FROM, PARAMETER, TEMPLATE, SYSTEM, ADAPTER, LICENSE, MESSAGE y REQUIRES.

Otro error común es usar una plantilla incorrecta para el modelo. Si no sabemos exactamente qué plantilla necesita, conviene partir del Modelfile original:
```
ollama show --modelfile nombre-del-modelo
```
También es habitual confundir un Modelfile con un fine-tuning. Un Modelfile no entrena el modelo. Sirve para empaquetar configuración, prompt de sistema, plantilla, parámetros y adaptadores.

Otro problema frecuente aparece cuando el archivo se guarda con una codificación incorrecta o caracteres raros al principio del archivo. Lo más seguro es crear el archivo como texto plano UTF-8.

Flujo recomendado

Primero descargamos o elegimos el modelo base:
```
ollama pull llama3.2
```
Después miramos su Modelfile original:
```
ollama show --modelfile llama3.2
```
Luego creamos nuestro propio Modelfile:
```
nano Modelfile
```
Lo construimos:
```
ollama create mi-modelo -f ./Modelfile
```
Y lo ejecutamos:
```
ollama run mi-modelo
```
Comprobar que el modelo personalizado existe

Podemos listar los modelos instalados con:
```
ollama list
```
Y podemos inspeccionar nuestro modelo personalizado con:
```
ollama show mi-modelo
```
Si queremos ver el Modelfile generado:
```
ollama show --modelfile mi-modelo
```
Cuándo merece la pena usar un Modelfile

Nos conviene usar un Modelfile cuando queremos tener un modelo reutilizable con una personalidad, parámetros o formato concreto. Por ejemplo, un asistente para Debian, un asistente de programación, un asistente para resumir documentos, un generador de comandos o un modelo con un LoRA aplicado.

También es útil cuando usamos Ollama desde API, porque en vez de enviar siempre el mismo mensaje de sistema desde nuestra aplicación, podemos crear un modelo ya configurado y llamarlo directamente por su nombre.
```
curl http://localhost:11434/api/generate -d '{
  "model": "debian-tech",
  "prompt": "Dime cómo ver los puertos abiertos en Debian"
}'
```
De esta forma mantenemos la configuración centralizada en Ollama y simplificamos el código de la aplicación que consume el modelo.

Ver como PDF

Los comentarios están cerrados.

Crear un Modelfile para Ollama

Crear un Modelfile básico

Ver el Modelfile de un modelo existente

FROM: elegir el modelo base

PARAMETER: ajustar el comportamiento del modelo

SYSTEM: definir el comportamiento del asistente

TEMPLATE: controlar cómo se construye el prompt

MESSAGE: añadir ejemplos de conversación

ADAPTER: aplicar un LoRA

LICENSE: añadir licencia

REQUIRES: exigir una versión mínima de Ollama

Ejemplo práctico: modelo técnico para Debian

Ejemplo práctico: modelo con respuestas más creativas

Ejemplo práctico: modelo más determinista

Errores comunes al crear un Modelfile

Flujo recomendado

Comprobar que el modelo personalizado existe

Cuándo merece la pena usar un Modelfile