Modelo de importação personalizado da Ollama

breve

Esta seção ensina como usar o Modelfile para personalizar modelos importados, dividida nas seguintes seções.

1. Importar do GGUF
2. Importar do Pytorch ou Safetensors
3. Importado diretamente do modelo
4. Prompt personalizado

I. Importação do GGUF

O GGUF (GPT-Generated Unified Format) é um formato de arquivo para salvar modelos de linguagem com ajuste fino. Esse formato foi projetado para ajudar os usuários a compartilhar e importar facilmente modelos entre diferentes plataformas e ambientes. Ele é compatível com vários formatos de quantificação, o que pode reduzir efetivamente o tamanho dos arquivos de modelo.

Sua antecessora foi a GGML (GPT-Generated Model Language), uma biblioteca de Tensor projetada especificamente para o aprendizado de máquina para ter um formato de arquivo único e ser fácil de raciocinar em diferentes arquiteturas de CPUs e GPUs, mas posteriormente encontrou problemas devido à falta de flexibilidade no desenvolvimento, compatibilidade e dificuldade de manutenção.

Ollama A importação de modelos de arquivos GGUF é suportada pelas seguintes etapas:

1. download .gguf papéis

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

Para fins de demonstração, escolhemos o modelo Qwen2-0.5B. Faça o download e copie-o para o diretório raiz da primeira parte. Você pode consultar a seguinte estrutura de diretórios:

├── 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

Dica

O código do Capítulo 3 e a documentação associada estão no notebook. Se você não tiver certeza de onde os arquivos de modelo estão instalados, consulte o notebook/C3

2. Criar um novo arquivo Modelfile

FROM ./Qwen2-0.5B.Q3_K_M.gguf

3. Criação de modelos no Ollama

Observação

Sempre execute os seguintes comandos de terminal no diretório em que o arquivo Modelfile está localizado!

ollama create mymodel -f Modelfile

4. Executar o modelo no terminal (foi testado que ele não é executado no notebook, é melhor executá-lo no terminal)

ollama run mymodel

II - Importação do Pytorch ou Safetensors

O Safetensors é um formato de arquivo para armazenar pesos de modelos de aprendizagem profunda, projetado para tratar de questões de segurança, eficiência e facilidade de uso. Essa parte da funcionalidade ainda está sendo desenvolvida pelos membros da comunidade, e os recursos de documentação são limitados no momento.

Se o modelo que estiver sendo importado for uma das arquiteturas a seguir, ele poderá ser importado diretamente para o Ollama por meio do Modelfile. Obviamente, você também pode converter o arquivo safetensors em um arquivo gguf e processá-lo. O processo de conversão pode ser encontrado na Parte III.

Informações mais detalhadas sobre os sensores de segurança e o GGUF podem ser obtidas neste link https://www.linkedin.com/pulse/llama-3-safetensors-vs-gguf-talles-carvalho-jjcqf

• LlamaParaCausalLM
• MistralParaCausalLM
• GemmaParaCausalLM

Como esta seção ainda está sendo otimizada pela comunidade, o código de amostra e o processo fornecidos aqui são apenas para referência e não é garantido que funcionem com êxito. Consulte a documentação oficial para obter detalhes.

1. Faça o download do 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. Crie um arquivo Modelfile no diretório raiz com o seguinte conteúdo:

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

3. Criação de modelos no Ollama

ollama create mymodel2 -f Modelfile

4. modelo operacional

ollama run mymodel2

III. importação direta de modelos

Felizmente, o hf fornece uma API muito conveniente para fazer download e processar esses modelos. Como o download direto acima é limitado pelo ambiente de rede, a velocidade é muito lenta, nesta pequena seção usaremos o script e o hf para concluir.

llama.cpp O GGUF é um projeto de código aberto que fornece funções de CLI e de servidor.

Para arquiteturas que não podem ser convertidas diretamente pelo Ollama, podemos usar o llama.cpp para quantificá-las e convertê-las para o formato GGUF e, em seguida, importá-las da primeira maneira. Todo o nosso processo de conversão está dividido nas seguintes etapas:

1. Faça o download do modelo em huggingface;
2. Use llama.cpp para realizar a conversão;
3. Use llama.cpp para quantificação do modelo;
4. Execute e carregue o modelo.

3.1 Baixando o modelo do HuggingFace

