Entrene, aplique fine-tune y despliegue Qwen (7B/14B/72B) en la plataforma Lingjun Intelligent Computing con Megatron. Esta guía utiliza Qwen-7B como ejemplo.
Requisitos previos
Esta guía utiliza Qwen-7B v1.1.4. Complete las siguientes preparaciones:
Active PAI (DSW, DLC y EAS) y cree un espacio de trabajo predeterminado. Activate PAI and create a default workspace.
-
Adquiera recursos de Lingjun y cree una cuota de recursos. Seleccione las especificaciones según el tamaño de su modelo. Precios: Lingjun Serverless pricing details. Configuración: Create a resource group and purchase Lingjun resources y Create a resource quota.
Tamaño del modelo
Recursos de entrenamiento con parámetros completos
Recursos de inference (mínimo)
Segmento del modelo de entrenamiento de Megatron
7B
8 × GPU gu7xf, 8 × GPU gu7ef
1 × V100 (32 GB VRAM), 1 × A10 (24 GB VRAM)
TP: 1, PP: 1
14B
8 × GPU gu7xf, 8 × GPU gu7ef
2 × V100 (32 GB VRAM), 2 × A10 (24 GB VRAM)
TP: 2, PP: 1
72B
4 × 8 GPU gu7xf, 4 × 8 GPU gu7ef
6 × V100 (32 GB VRAM), 2 × GPU gu7xf
TP: 8, PP: 2
Cree un conjunto de datos en un sistema de archivos NAS de uso general para almacenar los archivos y los resultados del entrenamiento. Configure la ruta de montaje predeterminada como
/mnt/data/nas. Create and manage datasets.-
Cree una instancia de DSW con a continuación configuración. Create a DSW instance.
Resource Quota: seleccione la cuota de recursos que creó para los recursos de Lingjun.
-
Instance Type: configure las siguientes especificaciones de recursos.
vCPUs: 90.
Memory (GiB): 1024.
Shared Memory (GiB): 1024.
GPUs: como mínimo 8.
Dataset Mounting: haga clic en Custom Dataset, seleccione el conjunto de datos que creó y utilice la ruta de montaje predeterminada.
Image Configuration: en la pestaña Image Address, establezca la imagen de tiempo de ejecución en
pai-image-manage-registry.cn-wulanchabu.cr.aliyuncs.com/pai/pytorch-training:1.12-ubuntu20.04-py3.10-cuda11.3-megatron-patch-llm.
Si utiliza un usuario de RAM, otorgue los permisos obligatorios para DSW, DLC o EAS. Cloud product dependencies and permissions: DSW, Cloud product dependencies and permissions: DLC o Cloud product dependencies and permissions: EAS.
Límites
Esta mejor práctica solo está disponible en la región China (Ulanqab).
Paso 1: Preparar el modelo Qwen
Descargue el modelo Qwen mediante uno de los siguientes métodos:
-
Acceda al entorno de desarrollo de PAI DSW.
Inicie sesión en la PAI console.
En la esquina superior izquierda de la página, seleccione la región donde desea utilizar el servicio: China (Ulanqab).
En el panel de navegación izquierdo, haga clic en Workspaces. En la página que aparece, haga clic en el nombre del espacio de trabajo que desea gestionar.
En el panel de navegación izquierdo, elija .
En la columna Actions de la instancia de destino, haga clic en Open.
En la barra de menú superior, haga clic en Terminal. En la pestaña que aparece, haga clic en create a terminal.
-
Descargue el modelo Qwen.
Descargar el modelo desde la comunidad ModelScope
En Terminal, ejecute el siguiente comando para instalar ModelScope.
Introduzca el entorno de Python.
El siguiente código descarga los archivos del modelo Qwen-7B.
Presione
Ctrl+Dpara salir del entorno de Python.Ejecute el siguiente comando para mover el modelo Qwen descargado a la carpeta correspondiente.
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-hfDescargar el modelo desde la comunidad HuggingFace
En el Terminal de DSW, ejecute el siguiente comando para descargar los archivos del modelo. Esta guía utiliza el modelo Qwen-7B como ejemplo. Para descargar los archivos del modelo Qwen-14B o Qwen-72B, modifique el siguiente código según sea necesario.
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
Paso 2: Preparar los datos de preentrenamiento
Prepare los datos de preentrenamiento en DSW. Este ejemplo utiliza WuDaoCorpora2.0 (solo para investigación) para demostrar el preprocesamiento de datos de Megatron. Descargue los datos de muestra proporcionados por PAI o prepare los suyos.
Utilizar los datos de muestra a pequeña escala procesados por PAI
PAI proporciona datos de muestra ya procesados. Ejecute el siguiente comando para descargarlos.
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.idxProcesar los datos por su cuenta
-
Descargue el conjunto de datos WuDaoCorpora2.0 en
/mnt/workspace/qwen-datasets. La carpeta descomprimida se llama wudao_200g.PAI proporciona datos de muestra para esta demostración. Ejecute el siguiente comando para descargar y descomprimir el conjunto de datos.
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 -
En Terminal, ejecute el siguiente comando para limpiar los datos de Wudao y convertir el formato de los archivos. Esto genera el archivo combinado 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_datasetUna vez ejecutado el comando, la estructura de archivos del directorio
qwen-datasetses la siguiente. Se agrega una nueva carpeta llamada wudao.qwen-datasets ├── wudao_200g └── wudao └── merged_wudao_cleaned.json -
En Terminal, ejecute el siguiente comando para dividir el archivo merged_wudao_cleaned.json en varios grupos y comprimirlos. Esto facilita el procesamiento multihilo en los pasos posteriores.
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.jsonUna vez ejecutado el comando, la estructura de archivos del directorio
qwen-datasetses la siguiente. Se agrega una nueva carpetacleaned_zstque contiene 10 archivos comprimidos.qwen-datasets ├── wudao_200g ├── wudao └── cleaned_zst ├── 00.jsonl.zst │ ... └── 09.jsonl.zst -
Cree un conjunto de datos de preentrenamiento en formato MMAP.
MMAP es un formato de datos pretokenizados que reduce el tiempo de espera durante la lectura de datos en el entrenamiento y el fine-tune. Resulta especialmente ventajoso al procesar datos a gran escala. Siga estos pasos:
-
En el Terminal de DSW, ejecute el siguiente comando para copiar el código fuente de PAI-Megatron-Patch al directorio de trabajo de DSW
/mnt/workspace/. Esta herramienta sirve para entrenar modelos con Megatron.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 -
En Terminal, ejecute el siguiente comando para convertir los datos al formato MMAP.
Una vez ejecutado el comando, se generan los archivos
.biny.idxen el directorio/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_zstLa siguiente tabla describe los parámetros de run_make_pretraining_dataset.sh.
Parámetro
Descripción
MEGATRON_PATH=$1
Ruta del código de código abierto de Megatron.
MEGATRON_PATCH_PATH=$2
Ruta del código de Megatron Patch.
input_data_dir=$3
Ruta de la carpeta que contiene el conjunto de datos WuDao empaquetado.
tokenizer=$4
Tipo de tokenizer. Establézcalo en qwenbpe.
output_data_dir=$5
Ruta donde se guardarán los archivos de salida
.biny.idx.load_dir=$6
Ruta del archivo tokenizer_config.json generado.
Estructura resultante del directorio
qwen-datasets:qwen-datasets ├── wudao_200g └── wudao ├── wudao_qwenbpe_content_document.bin └── wudao_qwenbpe_content_document.idx
-
Paso 3: Entrenar el modelo con Megatron
Entrene el modelo con Megatron.
Convertir el formato del modelo
Convierta los archivos del modelo de HuggingFace al formato de Megatron.
Descargar el modelo de Megatron convertido
PAI proporciona un modelo previamente convertido. Descárguelo:
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-pp1Convertir el modelo de HuggingFace al formato de Megatron
Ejecute el siguiente comando para convertir el modelo de HuggingFace al formato de 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 \
falseLa siguiente tabla describe los parámetros de model_convertor.sh.
Parámetro | Descripción |
MEGATRON_PATH=$1 | Ruta del código de código abierto de Megatron. |
SOURCE_CKPT_PATH=$2 | Ruta de los archivos del modelo de HuggingFace. |
TARGET_CKPT_PATH=$3 | Ruta donde se guardará el modelo de Megatron convertido. |
TP=$4 | Número de fragmentos de paralelismo de tensores. Debe coincidir con el valor utilizado durante el entrenamiento. Este número varía según el tamaño del modelo. Modifique este parámetro según sea necesario al convertir el modelo:
|
PP=$5 | Número de fragmentos de paralelismo de canalización. Debe coincidir con el valor utilizado durante el entrenamiento. Este número varía según el tamaño del modelo. Modifique este parámetro según sea necesario al convertir el modelo:
|
MN=$6 | Nombre del modelo: qwen-7b, qwen-14b o qwen-72b. |
EXTRA_VOCAB_SIZE=$7 | Tamaño adicional del vocabulario. |
mg2hf=$8 | Indica si se convertirá un modelo de Megatron a un modelo de HuggingFace. |
Modelo preentrenado
Realice el preentrenamiento en una sola instancia de DSW o envíe una tarea distribuida en DLC. El entrenamiento toma aproximadamente dos horas. Los archivos del modelo se guardan en el directorio /mnt/workspace/output_megatron_qwen/.
Modelo preentrenado independiente en DSW
Ejecute el siguiente comando para el modelo Qwen-7B en 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/ Parámetros de run_pretrain_megatron_qwen.sh:
Parámetro | Descripción |
ENV=$1 | El entorno de ejecución:
|
MEGATRON_PATH=$2 | La ruta del código de código abierto de Megatron. |
MODEL_SIZE=$3 | El tamaño del modelo: 7B, 14B o 72B. |
BATCH_SIZE=$4 | La cantidad de muestras para una iteración de entrenamiento en cada GPU: 4 u 8. |
GLOBAL_BATCH_SIZE=$5 | Cantidad total de muestras de entrenamiento. |
LR=$6 | La tasa de aprendizaje: 1e-5 o 5e-5. |
MIN_LR=$7 | La tasa de aprendizaje mínima: 1e-6 o 5e-6. |
SEQ_LEN=$8 | La longitud de la secuencia. |
PAD_LEN=${9} | La longitud de relleno. |
EXTRA_VOCAB_SIZE=${10} | El tamaño adicional del vocabulario:
|
PR=${11} | La precisión del entrenamiento: fp16 o bf16. |
TP=${12} | El grado de paralelismo del modelo. |
PP=${13} | El grado de paralelismo de pipeline. |
AC=${14} | El modo de checkpointing de activaciones:
|
DO=${15} | Indica si se usa la versión de Megatron del optimizador Zero-1 para reducir el uso de VRAM:
|
FL=${16} | Indica si se habilita Flash Attention:
|
SP=${17} | Indica si se usa paralelismo de secuencias:
|
TE=${18} | Indica si se habilita la aceleración de Transformer-engine. Esta función requiere GPU gu8xf. |
SAVE_INTERVAL=${19} | El intervalo para guardar los archivos de checkpoint. |
DATASET_PATH=${20} | La ruta del conjunto de datos de entrenamiento. |
PRETRAIN_CHECKPOINT_PATH=${21} | La ruta del modelo preentrenado. |
TRAIN_TOKENS=${22} | Tokens de entrenamiento |
WARMUP_TOKENS=${23} | La cantidad de tokens de warmup. |
OUTPUT_BASEPATH=${24} | La ruta donde se guardan los archivos del modelo de salida. |
Modelo preentrenado distribuido en DLC
Después de depurar en una sola instancia, configure una tarea distribuida con múltiples GPU en DLC:
-
Vaya a la página Create Job.
Inicie sesión en la PAI console, seleccione la región y el espacio de trabajo de destino, y haga clic en Deep Learning Containers (DLC).
En la página Deep Learning Containers (DLC), haga clic en Create Job.
-
En la página Create Job, configure los siguientes parámetros clave y conserve los valores predeterminados para el resto. Create a training task.
Parámetro
Descripción
Basic Information
Job Name
Introduzca un nombre personalizado para la tarea. En esta guía se usa test_qwen_dlc.
Environment Information
Image Configuration
Seleccione Image Address e introduzca
pai-image-manage-registry.cn-wulanchabu.cr.aliyuncs.com/pai/pytorch-training:1.12-ubuntu20.04-py3.10-cuda11.3-megatron-patch-llmen el cuadro de texto.Mount dataset
Haga clic en Custom Dataset y configure los siguientes parámetros:
Custom Dataset: Seleccione el conjunto de datos de NAS que creó.
Mount Path: Establezca este valor en
/mnt/workspace/.
Startup Command
Configure el siguiente comando. Los parámetros de inicio del script run_pretrain_megatron_qwen.sh son los mismos que se usan para preentrenar el modelo en una sola instancia de DSW.
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
Seleccione Lingjun Intelligent Computing.
Source
Seleccione Resource Type.
Resource Type
Seleccione la cuota de recursos que creó para los recursos de Lingjun.
Framework
Seleccione PyTorch.
Job Resource
Configure los siguientes parámetros para el nodo Worker:
Nodes: 2. Para ejecutar el entrenamiento en varios nodos, establezca Nodes con la cantidad de máquinas requerida.
GPUs: 8
vCPUs: 90
NotaLa cantidad de núcleos de CPU no puede superar 96.
Memory (GiB): 1024
Shared Memory (GiB): 1024
Haga clic en OK. La página redirige automáticamente a Deep Learning Containers (DLC). Cuando Status cambie a Succeeded, la tarea de entrenamiento habrá finalizado con éxito.
Ajuste fino del modelo con aprendizaje supervisado
Ejecute el fine-tune del modelo en una sola instancia de DSW o envíe una tarea distribuida en el entorno de DLC. El entrenamiento toma aproximadamente dos horas. Los archivos del modelo se guardan en /mnt/workspace/output_megatron_qwen/.
Antes de iniciar el fine-tune, vaya a Step 2: Prepare pre-training data y descargue el archivo JSON desde la pestaña Use the small-scale sample data processed by PAI.
-
Ejecute el fine-tune del modelo.
Fine-tune del modelo en una sola instancia de DSW
Ejecute el siguiente comando para el modelo Qwen-7B en 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/Parámetros de run_finetune_megatron_qwen_withGA.sh:
Parámetro
Descripción
ENV=$1
Entorno de ejecución:
dlc
dsw
MEGATRON_PATH=$2
Ruta del código de código abierto de Megatron.
MODEL_SIZE=$3
Tamaño del modelo: 7B, 14B o 72B.
BATCH_SIZE=$4
Cantidad de muestras para una iteración de entrenamiento en cada GPU: 1, 2, 4 u 8.
GLOBAL_BATCH_SIZE=$5
Cantidad total de muestras para una iteración de fine-tune: 64, 96 o 128.
LR=$6
Tasa de aprendizaje: 1e-5 o 5e-5.
MIN_LR=$7
Tasa de aprendizaje mínima: 1e-6 o 5e-6.
SEQ_LEN=$8
Longitud de la secuencia.
PAD_LEN=$9
Longitud de relleno de la secuencia.
EXTRA_VOCAB_SIZE=${10}
Tamaño adicional del vocabulario:
Qwen-7B: 85.
Qwen-14B: 213.
Qwen-72B: 213.
PR=${11}
Precisión del entrenamiento: fp16 o bf16.
TP=${12}
Grado de paralelismo del modelo.
PP=${13}
Grado de paralelismo de pipeline.
AC=${14}
Modo de checkpointing de activaciones: full o sel.
DO=${15}
Indica si se usa la versión de Megatron del optimizador Zero-1 para reducir el uso de VRAM:
true
false
FL=${16}
Indica si se habilita Flash Attention:
true
false
SP=${17}
Indica si se usa paralelismo de secuencias:
true
false
TE=${18}
Indica si se habilita la aceleración de Transformer-engine. Esta función requiere GPU gu8xf.
SAVE_INTERVAL=${19}
Intervalo de pasos para guardar el modelo.
DATASET_PATH=${20}
Ruta del conjunto de datos de entrenamiento.
VALID_DATASET_PATH=${21}
Ruta del conjunto de validación.
PRETRAIN_CHECKPOINT_PATH=${22}
Ruta del modelo preentrenado.
TRAIN_ITERS=${23}
Cantidad de iteraciones de entrenamiento.
LR_WARMUP_ITERS=${24}
Paso en el que la tasa de aprendizaje aumenta más.
OUTPUT_BASEPATH=${25}
Ruta donde se guardan los archivos del modelo de salida.
Fine-tune del modelo con entrenamiento distribuido en DLC
Después de depurar en una sola instancia de DSW, configure una tarea distribuida con servidores de múltiples GPU en el entorno de DLC. Al enviar la tarea de entrenamiento en DLC, configure Startup Command como se indica a continuación. Los demás parámetros son los mismos que en Step 2: Pre-train the model.
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/Los parámetros de run_finetune_megatron_qwen_withGA.sh son los mismos que se usan para el fine-tune en una sola instancia de DSW.
Paso 4: Ejecutar inference sin conexión
Una vez concluido el entrenamiento, use el pipeline de inference de Megatron para ejecutar la inference sin conexión y evaluar el modelo.
-
Descargue la muestra de prueba pred_input.jsonl y cárguela en el directorio
/mnt/workspacede DSW. Upload and download files.NotaLa estructura de los datos para la inference debe coincidir con la estructura utilizada durante el fine-tune.
-
Copie todos los archivos JSON y tokenizer.model desde la ruta del modelo de preentrenamiento hacia la ruta del modelo generado. Esta última corresponde al subdirectorio dentro de
{OUTPUT_BASEPATH }/checkpointy se encuentra al mismo nivel que latest_checkpointed_iteration.txt.NotaReemplace las rutas del comando por sus rutas reales.
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/ -
En Terminal, ejecute el siguiente comando para realizar la inference sin conexión. Los resultados se guardan en el archivo
/mnt/workspace/qwen_pred.txt. Evalúe el rendimiento del modelo con base en dichos resultados.NotaAntes de ejecutar el comando, establezca el parámetro CUDA_VISIBLE_DEVICES en 0 y el parámetro GPUS_PER_NODE en 1 dentro del 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.2A continuación se describen los parámetros de run_text_generation_megatron_qwen.sh.
Parámetro
Descripción
ENV=$1
Entorno de ejecución:
dlc
dsw
MEGATRON_PATCH_PATH=$2
Ruta del código de Megatron Patch.
CHECKPOINT_PATH=$3
Ruta donde se guardó el modelo durante la fase de entrenamiento.
ImportanteReemplace este valor con la ruta de su modelo.
MODEL_SIZE=$4
Tamaño del modelo: 7B, 14B o 72B.
TP=$5
Grado de paralelismo del modelo.
ImportanteSi este parámetro se establece en 1, se utiliza una sola GPU para la inference.
Si este parámetro se establece en un valor mayor que 1, se utiliza esa misma cantidad de GPU para la inference.
BS=$6
Cantidad de muestras para una iteración de inference en cada GPU: 1, 4 u 8.
SEQ_LEN=$7
Longitud de la secuencia: 256, 512 o 1024.
PAD_LEN=$8
Longitud de PAD: la longitud a la que se rellena el texto.
EXTRA_VOCAB_SIZE=${9}
Cantidad de tokens agregados durante la conversión del modelo:
Qwen-7B: 85.
Qwen-14B: 213.
Qwen-72B: 213.
PR=${10}
Precisión utilizada para la inference: fp16 o bf16.
TOP_K=${11}
Cantidad de tokens del vocabulario con mayor probabilidad que se conservan para el filtrado top-k (de 0 a n): 0, 5, 10 o 20.
INPUT_SEQ_LEN=${12}
Longitud de la secuencia de entrada: 512.
OUTPUT_SEQ_LEN=${13}
Longitud de la secuencia de salida: 256.
INPUT_FILE=${14}
Archivo de texto para la inference: pred_input.jsonl. Cada línea representa una muestra.
OUTPUT_FILE=${15}
Archivo de salida de la inference: qwen_pred.txt.
TOP_P=${16}
Probabilidad acumulada para el filtrado top-p (de 0 a 1): 0, 0.85 o 0.95.
NotaSolo uno de los parámetros TOP_K o TOP_P puede ser distinto de cero.
TEMPERATURE=${17}
Penalización de temperatura en la política de muestreo: de 1 a n.
REPETITION_PENALTY=${18}
Penalización por repetición. El valor puede ir de 1 a 2. El valor predeterminado es 1.2.
Paso 5: Convertir el formato del modelo
Convierta el modelo de Megatron entrenado al formato de HuggingFace para su despliegue en línea.
-
Ejecute el siguiente comando para convertir el modelo de Megatron al formato de 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 \ trueA continuación se describen los parámetros de model_convertor.sh.
Parámetro
Descripción
MEGATRON_PATH=$1
Ruta del código de código abierto de Megatron.
SOURCE_CKPT_PATH=$2
Ruta del modelo de Megatron obtenido durante el entrenamiento. Debe apuntar específicamente al directorio
iter_. Por ejemplo:${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_**.ImportanteReemplace este valor con la ruta de su modelo.
Si utiliza un modelo preentrenado para la conversión, elimine todos los archivos distrib_optim.pt de la ruta del modelo.
TARGET_CKPT_PATH=$3
Ruta donde se guarda el modelo de HuggingFace convertido.
TP=$4
Cantidad de fragmentos de paralelismo de tensores. Debe coincidir con la cantidad utilizada durante el entrenamiento.
PP=$5
Cantidad de fragmentos de paralelismo de pipeline. Debe coincidir con la cantidad utilizada durante el entrenamiento.
MN=$6
Nombre del modelo: qwen-7b, qwen-14b o qwen-72b.
EXTRA_VOCAB_SIZE=$7
Tamaño adicional del vocabulario.
mg2hf=$8
Indica si se convierte un modelo de Megatron a un modelo de HuggingFace.
-
Copie los archivos
.json,.pyy.tiktokende la carpeta del modelo de código abierto de HuggingFace/mnt/workspace/qwen-ckpts/qwen-7b-hfal directorio/mnt/workspace/qwen-ckpts/qwen-7b-mg-to-hf-tp1-pp1para garantizar que el modelo funcione correctamente.ImportanteTenga en cuenta que no es necesario copiar el archivo pytorch_model.bin.index.json.
Paso 6: Desplegar y llamar al servicio del modelo
Despliegue el modelo de HuggingFace como un servicio de inference en línea.
Desplegar el servicio del modelo
Inicie sesión en PAI console. Seleccione una región en la parte superior de la página. Después, seleccione el espacio de trabajo deseado y haga clic en Enter Elastic Algorithm Service (EAS).
Haga clic en Deploy Service. En la sección Inference Service, haga clic en Custom Deployment dentro de Custom Model Deployment.
-
En la página Custom Deployment, configure los siguientes parámetros clave y conserve los valores predeterminados para el resto.
Parámetro
Descripción
Basic Information
Service Name
Introduzca un nombre personalizado para el servicio del modelo que sea único dentro de la región. Esta guía utiliza test_qwen.
Environment Information
Deployment Method
Seleccione Image-based Deployment y active Enable Web App.
Image Configuration
Seleccione Image Address e introduzca la siguiente dirección de registro en el cuadro de texto:
eas-registry-vpc.cn-wulanchabu.cr.aliyuncs.com/pai-eas/chat-llm-webui:3.0.4-vllm.Directly Mount
Seleccione NAS como tipo de montaje. Haga clic en Standard NAS y configure los siguientes parámetros:
Select File System: seleccione el sistema de archivos NAS que utilizó para crear el conjunto de datos.
Mount Target: seleccione el destino de montaje que utilizó para crear el conjunto de datos.
File System Path: establezca la ruta donde se almacena el modelo de HuggingFace convertido en NAS. Esta guía utiliza
/qwen-ckpts/qwen-7b-mg-to-hf-tp1-pp1.Mount Path: especifique la ruta después del montaje. Esta guía utiliza
/qwen-7b.
Command
Establezca este valor en
python webui/webui_server.py --port=8000 --model-path=/qwen-7b --tensor-parallel-size 1 --backend=vllm.Donde:
--model-path: debe coincidir con la ruta de montaje definida en la configuración del modelo.
--tensor-parallel-size: indica el número de fragmentos de paralelismo de tensores del modelo. Este valor se ajusta según la cantidad de GPU. Establézcalo en 1 para un modelo de 7B y en 8 para uno de 72B (requiere una instancia con ocho GPU).
Port Number
Establezca este valor en 8000.
Resource Information
Resource Type
Seleccione Resource Quota.
Resource Quota
Seleccione la cuota de recursos que creó para los recursos de Lingjun.
Instance Count
Configure este valor según el modelo y los recursos seleccionados. Para un modelo de 7B, establezca Instance Count en 1.
Deployment
Para un modelo de 7B, configure los recursos que utilizará cada instancia de la siguiente manera:
vCPUs: 16.
Memory (GB): 64.
GPUs: 1.
Service Access
VPC
Una vez configurado el destino de montaje de NAS, el sistema asocia automáticamente la VPC, el vSwitch y el security group con el sistema de archivos NAS predefinido.
vSwitch
Security Group Name
-
Haga clic en Deploy.
Cuando Service Status cambie a Running, el despliegue del servicio habrá finalizado.
Llamar al servicio
Llame al servicio desplegado para ejecutar la inference.
En la lista de servicios, haga clic en el nombre del servicio correspondiente. En la esquina superior derecha de la página, haga clic en View Web App.
En la página de WebUI, ejecute la inference del modelo.