Eigenes Modell

Xinference bietet eine flexible und umfassende Möglichkeit, benutzerdefinierte Modelle zu integrieren, zu verwalten und anzuwenden.

Starten Sie ein benutzerdefiniertes Modell direkt ohne Registrierung.

Ab der Version v0.14.0 kannst du, wenn die Familie des zu registrierenden Modells von Xinference nativ unterstützt wird, dieses direkt über den model_path-Parameter der Launch-Schnittstelle starten, was den Registrierungsschritt überflüssig macht. Diese Methode wird jetzt sehr empfohlen.

Beispiel:

shellcURLPython

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

Das obige Beispiel zeigt, wie ich das Modell qwen1.5-chat direkt starten kann, wenn ich bereits die Modelldateien besitze.

Für verteilte Szenarien platzieren Sie Ihre Modelldatei auf einem bestimmten Worker und verwenden Sie dann die Parameter worker_ip und model_path der Launch-Schnittstelle, um einen direkten Launch-Effekt zu erzielen.

Bemerkung

Nutzen Sie für die Befehlszeilenschnittstelle (CLI) vorrangig --model-path (durch Semikolon getrennte, gemischte Schreibweise). --model_path ist aus Kompatibilitätsgründen mit älteren Spezifikationen weiterhin verfügbar, wird jedoch nicht empfohlen.

Definiere ein benutzerdefiniertes Modell

Web UI: Automatische Analyse der Konfiguration großer Sprachmodelle

Added in version v2.0.0.

Bei der Registrierung eines benutzerdefinierten LLM über die Web-Benutzeroberfläche kann Xinference die Modellkonfiguration automatisch analysieren und die wichtigsten Felder für Sie vorausfüllen.

Sie benötigen nur:

• Modellpfad/Modell-ID (Speicherort des Modells, lokaler Pfad oder Hub-ID)

• Modellfamilie

Nach der Analyse kann die Benutzeroberfläche die folgenden Felder automatisch ausfüllen:

• Kontextlänge

• Modellsprache

• Modellfähigkeiten

• Modellspezifikationen

Vor dem Speichern des benutzerdefinierten Modells können Sie diese Felder anzeigen und bearbeiten.

Definieren Sie ein benutzerdefiniertes Modell basierend auf der folgenden Vorlage:

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: Der Modellname. Der Name muss mit einem Buchstaben oder einer Ziffer beginnen und darf nur Buchstaben, Ziffern, Unterstriche oder Bindestriche enthalten.

• context_length: Eine optionale Ganzzahl, die die maximale Kontextlänge angibt, die das Modell unterstützt, einschließlich der Länge von Eingabe und Ausgabe. Falls nicht definiert, beträgt der Standardwert 2048 Token (etwa 1.500 Wörter).

• dimensions: Eine ganze Zahl, die die Vektorgröße der Ausgabe des Einbettungsmodells definiert.

• max_tokens: Eine ganze Zahl, die die maximale Anzahl von Eingabe-Token definiert, die das Einbettungsmodell in einer einzelnen Anfrage verarbeiten kann.

• model_lang: Eine Liste von Zeichenketten, die die vom Modell unterstützten Sprachen angeben. Beispiel: [‚en‘] bedeutet, dass das Modell Englisch unterstützt.

• model_ability: Eine Liste von Zeichenketten, die die Fähigkeiten des Modells definiert. Sie kann Optionen wie ‚embed‘, ‚generate‘ und ‚chat‘ enthalten. Das Beispiel zeigt, dass das Modell die Fähigkeit ‚generate‘ besitzt.

• model_family: Ein erforderlicher String, der die zu registrierende Modellfamilie angibt. Der Parameter darf nicht mit dem Namen eines integrierten Modells in Konflikt stehen.

• model_specs: Ein Array von Objekten, das die Modellspezifikationen definiert. Diese Spezifikationen umfassen:

  • model_format: Ein String, der das Modellformat definiert, kann ‚pytorch‘ oder ‚ggufv2‘ sein.

• model_size_in_billions: Eine ganze Zahl, die die Anzahl der Parameter des Modells in Milliarden definiert.

