Modello personalizzato

Xinference offre un modo flessibile e completo per integrare, gestire e applicare modelli personalizzati.

Avvia il modello personalizzato direttamente senza registrazione.

A partire dalla versione v0.14.0, se la famiglia del modello che desideri registrare è supportata nativamente da Xinference, puoi avviarlo direttamente tramite il parametro model_path nell’interfaccia launch, evitando così la procedura di registrazione. Ora si consiglia vivamente di utilizzare questo metodo.

Ad esempio:

shellcURLPython

xinference launch --model-path <model_file_path> --model-engine <engine> -n qwen1.5-chat

L’esempio sopra mostra come avviare direttamente il modello qwen1.5-chat quando ho già i file del modello.

Per scenari distribuiti, posiziona il file del tuo modello su un worker, quindi utilizza i parametri worker_ip e model_path dell’interfaccia launch per ottenere un effetto di avvio diretto.

Nota

Per l’uso dell’interfaccia a riga di comando (CLI), si prega di utilizzare prioritariamente --model-path (forma mista maiuscola/minuscola separata da punto e virgola). --model_path è compatibile con le specifiche precedenti, ma non è raccomandato.

Definire un modello personalizzato

Web UI: analisi automatica della configurazione del modello linguistico di grandi dimensioni

Added in version v2.0.0.

Quando si registra un LLM personalizzato tramite l’interfaccia Web, Xinference può analizzare automaticamente la configurazione del modello e precompilare i campi chiave per te.

È necessario solo fornire:

• Percorso del modello / ID del modello (posizione del modello, percorso locale o ID del centro)

• Famiglia di modelli

Dopo l’analisi, l’interfaccia utente può popolare automaticamente i seguenti campi:

• lunghezza del contesto

• Modello di lingua

• Capacità del modello

• Specifiche del modello

Prima di salvare un modello personalizzato, puoi visualizzare e modificare questi campi.

Definisci un modello personalizzato basandoti sul seguente template:

LLMembeddingRerankimageaudioflexible

{
    "version": 2,
    "context_length": 32768,
    "model_name": "custom-qwen-2.5",
    "model_lang": [
        "en",
        "zh"
    ],
    "model_ability": [
        "generate"
    ],
    "model_description": "This is a custom model description.",
    "model_family": "my-custom-qwen-2.5",
    "model_specs": [
        {
            "model_format": "pytorch",
            "model_size_in_billions": "0_5",
            "quantization": "none",
            "model_id": null,
            "model_hub": "huggingface",
            "model_uri": "file:///path/to/models--Qwen--Qwen2.5-0.5B",
            "model_revision": null,
            "activated_size_in_billions": null
        }
    ],
    "chat_template": null,
    "stop_token_ids": null,
    "stop": null,
    "reasoning_start_tag": null,
    "reasoning_end_tag": null,
    "cache_config": null,
    "virtualenv": {
        "packages": [],
        "inherit_pip_config": true,
        "index_url": null,
        "extra_index_url": null,
        "find_links": null,
        "trusted_host": null,
        "no_build_isolation": null
    },
    "is_builtin": false
}

• model_name: Nome del modello. Il nome deve iniziare con una lettera o un numero e può contenere solo lettere, numeri, trattini bassi o trattini.

• context_length: un intero opzionale, la lunghezza massima del contesto supportata dal modello, inclusa la lunghezza di input e output. Se non definito, il valore predefinito è di 2048 token (circa 1.500 parole).

• dimensions: Un intero che definisce la dimensione del vettore di output del modello di embedding.

• max_tokens: un numero intero che definisce il numero massimo di token di input che il modello di embedding può elaborare in una singola richiesta.

• model_lang: una lista di stringhe che rappresenta le lingue supportate dal modello. Ad esempio: [“en”], indica che il modello supporta l’inglese.

• model_ability: Una lista di stringhe che definisce le capacità del modello. Può includere opzioni come “embed”, “generate” e “chat”. L’esempio indica che il modello ha la capacità di “generate”.

• model_family: una stringa necessaria che indica la famiglia di modelli da registrare. Il nome di questo parametro non deve entrare in conflitto con alcun nome di modello integrato.

• model_specs: un array di oggetti che definiscono le specifiche del modello. Queste specifiche includono:

  • model_format: una stringa che definisce il formato del modello, può essere “pytorch” o “ggufv2”.

• model_size_in_billions: un intero che definisce la quantità di parametri del modello, in miliardi.