A maneira mais intuitiva de fazer o download é por meio de um clone ou link do git, mas como o llm conta cada parte por GB, evitar um OOM Error(Out of memory)Podemos escrever um download.py simples em Python.

Em primeiro lugar, é preciso acessar o hf para obter os dados pessoais do usuário ACCESS_TOKENpara abrir a página de configurações pessoais do huggingface.

Neste ponto, temos um ACCESS_TOKEN Em seguida, usamos o huggingface_hub (usado em uma expressão nominal) snapshot_download Para fazer o download do modelo, escolhemos aqui ou 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>")

O download pode demorar um pouco, portanto, seja paciente.

3.2 Conversão com llama.cpp

O llama.cpp foi desenvolvido pelo autor principal do GGML com base na versão c/c++ mais antiga do llama, com o objetivo de raciocinar sobre vários LLMs usando a CPU, e agora suporta a maioria dos modelos principais, até mesmo modelos multimodais, graças aos esforços contínuos da comunidade.

Primeiro, clonamos a biblioteca llama.cpp localmente, no mesmo diretório do modelo baixado:

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

Como o processo de conversão de modelos usando llama.cpp é baseado no desenvolvimento em python, você precisa instalar as bibliotecas relevantes, e é recomendável usar conda ou venv para criar um novo ambiente.

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

Se o seguinte for exibido, o programa de conversão está pronto.

Em seguida, convertemos o modelo que acabamos de baixar do HuggingFace para o formato GGUF usando o script a seguir:

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

Você pode ver um arquivo Qwen_instruct_0.5b.gguf adicional no diretório llama.cpp, e esse processo leva apenas alguns segundos.

Para economizar a sobrecarga durante o raciocínio, quantificamos o modelo e, em seguida, começamos a quantificar os exercícios práticos.

3.3 Quantificação do modelo usando llama.cpp

A quantificação do modelo é uma técnica que converte um modelo de ponto flutuante de alta precisão em um modelo de baixa precisão. O principal objetivo da quantificação do modelo é reduzir o tamanho e o custo computacional do modelo e manter o modelo o mais preciso possível, com o objetivo de permitir que o modelo seja executado em dispositivos com recursos limitados, como CPUs ou dispositivos móveis.

Da mesma forma, criamos o arquivo Modelfile primeiro e depois usamos o ollama create para criar nosso modelo a partir do arquivo gguf, mas um pouco diferente da primeira etapa de adição da lógica de quantificação, simplesmente executando o comando ollama create é simplesmente adicionar um parâmetro.

Primeiro, mova o Qwen_instruct_0.5b.gguf que você obteve na etapa anterior para o diretório raiz da terceira parte e, em seguida, crie um arquivo Modelfile com o seguinte conteúdo.

FROM ./Qwen_instruct_0.5b.gguf

O terminal executa os scripts de criação e quantificação.

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

Nesse ponto, nosso modelo é quantificado e criado e, em seguida, podemos executá-lo.

3.4 Executar e carregar o modelo

As etapas para executar um modelo com o gguf estão detalhadas na Parte I e não serão repetidas aqui.

Se o arquivo de modelo salvo localmente consumir muito espaço, podemos fazer upload do modelo gguf para o nosso próprio repositório no huggingface, a mesma ideia da etapa 1, podemos escrever uma lógica de upload.

Dica

Para concluir o upload, sua permissão HF_ACCESS_TOKEN deve ser gravada e seu model_id deve ser alterado. your_hf_name refere-se ao nome de sua conta 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)

Após o upload, você poderá vê-lo em seu repositório hf!

Prompt personalizado

O Ollama suporta Prompts personalizados, que permitem que o modelo gere um texto que atenda melhor às necessidades do usuário.

As etapas para personalizar o Prompt são as seguintes:

1. Crie um arquivo Modelfile no diretório raiz

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. Criação de modelos

ollama create mymodel -f ./Modelfile

A criação de um modelo pode demorar um pouco mais do que a extração de um modelo, portanto, seja paciente.

Execute-o novamente. ollama list Observando o modelo existente, você pode ver que o mymodel foi criado corretamente.

3. modelo operacional

ollama run mymodel

Como você pode ver, nossa pequena alpaca 🦙 se transformou no Mario! A personalização do Prompt foi bem-sucedida! 😘😘😘😘😘😘

link de referência

• 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