Modelo personalizado

Xinference oferece uma maneira flexível e abrangente de integrar, gerenciar e aplicar modelos personalizados.

Inicie o modelo personalizado sem necessidade de registro.

A partir da versão v0.14.0, se a família do modelo que você precisa registrar for compatível nativamente com o Xinference, você pode iniciá-lo diretamente através do parâmetro model_path na interface launch, eliminando a necessidade da etapa de registro. Agora, essa abordagem é altamente recomendada.

Por exemplo:

shellcURLPython

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

O exemplo acima mostra como fazer o launch diretamente quando já tenho o arquivo do modelo qwen1.5-chat.

Para cenários distribuídos, coloque seu arquivo de modelo em algum worker e, em seguida, utilize os parâmetros worker_ip e model_path da interface launch para obter o efeito de um lançamento direto.

Nota

Para uso da interface de linha de comando (CLI), priorize o uso de --model-path (formato misto de maiúsculas e minúsculas separado por ponto e vírgula). O --model_path é compatível com especificações antigas, mas não é recomendado.

Definir um modelo personalizado

Interface Web: Analisar automaticamente a configuração do modelo de linguagem grande

Adicionado na versão v2.0.0.

Ao registrar um LLM personalizado através da Web UI, o Xinference pode analisar automaticamente a configuração do modelo e preencher previamente os campos chave para você.

Você só precisa fornecer:

• Caminho do modelo/ID do modelo (Localização do modelo, caminho local ou ID do hub)

• Família de Modelos

Após a análise, a interface do usuário pode preencher automaticamente os seguintes campos:

• contexto de tamanho

• model language

• Capacidades do Modelo

• “Especificações do modelo”

Antes de salvar o modelo personalizado, você pode visualizar e editar esses campos.

Defina um modelo personalizado com base no seguinte 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 do modelo. O nome deve começar com uma letra ou número e pode conter apenas letras, números, sublinhados ou hífens.

• context_length: um inteiro opcional, o comprimento máximo de contexto suportado pelo modelo, incluindo o comprimento de entrada e saída. Se não definido, o valor padrão é de 2048 tokens (aproximadamente 1.500 palavras).

• dimensions: um inteiro usado para definir o tamanho do vetor de saída do modelo de incorporação.

• max_tokens: um inteiro que define o número máximo de tokens de entrada que o modelo de embedding pode processar em uma única solicitação.

• model_lang: Uma lista de strings que representa os idiomas suportados pelo modelo. Por exemplo: [‘en’], indica que o modelo suporta o inglês.

• model_ability: uma lista de strings que define as capacidades do modelo. Pode incluir opções como ‘embed’, ‘generate’ e ‘chat’. O exemplo indica que o modelo possui a capacidade ‘generate’.

• model_family: Uma string obrigatória que indica a família de modelos a ser registrada. O nome deste parâmetro não pode conflitar com nenhum nome de modelo interno.

• model_specs: um array de objetos contendo as especificações que definem o modelo. Estas especificações incluem:

  • model_format: uma string que define o formato do modelo, pode ser ‘pytorch’ ou ‘ggufv2’.

• model_size_in_billions: um número inteiro que define a quantidade de parâmetros do modelo, em bilhões.

• quantizations: uma lista de strings que define o método de quantização do modelo. Para modelos PyTorch, pode ser “4-bit”, “8-bit” ou “none”. Para modelos ggufv2, o método de quantização deve corresponder ao valor em model_file_name_template. Alguns mecanismos também suportam os formatos fp4 / fp8 / bnb (para mais detalhes sobre suporte de back-end, consulte Instalação ).

  • model_id: uma string que representa o ID do modelo, podendo ser o ID do repositório HuggingFace correspondente a esse modelo. Se o campo model_uri estiver ausente, o Xinference tentará baixar o modelo a partir do repositório HuggingFace indicado por esse ID.

  • model_hub: uma string opcional que indica de onde baixar o modelo, como HuggingFace ou modelscope.

  • model_uri: Uma string que indica a localização do arquivo do modelo, por exemplo, diretório local: “file:///path/to/llama-2-7b”. Quando o model_format for ggufv2, este campo deve ser o caminho específico do arquivo do modelo. E quando o model_format for pytorch, este campo deve ser um diretório contendo todos os arquivos do modelo.

  • model_revision: uma string que representa a versão específica ou hash de commit dos arquivos de modelo usados a partir do repositório.

• chat_template: Se model_ability contiver chat, esta opção deve ser configurada para gerar um prompt completo adequado. Esta é uma string de modelo Jinja. Normalmente, você pode encontrá-la no arquivo tokenizer_config.json do diretório do modelo.

• stop_token_ids: Se model_ability incluir chat, é recomendável configurar esta opção para controlar adequadamente a interrupção da conversa. Esta é uma lista de inteiros, e você pode extrair os valores correspondentes dos arquivos generation_config.json e tokenizer_config.json no diretório do modelo.

• stop: Se model_ability contiver chat, recomenda-se configurar esta opção para controlar adequadamente a interrupção da conversa. Esta é uma lista contendo strings, e você pode encontrar a string correspondente ao valor do token no arquivo tokenizer_config.json do diretório do modelo.

• reasoning_start_tag: Um token ou prompt especial usado para indicar explicitamente o ponto de partida da cadeia de pensamento ou do processo de raciocínio na saída do modelo de linguagem grande.

• reasoning_end_tag: Um token ou prompt especial usado para indicar explicitamente ao modelo de linguagem de grande porte o ponto final da cadeia de pensamento ou do processo de raciocínio em sua saída.

• cache_config: uma string que representa os parâmetros do sistema para armazenar e gerenciar dados temporários (cache).

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

Registrar um modelo personalizado

Registre um modelo personalizado por meio de 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)

No input text was provided.

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

Substitua <model_type> pela parte correspondente por LLM, embedding ou rerank.

Enumere modelos embutidos e personalizados

`markdown - Modelo interno: `ResNet-50` - Modelo personalizado: `CustomNet_v1` `

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

No input text was provided.

xinference registrations --model-type <model_type>

Iniciar modelo personalizado

Iniciar modelo personalizado através de código

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

No input text was provided.

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

Usando modelo personalizado

Chamar o modelo via código

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

O resultado é:

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

Ou, via linha de comando, substitua ${UID} pelo UID real do modelo:

xinference generate --model-uid ${UID}

Cancelar modelo personalizado

Revogar o modelo personalizado por meio de código.

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

No input text was provided.

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