• quantizations: Una lista di stringhe che definisce le modalità di quantizzazione del modello. Per i modelli PyTorch, può essere «4-bit», «8-bit» o «none». Per i modelli ggufv2, la modalità di quantizzazione deve corrispondere al valore in model_file_name_template. Alcuni motori supportano anche i formati fp4 / fp8 / bnb (per i dettagli sul supporto del backend, consultare Installazione ).

  • model_id: una stringa che rappresenta l’ID del modello, può essere l’ID del repository HuggingFace corrispondente al modello. Se il campo model_uri è mancante, Xinference cercherà di scaricare il modello dal repository Huggingface indicato da questo ID.

  • model_hub: una stringa opzionale che indica da dove scaricare il modello, ad esempio HuggingFace o modelscope.

  • model_uri: stringa che indica la posizione del file del modello, ad esempio directory locale: «file:///path/to/llama-2-7b». Quando model_format è ggufv2, questo campo deve essere il percorso specifico del file del modello. Mentre quando model_format è pytorch, questo campo deve essere una directory che contiene tutti i file del modello.

  • model_revision: una stringa che indica la versione specifica o l’hash di commit dei file del modello utilizzati dal repository.

• chat_template: Se model_ability contiene chat, allora questa opzione deve essere configurata per generare un prompt completo appropriato. Questa è una stringa template Jinja. Di solito è possibile trovarla nel file tokenizer_config.json della directory del modello.

• stop_token_ids: Se model_ability include chat, si consiglia di configurare questa opzione per controllare ragionevolmente l’arresto della conversazione. Si tratta di una lista di numeri interi; è possibile estrarre i valori corrispondenti dai file generation_config.json e tokenizer_config.json nella directory del modello.

• stop: se model_ability contiene chat, si consiglia di configurare questa opzione per controllare adeguatamente l’arresto della conversazione. Si tratta di una lista di stringhe; puoi trovare la stringa corrispondente al valore del token nel file tokenizer_config.json della directory del modello.

• reasoning_start_tag: un token o prompt speciale, utilizzato per indicare chiaramente al modello linguistico di grandi dimensioni il punto di partenza della catena di pensiero o del processo di ragionamento nella sua output.

• reasoning_end_tag: un token o prompt speciale, utilizzato per indicare esplicitamente al modello linguistico di grandi dimensioni il punto finale della catena di pensiero o del processo di ragionamento nel suo output.

• cache_config: una stringa che rappresenta il parametro per la memorizzazione e la gestione dei dati temporanei (cache) da parte del sistema.

• virtualenv: A settings object for model dependency isolation. Please refer to this document for details.

Registra un modello personalizzato.

Registrare un modello personalizzato tramite codice

import json
from xinference.client import Client

with open('model.json') as fd:
    model = fd.read()

# replace with real xinference endpoint
endpoint = 'http://localhost:9997'
client = Client(endpoint)
client.register_model(model_type="<model_type>", model=model, persist=False)

Tramite riga di comando

xinference register --model-type <model_type> --file model.json --persist

Assicurati di sostituire <model_type> nella parte seguente con LLM, embedding o rerank.

Elenco dei modelli incorporati e personalizzati

Ecco l’elenco in formato codice per modelli integrati e personalizzati:

registrations = client.list_model_registrations(model_type="<model_type>")

Tramite riga di comando

xinference registrations --model-type <model_type>

Avvia un modello personalizzato

Per avviare un modello personalizzato con il codice

uid = client.launch_model(model_name='custom-llama-2', model_format='pytorch')

Tramite riga di comando

xinference launch --model-name custom-llama-2 --model-format pytorch

Usare un modello personalizzato

Chiamata al modello tramite codice

model = client.get_model(model_uid=uid)
model.generate('What is the largest animal in the world?')

Il risultato è:

{
   "id":"cmpl-a4a9d9fc-7703-4a44-82af-fce9e3c0e52a",
   "object":"text_completion",
   "created":1692024624,
   "model":"43e1f69a-3ab0-11ee-8f69-fa163e74fa2d",
   "choices":[
      {
         "text":"\nWhat does an octopus look like?\nHow many human hours has an octopus been watching you for?",
         "index":0,
         "logprobs":"None",
         "finish_reason":"stop"
      }
   ],
   "usage":{
      "prompt_tokens":10,
      "completion_tokens":23,
      "total_tokens":33
   }
}

Oppure, tramite riga di comando, sostituisci ${UID} con l’UID effettivo del modello:

xinference generate --model-uid ${UID}

Annullamento del modello personalizzato

Disconnetti il modello personalizzato tramite codice.

model = client.unregister_model(model_type="<model_type>", model_name='custom-llama-2')

Tramite riga di comando

xinference unregister --model-type <model_type> --model-name custom-llama-2