Qwen3 déployer affiner évaluer Model Gallery PAI SGLang vLLM - Platform For AI

Qwen3 est la dernière série de grands modèles de langage proposée par l'équipe Qwen d'Alibaba Cloud. Elle comprend deux modèles MoE et six modèles denses, avec des améliorations en matière de raisonnement, de suivi des instructions, d'agents et de capacités multilingues. PAI-Model Gallery propose l'ensemble des 22 modèles, y compris les versions Base et FP8. Cette rubrique utilise le modèle Qwen3-235B-A22B comme exemple pour illustrer le déploiement, l'invocation, l'affinement et l'évaluation des modèles de cette série dans Model Gallery.

Déployer et invoquer un modèle

Déployer un modèle

Cet exemple déploie le modèle Qwen3-235B-A22B avec SGLang.

Accédez à la page Model Gallery.
1. Connectez-vous à la console PAI et sélectionnez une région dans le coin supérieur gauche. Changez de région pour trouver des ressources de calcul disponibles.
2. Dans le volet de navigation de gauche, choisissez Workspaces et cliquez sur le nom de l'espace de travail cible pour l'ouvrir.
3. Dans le volet de navigation de gauche, choisissez QuickStart > Model Gallery.
Dans la liste des modèles située à droite de la page Model Gallery, cliquez sur la carte du modèle Qwen3-235B-A22B pour ouvrir la page des détails du modèle.
Dans le coin supérieur droit, cliquez sur Deploy. Configurez les paramètres suivants et conservez les valeurs par défaut pour les autres afin de déployer le modèle sur la plateforme de service d'inférence EAS.
- Deployment Method: Définissez Inference Engine sur SGLang et Deployment Template sur Single-Node.
- Resource Information : Pour Resource Type, sélectionnez les ressources publiques. Le système recommande un type d'instance approprié. Pour la configuration minimale de chaque modèle, consultez la section Annexe : Ressources de calcul et limites de tokens.
  Important
  Si aucune spécification d'instance n'est disponible, cela signifie que les ressources publiques de cette région sont en rupture de stock. Envisagez les options suivantes :
  - Changer de région. La région Chine (Ulanqab) propose davantage de ressources Lingjun préemptibles (ml.gu7ef.8xlarge-gu100, ml.gu7xf.8xlarge-gu108, ml.gu8xf.8xlarge-gu108, ml.gu8tf.8.40xlarge). Les ressources préemptibles pouvant être récupérées, définissez votre enchère avec soin.
  - Utiliser un groupe de ressources EAS. Accédez à la page d'abonnement aux ressources dédiées EAS pour acheter des ressources dédiées EAS.

Déboguer en ligne

En bas de la page Service details, cliquez sur le débogage en ligne. La figure suivante illustre un exemple.

Invoquer l'API

Obtenez le point de terminaison du service et le jeton.
1. Dans Model Gallery > Job Management > Deployment Jobs, cliquez sur le nom du service déployé pour ouvrir la page des détails du service.
2. Cliquez sur View Call Information pour obtenir le point de terminaison Internet et le jeton.

Exemple d'appel à l'API de discussion /v1/chat/completions pour un service déployé avec SGLang.

curl

curl -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: <EAS_TOKEN>" \
    -d '{
        "model": "<model_name, obtained from the /v1/models API>",
        "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "hello!"
        }
        ]
    }' \
    <EAS_ENDPOINT>/v1/chat/completions

Python

from openai import OpenAI

##### API configuration #####
# Replace <EAS_ENDPOINT> with the service endpoint and <EAS_TOKEN> with the service token.
openai_api_key = "<EAS_TOKEN>"
openai_api_base = "<EAS_ENDPOINT>/v1"

client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)

models = client.models.list()
model = models.data[0].id
print(model)

stream = True
chat_completion = client.chat.completions.create(
    messages=[
        {"role": "user", "content": "Hello, could you please introduce yourself"}
    ],
    model=model,
    max_completion_tokens=2048,
    stream=stream,
)

if stream:
    for chunk in chat_completion:
        print(chunk.choices[0].delta.content, end="")
else:
    result = chat_completion.choices[0].message.content
    print(result)

