Что делает вот этот код worldsize = int(os.environ.get("WORLDSIZE", 1))ddp = world_size…
- User
Что делает вот этот код world_size = int(os.environ.get("WORLD_SIZE", 1))ddp = world_size != 1
- Assistant
В приведенной строке есть небольшая ошибка, из-за которой код не будет работать как ожидается. Но если мы разделим его на две части, то сможем понять, что он предполагалось сделать:
world_size = int(os.environ.get("WORLD_SIZE", 1))ddp = world_size != 1
Первая строка извлекает значение переменной окружения
WORLD_SIZE, преобразует его в целое число и присваивает это число переменнойworld_size. Если переменной окруженияWORLD_SIZEне существует, используется значение по умолчанию1.Вторая строка вычисляет логическую переменную
ddp, которая будет иметь значениеTrue, еслиworld_sizeне равен1, иFalse, еслиworld_sizeравен1. Это может использоваться, например, в распределенном машинном обучении для проверки того, находится ли код в режиме распределенного обучения (гдеworld_sizeбудет представлять количество процессов обучения).Чтобы код работал корректно, его нужно разделить на две строки:
import os world_size = int(os.environ.get("WORLD_SIZE", 1)) ddp = world_size != 1Теперь код будет корректно выполнять описанные выше действия.
- User
Для чего нужна вот это строчка os.environ["TOKENIZERS_PARALLELISM"] = "false"
- Assistant
Строка
os.environ["TOKENIZERS_PARALLELISM"] = "false"используется в Python для установки переменной окруженияTOKENIZERS_PARALLELISMв значение"false".Токенизаторы, такие как те, что предоставляются библиотекой
transformersот Hugging Face, часто используют библиотеку Rusttokenizersпод капотом для эффективного параллельного кодирования текста. Установка переменной окруженияTOKENIZERS_PARALLELISMв значение"false"отключает параллельное выполнение токенизации.Такая настройка может быть полезна в следующих случаях:
-
Когда вы запускаете свой код в среде, где параллельное выполнение нежелательно или не поддерживается. Например, в некоторых контейнерах или платформах ограниченное число потоков.
-
Если ваш код уже использует многопоточность или вы хотите избежать конкуренции за общие ресурсы, отключение внутренней многопоточности токенизатора может привести к лучшей работоспособности и стабильности программы.
-
Для устранения предупреждений об использовании параллельной обработки, которые могут возникать при использовании токенизаторов в некоторых контекстах (например, при выполнении в среде, контролируемой такими программами, как PyTorch DataLoader).
Важный момент при использовании этой переменной заключается в том, что значение должно быть установлено в строку
"false"а не в булево значениеFalse, поскольку значения переменных окружения всегда интерпретируются как строки. -
- User
Как работает ddp в pytorch
- Assistant
DDP в PyTorch относится к распределенному обучению с помощью модуля
torch.distributedи его компонентаDistributedDataParallel, часто сокращаемого до DDP.DistributedDataParallel- это класс, который позволяет автоматически разделить данные и модель для обучения на нескольких GPU или даже на нескольких узлах (машин).Вот основные шаги использования DDP в PyTorch:
-
Инициализация библиотеки для работы с распределенными системами: Прежде чем можно будет использовать DDP, нужно инициализировать процессы для распределенного обучения. Это обычно делается с помощью одной из функций инициализации, таких как
torch.distributed.init_process_group.torch.distributed.init_process_group( backend='nccl', # 'nccl' обычно используется для GPU, 'gloo' или 'mpi' для CPU init_method='env://', # метод инициализации, 'env://' указывает на использование переменных окружения world_size=N, # общее количество процессов rank=rank # уникальный идентификатор процесса внутри группы (от 0 до N-1) ) -
Разделение данных на подмножества: Входные данные нужно разделить на равные части, чтобы каждый процесс обрабатывал только свою часть данных. Это обычно делается с использованием
DistributedSampler, который гарантирует, что каждый процесс получает уникальный набор данных для обучения. -
Создание модели и ее обертывание в DDP: Модель должна быть обернута в экземпляр класса
torch.nn.parallel.DistributedDataParallel. Это автоматизирует синхронизацию градиентов и параметров между процессами.model = MyModel() # Это ваша модель model = model.cuda(rank) # Перемещение модели на соответствующее устройство model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[rank]) -
Обучение модели: Обучение можно проводить так, как если бы вы работали на одном устройстве, но градиенты автоматически агрегируются на всех устройствах после каждой операции обратного распространения (
backward).
При обучении с использованием DDP PyTorch способен максимально использовать вычислительные ресурсы на нескольких устройствах, значительно увеличивая пропускную полосу и эффективность обучения.
-
- User
Что делает вот этот код if ddp: device_map = {"": int(os.environ.get("LOCAL_RANK") or 0)} gradient_accumulation_steps = trainer_config["gradient_accumulation_steps"] gradient_accumulation_steps = gradient_accumulation_steps // world_size trainer_config["gradient_accumulation_steps"] = gradient_accumulation_steps
- Assistant
Кусок кода, который вы предоставили, выглядит как часть более обширного скрипта на Python, который настраивает настройки тренировщика (trainer) для использования в распределенной тренировочной сессии, вероятно с использованием библиотеки PyTorch. Давайте разберем его по строкам:
-
if ddp:- Это условное выражение проверяет, имеет ли переменнаяddpистинное значение (True). Если это так, то последующий блок кода будет выполнен. Мы можем предположить, чтоddpозначает использование распределенного обучения. -
device_map = {"": int(os.environ.get("LOCAL_RANK") or 0)}- Создает словарьdevice_map, ключом которого является пустая строка "". Значение - это номер локального ранга (LOCAL_RANK), который есть в окружении, и если его нет, то по умолчанию используется0. Этот локальный ранг обычно используется для идентификации конкретного GPU на машине при распределенном обучении. При использовании нескольких GPU одновременно каждый процесс будет иметь свой LOCAL_RANK. -
gradient_accumulation_steps = trainer_config["gradient_accumulation_steps"]- Извлекает значениеgradient_accumulation_stepsиз конфигурации тренировщикаtrainer_config. Этот параметр часто используется для накопления градиентов во время обучения, что позволяет эффективно использовать память и выполнять обновление параметров менее часто. -
gradient_accumulation_steps = gradient_accumulation_steps // world_size- Делит значениеgradient_accumulation_stepsнаworld_sizeс использованием целочисленного деления (//). Деление наworld_size(количество процессов в распределенной тренировке) нужно для того, чтобы учитывать, что теперь градиенты накапливаются и обновляются синхронно на нескольких устройствах. -
trainer_config["gradient_accumulation_steps"] = gradient_accumulation_steps- Обновляет значениеgradient_accumulation_stepsв конфигурации тренировщика. Это потенциально уменьшает количество шагов накопления градиентов на каждом отдельном устройстве в распределенной системе.
Обратите внимание, что для полного понимания этой части кода, необходим контекст, в котором он используется. В частности, отсутствует информация о том, как используется переменная
device_map, и могут существовать другие места в коде, где важны значения, установленные вtrainer_config. -
- User
Как изменить этот код, что провести обучение на нескольких gpu import random import json import os
import fire import wandb import torch import numpy as np from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForTokenClassification, AutoConfig from transformers import Trainer, TrainingArguments, logging, TrainerCallback, TrainerState, TrainerControl, BitsAndBytesConfig from transformers.trainer_utils import PREFIX_CHECKPOINT_DIR from peft import get_peft_model, LoraConfig, prepare_model_for_kbit_training
from src.dataset import ChatDataset from src.util.dl import set_random_seed, fix_tokenizer, fix_model from src.util.io import read_jsonl
os.environ["TOKENIZERS_PARALLELISM"] = "false"
class TrainerNoBaseSave(Trainer): def init(self, *args, **kwargs): return super().init(*args, **kwargs)
def _save_checkpoint(self, model, trial, metrics=None): print("Running custom _save_checkpoint") checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}" run_dir = self._get_output_dir(trial=trial) output_dir = os.path.join(run_dir, checkpoint_folder) if metrics is not None and self.args.metric_for_best_model is not None: metric_to_check = self.args.metric_for_best_model if not metric_to_check.startswith("eval_"): metric_to_check = f"eval_{metric_to_check}" metric_value = metrics[metric_to_check] operator = np.greater if self.args.greater_is_better else np.less if ( self.state.best_metric is None or self.state.best_model_checkpoint is None or operator(metric_value, self.state.best_metric) ): self.state.best_metric = metric_value self.state.best_model_checkpoint = output_dir os.makedirs(output_dir, exist_ok=True) if self.args.should_save: self._rotate_checkpoints(use_mtime=True, output_dir=run_dir)class SavePeftModelCallback(TrainerCallback): def on_save( self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs, ): checkpoint_path = f"{PREFIX_CHECKPOINT_DIR}-{state.global_step}" checkpoint_folder = os.path.join(args.output_dir, checkpoint_path) kwargs["model"].save_pretrained(checkpoint_folder) return control
def custom_prepare_model_for_int8_training( model, output_embedding_layer_name="lm_head", layer_norm_names=["layer_norm"] ): for name, param in model.named_parameters(): param.requires_grad = False
for name, param in model.named_parameters(): if param.ndim == 1 and any(layer_norm_name in name for layer_norm_name in layer_norm_names): param.data = param.data.to(torch.float32) if hasattr(model, "enable_input_require_grads"): model.enable_input_require_grads() else: def make_inputs_require_grad(module, input, output): output.requires_grad_(True) model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) if hasattr(model, output_embedding_layer_name): output_embedding_layer = getattr(model, output_embedding_layer_name) input_dtype = output_embedding_layer.weight.dtype class CastOutputToFloat(torch.nn.Sequential): def forward(self, x): return super().forward(x.to(input_dtype)).to(torch.float32) setattr(model, output_embedding_layer_name, CastOutputToFloat(output_embedding_layer)) model.gradient_checkpointing_enable() return modeldef train( config_file: str, train_file: str, val_file: str, output_dir: str, checkpoint: str = None, sample_rate: float = 1.0, report_to: str = "wandb", seed: int = 42, use_flash_attention_2: bool = False ): set_random_seed(seed) logging.set_verbosity_info() with open(config_file, "r") as r: config = json.load(r)
device_map = "auto" world_size = int(os.environ.get("WORLD_SIZE", 1)) ddp = world_size != 1 deepspeed_config = config.get("deepspeed") trainer_config = config.get("trainer") lora_config = config.get("lora") callbacks = [SavePeftModelCallback] if lora_config else [] training_args = TrainingArguments( output_dir=output_dir, save_total_limit=1, load_best_model_at_end=True, report_to=report_to, ddp_find_unused_parameters=False if ddp else None, deepspeed=deepspeed_config, **trainer_config ) model_name = config["model_name"] tokenizer_name = config.get("tokenizer_name", model_name) use_fast = config.get("use_fast", False) if ddp: device_map = {"": int(os.environ.get("LOCAL_RANK") or 0)} gradient_accumulation_steps = trainer_config["gradient_accumulation_steps"] gradient_accumulation_steps = gradient_accumulation_steps // world_size trainer_config["gradient_accumulation_steps"] = gradient_accumulation_steps tokenizer = AutoTokenizer.from_pretrained(tokenizer_name, use_fast=use_fast) model_config = AutoConfig.from_pretrained(model_name) tokenizer = fix_tokenizer(tokenizer, model_config) tokenizer.save_pretrained(output_dir) train_records = read_jsonl(train_file) val_records = read_jsonl(val_file) random.shuffle(train_records) print(train_records[0]) model_type = config.get("model_type", "causal") templates_path = config["templates_path"] only_target_loss = config.get("only_target_loss", True) mode = config.get("mode", "chat") assert mode == "chat", "Only chat mode is supported in new versions!" assert model_type == "causal", "Only causal models are supported in new versions!" max_tokens_count = config["max_tokens_count"] datasets = [] for records in (train_records, val_records): datasets.append(ChatDataset( records, tokenizer, max_tokens_count=max_tokens_count, sample_rate=sample_rate, templates_path=templates_path, only_target_loss=only_target_loss )) train_dataset, val_dataset = datasets data_collator = DataCollatorForTokenClassification(tokenizer, pad_to_multiple_of=8) print("INPUT_IDS") print(data_collator([train_dataset[0], train_dataset[1]])["input_ids"][0]) print("MASK") print(data_collator([train_dataset[0], train_dataset[1]])["attention_mask"][0]) print("LABELS") print(data_collator([train_dataset[0], train_dataset[1]])["labels"][0]) model_types = { "causal": AutoModelForCausalLM, } load_in_8bit = bool(config.get("load_in_8bit", False)) load_in_4bit = bool(config.get("load_in_4bit", False)) use_bf16 = bool(trainer_config.get("bf16", False)) torch_dtype = torch.bfloat16 if use_bf16 else torch.float16 if load_in_8bit: assert not load_in_4bit model = model_types[model_type].from_pretrained( model_name, load_in_8bit=True, device_map=device_map, torch_dtype=torch_dtype, use_flash_attention_2=use_flash_attention_2 ) model = fix_model(model, tokenizer, use_resize=False) model = custom_prepare_model_for_int8_training(model) elif load_in_4bit: assert not load_in_8bit model = model_types[model_type].from_pretrained( model_name, load_in_4bit=True, device_map=device_map, quantization_config=BitsAndBytesConfig( load_in_4bit=True, llm_int8_threshold=6.0, llm_int8_has_fp16_weight=False, bnb_4bit_compute_dtype=torch_dtype, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4" ), torch_dtype=torch_dtype, use_flash_attention_2=use_flash_attention_2 ) model = fix_model(model, tokenizer, use_resize=False) model = prepare_model_for_kbit_training(model) else: model = model_types[model_type].from_pretrained( model_name, device_map=device_map, torch_dtype=torch_dtype, use_flash_attention_2=use_flash_attention_2 ) model = fix_model(model, tokenizer, use_resize=False) model = custom_prepare_model_for_int8_training(model) # Default model generation params model.config.num_beams = 5 model.config.max_length = max_tokens_count if not ddp and torch.cuda.device_count() > 1: model.is_parallelizable = True model.model_parallel = True if lora_config: lora_config = LoraConfig(**lora_config) model = get_peft_model(model, lora_config) trainer = TrainerNoBaseSave( model=model, args=training_args, train_dataset=train_dataset, eval_dataset=val_dataset, callbacks=callbacks, data_collator=data_collator ) if trainer_config.get("report_to", "wandb") == "wandb": wandb.init(project="rulm_self_instruct", name=config_file) trainer.train(checkpoint) model.save_pretrained(output_dir)if name == "main": fire.Fire(train)
- Assistant
Этот скрипт предназначен для тренировки языковой модели с использованием PyTorch и библиотеки transformers от Hugging Face. Скрипт также включает интеграцию с библиотекой Weights & Biases для логирования (wandb) и оптимизирует модель с использованием 8-бит или 4-бит сжатия. Хотя в коде уже есть некоторые элементы работы с распределенными вычислениями (DDP), он не полностью настроен для тренировки на нескольких GPU.
Чтобы запустить обучение этого скрипта на нескольких GPU с помощью DDP, выполните следующие шаги:
-
Убедитесь, что ваша среда уже настроена для работы с несколькими GPU. Если вы используете PyTorch с CUDA, то
torch.cuda.device_count()должен вернуть число больше 1. -
Убедитесь, что значение переменной
world_sizeсоответствует количеству используемых GPU. Обычно это количество устанавливается в переменной окруженияWORLD_SIZEпри запуске обучающего скрипта. -
Проверьте, что
LOCAL_RANKправильно установлен для каждого процесса DDP. Обычно эту переменную устанавливает инструмент запуска, напримерtorch.distributed.launch. -
Используйте правильные настройки в
TrainingArgumentsдля работы с DDP. Например, зачастую для DDP устанавливают параметрlocal_rankс помощьюos.environ.get("LOCAL_RANK", -1).
В коде уже предусмотрена возможность DDP (как видно из проверки условия
if ddp:), но, чтобы полностью реализовать поддержку DDP, вам возможно потребуется:- Установить параметры глубокого обучения (DeepSpeed), если вы хотите использовать эту функциональность.
- Настроить или проверить настройки
device_mapв коде приведенного загрузчика модели, чтобы убедиться, что модели правильно распределяются по GPU. - Использовать запуск с помощью специального скрипта или утилиты для DDP, такой как
torch.distributed.launch.
При использовании DDP важно управлять
TrainingArgumentsи загрузкой модели, чтобы она правильно распределялась по нескольким GPU. В вашем случаеdeepspeedконфигурация также может управлять некоторыми аспектами масштабирования на несколько GPU.В зависимости от вашей конкретной ситуации у вас может потребоваться дополнительная настройка. Обратитесь к документации PyTorch, transformers и DeepSpeed для получения более подробной информации о настройке среды для обучения на нескольких GPU с использованием DDP.
-
- User
device_map = "auto" world_size = int(os.environ.get("WORLD_SIZE", 1)) ddp = world_size != 1
Что делает этот код
- Assistant
Этот код выполняет проверку, требуется ли использовать распределенное обучение (Distributed Data Parallel, DDP) на основе числа доступных или задействованных устройств (обычно GPU). Он состоит из трех операций:
-
device_map = "auto": Здесь устанавливается значение переменнойdevice_mapв строку"auto", которое может быть использовано впоследствии при загрузке моделей с помощью библиотекиtransformersот Hugging Face. Значение"auto"указывает на автоматическое распределение модели по доступным GPU. -
world_size = int(os.environ.get("WORLD_SIZE", 1)): Эта строка извлекает значение переменной окруженияWORLD_SIZE, которое обозначает общее количество устройств (процессов), участвующих в распределенном обучении. Если переменная окруженияWORLD_SIZEне установлена, то используется значение по умолчанию1, что предполагает отсутствие распределенного обучения (обучение на одном устройстве/проецессе). -
ddp = world_size != 1: Проверка, равно ли значениеworld_sizeединице. Если нет, это означает, что в вашей обучающей сессии используется более одного процесса (например, при обучении с несколькими GPU или на кластере из нескольких машин), и устанавливаетсяddp(флаг распределенного обучения) вTrue. Еслиworld_sizeравно1, тоddpбудетFalse, что означает, что распределенное обучение не используется.
Этот код представляет начальную настройку для распределенного обучения и может использоваться далее для настройки тренировочных аргументов, инициализации модели, загрузки данных и определения того, как должно происходить обучение.
-
- User
Как задается переменная окружения world_size
- Assistant
Переменная окружения
WORLD_SIZEзадаётся в операционной системе и обычно используется при распределённом обучении моделей, чтобы указать общее количество процессов (например, GPU или узлов кластера), которые будут участвовать в обучении. Количество процессов обычно соответствует количеству устройств, на которых будут параллельно выполняться вычисления.Задать переменную окружения
WORLD_SIZEможно несколькими способами, в зависимости от операционной системы:В Unix/Linux/Mac OS X:
Перед запуском скрипта Python с терминала:
export WORLD_SIZE=4 python your_script.pyЗдесь число
4должно быть заменено на желаемое количество процессов.В Windows (командная строка):
set WORLD_SIZE=4 python your_script.pyИли если вы используете PowerShell:
$env:WORLD_SIZE=4 python your_script.pyЕсли
WORLD_SIZEиспользуется в PyTorch при запуске скрипта с использованием специального скрипта запуска, напримерtorch.distributed.launchилиtorchrunв новых версиях PyTorch, то значениеWORLD_SIZEобычно задается автоматически этими запускающими скриптами. В таком случае, параметр количество процессов как правило определяется при запуске, как в примере ниже:python -m torch.distributed.launch --nproc_per_node=4 --nnodes=1 your_script.pyВ примере выше,
--nproc_per_node=4указывает, что каждый узел будет использовать 4 процесса (например, 4 GPU), и скрипт запуска установит переменные окружения, включаяWORLD_SIZE, которые будут равны общему количеству процессов. Таким образом,WORLD_SIZEбудет равно 4.Важно, что при использовании таких утилит, как
torch.distributed.launch, вы не должны задаватьWORLD_SIZEсамостоятельно, так как это может привести к конфликтам с тем, как утилита настраивает среду для распределённого обучения. - User
что делает этот кусок кода deepspeed_config = config.get("deepspeed")
- Assistant
Этот кусок кода извлекает ключ
'deepspeed'из словаряconfigи присваивает полученное значение переменнойdeepspeed_config.Функция
get- это метод словаря в Python. Он позволяет безопасно получать значение по ключу из словаря. Если ключ'deepspeed'существует в словареconfig, то будет возвращено его значение. Если же ключа не существует, функцияgetвернет значениеNone(которое является значением по умолчанию, если второй аргумент вgetне указан).В контексте этого кода,
config- это, по всей видимости, словарь с параметрами конфигурации, который был загружен из файла конфигурации (предположительно в формате JSON).Дополнение
'deepspeed'в ключе указывает на то, что конфигурация предназначена для использования с DeepSpeed, который является библиотекой для оптимизации и ускорения обучения моделей на крупномасштабных GPU. DeepSpeed предоставляет функции такие, как оптимизация пропускной способности, уменьшение потребляемой памяти, ускорение тренировки и др.Таким образом,
deepspeed_configможет содержать различные параметры конфигурации, специфичные для DeepSpeed, например пути к файлам конфигурации, настройки оптимизаторов, настройки для сжатия модели и другие опции, которые обычно указываются в JSON-файле конфигурации DeepSpeed. - User
training_args = TrainingArguments( output_dir=output_dir, save_total_limit=1, load_best_model_at_end=True, report_to=report_to, ddp_find_unused_parameters=False if ddp else None, deepspeed=deepspeed_config, **trainer_config )
За что отвечает ddp_find_unused_parameters=False if ddp else None, deepspeed=deepspeed_config,
- Assistant
В конструктор
TrainingArgumentsклассаtransformersпередаются различные тренировочные параметры для настройки процесса обучения. Рассмотрим два указанных параметра:ddp_find_unused_parameters=False if ddp else None: Этот параметр находит использование в распределённом обучении с помощьюtorch.nn.parallel.DistributedDataParallelв PyTorch.
- Когда используется
DistributedDataParallel(DDP), важно, чтобы все параметры модели участвовали в подсчёте градиентов. Если же некоторые параметры не использовались во время прямого прохода (forward pass), PyTorch должен быть осведомлён об этом, чтобы обработать такие случаи соответствующим образом во время обратного прохода (backward pass). - Параметр
ddp_find_unused_parametersотвечает за поиск неиспользуемых параметров. Если он установлен вTrue, то PyTorch будет искать параметры, которые не использовались при последнем прямом проходе, что может быть полезным при определённых моделях или способах их обработки. Однако это может замедлить процесс обучения. - В данном случае, если переменная
ddpистинна (то есть используется распределённое обучение), поиск неиспользуемых параметров отключается (ddp_find_unused_parameters=False). Если распределённое обучение не используется (то естьddpложна), то параметруddp_find_unused_parametersприсваивается значениеNone. Это может быть сделано для оптимизации производительности обучения.
deepspeed=deepspeed_config: DeepSpeed - это опциональная библиотека для ускорения и масштабирования обучения моделей на крупномасштабных системах с множеством GPU. Когда параметрdeepspeedустановлен не вNone, вместо стандартного тренера PyTorch используется интеграция с DeepSpeed тренером.
- Параметр
deepspeedожидает, что ему будет передан путь к файлу конфигурации DeepSpeed в формате JSON или непосредственно словарь с параметрами конфигурации. - В данном случае предоставляется переменная
deepspeed_config, которая содержит параметры конфигурации, загруженные из файла или заданные в словареconfig. - Использование DeepSpeed может помочь при обучении очень больших моделей, оптимизации использования памяти, ускорении тренировок и в некоторых случаях снижению стоимости вычислительных ресурсов за счёт эффективного использования.
Таким образом, эти параметры служат для тонкой настройки процесса обучения в распределённой среде и при использовании DeepSpeed, соответственно.
- User
Что делает вот этот код if ddp: device_map = {"": int(os.environ.get("LOCAL_RANK") or 0)} gradient_accumulation_steps = trainer_config["gradient_accumulation_steps"] gradient_accumulation_steps = gradient_accumulation_steps // world_size trainer_config["gradient_accumulation_steps"] = gradient_accumulation_steps
- Assistant
Этот код предназначен для работы со средой распределенного обучения в PyTorch, возможно, с использованием Distributed Data Parallel (DDP). Предполагается, что обучение производится на нескольких GPU или нескольких устройствах.
-
if ddp:проверяет, используется ли распределенное обучение, т.е.ddp(Distributed Data Parallel) True, что означает, чтоworld_sizeбольше 1 (это количество процессов которые участвуют в тренировке, как правило, соответствует количеству GPU). -
device_map = {"": int(os.environ.get("LOCAL_RANK") or 0)}создает словарь, который будет использован для указания того, на каком устройстве будет работать каждый процесс.LOCAL_RANK- это переменная окружения, которая обычно указывает порядковый номер текущего устройства в рамках локального узла (например, если на одной машине используется несколько GPU). ЕслиLOCAL_RANKне установлен, код использует значение0как значение по умолчанию. Ключ в словаре является пустой строкой, потому что некоторые API распределенного обучения могут ожидать определенные форматы ключей для соответствия устройствам. -
gradient_accumulation_steps = trainer_config["gradient_accumulation_steps"]извлекает текущее количество шагов накопления градиента из конфигурации тренера (это количество шагов, на протяжении которых градиенты накапливаются перед их обратной передачей и обновлением весов; это техника, позволяющая использовать большие пакеты данных при ограниченной памяти). -
gradient_accumulation_steps = gradient_accumulation_steps // world_sizeделит количество шагов накопления градиента на количество процессов (world_size). Это делается для масштабирования параметров тренировки в зависимости от количества процессов, так чтобы каждый процесс обрабатывал меньше данных, что в сумме будет эквивалентно первоначальному объему. -
trainer_config["gradient_accumulation_steps"] = gradient_accumulation_stepsприсваивает новое значение количеству шагов накопления градиента в конфигурации тренера, таким образом, обновляя его для текущего рабочего процесса.
Этот код настраивает параметры обучения для эффективного использования при распределенной тренировке на многих устройствах, позволяя более равномерно распределить нагрузку и управлять ресурсами использования памяти.
-
- User
Как задается переменная окружения world_size и local_rank с помощью torch.distributed.launch
- Assistant
Для распределенного обучения в PyTorch, когда вы используете
torch.distributed.launch, переменные окруженияWORLD_SIZEиLOCAL_RANKустанавливаются автоматически инструментом запуска. Эти переменные окружения используются для определения того, сколько всего процессов участвует в обучении (WORLD_SIZE) и какой уникальный идентификатор имеет каждый процесс на текущем узле (LOCAL_RANK).Вот как мог выглядеть вызов
torch.distributed.launch:python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE --nnodes=NUM_NODES_YOU_HAVE --node_rank=NODE_RANK --master_addr=MASTER_NODE_ADDRESS --master_port=MASTER_PORT YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3 и так далее)--nproc_per_nodeуказывает, сколько процессов запускать на каждом узле. Обычно это число равно количеству GPU на узле.--nnodesуказывает общее количество узлов в распределенной системе.--node_rankопределяет порядковый номер текущего узла; номера начинаются с 0.--master_addrи--master_portзадают IP-адрес и порт "главного" узла, который координирует начало процессов на различных узлах.
Когда вы запускаете обучение с такими параметрами,
torch.distributed.launchавтоматически задает следующие переменные окружения для каждого процесса обучения:WORLD_SIZE: общее количество процессов в обучении, которое равно--nnodesумноженное на--nproc_per_node.LOCAL_RANK: идентификатор GPU в текущем узле, к которому привязан запускаемый процесс.LOCAL_RANKдля каждого процесса узла начинается с 0 и идет до--nproc_per_node - 1.
Например, если у вас есть 2 узла и на каждом узле по 4 GPU, вы бы установили
--nproc_per_node=4и--nnodes=2, при этомWORLD_SIZEбудет равен 8 (4 на каждом узле). При запускеLOCAL_RANKбудет присвоен каждому процессу от 0 до 3 на каждом узле.Обратите внимание, что если вы используете PyTorch версии 1.9 или новее,
torch.distributed.launchстановится устаревшим, и рекомендуется использовать новую утилитуtorchrun:torchrun --nproc_per_node=NUM_GPUS_YOU_HAVE --nnodes=NUM_NODES_YOU_HAVE --node_rank=NODE_RANK --master_addr=MASTER_NODE_ADDRESS --master_port=MASTER_PORT YOUR_TRAINING_SCRIPT.py
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.