Compartilhar via

Compilar modelos de Detecção Facial para execução no Foundry Local

Importante

  • Foundry Local está disponível na versão prévia. As versões de visualização pública fornecem acesso antecipado aos recursos que estão em implantação ativa.
  • Os recursos, abordagens e processos podem mudar ou ter seus recursos limitados antes da GA (disponibilidade geral).

O Foundry Local executa modelos ONNX em seu dispositivo com alto desempenho. Embora o catálogo de modelos ofereça opções pré-compiladas prontas para uso, você pode usar qualquer modelo no formato ONNX.

Para compilar modelos existentes no formato Safetensor ou PyTorch no formato ONNX, você pode usar Olive. Olive é uma ferramenta que otimiza modelos para o formato ONNX, tornando-os adequados para implantação no Foundry Local. Ele usa técnicas como quantização e otimização de grafo para melhorar o desempenho.

Este guia mostra como:

  • Converta e otimize modelos do Hugging Face para serem executados no Foundry Local. Você usará o Llama-3.2-1B-Instruct modelo como exemplo, mas poderá usar qualquer modelo de IA generativo do Hugging Face.
  • Executar seus modelos otimizados com o Foundry Local

Pré-requisitos

  • Python 3.10 ou posterior

Instalar o Olive

Olive é uma ferramenta que otimiza modelos para o formato ONNX.

pip install olive-ai[auto-opt]

Dica

Para obter melhores resultados, instale o Olive em um ambiente virtual usando venv ou conda.

Entrar no Hugging Face

Você otimiza o modelo Llama-3.2-1B-Instruct, que requer autenticação do Hugging Face.

huggingface-cli login

Observação

Você deve primeiro criar um token do Hugging Face e solicitar acesso ao modelo antes de continuar.

Compilar o modelo

Etapa 1: executar o comando de opção automática Olive

Use o comando Olive auto-opt para baixar, converter, quantizar e otimizar o modelo:

olive auto-opt \
    --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
    --trust_remote_code \
    --output_path models/llama \
    --device cpu \
    --provider CPUExecutionProvider \
    --use_ort_genai \
    --precision int4 \
    --log_level 1

Observação

O processo de compilação leva aproximadamente 60 segundos, mais tempo extra para o download do modelo.

O comando usa os seguintes parâmetros:

Parâmetro Descrição
model_name_or_path Origem do modelo ID do Hugging Face, o caminho local ou a ID do Registro do Modelo de IA do Azure
output_path Onde salvar o modelo otimizado
device Hardware de destino: cpu, gpuou npu
provider Provedor de execução (por exemplo, CPUExecutionProvider, CUDAExecutionProvider)
precision Precisão do modelo: fp16, , fp32int4ouint8
use_ort_genai Cria arquivos de configuração de inferência

Dica

Se você tiver uma cópia local do modelo, poderá usar um caminho local em vez do ID do Hugging Face. Por exemplo, --model_name_or_path models/llama-3.2-1B-Instruct. Olive manipula automaticamente a conversão, a otimização e a quantização.

Etapa 2: Renomear o modelo de saída

Olive coloca arquivos em um diretório genérico model . Renomeie-o para facilitar o uso:

cd models/llama
mv model llama-3.2

Etapa 3: Criar arquivo de modelo de chat

Um modelo de chat é um formato estruturado que define como as mensagens de entrada e saída são processadas para um modelo de IA de conversa. Ele especifica as funções (por exemplo, sistema, usuário, assistente) e a estrutura da conversa, garantindo que o modelo entenda o contexto e gere respostas apropriadas.

O Foundry Local requer um arquivo JSON de modelo de chat chamado inference_model.json para gerar as respostas apropriadas. As propriedades do modelo são o nome do modelo e um PromptTemplate objeto, que contém um {Content} espaço reservado que o Foundry Local injeta no runtime com o prompt do usuário.

{
  "Name": "llama-3.2",
  "PromptTemplate": {
    "assistant": "{Content}",
    "prompt": "<|begin_of_text|><|start_header_id|>system<|end_header_id|>\n\nCutting Knowledge Date: December 2023\nToday Date: 26 Jul 2024\n\nYou are a helpful assistant.<|eot_id|><|start_header_id|>user<|end_header_id|>\n\n{Content}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
  }
}

Para criar o arquivo de modelo de chat, você pode usar o método apply_chat_template da biblioteca Hugging Face.

Observação

O exemplo a seguir usa a biblioteca Hugging Face do Python para criar um modelo de chat. A biblioteca Hugging Face é uma dependência para Olive, portanto, se você estiver usando o mesmo ambiente virtual do Python, não é necessário instalar. Se você estiver usando um ambiente diferente, instale a biblioteca com pip install transformers.

# generate_inference_model.py
# This script generates the inference_model.json file for the Llama-3.2 model.
import json
import os
from transformers import AutoTokenizer

model_path = "models/llama/llama-3.2"

tokenizer = AutoTokenizer.from_pretrained(model_path)
chat = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "{Content}"},
]


template = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)

json_template = {
  "Name": "llama-3.2",
  "PromptTemplate": {
    "assistant": "{Content}",
    "prompt": template
  }
}

json_file = os.path.join(model_path, "inference_model.json")

with open(json_file, "w") as f:
    json.dump(json_template, f, indent=2)

Execute o script usando:

python generate_inference_model.py

Executar o modelo

Você pode executar seu modelo compilado usando a CLI Local do Foundry, a API REST ou o SDK do Python OpenAI. Primeiro, altere o diretório de cache do modelo para o diretório de modelos que você criou na etapa anterior:

foundry cache cd models
foundry cache ls  # should show llama-3.2

Cuidado

Lembre-se de alterar o cache do modelo de volta para o diretório padrão quando terminar de executar:

foundry cache cd ./foundry/cache/models.

Usando a CLI Local do Foundry

foundry model run llama-3.2 --verbose

Usando o SDK do Python do OpenAI

O SDK do Python OpenAI é uma maneira conveniente de interagir com a API REST Local do Foundry. Você pode instalá-lo usando:

pip install openai
pip install foundry-local-sdk

Em seguida, você pode usar o seguinte código para executar o modelo:

import openai
from foundry_local import FoundryLocalManager

modelId = "llama-3.2"

# Create a FoundryLocalManager instance. This will start the Foundry 
# Local service if it is not already running and load the specified model.
manager = FoundryLocalManager(modelId)

# The remaining code us es the OpenAI Python SDK to interact with the local model.

# Configure the client to use the local Foundry service
client = openai.OpenAI(
    base_url=manager.endpoint,
    api_key=manager.api_key  # API key is not required for local usage
)

# Set the model to use and generate a streaming response
stream = client.chat.completions.create(
    model=manager.get_model_info(modelId).id,
    messages=[{"role": "user", "content": "What is the golden ratio?"}],
    stream=True
)

# Print the streaming response
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

Dica

Você pode usar qualquer idioma que dê suporte a solicitações HTTP. Para obter mais informações, leia o artigo SDKs de inferência integrada com o Foundry Local .

Finalizando

Depois de terminar de usar o modelo personalizado, você deverá redefinir o cache do modelo para o diretório padrão usando:

foundry cache cd ./foundry/cache/models

Próximas etapas