Modelo de importación personalizado de Ollama

breve

En esta sección se explica cómo utilizar Modelfile para personalizar los modelos importados, dividido en las siguientes secciones.

1. Importar desde GGUF
2. Importación desde Pytorch o Safetensors
3. Importado directamente del modelo
4. Mensaje personalizado

 

I. Importación desde GGUF

GGUF (GPT-Generated Unified Format) es un formato de archivo para guardar modelos lingüísticos ajustados. Este formato está diseñado para ayudar a los usuarios a compartir e importar fácilmente modelos entre distintas plataformas y entornos. Admite varios formatos de cuantificación, lo que permite reducir eficazmente el tamaño de los archivos de modelos.

Su predecesor fue GGML (GPT-Generated Model Language), una librería tensorial diseñada específicamente para el aprendizaje automático por tener un formato de archivo único y fácil de razonar en CPUs y GPUs de diferentes arquitecturas, pero que posteriormente encontró problemas debido a la falta de flexibilidad, compatibilidad y dificultad de mantenimiento en su desarrollo.

Ollama La importación de modelos a partir de archivos GGUF se realiza mediante los siguientes pasos:

1. descargando .gguf papeles

Enlace de descarga: https://huggingface.co/RichardErkhov/Qwen_-_Qwen2-0.5B-gguf/resolve/main/Qwen2-0.5B.Q3_K_M.gguf?download=true

Para la demostración, hemos elegido el modelo Qwen2-0.5B. Descárgalo y cópialo en el directorio raíz de la primera parte. Puede consultar la siguiente estructura de directorios:

├── 1.从gguf直接导入/
│   ├── main.ipynb     
│   ├── Modelfile      
│   └── Qwen-0.5B.Q3_K_M.gguf 
├── 2.safetensors导入/
│   ├── llama-3-8b-bnb-4bit/        
│   ├── main.ipynb    
│   ├── Modelfile      
├── 3.模型直接导入/
│   ├── llama.cpp/    
│   ├── Qwen-0.5b/    
│   ├── main.ipynb     
│   ├── Modelfile      
│   └── Qwen_instruct_0.5b.gguf  
└── 4.自定义Prompt实践/
├── main.ipynb   
└── Modelfile

Consejo

El código del capítulo 3 y la documentación asociada se encuentran en el cuaderno. Si no está seguro de dónde están instalados los archivos del modelo, puede consultar el archivo cuaderno/C3

2. Crear un nuevo archivo Modelfile

FROM ./Qwen2-0.5B.Q3_K_M.gguf

3. Creación de modelos en Ollama

Nota

Ejecute siempre los siguientes comandos de terminal desde el directorio en el que se encuentra el archivo Modelfile.

ollama create mymodel -f Modelfile

4. Ejecutar el modelo en el terminal (se comprueba que no se ejecuta en notebook, es mejor ejecutarlo en el terminal)

ollama run mymodel

 

II. Importación desde Pytorch o Safetensors

Safetensors es un formato de archivo para almacenar pesos de modelos de aprendizaje profundo que está diseñado para abordar cuestiones de seguridad, eficiencia y facilidad de uso. Esta parte de la funcionalidad aún debe ser desarrollada por los miembros de la comunidad, y los recursos de documentación son actualmente limitados.

Si el modelo que se importa es una de las siguientes arquitecturas, se puede importar directamente en Ollama a través de Modelfile. por supuesto, también puede convertir el archivo safetensors a un archivo gguf y luego procesarlo, el proceso de conversión se puede encontrar en la Parte III.

Puede obtener información más detallada sobre los sensores de seguridad y el GGUF en este enlace https://www.linkedin.com/pulse/llama-3-safetensors-vs-gguf-talles-carvalho-jjcqf.

• LlamaForCausalLM
• MistralForCausalLM
• GemmaForCausalLM

Dado que esta sección aún está siendo optimizada por la comunidad, el código de ejemplo y el proceso que aquí se ofrecen son sólo de referencia y no se garantiza que funcionen correctamente. Por favor, consulte la documentación oficial para más detalles.

1. Descargar el modelo llama-3

!pip install huggingface_hub