Remplacez <EAS_ENDPOINT> par le point de terminaison du service et <EAS_TOKEN> par le jeton du service.

Les méthodes d'invocation varient selon la méthode de déploiement. Pour plus de méthodes d'invocation, consultez la rubrique Invoquer une API pour un service LLM déployé.

Intégration tierce

Pour vous connecter à Chatbox, Dify ou Cherry Studio, consultez la rubrique Intégrer des clients tiers.

Configuration avancée

Modifiez la configuration JSON du service pour activer des fonctionnalités avancées, telles que l'ajustement de la limite de tokens et l'activation de l'appel d'outils (Function Calling).

Procédure : Sur la page de déploiement, modifiez le code JSON dans la section Service Configuration. Si le service est déjà déployé, mettez-le à jour pour accéder à la page de déploiement.

Modifier la limite de tokens

Les modèles Qwen3 prennent nativement en charge 32 768 tokens. La mise à l'échelle RoPE étend cette limite à 131 072, bien que les performances puissent légèrement se dégrader. Modifiez le champ containers.script dans le fichier JSON de configuration du service :

vLLM :

vllm serve ... --rope-scaling '{"rope_type":"yarn","factor":4.0,"original_max_position_embeddings":32768}' --max-model-len 131072

SGLang :

python -m sglang.launch_server ... --json-model-override-args '{"rope_scaling":{"rope_type":"yarn","factor":4.0,"original_max_position_embeddings":32768}}'

Analyser les appels d'outils

vLLM et SGLang peuvent analyser le contenu des appels d'outils générés par le modèle en messages structurés. Modifiez le champ containers.script dans le fichier JSON de configuration du service :

vLLM :

vllm serve ... --enable-auto-tool-choice --tool-call-parser hermes

SGLang :

python -m sglang.launch_server ... --tool-call-parser qwen25

Contrôler le mode de réflexion

Qwen3 utilise le mode de réflexion par défaut. Un commutateur matériel désactive entièrement la réflexion ; un commutateur logiciel permet au modèle de suivre vos instructions concernant l'activation ou non de la réflexion.

Utiliser le commutateur logiciel/no_think

L'exemple suivant montre le corps de la requête :

{
  "model": "<MODEL_NAME>",
  "messages": [
    {
      "role": "user",
      "content": "/no_think Hello!"
    }
  ],
  "max_tokens": 1024
}

Commutateur matériel

Contrôle via les paramètres de l'API (vLLM et SGLang): Ajoutez le paramètre chat_template_kwargs à l'appel API. Exemple :

curl

curl -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: <EAS_TOKEN>" \
    -d '{
        "model": "<MODEL_NAME>",
        "messages": [
            {
                "role": "user",
                "content": "Give me a short introduction to large language models."
            }
        ],
        "temperature": 0.7,
        "top_p": 0.8,
        "max_tokens": 8192,
        "presence_penalty": 1.5,
        "chat_template_kwargs": {"enable_thinking": false}
    }' \
    <EAS_ENDPOINT>/v1/chat/completions

Python

from openai import OpenAI
# # Replace <EAS_ENDPOINT> with the service endpoint and <EAS_TOKEN> with the service token.
openai_api_key = "<<EAS_TOKEN>"
openai_api_base = "<EAS_ENDPOINT>/v1"

client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)

chat_response = client.chat.completions.create(
    model="<MODEL_NAME>",
    messages=[
        {"role": "user", "content": "Give me a short introduction to large language models."},
    ],
    temperature=0.7,
    top_p=0.8,
    presence_penalty=1.5,
    extra_body={"chat_template_kwargs": {"enable_thinking": False}},
)
print("Chat response:", chat_response)

Remplacez <EAS_ENDPOINT> par le point de terminaison du service, <EAS_TOKEN> par le jeton et <MODEL_NAME> par le nom du modèle obtenu via l'API /v1/models.

