Déployer affiner le modèle MoE Mixtral-8x7B PAI Model Gallery - Platform For AI

Mixtral-8x7B est un modèle open source de type Sparse Mixture-of-Experts développé par Mistral AI, qui surpasse GPT-3,5 sur de nombreux benchmarks. PAI Model Gallery propose des solutions prêtes à l'emploi pour le déploiement et l'affinage LoRA de ce modèle.

Présentation du modèle

Mixtral-8x7B est un LLM basé uniquement sur un décodeur, reposant sur une architecture Sparse Mixture-of-Experts (SMoE) et publié sous licence Apache 2.0. Un réseau de routeurs sélectionne deux des huit groupes d'experts pour chaque jeton et combine leurs sorties. Bien que le modèle compte au total 47 milliards de paramètres, seuls 13 milliards sont actifs par jeton, ce qui offre une vitesse d'inférence comparable à celle d'un modèle de 13 milliards de paramètres.

Mixtral-8x7B prend en charge l'anglais, le français, l'allemand, l'espagnol et l'italien, avec une longueur de contexte de 32 000 jetons. Il égale ou surpasse LLaMA2-70B et GPT-3,5 sur tous les benchmarks évalués, et affiche des performances nettement supérieures à celles de LLaMA2-70B dans les tâches mathématiques, la génération de code et les traitements multilingues.

*Source : arXiv:2401.04088*

Mistral AI a également publié Mixtral-8x7B-Instruct-v0.1, une variante affinée pour suivre les instructions, optimisée via un affinage supervisé et une optimisation directe des préférences (DPO). Ce modèle suit plus précisément les instructions humaines et surpasse les autres modèles open source affinés pour les instructions dans les tâches conversationnelles.

*Source : Chatbot Arena Leaderboard*

Prérequis

Les ressources du service Lingjun Intelligent Computing Service sont activées. Créer un groupe de ressources et acheter des ressources Lingjun Intelligent Computing Service.

Configuration requise

Cet exemple nécessite des clusters PAI Lingjun dans la région China (Ulanqab).
Les GPU GU108 (80 Go de VRAM) sont recommandés. L'inférence requiert au moins deux GPU ; l'affinage LoRA nécessite au moins quatre GPU.

Utiliser le modèle dans la PAI console

Déployer et appeler le modèle

Accédez à la page Model Gallery.
1. Connectez-vous à la PAI console.
2. Dans la barre de navigation supérieure, sélectionnez la région China (Ulanqab).
3. Dans le volet de navigation de gauche, cliquez sur workspaces. Sur la page Workspaces, cliquez sur le nom de l'espace de travail que vous souhaitez utiliser.
4. Dans le volet de navigation de gauche, choisissez QuickStart > Model Gallery pour accéder à la page Model Gallery.
Dans la liste des modèles située à droite, cliquez sur la carte du modèle Mixtral-8x7B-Instruct-v0.1 pour ouvrir la page Model Details.
Dans le coin supérieur droit, cliquez sur Deploy. Configurez les ressources de calcul Lingjun, puis cliquez sur Deploy pour déployer le modèle sur PAI-EAS.

Ce modèle nécessite des ressources Lingjun Intelligent Computing Service. Le quota de ressources doit inclure au moins deux GPU GU108.

Dans le panneau de configuration du déploiement, définissez Resource group type sur Lingjun Intelligent Computing Service, Number of instances sur 1, CPU sur 40 et Memory (MB) sur 256000. Ensuite, cliquez sur Deploy.

Appelez le service d'inférence.

HTTP API

Le service d'inférence prend en charge une API compatible avec OpenAI. Récupérez le point de terminaison du service et le jeton d'accès depuis la page des détails du service, puis appelez le service à l'aide de cURL :

# Replace  and  with the actual endpoint and token of your service.
export API_ENDPOINT="<ENDPOINT>"
export API_TOKEN="<TOKEN>"
# List available models
curl $API_ENDPOINT/v1/models \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer $API_TOKEN"
# Call the general text completion API
curl $API_ENDPOINT/v1/completions \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $API_TOKEN" \
    -d '{
			"model": "Mixtral-8x7B-Instruct-v0.1",
			"prompt": "San Francisco is a",
			"max_tokens": 256,
			"temperature": 0
	}'
# Call the chat completion API
curl $API_ENDPOINT/v1/chat/completions \
    -H "Authorization: Bearer $API_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{
			"model": "Mixtral-8x7B-Instruct-v0.1",
      "messages": [
          {"role": "user", "content": "Tell me about the history of Shanghai."}
        ]
      }'

SDK

Pour appeler le service à l'aide du SDK OpenAI, installez d'abord le SDK :

# Install the SDK to call the service
python -m pip install openai

Appelez le service d'inférence à l'aide du SDK :

import openai
# Replace  and  with the token and endpoint from the service details page.
openai.api_key = "<TOKEN>"
openai.base_url = "<ENDPOINT>" + "/v1"
# Call the chat completion API
completion = openai.chat.completions.create(
    model="Mixtral-8x7B-Instruct-v0.1",
    temperature=0.0,
    top_p=0.8,
    frequency_penalty=0.0,
    messages=[{"role": "user", "content": "Tell me about yourself."}],
    # stream=True,
)
# Print the output content
print(completion.choices[0].message.content)