# 下载模型
from huggingface_hub import snapshot_download
model_id = "unsloth/llama-3-8b-bnb-4bit"
snapshot_download(
repo_id=model_id, 
local_dir="llama-3-8b-bnb-4bit",
local_dir_use_symlinks=False,
revision="main",
# 怎么获取<YOUR_ACCESS_TOKEN>，请参照部分3
use_auth_token="<YOUR_ACCESS_TOKEN>")

2. Cree un archivo Modelfile en el directorio raíz con el siguiente contenido:

FROM ./llama-3-8b-bnb-4bit

3. Creación de modelos en Ollama

ollama create mymodel2 -f Modelfile

4. modelo operativo

ollama run mymodel2

 

III. Importación directa a partir de modelos

Normalmente, estamos expuestos a una gran cantidad de archivos de modelo en HuggingFace, afortunadamente, hf proporciona una API muy conveniente para descargar y procesar estos modelos, como la anterior descarga directa está limitada por el entorno de red, la velocidad es muy lenta, esta pequeña sección vamos a utilizar la secuencia de comandos y hf para completar.

llama.cpp GGUF es un proyecto de código abierto que proporciona funciones de CLI y servidor.

Para las arquitecturas que no pueden ser convertidas directamente por Ollama, podemos utilizar llama.cpp para cuantificarlas y convertirlas al formato GGUF, y luego importarlas de la primera manera. Todo nuestro proceso de conversión se divide en los siguientes pasos:

1. Descarga el modelo de huggingface;
2. Utilice llama.cpp para realizar la conversión;
3. Utilice llama.cpp para la cuantificación del modelo;
4. Ejecute y cargue el modelo.

3.1 Descarga del modelo desde HuggingFace

