Chat & Génération#

Apprenez à discuter avec un LLM dans Xinference.

Introduction#

Les modèles capables de chat ou de generate sont souvent appelés grands modèles de langage (LLM) ou modèles de génération de texte. Ces modèles sont conçus pour répondre sous forme de texte en fonction des entrées reçues, généralement appelées « prompts ». En général, il est possible de guider ces modèles pour accomplir des tâches en leur fournissant des instructions spécifiques ou des exemples concrets.

Les modèles capables de la fonction generate sont généralement de grands modèles de langage pré-entraînés. En revanche, les modèles dotés de la fonction chat sont des LLM (Language Model) affinés et alignés, optimisés pour les scénarios de dialogue. Dans la plupart des cas, les modèles se terminant par « chat » (par exemple llama-2-chat, qwen-chat, etc.) possèdent la fonction chat.

L’API Chat et l’API Generate offrent deux méthodes différentes d’interaction avec les LLMs :

API de Chat (similaire à l”API de complétion de chat d’OpenAI) permet des dialogues multi-tours.
L’API de génération (similaire à l”API Completions d’OpenAI) vous permet de générer du texte à partir d’une invite textuelle.

Capacité du modèle	Endpoint API	Point de terminaison compatible OpenAI
chat	Chat API	/v1/chat/completions
generate	Generate API	/v1/completions

Liste des modèles pris en charge#

Vous pouvez consulter toutes les capacités des modèles LLM intégrés dans Xinference.

Modèle de chat#

Chat API#

Essayez d’utiliser cURL, OpenAI Client ou le client Python de Xinference pour tester l’API Chat :

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/chat/completions' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "<MODEL_UID>",
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "What is the largest animal?"
        }
    ],
    "max_tokens": 512,
    "temperature": 0.7
  }'

import openai

client = openai.Client(
    api_key="cannot be empty",
    base_url="http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1"
)
client.chat.completions.create(
    model="<MODEL_UID>",
    messages=[
        {
            "content": "What is the largest animal?",
            "role": "user",
        }
    ],
    max_tokens=512,
    temperature=0.7
)

from xinference.client import RESTfulClient

client = RESTfulClient("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")
model = client.get_model("<MODEL_UID>")
messages = [{"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": "What is the largest animal?"}]
model.chat(
    messages,
    generate_config={
      "max_tokens": 512,
      "temperature": 0.7
    }
)

{
  "id": "chatcmpl-8d76b65a-bad0-42ef-912d-4a0533d90d61",
  "model": "<MODEL_UID>",
  "object": "chat.completion",
  "created": 1688919187,
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The largest animal that has been scientifically measured is the blue whale, which has a maximum length of around 23 meters (75 feet) for adult animals and can weigh up to 150,000 pounds (68,000 kg). However, it is important to note that this is just an estimate and that the largest animal known to science may be larger still. Some scientists believe that the largest animals may not have a clear \"size\" in the same way that humans do, as their size can vary depending on the environment and the stage of their life."
      },
      "finish_reason": "None"
    }
  ],
  "usage": {
    "prompt_tokens": -1,
    "completion_tokens": -1,
    "total_tokens": -1
  }
}

Vous pouvez trouver plus d’exemples de l’API Chat dans le carnet de tutoriel.

Gradio Chat

Exemple d’apprentissage de l’utilisation de l’API Chat de Xinference et du client Python.

https://github.com/xorbitsai/inference/blob/main/examples/gradio_chatinterface.py

Modèle de réflexion hybride#

Certains grands modèles de langage sont étiquetés comme hybrides, avec la possibilité de choisir d’activer ou non le mode réflexion.

Ajouté dans la version v1.17.0: Le commutateur enable_thinking au niveau de la requête est pris en charge dans la v1.17.0.

Xinference fournit un interrupteur enable_thinking au niveau de la requête, qui s’applique à différents modèles de templates (par exemple, Qwen utilise enable_thinking, tandis que certains templates DeepSeek utilisent thinking).

Exemple d’utilisation :

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/chat/completions' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "<MODEL_UID>",
    "messages": [
        {"role": "user", "content": "What is the largest animal?"}
    ],
    "enable_thinking": false
  }'

import openai

client = openai.Client(
    api_key="cannot be empty",
    base_url="http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1"
)
client.chat.completions.create(
    model="<MODEL_UID>",
    messages=[
        {"role": "user", "content": "What is the largest animal?"}
    ],
    extra_body={"enable_thinking": False}
)

from xinference.client import RESTfulClient

client = RESTfulClient("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")
model = client.get_model("<MODEL_UID>")
model.chat(
    [{"role": "user", "content": "What is the largest animal?"}],
    enable_thinking=False,
)

model.chat(
    [{"role": "user", "content": "What is the largest animal?"}],
    generate_config={"chat_template_kwargs": {"enable_thinking": False}},
)

Modèle génératif#

Generate API#

Generate API reproduit l”API Completions d’OpenAI.

La principale différence entre l’API Generate et l’API Chat réside dans le format d’entrée. L’API Chat accepte une liste de messages en entrée, tandis que l’API Generate accepte une chaîne de texte libre appelée prompt en entrée.

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/completions' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "<MODEL_UID>",
    "prompt": "What is the largest animal?",
    "max_tokens": 512,
    "temperature": 0.7
  }'

import openai

client = openai.Client(api_key="cannot be empty", base_url="http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1")
client.chat.completions.create(
    model=("<MODEL_UID>",
    messages=[
        {"role": "user", "content": "What is the largest animal?"}
    ],
    max_tokens=512,
    temperature=0.7
)

from xinference.client import RESTfulClient

client = RESTfulClient("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")
model = client.get_model("<MODEL_UID>")
print(model.generate(
    prompt="What is the largest animal?",
    generate_config={
      "max_tokens": 512,
      "temperature": 0.7
    }
))

{
  "id": "cmpl-8d76b65a-bad0-42ef-912d-4a0533d90d61",
  "model": "<MODEL_UID>",
  "object": "text_completion",
  "created": 1688919187,
  "choices": [
    {
      "index": 0,
      "text": "The largest animal that has been scientifically measured is the blue whale, which has a maximum length of around 23 meters (75 feet) for adult animals and can weigh up to 150,000 pounds (68,000 kg). However, it is important to note that this is just an estimate and that the largest animal known to science may be larger still. Some scientists believe that the largest animals may not have a clear \"size\" in the same way that humans do, as their size can vary depending on the environment and the stage of their life.",
      "finish_reason": "None"
    }
  ],
  "usage": {
    "prompt_tokens": -1,
    "completion_tokens": -1,
    "total_tokens": -1
  }
}

FAQ#

Xinference fournit-il des méthodes d’intégration avec LangChain ou LlamaIndex pour son LLM ?#

Oui, vous pouvez vous référer aux sections correspondantes de la documentation officielle Xinference pour chacun d’eux. Voici les liens :