Affiner le modèle

Model Gallery fournit un algorithme d'affinage prêt à l'emploi pour Mixtral-8x7B-Instruct-v0.1.

Les données d'entraînement doivent être au format JSON. Chaque entrée requiert un champ instruction (question) et un champ output (réponse) :

[
    {
        "instruction": "Write a poem on a topic 'On a Political Prisoner': \n",
        "output": "She that but little patience knew,\r\nFrom childhood on, had now so much\r\nA grey gull lost its fear and flew\r\nDown to her cell and there alit,\r\nAnd there endured her fingers' touch\r\nAnd from her fingers ate its bit.\r\nDid she in touching that lone wing."
    },
    {
        "instruction": "Write a poem on a topic 'To His Love': ",
        "output": "He's gone, and all our plans\r\n   Are useless indeed.\r\nWe'll walk no more on Cotswold\r\n   Where the sheep feed\r\n   Quietly and take no heed.\r\n His body that was so quick\r\n   Is not as you\r\nKnew it, on Severn river\r\n   Under the blue\r\n   Driving our small boat through."
    }
]

Sur la page Model Details, cliquez sur Fine-tune dans le coin supérieur droit. Les configurations clés sont les suivantes :

Dataset configuration : Téléchargez les données dans un bucket OSS, ou spécifiez un jeu de données NAS ou CPFS. PAI met également à disposition des jeux de données publics pour les tests.
Compute resource configuration : Quatre GPU GU108 (80 Go de VRAM) sont requis. Assurez-vous que votre quota est suffisant.

Hyperparameter configuration : Ajustez les hyperparamètres suivants en fonction de vos données et de vos ressources de calcul, ou utilisez les valeurs par défaut.

Parameter	Type	Default	Required	Description
learning_rate	float	5e-5	Yes	Controls the step size of weight updates during training.
num_train_epochs	int	1	Yes	The number of times the training dataset is iterated over.
per_device_train_batch_size	int	1	Yes	Samples processed per GPU per iteration. Larger values improve throughput but increase VRAM usage.
seq_length	int	128	Yes	Input sequence length per training step.
lora_dim	int	16	No	The LoRA dimension. If lora_dim > 0, this enables lightweight fine-tuning with LoRA or QLoRA.
lora_alpha	int	32	No	LoRA alpha scaling factor. Used when lora_dim > 0.
load_in_4bit	bool	true	No	Specifies whether to load the model in 4-bit. If lora_dim > 0, load_in_4bit is true, and load_in_8bit is false, lightweight fine-tuning uses 4-bit QLoRA.
load_in_8bit	bool	false	No	Specifies whether to load the model in 8-bit. If lora_dim > 0, load_in_4bit is false, and load_in_8bit is true, lightweight fine-tuning uses 8-bit QLoRA.
gradient_accumulation_steps	int	8	No	The number of gradient accumulation steps.
apply_chat_template	bool	true	No	Specifies whether the algorithm applies the model's default chat template to the training data. Example: Question: `<\|begin_of_text\|><\|start_header_id\|>user<\|end_header_id\|>\n\n + instruction + <\|eot_id\|>` Answer: `<\|start_header_id\|>assistant<\|end_header_id\|>\n\n + output + <\|eot_id\|>`

En cliquant sur Fine-tune, vous accédez à la page de la tâche d'entraînement. La tâche démarre automatiquement.

Dans le coin supérieur droit, cliquez sur Tensorboard pour ouvrir TensorBoard et surveiller la convergence du modèle.

Le modèle entraîné est automatiquement enregistré dans AI Assets - Model Management. Register and manage models.

Utiliser le modèle avec le SDK PAI

Vous pouvez également utiliser les modèles de Model Gallery avec le SDK PAI pour Python. Installez et configurez le SDK :

# Install the PAI SDK for Python
python -m pip install alipai --upgrade
# Interactively configure your access credentials, PAI workspace, and other information
python -m pai.toolkit.config

Configurez les identifiants d'accès (paire AccessKey) et l'espace de travail comme décrit dans Installation and configuration.

Déployer et appeler le modèle

Déployez le modèle Mixtral sur PAI-EAS en utilisant les paramètres d'inférence préconfigurés de Model Gallery. Indiquez le nom du service et les détails des ressources :

from pai.session import get_default_session
from pai.model import RegisteredModel
from pai.common.utils import random_str
from pai.predictor import Predictor
session = get_default_session()
# Get the model provided by PAI QuickStart
m = RegisteredModel(
    model_name="Mixtral-8x7B-Instruct-v0.1",
    model_provider="pai",
)
# View the default deployment configuration of the model
print(m.inference_spec)
# Deploy the inference service
# You must provide the ID of a Lingjun resource quota (QuotaId) that has at least two GU108 (80 GB of VRAM) GPU cards.
predictor = m.deploy(
    service_name="mixtral_8_7b_{}".format(random_str(6)),
    options={
        # Resource quota ID
        "metadata.quota_id": "<LingJunResourceQuotaId>",
        "metadata.quota_type": "Lingjun",
        "metadata.workspace_id": session.workspace_id,
    }
)
# Get the endpoint and token of the inference service
endpoint = predictor.internet_endpoint
token = predictor.access_token

