Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· OpenAIAi2 WildChat-4.8M (AI2)

Что делает вот этот код worldsize = int(os.environ.get("WORLDSIZE", 1))ddp = world_size…

  1. User

    Что делает вот этот код world_size = int(os.environ.get("WORLD_SIZE", 1))ddp = world_size != 1

  2. Assistant

    В приведенной строке есть небольшая ошибка, из-за которой код не будет работать как ожидается. Но если мы разделим его на две части, то сможем понять, что он предполагалось сделать:

    1. world_size = int(os.environ.get("WORLD_SIZE", 1))
    2. 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
    

    Теперь код будет корректно выполнять описанные выше действия.

  3. User

    Для чего нужна вот это строчка os.environ["TOKENIZERS_PARALLELISM"] = "false"

  4. Assistant

    Строка os.environ["TOKENIZERS_PARALLELISM"] = "false" используется в Python для установки переменной окружения TOKENIZERS_PARALLELISM в значение "false".

    Токенизаторы, такие как те, что предоставляются библиотекой transformers от Hugging Face, часто используют библиотеку Rust tokenizers под капотом для эффективного параллельного кодирования текста. Установка переменной окружения TOKENIZERS_PARALLELISM в значение "false" отключает параллельное выполнение токенизации.

    Такая настройка может быть полезна в следующих случаях:

    1. Когда вы запускаете свой код в среде, где параллельное выполнение нежелательно или не поддерживается. Например, в некоторых контейнерах или платформах ограниченное число потоков.

    2. Если ваш код уже использует многопоточность или вы хотите избежать конкуренции за общие ресурсы, отключение внутренней многопоточности токенизатора может привести к лучшей работоспособности и стабильности программы.

    3. Для устранения предупреждений об использовании параллельной обработки, которые могут возникать при использовании токенизаторов в некоторых контекстах (например, при выполнении в среде, контролируемой такими программами, как PyTorch DataLoader).

    Важный момент при использовании этой переменной заключается в том, что значение должно быть установлено в строку "false" а не в булево значение False, поскольку значения переменных окружения всегда интерпретируются как строки.

  5. User

    Как работает ddp в pytorch

  6. Assistant

    DDP в PyTorch относится к распределенному обучению с помощью модуля torch.distributed и его компонента DistributedDataParallel, часто сокращаемого до DDP. DistributedDataParallel - это класс, который позволяет автоматически разделить данные и модель для обучения на нескольких GPU или даже на нескольких узлах (машин).

    Вот основные шаги использования DDP в PyTorch:

    1. Инициализация библиотеки для работы с распределенными системами: Прежде чем можно будет использовать 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)
      )
      
    2. Разделение данных на подмножества: Входные данные нужно разделить на равные части, чтобы каждый процесс обрабатывал только свою часть данных. Это обычно делается с использованием DistributedSampler, который гарантирует, что каждый процесс получает уникальный набор данных для обучения.

    3. Создание модели и ее обертывание в DDP: Модель должна быть обернута в экземпляр класса torch.nn.parallel.DistributedDataParallel. Это автоматизирует синхронизацию градиентов и параметров между процессами.

      model = MyModel()  # Это ваша модель
      model = model.cuda(rank)  # Перемещение модели на соответствующее устройство
      model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[rank])
      
    4. Обучение модели: Обучение можно проводить так, как если бы вы работали на одном устройстве, но градиенты автоматически агрегируются на всех устройствах после каждой операции обратного распространения (backward).

    При обучении с использованием DDP PyTorch способен максимально использовать вычислительные ресурсы на нескольких устройствах, значительно увеличивая пропускную полосу и эффективность обучения.

  7. 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

  8. Assistant

    Кусок кода, который вы предоставили, выглядит как часть более обширного скрипта на Python, который настраивает настройки тренировщика (trainer) для использования в распределенной тренировочной сессии, вероятно с использованием библиотеки PyTorch. Давайте разберем его по строкам:

    1. if ddp: - Это условное выражение проверяет, имеет ли переменная ddp истинное значение (True). Если это так, то последующий блок кода будет выполнен. Мы можем предположить, что ddp означает использование распределенного обучения.

    2. device_map = {"": int(os.environ.get("LOCAL_RANK") or 0)} - Создает словарь device_map, ключом которого является пустая строка "". Значение - это номер локального ранга (LOCAL_RANK), который есть в окружении, и если его нет, то по умолчанию используется 0. Этот локальный ранг обычно используется для идентификации конкретного GPU на машине при распределенном обучении. При использовании нескольких GPU одновременно каждый процесс будет иметь свой LOCAL_RANK.

    3. gradient_accumulation_steps = trainer_config["gradient_accumulation_steps"] - Извлекает значение gradient_accumulation_steps из конфигурации тренировщика trainer_config. Этот параметр часто используется для накопления градиентов во время обучения, что позволяет эффективно использовать память и выполнять обновление параметров менее часто.

    4. gradient_accumulation_steps = gradient_accumulation_steps // world_size - Делит значение gradient_accumulation_steps на world_size с использованием целочисленного деления (//). Деление на world_size (количество процессов в распределенной тренировке) нужно для того, чтобы учитывать, что теперь градиенты накапливаются и обновляются синхронно на нескольких устройствах.

    5. trainer_config["gradient_accumulation_steps"] = gradient_accumulation_steps - Обновляет значение gradient_accumulation_steps в конфигурации тренировщика. Это потенциально уменьшает количество шагов накопления градиентов на каждом отдельном устройстве в распределенной системе.

    Обратите внимание, что для полного понимания этой части кода, необходим контекст, в котором он используется. В частности, отсутствует информация о том, как используется переменная device_map, и могут существовать другие места в коде, где важны значения, установленные в trainer_config.

  9. 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 model
    

    def 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)

  10. Assistant

    Этот скрипт предназначен для тренировки языковой модели с использованием PyTorch и библиотеки transformers от Hugging Face. Скрипт также включает интеграцию с библиотекой Weights & Biases для логирования (wandb) и оптимизирует модель с использованием 8-бит или 4-бит сжатия. Хотя в коде уже есть некоторые элементы работы с распределенными вычислениями (DDP), он не полностью настроен для тренировки на нескольких GPU.

    Чтобы запустить обучение этого скрипта на нескольких GPU с помощью DDP, выполните следующие шаги:

    1. Убедитесь, что ваша среда уже настроена для работы с несколькими GPU. Если вы используете PyTorch с CUDA, то torch.cuda.device_count() должен вернуть число больше 1.

    2. Убедитесь, что значение переменной world_size соответствует количеству используемых GPU. Обычно это количество устанавливается в переменной окружения WORLD_SIZE при запуске обучающего скрипта.

    3. Проверьте, что LOCAL_RANK правильно установлен для каждого процесса DDP. Обычно эту переменную устанавливает инструмент запуска, например torch.distributed.launch.

    4. Используйте правильные настройки в 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.

  11. User

    device_map = "auto" world_size = int(os.environ.get("WORLD_SIZE", 1)) ddp = world_size != 1

    Что делает этот код

  12. Assistant

    Этот код выполняет проверку, требуется ли использовать распределенное обучение (Distributed Data Parallel, DDP) на основе числа доступных или задействованных устройств (обычно GPU). Он состоит из трех операций:

    1. device_map = "auto": Здесь устанавливается значение переменной device_map в строку "auto", которое может быть использовано впоследствии при загрузке моделей с помощью библиотеки transformers от Hugging Face. Значение "auto" указывает на автоматическое распределение модели по доступным GPU.

    2. world_size = int(os.environ.get("WORLD_SIZE", 1)): Эта строка извлекает значение переменной окружения WORLD_SIZE, которое обозначает общее количество устройств (процессов), участвующих в распределенном обучении. Если переменная окружения WORLD_SIZE не установлена, то используется значение по умолчанию 1, что предполагает отсутствие распределенного обучения (обучение на одном устройстве/проецессе).

    3. ddp = world_size != 1: Проверка, равно ли значение world_size единице. Если нет, это означает, что в вашей обучающей сессии используется более одного процесса (например, при обучении с несколькими GPU или на кластере из нескольких машин), и устанавливается ddp (флаг распределенного обучения) в True. Если world_size равно 1, то ddp будет False, что означает, что распределенное обучение не используется.

    Этот код представляет начальную настройку для распределенного обучения и может использоваться далее для настройки тренировочных аргументов, инициализации модели, загрузки данных и определения того, как должно происходить обучение.

  13. User

    Как задается переменная окружения world_size

  14. 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 самостоятельно, так как это может привести к конфликтам с тем, как утилита настраивает среду для распределённого обучения.

  15. User

    что делает этот кусок кода deepspeed_config = config.get("deepspeed")

  16. Assistant

    Этот кусок кода извлекает ключ 'deepspeed' из словаря config и присваивает полученное значение переменной deepspeed_config.

    Функция get - это метод словаря в Python. Он позволяет безопасно получать значение по ключу из словаря. Если ключ 'deepspeed' существует в словаре config, то будет возвращено его значение. Если же ключа не существует, функция get вернет значение None (которое является значением по умолчанию, если второй аргумент в get не указан).

    В контексте этого кода, config - это, по всей видимости, словарь с параметрами конфигурации, который был загружен из файла конфигурации (предположительно в формате JSON).

    Дополнение 'deepspeed' в ключе указывает на то, что конфигурация предназначена для использования с DeepSpeed, который является библиотекой для оптимизации и ускорения обучения моделей на крупномасштабных GPU. DeepSpeed предоставляет функции такие, как оптимизация пропускной способности, уменьшение потребляемой памяти, ускорение тренировки и др.

    Таким образом, deepspeed_config может содержать различные параметры конфигурации, специфичные для DeepSpeed, например пути к файлам конфигурации, настройки оптимизаторов, настройки для сжатия модели и другие опции, которые обычно указываются в JSON-файле конфигурации DeepSpeed.

  17. 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,

  18. Assistant

    В конструктор TrainingArguments класса transformers передаются различные тренировочные параметры для настройки процесса обучения. Рассмотрим два указанных параметра:

    1. 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. Это может быть сделано для оптимизации производительности обучения.
    1. deepspeed=deepspeed_config: DeepSpeed - это опциональная библиотека для ускорения и масштабирования обучения моделей на крупномасштабных системах с множеством GPU. Когда параметр deepspeed установлен не в None, вместо стандартного тренера PyTorch используется интеграция с DeepSpeed тренером.
    • Параметр deepspeed ожидает, что ему будет передан путь к файлу конфигурации DeepSpeed в формате JSON или непосредственно словарь с параметрами конфигурации.
    • В данном случае предоставляется переменная deepspeed_config, которая содержит параметры конфигурации, загруженные из файла или заданные в словаре config.
    • Использование DeepSpeed может помочь при обучении очень больших моделей, оптимизации использования памяти, ускорении тренировок и в некоторых случаях снижению стоимости вычислительных ресурсов за счёт эффективного использования.

    Таким образом, эти параметры служат для тонкой настройки процесса обучения в распределённой среде и при использовании DeepSpeed, соответственно.

  19. 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

  20. Assistant

    Этот код предназначен для работы со средой распределенного обучения в PyTorch, возможно, с использованием Distributed Data Parallel (DDP). Предполагается, что обучение производится на нескольких GPU или нескольких устройствах.

    1. if ddp: проверяет, используется ли распределенное обучение, т.е. ddp (Distributed Data Parallel) True, что означает, что world_size больше 1 (это количество процессов которые участвуют в тренировке, как правило, соответствует количеству GPU).

    2. device_map = {"": int(os.environ.get("LOCAL_RANK") or 0)} создает словарь, который будет использован для указания того, на каком устройстве будет работать каждый процесс. LOCAL_RANK - это переменная окружения, которая обычно указывает порядковый номер текущего устройства в рамках локального узла (например, если на одной машине используется несколько GPU). Если LOCAL_RANK не установлен, код использует значение 0 как значение по умолчанию. Ключ в словаре является пустой строкой, потому что некоторые API распределенного обучения могут ожидать определенные форматы ключей для соответствия устройствам.

    3. gradient_accumulation_steps = trainer_config["gradient_accumulation_steps"] извлекает текущее количество шагов накопления градиента из конфигурации тренера (это количество шагов, на протяжении которых градиенты накапливаются перед их обратной передачей и обновлением весов; это техника, позволяющая использовать большие пакеты данных при ограниченной памяти).

    4. gradient_accumulation_steps = gradient_accumulation_steps // world_size делит количество шагов накопления градиента на количество процессов (world_size). Это делается для масштабирования параметров тренировки в зависимости от количества процессов, так чтобы каждый процесс обрабатывал меньше данных, что в сумме будет эквивалентно первоначальному объему.

    5. trainer_config["gradient_accumulation_steps"] = gradient_accumulation_steps присваивает новое значение количеству шагов накопления градиента в конфигурации тренера, таким образом, обновляя его для текущего рабочего процесса.

    Этот код настраивает параметры обучения для эффективного использования при распределенной тренировке на многих устройствах, позволяя более равномерно распределить нагрузку и управлять ресурсами использования памяти.

  21. User

    Как задается переменная окружения world_size и local_rank с помощью torch.distributed.launch

  22. 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
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.