Désactivation via la modification de la configuration du service (BladeLLM) : Utilisez un modèle de conversation qui empêche le modèle de générer du contenu de réflexion au démarrage.
- Sur la page du modèle dans Model Gallery, vérifiez si une méthode est fournie pour désactiver le mode de réflexion pour BladeLLM. Par exemple, avec Qwen3-8B, modifiez le champ containers.script dans le fichier JSON de configuration du service pour désactiver le mode de réflexion :
```
blade_llm_server ... --chat_template /model_dir/no_thinking.jinja
```
- Rédigez votre propre modèle de conversation, tel que no_thinking.jinja, montez-le depuis OSS et mettez à jour le champ containers.script dans le fichier JSON de configuration du service.

Analyser le contenu de réflexion

Pour afficher séparément le contenu de réflexion, modifiez le champ containers.script dans le fichier JSON de configuration du service :

vLLM :

vllm serve ... --enable-reasoning --reasoning-parser qwen3

SGLang :

python -m sglang.launch_server ... --reasoning-parser deepseek-r1

Affiner un modèle

Qwen3-32B, 14B, 8B, 4B, 1,7B et 0,6B prennent en charge le SFT (affinement complet des paramètres, LoRA et QLoRA) ainsi que l'entraînement GRPO.
Utilisez la soumission de tâches d'entraînement en un clic pour former un modèle dédié à vos scénarios métier d'entreprise.

Évaluer un modèle

Pour des instructions détaillées sur l'évaluation des modèles, consultez les rubriques Évaluation des modèles et Bonnes pratiques pour l'évaluation des LLM.

Annexe : Ressources de calcul et limites de tokens

Le tableau suivant répertorie la configuration de déploiement minimale de chaque modèle Qwen3, ainsi que le nombre maximal de tokens pris en charge par chaque type d'instance sous différents frameworks d'inférence.

Remarque

Parmi les modèles FP8, seul Qwen3-235B-A22B nécessite moins de puissance de calcul que son modèle d'origine. Les autres modèles FP8 requièrent la même puissance de calcul que leurs versions non-FP8 ; ils ne sont donc pas listés dans le tableau. Par exemple, pour connaître la puissance de calcul requise par Qwen3-30B-A3B-FP8, reportez-vous à Qwen3-30B-A3B.

Modèle	Tokens maximaux (entrée + sortie)		Configuration minimale
Modèle	Déploiement accéléré SGLang	Déploiement accéléré vLLM	Configuration minimale
Qwen3-235B-A22B	32 768 (avec mise à l'échelle RoPE : 131 072)	32 768 (avec mise à l'échelle RoPE : 131 072)	8 × GPU H / GU120 (8 × 96 Go VARM)
Qwen3-235B-A22B-FP8	32 768 (avec mise à l'échelle RoPE : 131 072)	32 768 (avec mise à l'échelle RoPE : 131 072)	4 × GPU H / GU120 (4 × 96 Go VARM)
Qwen3-30B-A3B Qwen3-30B-A3B-Base Qwen3-32B	32 768 (avec mise à l'échelle RoPE : 131 072)	32 768 (avec mise à l'échelle RoPE : 131 072)	1 × GPU H / GU120 (96 Go VARM)
Qwen3-14B Qwen3-14B-Base	32 768 (avec mise à l'échelle RoPE : 131 072)	32 768 (avec mise à l'échelle RoPE : 131 072)	1 × GPU L / GU60 (48 Go VARM)
Qwen3-8B Qwen3-4B Qwen3-1.7B Qwen3-0.6B Qwen3-8B-Base Qwen3-4B-Base Qwen3-1.7B-Base Qwen3-0,6B-Base	32 768 (avec mise à l'échelle RoPE : 131 072)	32 768 (avec mise à l'échelle RoPE : 131 072)	1 × A10 / GU30 (24 Go VARM) Important Un modèle 8B avec mise à l'échelle RoPE nécessite 48 Go de VARM.

FAQ

Q : Les services de modèles déployés sur PAI prennent-ils en charge les sessions conservant le contexte entre plusieurs requêtes ?

Non. Les API des services de modèles déployés sur PAI sont sans état. Chaque appel est totalement indépendant et le serveur ne conserve aucun contexte ni état de session entre les requêtes.

Pour implémenter des conversations multi-tours, le client doit stocker l'historique des conversations et le joindre à chaque requête. Pour un exemple de requête, consultez la rubrique Comment implémenter une conversation multi-tours ?