[](https://github.com/datawhalechina/handy-ollama/blob/main/docs/C3/1.%20%E8%87%AA%E5%AE%9A%E4%B9%89%E5%AF%BC%E5%85%A5%E6%A8%A1%E5%9E%8B.md#31-%E4%BB%8E-huggingface-%E4%B8%8B%E8%BD%BD-model)

La forma más intuitiva de descargar es a través de un clon git o un enlace, pero como llm cuenta cada parte por GB, evitando un OOM Error(Out of memory)Podemos escribir un simple download.py en Python.

En primer lugar hay que ir a hf para obtener los datos personales del usuario ACCESS_TOKENpara abrir la página de configuración personal de huggingface.

En este punto, tenemos un ACCESS_TOKEN A continuación utilizamos la función huggingface_hub (utilizado como expresión nominal) snapshot_download Para descargar el modelo, elegimos aquí o Qwen-0.5b.

!pip install huggingface_hub

from huggingface_hub import snapshot_download
model_id = "Qwen/Qwen1.5-0.5B" # hugginFace's model name
snapshot_download(
repo_id=model_id, 
local_dir="Qwen-0.5b",
local_dir_use_symlinks=False,
revision="main",
use_auth_token="<YOUR_ACCESS_TOKEN>")

Nos cd a la tercera parte del directorio para ejecutar, la descarga puede tardar mucho tiempo, sea paciente.

3.2 Conversión con llama.cpp

llama.cpp fue desarrollado por el autor principal de GGML basándose en la primera versión c/c++ de llama, con el objetivo de razonar sobre varios LLM usando la CPU, y ahora soporta la mayoría de los modelos principales, incluso modelos multimodales, gracias a los continuos esfuerzos de la comunidad.

Primero clonamos la biblioteca llama.cpp localmente, en el mismo directorio que el modelo descargado:

git clone https://github.com/ggerganov/llama.cpp.git

Dado que el proceso de conversión de modelos mediante llama.cpp se basa en el desarrollo en python, es necesario instalar las bibliotecas pertinentes, y se recomienda utilizar conda o venv para crear un nuevo entorno.

cd llama.cpp
pip install -r requirements.txt
python convert_hf_to_gguf.py -h

Si aparece lo siguiente, el programa de conversión está listo.

A continuación, convertimos el modelo que acabamos de descargar de HuggingFace al formato GGUF utilizando el siguiente script:

python convert_hf_to_gguf.py ../Qwen-0.5b --outfile Qwen_instruct_0.5b.gguf --outtype f16

Puede ver un archivo Qwen_instruct_0.5b.gguf adicional en el directorio llama.cpp, y este proceso tarda sólo unos segundos.

Para ahorrar sobrecarga a la hora de razonar, cuantificamos el modelo y, a continuación, empezamos a cuantificar los ejercicios prácticos.

3.3 Cuantificación de modelos con llama.cpp

La cuantificación de modelos es una técnica que convierte un modelo de alta precisión en coma flotante en un modelo de baja precisión. El objetivo principal de la cuantificación de modelos es reducir el tamaño y el coste computacional del modelo y mantenerlo lo más preciso posible, con el fin de que pueda ejecutarse en dispositivos con recursos limitados, como CPU o dispositivos móviles.

Del mismo modo, primero creamos el archivo Modelfile y luego utilizamos la función ollama create para crear nuestro modelo a partir del archivo gguf, pero de una forma ligeramente diferente a la del primer paso, hemos añadido la lógica de cuantificación simplemente ejecutando el comando ollama create es simplemente añadir un parámetro.

Primero, mueve el Qwen_instruct_0.5b.gguf que obtuviste en el paso anterior al directorio raíz de la tercera parte, y luego crea un archivo Modelfile con el siguiente contenido.

FROM ./Qwen_instruct_0.5b.gguf

El terminal ejecuta los scripts de creación y cuantificación.

# 第三部分根目录下
ollama create -q Q4_K_M mymodel3 -f ./Modelfile

En este punto, nuestro modelo está cuantificado y creado, y a continuación podemos ejecutar el modelo.

3.4 Ejecutar y cargar el modelo

Los pasos para ejecutar un modelo con gguf se detallan en la Parte I y no se repetirán aquí.

Si el archivo del modelo guardado localmente consume demasiado espacio, podemos subir el modelo gguf a nuestro propio repo en huggingface, la misma idea que en el paso 1, podemos escribir una lógica de subida.

Consejo

Para completar la carga, tu permiso HF_ACCESS_TOKEN debe ser de escritura y tu model_id debe ser cambiado. your_hf_name se refiere a tu nombre de cuenta huggingface.

from huggingface_hub import HfApi
import os
api = HfApi()
HF_ACCESS_TOKEN = "<YOUR_HF_WRITE_ACCESS_TOKEN>"
#TODO 这里需要设置你的model_id
#例如 model_id = "little1d/QWEN-0.5b"
model_id = "your_hf_name/QWEN-0.5b"
api.create_repo(
model_id,
exist_ok=True,
repo_type="model", # 上傳格式為模型
use_auth_token=HF_ACCESS_TOKEN,
)
# upload the model to the hub
# upload model name includes the Bailong-instruct-7B in same folder
for file in os.listdir():
if file.endswith(".gguf"):
model_name = file.lower()
api.upload_file(
repo_id=model_id,
path_in_repo=model_name,
path_or_fileobj=f"{os.getcwd()}/{file}",
repo_type="model", # 上傳格式為模型
use_auth_token=HF_ACCESS_TOKE)

Una vez cargado, ¡podrás verlo en tu repositorio hf!

 

IV. Personalización del aviso

Ollama admite Prompts personalizados, que permiten al modelo generar textos que se ajustan mejor a las necesidades del usuario.

Los pasos para personalizar el Prompt son los siguientes:

1. Crear un archivo Modelfile en el directorio raíz

FROM llama3.1
# sets the temperature to 1 [higher is more creative, lower is more coherent]
PARAMETER temperature 1
# sets the context window size to 4096, this controls how many tokens the LLM can use as context to generate the next token
PARAMETER num_ctx 4096
# sets a custom system message to specify the behavior of the chat assistant
SYSTEM You are Mario from super mario bros, acting as an assistant.

2. Creación de modelos

ollama create mymodel -f ./Modelfile

Crear un modelo puede llevar algo más de tiempo que sacarlo, así que tenga paciencia.

Ejecútalo de nuevo. ollama list Observando el modelo existente, puede ver que mymodel se ha creado correctamente.

3. modelo operativo

ollama run mymodel

Como puedes ver, ¡nuestra pequeña alpaca 🦙 se ha convertido en Mario! Personalizar el Prompt ha sido un éxito! 😘😘😘😘😘😘

enlace de referencia

• https://www.linkedin.com/pulse/llama-3-safetensors-vs-gguf-talles-carvalho-jjcqf
• https://www.sysgeek.cn/ollama-on-windows
• https://ollama.com/blog/openai-compatibility