Appelez le service d'inférence via les méthodes décrites dans la section Appeler le service d'inférence ci-dessus, ou utilisez directement le SDK PAI :

from pai.predictor import Predictor
p = Predictor("<MixtralServiceName>")
res = p.raw_predict(
    path="/v1/chat/completions",
    method="POST",
    data={
        "model": "Mixtral-8x7B-Instruct-v0.1",
        "messages": [
            {"role": "user", "content": "Tell me about the history of Shanghai."}
        ]
    }
)
print(res.json())

Après les tests, supprimez le service depuis la console ou via le SDK afin de libérer les ressources associées.

# Delete the service
predictor.delete_service()

Affiner le modèle

Récupérez un modèle depuis Model Gallery pour consulter son algorithme d'affinage, les hyperparamètres pris en charge ainsi que la configuration des entrées/sorties :

from pai.model import RegisteredModel
# Get the Mixtral-8x7B-Instruct-v0.1 model provided by PAI QuickStart
m = RegisteredModel(
    model_name="Mixtral-8x7B-Instruct-v0.1",
    model_provider="pai",
)
# Get the fine-tuning algorithm configured for the model
est = m.get_estimator()
# View the supported hyperparameters and the input/output information of the algorithm
print(est.hyperparameter_definitions)
print(est.input_channel_definitions)

L'algorithme d'affinage de Mixtral-8x7B-Instruct-v0.1 prend actuellement en charge uniquement les ressources Lingjun Intelligent Computing Service. Obtenez votre ID de quota de ressources depuis la PAI console et configurez les hyperparamètres avant de soumettre la tâche :

# Configure the Lingjun resource quota ID for the training job
est.resource_id = "<LingjunResourceQuotaId>"
# Configure the hyperparameters for the training job
hps = {
    "learning_rate": 1e-5,
    "per_device_train_batch_size": 2,
}
est.set_hyperparameters(**hps)

L'algorithme d'affinage accepte trois types d'entrées :

model : Le modèle pré-entraîné Mixtral-8x7B-Instruct-v0.1.
train : Le jeu de données d'entraînement pour l'affinage.
validation : Le jeu de données de validation pour l'affinage.

Le format de jeu de données requis est décrit dans la section Affiner le modèle. Téléchargez les données vers un bucket OSS à l'aide d'ossutil, de la console ou du SDK :

from pai.common.oss_utils import upload
# View the inputs used by the model's fine-tuning algorithm
# Get the input data for the algorithm, including the model and a public dataset for testing.
training_inputs = m.get_estimator_inputs()
print(training_inputs)
# {
#     "model": "oss://pai-quickstart-cn-wulanchabu.oss-cn-wulanchabu-internal.aliyuncs.com/huggingface/models/Mixtral-8x7B-Instruct-v0.1/main/",
#     "train": "oss://pai-quickstart-cn-wulanchabu.oss-cn-wulanchabu-internal.aliyuncs.com/huggingface/datasets/llm_instruct/en_poetry_train_mixtral.json",
#     "validation": "oss://pai-quickstart-cn-wulanchabu.oss-cn-wulanchabu-internal.aliyuncs.com/huggingface/datasets/llm_instruct/en_poetry_test_mixtral.json",
# }
# Upload user data. Replace the following local file path and the destination OSS bucket path.
train_data_uri = upload("/path/to/local/train.json", "path/of/train/data")
validation_data_uri = upload("/path/to/local/validation.json", "path/of/validation/data")
# Replace the training data with your own.
# training_inputs["train"] = train_data_uri
# training_inputs["validation"] = validation_data_uri

Remplacez les entrées train et validation par vos propres jeux de données, puis soumettez la tâche d'affinage. Utilisez le lien de la tâche affiché pour consulter l'état et les journaux dans la PAI console, ou ouvrez TensorBoard pour surveiller la convergence :

from pai.common.oss_utils import download
# Submit the training job and print the link to the job
est.fit(
    inputs=training_inputs,
    wait=False,
)
# Open TensorBoard to view training progress
est.tensorboard()
# Wait for the training job to complete
est.wait()
# View the model path on the OSS bucket
print(est.model_data())
# You can download the model to your local machine by using ossutil or the utility methods provided by the SDK.
download(est.model_data())

Guide d'intégration complet du SDK : Use pre-trained models — PAI SDK for Python.

Platform For AI:Démarrage rapide : Déployer et affiner Mixtral-8x7B

Présentation du modèle

Prérequis

Configuration requise

Utiliser le modèle dans la PAI console

Déployer et appeler le modèle

HTTP API

SDK

Affiner le modèle

Utiliser le modèle avec le SDK PAI

Déployer et appeler le modèle

Affiner le modèle

Références