• quantizations: Eine Liste von Zeichenfolgen, die die Quantisierungsmethode des Modells definieren. Für PyTorch-Modelle kann dies „4-bit“, „8-bit“ oder „none“ sein. Für ggufv2-Modelle sollte die Quantisierungsmethode dem Wert in model_file_name_template entsprechen. Einige Engines unterstützen auch die Formate fp4 / fp8 / bnb (Details zur Backend-Unterstützung finden Sie unter Installation).

  • model_id: Ein String, der die Modell-ID darstellt. Es kann sich um die HuggingFace-Repository-ID des entsprechenden Modells handeln. Wenn das Feld model_uri fehlt, versucht Xinference, das Modell von dem durch diese ID angegebenen HuggingFace-Repository herunterzuladen.

  • model_hub: Ein optionaler String, der angibt, von wo das Modell heruntergeladen werden soll, z. B. HuggingFace oder modelscope.

  • model_uri: Eine Zeichenfolge, die den Speicherort der Modelldatei angibt, z. B. ein lokales Verzeichnis: „file:///path/to/llama-2-7b“. Wenn model_format auf ggufv2 gesetzt ist, muss dieses Feld der genaue Pfad zur Modelldatei sein. Wenn model_format dagegen auf pytorch gesetzt ist, muss dieses Feld ein Verzeichnis sein, das alle Modelldateien enthält.

  • model_revision: Ein String, der die spezifische Version oder den Commit-Hash des Modells aus dem Repository angibt.

• chat_template: Falls model_ability chat enthält, muss diese Option konfiguriert werden, um geeignete vollständige Eingabeaufforderungen zu generieren. Dies ist ein Jinja-Vorlagen-String. Normalerweise findest du diesen im tokenizer_config.json-Datei des Modellverzeichnisses.

• stop_token_ids: Falls model_ability den Wert chat enthält, wird empfohlen, diese Option zu konfigurieren, um das Ende des Dialogs angemessen zu steuern. Dies ist eine Liste mit Ganzzahlen, deren entsprechende Werte Sie in den Dateien generation_config.json und tokenizer_config.json im Modellverzeichnis extrahieren können.

• stop：Falls model_ability den Wert chat enthält, wird empfohlen, diese Option zu konfigurieren, um das Gespräch angemessen zu stoppen. Dies ist eine Liste mit Zeichenketten; Sie finden die Zeichenkette, die dem Token-Wert entspricht, in der Datei tokenizer_config.json des Modellverzeichnisses.

• reasoning_start_tag: Ein spezielles Token oder Prompt, das verwendet wird, um das große Sprachmodell explizit auf den Startpunkt der Gedankenkette oder des Denkprozesses in seiner Ausgabe hinzuweisen.

• reasoning_end_tag: Ein spezieller Token oder Prompt, der das Ende einer Gedankenkette oder eines Reasoning-Prozesses in der Ausgabe des Large Language Models eindeutig kennzeichnet.

• cache_config: Ein String, der die Parameter des Systems zur Speicherung und Verwaltung temporärer Daten (Cache) darstellt.

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

Registrieren Sie ein benutzerdefiniertes Modell.

Registrieren eines benutzerdefinierten Modells im Code

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)

Als Befehlszeile

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

Achten Sie darauf, den Teil <model_type> durch LLM, embedding oder rerank zu ersetzen.

Aufzählung integrierter und benutzerdefinierter Modelle

Hier ist der Code, der integrierte und benutzerdefinierte Modelle auflistet:

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

Als Befehlszeile

xinference registrations --model-type <model_type>

Starten des benutzerdefinierten Modells

Starten eines benutzerdefinierten Modells im Code-Modus

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

Als Befehlszeile

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

Verwendung eines benutzerdefinierten Modells

Rufen Sie das Modell programmatisch auf.

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

Ergebnis ist:

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

Oder über die Befehlszeile, indem Sie ${UID} durch die tatsächliche Modell-UID ersetzen:

xinference generate --model-uid ${UID}

Löschen eines benutzerdefinierten Modells

Abmelden eines benutzerdefinierten Modells mittels Code

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

Als Befehlszeile

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