Modelo personalizado

Xinference ofrece una forma flexible y completa de integrar, gestionar y utilizar modelos personalizados.

Iniciar un modelo personalizado sin necesidad de registro.

A partir de la versión v0.14.0, si la familia del modelo que necesitas registrar es compatible de forma nativa con Xinference, puedes iniciarlo directamente a través del parámetro model_path en la interfaz launch, evitando así la molestia del paso de registro. Ahora se recomienda encarecidamente usar este método.

Por ejemplo:

shellcURLPython

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

El ejemplo anterior muestra cómo lanzar directamente el modelo qwen1.5-chat cuando ya tengo sus archivos.

Para escenarios distribuidos, coloca tu archivo de modelo en algún worker, y luego utiliza los parámetros worker_ip y model_path de la interfaz launch para lograr el efecto de inicio directo.

Nota

Para el uso de la interfaz de línea de comandos (CLI), priorice el uso de --model-path (en formato mixto mayúsculas/minúsculas separado por punto y coma). --model_path es compatible con versiones anteriores, pero no se recomienda su uso.

Define un modelo personalizado.

Web UI: análisis automático de configuraciones de modelos de lenguaje grandes

Added in version v2.0.0.

Al registrar un LLM personalizado a través de la interfaz web, Xinference puede analizar automáticamente la configuración del modelo y rellenar previamente los campos clave para usted.

Solo necesita proporcionar:

• Ruta del modelo / ID del modelo (ubicación del modelo, ruta local o ID central)

• Familia de modelos

Después del análisis, la interfaz de usuario puede completar automáticamente los siguientes campos:

• Tamaño del contexto

• modelo de lenguaje

• Capacidad del modelo

• Especificaciones del modelo

Antes de guardar un modelo personalizado, puede ver y editar estos campos.

Define un modelo personalizado basado en la siguiente plantilla:

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: Nombre del modelo. El nombre debe comenzar con una letra o un número y solo puede contener letras, números, guiones bajos o guiones.

• context_length: un entero opcional, la longitud máxima de contexto que soporta el modelo, incluyendo la longitud de entrada y salida. Si no se define, el valor predeterminado es de 2048 tokens (aproximadamente 1,500 palabras).

• dimensions: un entero que define el tamaño del vector de salida del modelo de incrustación.

• max_tokens: un número entero que define la cantidad máxima de tokens de entrada que el modelo de incrustación puede procesar en una sola solicitud.

• model_lang: una lista de cadenas que indica los idiomas compatibles con el modelo. Por ejemplo: [“en”], significa que el modelo admite inglés.

• model_ability: Una lista de cadenas que define las capacidades del modelo. Puede incluir opciones como “embed”, “generate” y “chat”. El ejemplo indica que el modelo tiene la capacidad de “generate”.

• model_family: una cadena necesaria que indica la familia de modelos a registrar. El nombre de este parámetro no debe entrar en conflicto con ningún nombre de modelo incorporado.

• model_specs: un arreglo de objetos que definen las especificaciones del modelo. Estas especificaciones incluyen:

  • model_format: una cadena que define el formato del modelo, puede ser “pytorch” o “ggufv2”.

• model_size_in_billions: un entero que define la cantidad de parámetros del modelo, en miles de millones.

• quantizations: Una lista de cadenas que define los métodos de cuantificación del modelo. Para modelos PyTorch, puede ser «4-bit», «8-bit» o «none». Para modelos ggufv2, el método de cuantificación debe corresponder al valor en model_file_name_template. Algunos motores también admiten los formatos fp4 / fp8 / bnb (consulte Instalación para más detalles sobre la compatibilidad del backend).

  • model_id: Cadena que representa el id del modelo, puede ser el id del repositorio de HuggingFace correspondiente a este modelo. Si falta el campo model_uri, Xinference intentará descargar el modelo desde el repositorio de HuggingFace indicado por este id.

  • model_hub: una cadena opcional que indica desde dónde descargar el modelo, por ejemplo HuggingFace o modelscope.

  • model_uri: cadena que indica la ubicación del archivo del modelo, por ejemplo, un directorio local: «file:///path/to/llama-2-7b». Cuando model_format es ggufv2, este campo debe ser la ruta específica del archivo del modelo. Y cuando model_format es pytorch, este campo debe ser un directorio que contenga todos los archivos del modelo.

  • model_revision: una cadena que representa la versión específica o el hash de confirmación de los archivos del modelo utilizados desde el repositorio.

• chat_template: Si model_ability contiene chat, entonces esta opción debe configurarse para generar un prompt completo adecuado. Se trata de una cadena de plantilla Jinja. Normalmente, puedes encontrarla en el archivo tokenizer_config.json del directorio del modelo.

• stop_token_ids: Si model_ability contiene chat, se recomienda configurar esta opción para controlar adecuadamente la detención de la conversación. Es una lista que contiene números enteros; puedes extraer los valores correspondientes de los archivos generation_config.json y tokenizer_config.json en el directorio del modelo.

• stop: Si model_ability contiene chat, se recomienda configurar esta opción para controlar adecuadamente la detención del diálogo. Esta es una lista que contiene cadenas de texto, y puedes encontrar la cadena correspondiente al valor del token en el archivo tokenizer_config.json del directorio del modelo.

• reasoning_start_tag: un token o prompt especial que se utiliza para indicar explícitamente al modelo de lenguaje grande el punto de inicio de la cadena de pensamiento o proceso de razonamiento en su salida.

• reasoning_end_tag: un token o prompt especial que se utiliza para indicar claramente el punto final de la cadena de pensamiento o proceso de razonamiento en la salida del modelo de lenguaje grande.

• cache_config: una cadena que representa los parámetros del sistema para almacenar y gestionar datos temporales (caché).

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

Registrar un modelo personalizado

Registrar un modelo personalizado mediante código.

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)

Modo de línea de comandos

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

Reemplaza <model_type> por LLM, embedding o rerank en la siguiente parte.

Enumera los modelos integrados y personalizados.

enumere los modelos integrados y personalizados de manera similar al código

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

Modo de línea de comandos

xinference registrations --model-type <model_type>

Iniciar modelo personalizado

Iniciar un modelo personalizado con código.

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

Modo de línea de comandos

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

Usar un modelo personalizado

Llamar al modelo mediante código

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

El resultado es:

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

O bien desde la línea de comandos, reemplaza ${UID} con el UID real del modelo:

xinference generate --model-uid ${UID}

Cancelar modelo personalizado

Cerrar sesión del modelo personalizado mediante código.

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

Modo de línea de comandos

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