Dela via

Kompilera Hugging Face-modeller som ska köras på Foundry Local

Viktigt!

  • Foundry Local är tillgängligt i förhandsversionen. Offentliga förhandsversioner ger tidig åtkomst till funktioner som är i aktiv distribution.
  • Funktioner, metoder och processer kan ändra eller ha begränsade funktioner, före allmän tillgänglighet (GA).

Foundry Local kör ONNX-modeller på enheten med höga prestanda. Även om modellkatalogen erbjuder färdiga förkompilerade alternativ kan du använda valfri modell i ONNX-format .

Om du vill kompilera befintliga modeller i Safetensor- eller PyTorch-format till ONNX-format kan du använda Olive. Olive är ett verktyg som optimerar modeller till ONNX-format, vilket gör dem lämpliga för distribution i Foundry Local. Den använder tekniker som kvantisering och grafoptimering för att förbättra prestanda.

Den här guiden visar hur du:

  • Konvertera och optimera modeller från Hugging Face för att köras i Foundry Local. Du använder Llama-3.2-1B-Instruct modellen som exempel, men du kan använda valfri generativ AI-modell från Hugging Face.
  • Kör dina optimerade modeller med Foundry Local

Förutsättningar

  • Python 3.10 eller senare

Installera Olive

Olive är ett verktyg som optimerar modeller till ONNX-format.

pip install olive-ai[auto-opt]

Tips/Råd

För bästa resultat installerar du Olive i en virtuell miljö med venv eller conda.

Logga in på Hugging Face

Du optimerar modellen Llama-3.2-1B-Instruct, vilket kräver autentisering med Hugging Face.

huggingface-cli login

Anmärkning

Du måste först skapa en Hugging Face-token och begära modellåtkomst innan du fortsätter.

Kompilera modellen

Steg 1: Kör kommandot Olive auto-opt

Använd kommandot Olive auto-opt för att ladda ned, konvertera, kvantifiera och optimera modellen:

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

Anmärkning

Kompileringsprocessen tar cirka 60 sekunder, plus extra tid för modellnedladdning.

Kommandot använder följande parametrar:

Parameter Beskrivning
model_name_or_path Modellkälla: Hugging Face ID, lokal sökväg eller Azure AI Model registry ID
output_path Var du kan spara den optimerade modellen
device Målmaskinvara: cpu, gpu, eller npu
provider Exekveringsleverantör (till exempel CPUExecutionProvider, CUDAExecutionProvider)
precision Modellprecision: fp16, fp32, int4eller int8
use_ort_genai Skapar inferenskonfigurationsfiler

Tips/Råd

Om du har en lokal kopia av modellen kan du använda en lokal sökväg i stället för Hugging Face ID. Till exempel --model_name_or_path models/llama-3.2-1B-Instruct. Olive hanterar konverteringen, optimeringen och kvantiseringen automatiskt.

Steg 2: Byt namn på utdatamodellen

Olive placerar filer i en allmän model katalog. Byt namn på den så att den blir enklare att använda:

cd models/llama
mv model llama-3.2

Steg 3: Skapa chattmallfil

En chattmall är ett strukturerat format som definierar hur indata- och utdatameddelanden bearbetas för en konversations-AI-modell. Den anger rollerna (till exempel system, användare, assistent) och konversationens struktur, vilket säkerställer att modellen förstår kontexten och genererar lämpliga svar.

Foundry Local kräver en JSON-fil för chattmallen som anropas inference_model.json för att generera lämpliga svar. Mallegenskaperna är modellnamnet och ett PromptTemplate objekt, som innehåller en {Content} platshållare som Foundry Local matar in vid körning med användarprompten.

{
  "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"
  }
}

Om du vill skapa chattmallfilen kan du använda apply_chat_template metoden från biblioteket Hugging Face:

Anmärkning

I följande exempel används Python Hugging Face-biblioteket för att skapa en chattmall. Biblioteket Hugging Face är ett beroende för Olive, så om du använder samma virtuella Python-miljö behöver du inte installera. Om du använder en annan miljö installerar du biblioteket med 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)

Kör skriptet med:

python generate_inference_model.py

Kör modellen

Du kan köra din kompilerade modell med hjälp av Foundry Local CLI, REST API eller OpenAI Python SDK. Ändra först katalogen för modellcache till den modellkatalog som du skapade i föregående steg:

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

Försiktighet

Kom ihåg att ändra modellcachen tillbaka till standardkatalogen när du är klar genom att köra:

foundry cache cd ./foundry/cache/models.

Använda det lokala gjuteri-CLI:et

foundry model run llama-3.2 --verbose

Använda OpenAI Python SDK

OpenAI Python SDK är ett bekvämt sätt att interagera med Foundry Local REST API. Du kan installera den med hjälp av:

pip install openai
pip install foundry-local-sdk

Sedan kan du använda följande kod för att köra modellen:

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)

Tips/Råd

Du kan använda valfritt språk som stöder HTTP-begäranden. Mer information finns i artikeln Integrerad slutsatsdragnings-SDK:er med Foundry Local .

Slutför

När du är klar med den anpassade modellen bör du återställa modellcachen till standardkatalogen med hjälp av:

foundry cache cd ./foundry/cache/models

Nästa steg