Entraînez, affinez et déployez Qwen (7B/14B/72B) sur la plateforme de calcul intelligent Lingjun avec Megatron. Ce guide utilise Qwen-7B comme exemple.
Prérequis
Ce guide utilise Qwen-7B v1.1.4. Effectuez les préparations suivantes :
Activez PAI (DSW, DLC et EAS) et créez un espace de travail par défaut. Activation de PAI et création d'un espace de travail par défaut.
-
Achetez des ressources Lingjun et créez un quota de ressources. Sélectionnez les spécifications en fonction de la taille de votre modèle. Tarification : Détails de tarification de Lingjun Serverless. Configuration : Création d'un groupe de ressources et achat de ressources Lingjun et Création d'un quota de ressources.
Taille du modèle
Ressources pour l'entraînement complet des paramètres
Ressources d'inférence (minimum)
Segment de modèle d'entraînement Megatron
7B
8 × gu7xf GPUs, 8 × gu7ef GPUs
1 × V100 (32 GB VRAM), 1 × A10 (24 GB VRAM)
TP: 1, PP: 1
14B
8 × gu7xf GPUs, 8 × gu7ef GPUs
2 × V100 (32 GB VRAM), 2 × A10 (24 GB VRAM)
TP: 2, PP: 1
72B
4 × 8 gu7xf GPUs, 4 × 8 gu7ef GPUs
6 × V100 (32 GB VRAM), 2 × gu7xf GPUs
TP: 8, PP: 2
Créez un jeu de données de système de fichiers NAS généraliste pour stocker les fichiers d'entraînement et les résultats. Configurez le chemin de montage par défaut sur
/mnt/data/nas. Création et gestion des jeux de données.-
Créez une instance DSW avec les paramètres suivants. Création d'une instance DSW.
Resource Quota : sélectionnez le quota de ressources que vous avez créé pour les ressources Lingjun.
-
Instance Type : configurez les spécifications de ressources suivantes.
vCPUs : 90.
Memory (GiB) : 1024.
Shared Memory (GiB) : 1024.
GPUs : au moins 8.
Dataset Mounting : cliquez sur Custom Dataset, sélectionnez le jeu de données que vous avez créé et utilisez le chemin de montage par défaut.
Image Configuration : dans l'onglet Image Address, définissez l'image d'exécution sur
pai-image-manage-registry.cn-wulanchabu.cr.aliyuncs.com/pai/pytorch-training:1.12-ubuntu20.04-py3.10-cuda11.3-megatron-patch-llm.
Si vous utilisez un utilisateur RAM, accordez les autorisations requises pour DSW, DLC ou EAS. Dépendances et autorisations des produits cloud : DSW, Dépendances et autorisations des produits cloud : DLC ou Dépendances et autorisations des produits cloud : EAS.
Limites
Cette bonne pratique est disponible uniquement dans la région Chine (Ulanqab).
Étape 1 : Préparation du modèle Qwen
Téléchargez le modèle Qwen en utilisant l'une des méthodes suivantes :
-
Accédez à l'environnement de développement PAI DSW.
Connectez-vous à la console PAI.
Dans le coin supérieur gauche de la page, sélectionnez la région où vous souhaitez utiliser le service : Chine (Ulanqab).
Dans le volet de navigation de gauche, cliquez sur Workspaces. Sur la page qui s'affiche, cliquez sur le nom de l'espace de travail que vous souhaitez gérer.
Dans le volet de navigation de gauche, choisissez .
Dans la colonne Actions de l'instance cible, cliquez sur Open.
Dans la barre de menu supérieure, cliquez sur Terminal. Dans l'onglet qui s'affiche, cliquez sur create a terminal.
-
Téléchargez le modèle Qwen.
Téléchargement du modèle depuis la communauté ModelScope
Dans le Terminal, exécutez la commande suivante pour installer ModelScope.
Entrez dans l'environnement Python.
Le code suivant télécharge les fichiers du modèle Qwen-7B.
Appuyez sur
Ctrl+Dpour quitter l'environnement Python.Exécutez la commande suivante pour déplacer le modèle Qwen téléchargé vers le dossier correspondant.
pip install modelscopepython# ### Loading Model and Tokenizer from modelscope.hub.snapshot_download import snapshot_download model_dir = snapshot_download('qwen/Qwen-7B', 'v1.1.4') # model_dir = snapshot_download('qwen/Qwen-14B', 'v1.0.4') # model_dir = snapshot_download('qwen/Qwen-72B') # Get the download path. print(model_dir) # /root/.cache/modelscope/hub/qwen/Qwen-7B# mkdir -p /mnt/workspace/qwen-ckpts/${ckpt_folder_with_hf_suffix} mkdir -p /mnt/workspace/qwen-ckpts/qwen-7b-hf # cp -r ${path_to_downloaded_model}/* /mnt/workspace/qwen-ckpts/${ckpt_folder_with_hf_suffix} cp -r /root/.cache/modelscope/hub/qwen/Qwen-7B/* /mnt/workspace/qwen-ckpts/qwen-7b-hfTéléchargement du modèle depuis la communauté HuggingFace
Dans le terminal DSW, exécutez la commande suivante pour télécharger les fichiers du modèle. Ce guide utilise le modèle Qwen-7B comme exemple. Pour télécharger les fichiers du modèle Qwen-14B ou Qwen-72B, modifiez le code suivant selon vos besoins.
mkdir /mnt/workspace/qwen-ckpts cd /mnt/workspace/qwen-ckpts git clone https://huggingface.co/Qwen/Qwen-7B # git clone https://huggingface.co/Qwen/Qwen-7B-Chat # git clone https://huggingface.co/Qwen/Qwen-14B # git clone https://huggingface.co/Qwen/Qwen-14B-Chat # git clone https://huggingface.co/Qwen/Qwen-72B # git clone https://huggingface.co/Qwen/Qwen-72B-Chat
Étape 2 : Préparation des données de pré-entraînement
Préparez les données de pré-entraînement dans DSW. Cet exemple utilise WuDaoCorpora2,0 (recherche uniquement) pour illustrer le prétraitement des données Megatron. Téléchargez les exemples de données fournis par PAI ou préparez les vôtres.
Utilisation des petits échantillons de données traités par PAI
PAI fournit des exemples de données traitées. Exécutez la commande suivante pour les télécharger.
mkdir /mnt/workspace/qwen-datasets/
cd /mnt/workspace/qwen-datasets
wget https://atp-modelzoo-wlcb-pai.oss-cn-wulanchabu.aliyuncs.com/release/models/pai-megatron-patch/qwen-datasets/alpaca_zh-qwen-train.json
wget https://atp-modelzoo-wlcb-pai.oss-cn-wulanchabu.aliyuncs.com/release/models/pai-megatron-patch/qwen-datasets/alpaca_zh-qwen-valid.json
mkdir -p /mnt/workspace/qwen-datasets/wudao
cd /mnt/workspace/qwen-datasets/wudao
wget https://atp-modelzoo-wlcb-pai.oss-cn-wulanchabu.aliyuncs.com/release/models/pai-megatron-patch/qwen-datasets/wudao_qwenbpe_content_document.bin
wget https://atp-modelzoo-wlcb-pai.oss-cn-wulanchabu.aliyuncs.com/release/models/pai-megatron-patch/qwen-datasets/wudao_qwenbpe_content_document.idxTraitement des données par vous-même
-
Téléchargez le jeu de données WuDaoCorpora2,0 vers
/mnt/workspace/qwen-datasets. Le dossier décompressé est nommé wudao_200g.PAI fournit des exemples de données à titre de démonstration. Exécutez la commande suivante pour télécharger et décompresser le jeu de données.
mkdir /mnt/workspace/qwen-datasets cd /mnt/workspace/qwen-datasets wget https://atp-modelzoo.oss-cn-hangzhou.aliyuncs.com/release/datasets/WuDaoCorpus2.0_base_sample.tgz tar zxvf WuDaoCorpus2.0_base_sample.tgz mv WuDaoCorpus2.0_base_sample wudao_200g -
Dans le Terminal, exécutez la commande suivante pour effectuer le nettoyage des données et la conversion du format de fichier sur les données Wudao. Cela génère un fichier fusionné merged_wudao_cleaned.json.
#! /bin/bash set -ex # Set the path where the raw data is stored. data_dir=/mnt/workspace/qwen-datasets/wudao_200g # Start the data cleansing process. dataset_dir=$(dirname $data_dir) mkdir -p ${dataset_dir}/cleaned_wudao_dataset cd ${dataset_dir}/cleaned_wudao_dataset wget https://atp-modelzoo-wlcb-pai.oss-cn-wulanchabu.aliyuncs.com/release/models/pai-megatron-patch/llama2-codes/preprocess_wudao2.py # Unlike the previous section, the key parameter is added and set to text. python preprocess_wudao2.py -i ${data_dir} -o ${dataset_dir}/cleaned_wudao_dataset -k text -p 32 # Merge the cleansed data. mkdir ${dataset_dir}/wudao cd ${dataset_dir}/wudao find ${dataset_dir}/cleaned_wudao_dataset -name "*.json" -exec cat {} + > ${dataset_dir}/wudao/merged_wudao_cleaned.json rm -rf ${dataset_dir}/cleaned_wudao_datasetUne fois la commande exécutée, la structure de fichiers du répertoire
qwen-datasetsest la suivante. Un nouveau dossier wudao est ajouté.qwen-datasets ├── wudao_200g └── wudao └── merged_wudao_cleaned.json -
Dans le Terminal, exécutez la commande suivante pour diviser le fichier merged_wudao_cleaned.json en plusieurs groupes et les compresser. Cela facilite le multithreading dans les étapes ultérieures.
apt-get update apt-get install zstd # The number of chunks is set to 10. increase this value if data processing is slow. NUM_PIECE=10 # Process the merged_wudao_cleaned.json file. mkdir -p ${dataset_dir}/cleaned_zst/ # Query the total data length and split the data. NUM=$(sed -n '$=' ${dataset_dir}/wudao/merged_wudao_cleaned.json) echo "total line of dataset is $NUM, data will be split into $NUM_PIECE pieces for processing" NUM=`expr $NUM / $NUM_PIECE` echo "each group is processing $NUM sample" split_dir=${dataset_dir}/split mkdir $split_dir split -l $NUM --numeric-suffixes --additional-suffix=.jsonl ${dataset_dir}/wudao/merged_wudao_cleaned.json $split_dir/ # Compress the data. o_path=${dataset_dir}/cleaned_zst/ mkdir -p $o_path files=$(ls $split_dir/*.jsonl) for filename in $files do f=$(basename $filename) zstd -z $filename -o $o_path/$f.zst & done rm -rf $split_dir rm ${dataset_dir}/wudao/merged_wudao_cleaned.jsonUne fois la commande exécutée, la structure de fichiers du répertoire
qwen-datasetsest la suivante. Un nouveau dossiercleaned_zstest ajouté, contenant 10 fichiers compressés.qwen-datasets ├── wudao_200g ├── wudao └── cleaned_zst ├── 00.jsonl.zst │ ... └── 09.jsonl.zst -
Créez un jeu de données de pré-entraînement au format MMAP.
MMAP est un format de données pré-tokenisé qui réduit le temps d'attente lors de la lecture des données pendant l'entraînement et l'affinage. Ceci est particulièrement avantageux lors du traitement de données à grande échelle. Suivez ces étapes :
-
Dans le terminal DSW, exécutez la commande suivante pour copier le code source de PAI-Megatron-Patch, qui est un outil d'entraînement de modèle pour Megatron, dans le répertoire de travail DSW
/mnt/workspace/.cd /mnt/workspace/ # Method 1: Obtain the training code from the open source website. git clone --recurse-submodules https://github.com/alibaba/Pai-Megatron-Patch.git # Method 2: Obtain the training code using wget. run tar zxvf Pai-Megatron-Patch.tgz to decompress the file. wget https://atp-modelzoo.oss-cn-hangzhou.aliyuncs.com/release/models/Pai-Megatron-Patch.tgz -
Dans le Terminal, exécutez la commande suivante pour convertir les données au format MMAP.
Une fois la commande exécutée, des fichiers
.binet.idxsont générés dans le répertoire/mnt/workspace/qwen-datasets/wudao.# Install the tokenizer library required by Qwen. pip install tiktoken # Set the dataset path and working directory. export dataset_dir=/mnt/workspace/qwen-datasets export WORK_DIR=/mnt/workspace # Generate MMAP-format pre-training datasets for the training and validation sets. cd ${WORK_DIR}/Pai-Megatron-Patch/toolkits/pretrain_data_preprocessing bash run_make_pretraining_dataset.sh \ ../../Megatron-LM-23.04 \ ${WORK_DIR}/Pai-Megatron-Patch/ \ ${dataset_dir}/cleaned_zst/ \ qwenbpe \ ${dataset_dir}/wudao/ \ ${WORK_DIR}/qwen-ckpts/qwen-7b-hf rm -rf ${dataset_dir}/cleaned_zstLe tableau suivant décrit les paramètres de run_make_pretraining_dataset.sh.
Paramètre
Description
MEGATRON_PATH=$1
chemin du code Megatron open source.
MEGATRON_PATCH_PATH=$2
chemin du code Megatron Patch.
input_data_dir=$3
chemin du dossier contenant le jeu de données WuDao emballé.
tokenizer=$4
type de tokenizer. Définissez-le sur qwenbpe.
output_data_dir=$5
chemin pour enregistrer les fichiers de sortie
.binet.idx.load_dir=$6
chemin du fichier tokenizer_config.json généré.
Structure du répertoire
qwen-datasetsrésultant :qwen-datasets ├── wudao_200g └── wudao ├── wudao_qwenbpe_content_document.bin └── wudao_qwenbpe_content_document.idx
-
Étape 3 : Entraînement du modèle avec Megatron
Entraînez le modèle avec Megatron.
Conversion du format de modèle
Convertissez les fichiers de modèle HuggingFace au format Megatron.
Téléchargement du modèle Megatron converti
PAI fournit un modèle pré-converti. Téléchargez-le :
cd /mnt/workspace/
mkdir qwen-ckpts
cd qwen-ckpts
wget https://atp-modelzoo-wlcb-pai.oss-cn-wulanchabu.aliyuncs.com/release/models/pai-megatron-patch/qwen-ckpts/qwen-7b-hf-to-mg-tp1-pp1.tgz
tar -zxf qwen-7b-hf-to-mg-tp1-pp1.tgz
mv qwen-7b-hf-to-mg-tp1-pp1 qwen-7b-hf-to-megatron-tp1-pp1Conversion du modèle HuggingFace au format Megatron
Exécutez la commande suivante pour convertir le modèle HuggingFace au format Megatron :
# Convert the model.
cd /mnt/workspace/Pai-Megatron-Patch/toolkits/model_checkpoints_convertor/qwen
sh model_convertor.sh \
../../../Megatron-LM-main \
/mnt/workspace/qwen-ckpts/qwen-7b-hf \
/mnt/workspace/qwen-ckpts/qwen-7b-hf-to-megatron-tp1-pp1 \
1 \
1 \
qwen-7b \
0 \
falseLe tableau suivant décrit les paramètres de model_convertor.sh.
Paramètre | Description |
MEGATRON_PATH=$1 | chemin du code Megatron open source. |
SOURCE_CKPT_PATH=$2 | chemin des fichiers du modèle HuggingFace. |
TARGET_CKPT_PATH=$3 | chemin pour enregistrer le modèle Megatron converti. |
TP=$4 | nombre de fragments de parallélisme tensoriel. Il doit être identique à celui utilisé pour l'entraînement. Le nombre de fragments varie en fonction de la taille du modèle. Modifiez ce paramètre selon vos besoins lors de la conversion du modèle :
|
PP=$5 | nombre de fragments de parallélisme de pipeline. Il doit être identique à celui utilisé pour l'entraînement. Le nombre de fragments varie en fonction de la taille du modèle. Modifiez ce paramètre selon vos besoins lors de la conversion du modèle :
|
MN=$6 | nom du modèle : qwen-7b, qwen-14b ou qwen-72b. |
EXTRA_VOCAB_SIZE=$7 | taille supplémentaire du vocabulaire. |
mg2hf=$8 | Indique s'il faut convertir un modèle Megatron en modèle HuggingFace. |
Modèle pré-entraîné
Effectuez un pré-entraînement sur une seule instance DSW ou soumettez une tâche distribuée dans DLC. L'entraînement prend environ deux heures. Les fichiers de modèle sont enregistrés dans le répertoire /mnt/workspace/output_megatron_qwen/.
Modèle pré-entraîné autonome DSW
Exécutez la commande suivante pour le modèle Qwen-7B dans le Terminal :
export WORK_DIR=/mnt/workspace
cd ${WORK_DIR}/Pai-Megatron-Patch/examples/qwen
sh run_pretrain_megatron_qwen.sh \
dsw \
${WORK_DIR}/Pai-Megatron-Patch \
7B \
1 \
8 \
1e-5 \
1e-6 \
2048 \
2048 \
85 \
fp16 \
1 \
1 \
sel \
true \
false \
false \
false \
100000 \
${WORK_DIR}/qwen-datasets/wudao/wudao_qwenbpe_content_document \
${WORK_DIR}/qwen-ckpts/qwen-7b-hf-to-megatron-tp1-pp1 \
100000000 \
10000 \
${WORK_DIR}/output_megatron_qwen/ Paramètres du script run_pretrain_megatron_qwen.sh :
Parameter | Description |
ENV=$1 | L'environnement d'exécution :
|
MEGATRON_PATH=$2 | Le chemin d'accès au code Megatron open source. |
MODEL_SIZE=$3 | La taille du modèle : 7B, 14B ou 72B. |
BATCH_SIZE=$4 | Le nombre d'échantillons pour une itération d'entraînement sur chaque GPU : 4 ou 8. |
GLOBAL_BATCH_SIZE=$5 | Le nombre total d'échantillons d'entraînement. |
LR=$6 | Le taux d'apprentissage : 1e-5 ou 5e-5. |
MIN_LR=$7 | Le taux d'apprentissage minimal : 1e-6 ou 5e-6. |
SEQ_LEN=$8 | La longueur de la séquence. |
PAD_LEN=${9} | La longueur du remplissage (padding). |
EXTRA_VOCAB_SIZE=${10} | La taille supplémentaire du vocabulaire :
|
PR=${11} | La précision d'entraînement : fp16 ou bf16. |
TP=${12} | Le degré de parallélisme du modèle. |
PP=${13} | Le degré de parallélisme de pipeline. |
AC=${14} | Le mode de point de contrôle d'activation :
|
DO=${15} | Indique s'il faut utiliser la version Megatron de l'optimiseur Zero-1 pour réduire l'utilisation de la VRAM :
|
FL=${16} | Indique s'il faut activer Flash Attention :
|
SP=${17} | Indique s'il faut utiliser le parallélisme de séquence :
|
TE=${18} | Indique s'il faut activer l'accélération Transformer-engine. Cette fonctionnalité nécessite des GPU gu8xf. |
SAVE_INTERVAL=${19} | L'intervalle d'enregistrement des fichiers de point de contrôle. |
DATASET_PATH=${20} | Le chemin d'accès au jeu de données d'entraînement. |
PRETRAIN_CHECKPOINT_PATH=${21} | Le chemin d'accès au modèle pré-entraîné. |
TRAIN_TOKENS=${22} | Jetons d'entraînement |
WARMUP_TOKENS=${23} | Le nombre de jetons de warmup. |
OUTPUT_BASEPATH=${24} | Le chemin d'accès pour enregistrer les fichiers de modèle de sortie. |
Modèle pré-entraîné distribué DLC
Après le débogage sur une instance unique, configurez une tâche distribuée multi-GPU dans DLC :
-
Accédez à la page Create Job.
Connectez-vous à la console PAI, sélectionnez la région et l'espace de travail cibles, puis cliquez sur Deep Learning Containers (DLC).
Sur la page Deep Learning Containers (DLC), cliquez sur Create Job.
-
Sur la page Create Job, configurez les paramètres clés suivants et conservez les valeurs par défaut pour les autres paramètres. Créer une tâche d'entraînement.
Parameter
Description
Basic Information
Job Name
Saisissez un nom de tâche personnalisé. Ce guide utilise test_qwen_dlc.
Environment Information
Image Configuration
Sélectionnez Image Address et saisissez
pai-image-manage-registry.cn-wulanchabu.cr.aliyuncs.com/pai/pytorch-training:1.12-ubuntu20.04-py3.10-cuda11,3-megatron-patch-llmdans la zone de texte.Mount dataset
Cliquez sur Custom Dataset et configurez les paramètres suivants :
Custom Dataset : Sélectionnez le jeu de données NAS que vous avez créé.
Mount Path : Définissez cette valeur sur
/mnt/workspace/.
Startup Command
Configurez la commande suivante. Les paramètres de démarrage du script run_pretrain_megatron_qwen.sh sont identiques à ceux du pré-entraînement du modèle sur une instance DSW unique.
export WORK_DIR=/mnt/workspace cd ${WORK_DIR}/Pai-Megatron-Patch/examples/qwen sh run_pretrain_megatron_qwen.sh \ dlc \ ${WORK_DIR}/PAI-Megatron-Patch \ 7B \ 1 \ 8 \ 1e-5 \ 1e-6 \ 2048 \ 2048 \ 85 \ fp16 \ 1 \ 1 \ sel \ true \ false \ false \ false \ 100000 \ ${WORK_DIR}/qwen-datasets/wudao/wudao_qwenbpe_content_document \ ${WORK_DIR}/qwen-ckpts/qwen-7b-hf-to-megatron-tp1-pp1 \ 100000000 \ 10000 \ ${WORK_DIR}/output_megatron_qwen/Resource Information
Resource Type
Sélectionnez Lingjun Intelligent Computing.
Source
Sélectionnez Resource Type.
Resource Type
Sélectionnez le quota de ressources que vous avez créé pour les ressources Lingjun.
Framework
Sélectionnez PyTorch.
Job Resource
Configurez les paramètres suivants pour le nœud Worker :
Nodes : 2. Pour effectuer un entraînement multi-nœuds, définissez Nodes sur le nombre de machines requis.
GPUs : 8
vCPUs : 90
Remarquele nombre de cœurs CPU ne peut pas dépasser 96.
Memory (GiB) : 1024
Shared Memory (GiB) : 1024
Cliquez sur OK. La page accède automatiquement à la page Deep Learning Containers (DLC). Lorsque le Status passe à Succeeded, la tâche d'entraînement est réussie.
Affiner le modèle avec l'apprentissage supervisé
Affinez le modèle sur une instance DSW unique ou soumettez une tâche distribuée dans l'environnement DLC. L'entraînement prend environ deux heures. Les fichiers de modèle sont enregistrés dans /mnt/workspace/output_megatron_qwen/.
Avant l'affinage, accédez à l'Étape 2 : Préparer les données de pré-entraînement et téléchargez le fichier JSON depuis l'onglet Use the small-scale sample data processed by PAI.
-
Affinez le modèle.
Affiner le modèle sur une instance DSW unique
Exécutez la commande suivante pour le modèle Qwen-7B dans le Terminal :
export WORK_DIR=/mnt/workspace cd ${WORK_DIR}/Pai-Megatron-Patch/examples/qwen sh run_finetune_megatron_qwen_withGA.sh \ dsw \ ${WORK_DIR}/Pai-Megatron-Patch \ 7B \ 1 \ 96 \ 1e-5 \ 1e-6 \ 2048 \ 2048 \ 85 \ bf16 \ 1 \ 1 \ sel \ true \ false \ false \ false \ 1000 \ ${WORK_DIR}/qwen-datasets/alpaca_zh-qwen-train.json \ ${WORK_DIR}/qwen-datasets/alpaca_zh-qwen-valid.json \ ${WORK_DIR}/qwen-ckpts/qwen-7b-hf-to-megatron-tp1-pp1 \ 2000 \ 10 \ ${WORK_DIR}/output_megatron_qwen/Paramètres du script run_finetune_megatron_qwen_withGA.sh :
Parameter
Description
ENV=$1
environnement d'exécution :
dlc
dsw
MEGATRON_PATH=$2
chemin d'accès au code Megatron open source.
MODEL_SIZE=$3
taille du modèle : 7B, 14B ou 72B.
BATCH_SIZE=$4
nombre d'échantillons pour une itération d'entraînement sur chaque GPU : 1, 2, 4 ou 8.
GLOBAL_BATCH_SIZE=$5
nombre total d'échantillons pour une itération d'affinage : 64, 96 ou 128.
LR=$6
taux d'apprentissage : 1e-5 ou 5e-5.
MIN_LR=$7
taux d'apprentissage minimal : 1e-6 ou 5e-6.
SEQ_LEN=$8
longueur de la séquence.
PAD_LEN=$9
longueur de la séquence de remplissage.
EXTRA_VOCAB_SIZE=${10}
taille supplémentaire du vocabulaire :
Qwen-7B : 85.
Qwen-14B : 213.
Qwen-72B : 213.
PR=${11}
précision d'entraînement : fp16 ou bf16.
TP=${12}
degré de parallélisme du modèle.
PP=${13}
degré de parallélisme de pipeline.
AC=${14}
mode de point de contrôle d'activation : full ou sel.
DO=${15}
Indique s'il faut utiliser la version Megatron de l'optimiseur Zero-1 pour réduire l'utilisation de la VRAM :
true
false
FL=${16}
Indique s'il faut activer Flash Attention :
true
false
SP=${17}
Indique s'il faut utiliser le parallélisme de séquence :
true
false
TE=${18}
Indique s'il faut activer l'accélération Transformer-engine. Cette fonctionnalité nécessite des GPU gu8xf.
SAVE_INTERVAL=${19}
intervalle d'étapes pour l'enregistrement du modèle.
DATASET_PATH=${20}
chemin d'accès au jeu de données d'entraînement.
VALID_DATASET_PATH=${21}
chemin d'accès au jeu de validation.
PRETRAIN_CHECKPOINT_PATH=${22}
chemin d'accès au modèle pré-entraîné.
TRAIN_ITERS=${23}
nombre d'itérations d'entraînement.
LR_WARMUP_ITERS=${24}
étape à laquelle le taux d'apprentissage augmente le plus.
OUTPUT_BASEPATH=${25}
chemin d'accès pour enregistrer les fichiers de modèle de sortie.
Affiner le modèle avec un entraînement distribué sur DLC
Après le débogage sur une instance DSW unique, configurez une tâche distribuée avec des serveurs multi-GPU dans l'environnement DLC. Lors de la soumission de la tâche d'entraînement DLC, configurez la Startup Command comme suit. Les autres paramètres sont identiques à ceux de l'Étape 2 : Pré-entraîner le modèle.
export WORK_DIR=/mnt/workspace cd ${WORK_DIR}/Pai-Megatron-Patch/examples/qwen sh run_finetune_megatron_qwen_withGA.sh \ dlc \ ${WORK_DIR}/Pai-Megatron-Patch \ 7B \ 1 \ 96 \ 1e-5 \ 1e-6 \ 2048 \ 2048 \ 85 \ bf16 \ 1 \ 1 \ sel \ true \ false \ false \ false \ 1000 \ ${WORK_DIR}/qwen-datasets/alpaca_zh-qwen-train.json \ ${WORK_DIR}/qwen-datasets/alpaca_zh-qwen-valid.json \ ${WORK_DIR}/qwen-ckpts/qwen-7b-hf-to-megatron-tp1-pp1 \ 2000 \ 10 \ ${WORK_DIR}/output_megatron_qwen/Les paramètres du script run_finetune_megatron_qwen_withGA.sh sont identiques à ceux de l'affinage sur une instance DSW unique.
Étape 4 : Effectuer une inférence hors ligne
Après l'entraînement, utilisez le pipeline d'inférence Megatron pour l'inférence hors ligne et l'évaluation du modèle.
-
Téléchargez l'échantillon de test pred_input.jsonl et téléchargez-le dans le répertoire
/mnt/workspacedans DSW. Télécharger et télécharger des fichiers.RemarqueLa structure des données pour l'inférence doit correspondre à la structure utilisée pour l'affinage.
-
Copiez tous les fichiers JSON et tokenizer.model du chemin du modèle de pré-entraînement vers le chemin du modèle généré. Le chemin du modèle généré est le sous-répertoire sous
{OUTPUT_BASEPATH }/checkpointet se trouve au même niveau que latest_checkpointed_iteration.txt.RemarqueRemplacez les chemins d'accès dans la commande par vos chemins d'accès réels.
cd /mnt/workspace/qwen-ckpts/qwen-7b-hf-to-megatron-tp1-pp1 cp *.json /mnt/workspace/output_megatron_qwen/checkpoint/dswXXX/ cp tokenizer.model /mnt/workspace/output_megatron_qwen/checkpoint/dswXXX/ -
Dans le Terminal, exécutez la commande suivante pour effectuer une inférence hors ligne. Les résultats de l'inférence sont enregistrés dans le fichier
/mnt/workspace/qwen_pred.txt. Évaluez les performances du modèle en fonction des résultats.RemarqueAvant d'exécuter la commande, définissez le paramètre CUDA_VISIBLE_DEVICES sur 0 et le paramètre GPUS_PER_NODE sur 1 dans le script run_text_generation_megatron_qwen.sh.
export WORK_DIR=/mnt/workspace cd ${WORK_DIR}/Pai-Megatron-Patch/examples/qwen bash run_text_generation_megatron_qwen.sh \ dsw \ ${WORK_DIR}/PAI-Megatron-Patch \ /mnt/workspace/output_megatron_qwen/checkpoint/dswXXX \ 7B \ 1 \ 1 \ 1024 \ 1024 \ 85 \ fp16 \ 10 \ 512 \ 512 \ ${WORK_DIR}/pred_input.jsonl \ ${WORK_DIR}/qwen_pred.txt \ 0 \ 1.0 \ 1.2Le tableau suivant décrit les paramètres du script run_text_generation_megatron_qwen.sh.
Parameter
Description
ENV=$1
environnement d'exécution :
dlc
dsw
MEGATRON_PATCH_PATH=$2
chemin d'accès au code Megatron Patch.
CHECKPOINT_PATH=$3
chemin où le modèle a été enregistré pendant la phase d'entraînement.
ImportantRemplacez cette valeur par le chemin de votre modèle.
MODEL_SIZE=$4
taille du modèle : 7B, 14B ou 72B.
TP=$5
degré de parallélisme du modèle.
ImportantSi ce paramètre est défini sur 1, utilisez un seul GPU pour l'inférence.
Si ce paramètre est défini sur une valeur supérieure à 1, utilisez le nombre correspondant de GPU pour l'inférence.
BS=$6
nombre d'échantillons pour une itération d'inférence sur chaque GPU : 1, 4 ou 8.
SEQ_LEN=$7
longueur de la séquence : 256, 512 ou 1024.
PAD_LEN=$8
Longueur PAD : La longueur à laquelle le texte est complété.
EXTRA_VOCAB_SIZE=${9}
nombre de jetons ajoutés lors de la conversion du modèle :
Qwen-7B : 85.
Qwen-14B : 213.
Qwen-72B : 213.
PR=${10}
précision utilisée pour l'inférence : fp16 ou bf16.
TOP_K=${11}
nombre de jetons de vocabulaire de probabilité la plus élevée à conserver pour le filtrage top-k (0 à n) : 0, 5, 10 ou 20.
INPUT_SEQ_LEN=${12}
longueur de la séquence d'entrée : 512.
OUTPUT_SEQ_LEN=${13}
longueur de la séquence de sortie : 256.
INPUT_FILE=${14}
fichier texte pour l'inférence : pred_input.jsonl. Chaque ligne est un échantillon.
OUTPUT_FILE=${15}
fichier de sortie pour l'inférence : qwen_pred.txt.
TOP_P=${16}
probabilité cumulative pour le filtrage top-p (0 à 1) : 0, 0,85 ou 0,95.
RemarqueSeul l'un des paramètres TOP_K et TOP_P peut être non nul.
TEMPERATURE=${17}
Pénalité de température dans la politique d'échantillonnage : 1–n.
REPETITION_PENALTY=${18}
pénalité pour la répétition. La valeur peut aller de 1 à 2. La valeur par défaut est 1,2.
Étape 5 : Convertir le format du modèle
Convertissez le modèle Megatron entraîné au format HuggingFace pour un déploiement en ligne.
-
Exécutez la commande suivante pour convertir le modèle Megatron au format HuggingFace.
export WORK_DIR=/mnt/workspace cd /mnt/workspace/Pai-Megatron-Patch/toolkits/model_checkpoints_convertor/qwen sh model_convertor.sh \ ../../../Megatron-LM-main \ ${WORK_DIR}/output_megatron_qwen/checkpoint/${path}/iter_******* \ /mnt/workspace/qwen-ckpts/qwen-7b-mg-to-hf-tp1-pp1/ \ 1 \ 1 \ qwen-7b \ 0 \ trueLe tableau suivant décrit les paramètres du script model_convertor.sh.
Parameter
Description
MEGATRON_PATH=$1
chemin d'accès au code Megatron open source.
SOURCE_CKPT_PATH=$2
chemin d'accès au modèle Megatron obtenu à partir de l'entraînement. Le chemin doit être spécifique au répertoire
iter_. Par exemple :${WORK_DIR}/output_megatron_qwen/checkpoint/dsw-pretrain-megatron-qwen-7B-lr-1e-5-bs-1-seqlen-2048-pr-bf16-tp-1-pp-1-ac-sel-do-true-sp-false-tt--wt-/iter_**.ImportantRemplacez cette valeur par le chemin de votre modèle.
Si vous utilisez un modèle pré-entraîné pour la conversion, supprimez tous les fichiers distrib_optim.pt du chemin du modèle.
TARGET_CKPT_PATH=$3
chemin d'accès pour enregistrer le modèle HuggingFace converti.
TP=$4
nombre de fragments de parallélisme tensoriel. Cela doit être identique au nombre utilisé pour l'entraînement.
PP=$5
nombre de fragments de parallélisme de pipeline. Cela doit être identique au nombre utilisé pour l'entraînement.
MN=$6
nom du modèle : qwen-7b, qwen-14b ou qwen-72b.
EXTRA_VOCAB_SIZE=$7
taille supplémentaire du vocabulaire.
mg2hf=$8
Indique s'il faut convertir un modèle Megatron en modèle HuggingFace.
-
Copiez les fichiers
.json,.pyet.tiktokendu dossier du modèle HuggingFace open source/mnt/workspace/qwen-ckpts/qwen-7b-hfvers le répertoire/mnt/workspace/qwen-ckpts/qwen-7b-mg-to-hf-tp1-pp1pour garantir que le modèle peut être utilisé.ImportantNotez que vous n'avez pas besoin de copier le fichier pytorch_model.bin.index.json.
Étape 6 : Déployer et appeler le service de modèle
Déployez le modèle HuggingFace en tant que service d'inférence en ligne.
Déployer le service de modèle
Connectez-vous à la PAI console. Sélectionnez une région en haut de la page. Ensuite, sélectionnez l'espace de travail souhaité et cliquez sur Enter Elastic Algorithm Service (EAS).
Cliquez sur Deploy Service. Dans la section Inference Service, cliquez sur Custom Deployment dans la section Custom Model Deployment.
-
Sur la page Custom Deployment, configurez les paramètres clés suivants et conservez les valeurs par défaut pour les autres paramètres.
Paramètre
Description
Basic Information
Service Name
Saisissez un nom de service de modèle personnalisé unique au sein de la région. Ce guide utilise test_qwen.
Environment Information
Deployment Method
Sélectionnez Image-based Deployment et sélectionnez Enable Web App.
Image Configuration
Sélectionnez Image Address et saisissez l'adresse de registre suivante dans la zone de texte :
eas-registry-vpc.cn-wulanchabu.cr.aliyuncs.com/pai-eas/chat-llm-webui:3.0.4-vllm.Directly Mount
Sélectionnez NAS comme type de montage. Cliquez sur Standard NAS et configurez les paramètres suivants :
Select File System : Sélectionnez le système de fichiers NAS que vous avez utilisé pour créer le jeu de données.
Mount Target : Sélectionnez la cible de montage que vous avez utilisée pour créer le jeu de données.
File System Path : Définissez-le sur le chemin du modèle HuggingFace converti stocké dans NAS. Ce guide utilise
/qwen-ckpts/qwen-7b-mg-to-hf-tp1-pp1.Mount Path : Spécifiez le chemin après le montage. Ce guide utilise
/qwen-7b.
Command
Définissez-le sur
python webui/webui_server.py --port=8000 --model-path=/qwen-7b --tensor-parallel-size 1 --backend=vllm.Où :
--model-path : Doit être identique au chemin de montage dans la configuration du modèle.
--tensor-parallel-size : Le nombre de fragments de parallélisme tensoriel pour le modèle. Cela doit être ajusté en fonction du nombre de GPU. Définissez-le sur 1 pour un modèle 7B et sur 8 pour un modèle 72B (nécessite une instance à huit GPU).
Port Number
Définissez-le sur 8000.
Resource Information
Resource Type
Sélectionnez Resource Quota.
Resource Quota
Sélectionnez le quota de ressources que vous avez créé pour les ressources Lingjun.
Instance Count
Configurez-le en fonction du modèle et des ressources sélectionnées. Pour un modèle 7B, définissez Instance Count sur 1.
Deployment
Pour un modèle 7B, configurez les ressources utilisées par chaque instance comme suit :
vCPUs : 16.
Memory (GB) : 64.
GPUs : 1.
Service Access
VPC
Après avoir configuré la cible de montage NAS, le système fait correspondre automatiquement le VPC, le vSwitch et le groupe de sécurité avec le système de fichiers NAS prédéfini.
vSwitch
Security Group Name
-
Cliquez sur Deploy.
Lorsque le Service Status passe à Running, le service est déployé.
Appeler le service
Appelez le service déployé pour l'inférence.
Dans la liste des services, cliquez sur le nom du service cible. Dans le coin supérieur droit de la page, cliquez sur View Web App.
Sur la page WebUI, effectuez l'inférence du modèle.