DeepSpeed-Chat-Codeanalyse und Nutzungsdetails

In diesem Kapitel wollen wir verstehen, wie dieses Tool funktioniert. Wenn wir verstehen, wie es funktioniert, können wir:

Ersetzen Sie das vorab trainierte Modell und die Trainingsdaten: Zusätzlich zum vorab trainierten Modell von Facebook können wir auch versuchen, andere Modelle zu verwenden; insbesondere können wir andere Daten verwenden, um das Modell zu optimieren.
Beherrschen Sie die Verwendung von DeepSpeed: Durch das vorherige Kapitel wissen wir, dass DeepSpeed ein leistungsstarkes Trainingstool für groß angelegte Modelle ist. Lernen Sie, DeepSeed nicht nur für das Training von LLM, sondern auch für das Training großer Modelle für andere DL-Aufgaben zu verwenden.

1. Übersicht

[Sehen Sie sich die Videoerklärung an]

DeepSpeed-Chat besteht aus drei Schritten. Unter diesen sind Schritt 1 und 2 relativ ähnlich und im Vergleich zu Schritt 3 auch relativ einfach. Daher lernen wir die Grundfunktionen dieses Tools kennen, indem wir Schritt 1 studieren. Wir untersuchen hauptsächlich die Programme step1_supervised_finetuning im Verzeichnis und den main.py damit verbundenen utils Code .
Wir werden den Code in den folgenden Aspekten interpretieren:

Datenverarbeitungsteil
Modellinitialisierungsteil
Teil des Trainingscodes
Verständnis des parallelen Verarbeitungs- und Nutzungsprozesses von DeepSpeed

2 Code-Zusammenfassung

Der Trainingsprozess von Schritt 1 wird über das Bash-Skript zum Training run_1.3b.sh aufgerufen main.py , sodass wir hauptsächlich main.py das Programm lernen.

Das Skript run_1.3b.sh enthält hauptsächlich die folgenden Inhalte

deepspeed main.py \
   --data_path Dahoas/rm-static \
   --data_split 2,4,4 \
   --model_name_or_path facebook/opt-1.3b \
   --per_device_train_batch_size 8 \
   --per_device_eval_batch_size 8 \
   --max_seq_len 512 \
   --learning_rate 9.65e-6 \
   --weight_decay 0.1 \
   --num_train_epochs 2 \
   --gradient_accumulation_steps 1 \
   --lr_scheduler_type cosine \
   --num_warmup_steps 0 \
   --seed 1234 \
   --zero_stage $ZERO_STAGE \
   --deepspeed \
   --output_dir $OUTPUT \
   &> $OUTPUT/training.log

In Kombination mit main.py dem Programm können wir die Parameter in drei Hauptkategorien einteilen

Datenbezogene Parameter

data_path        : 数据路径，huggingface数据库， 比如：Dahoas/rm-static
data_split       : 数据的拆分方式，比如 2,4,4 是为step1，2，3分配的数据比例
max_seq_len      : 最大序列长度（超过长度会被截掉）
data_output_path : 相关数据的存储地址（local storage，不能是shared storage）

Parameter im Zusammenhang mit dem Modell

model_name_or_path : 模型名称或路径，huggingface模型，比如：facebook/opt-1.3b
lora_dim           : 如果大于0，则使用LoRA优化
lora_module_name   : 设置LoRA的范围，比如可以只针对 decoder.layers
only_optimize_lora : 是否只优化LoRA的参数

Parameter im Zusammenhang mit dem Training

per_device_train_batch_size : 训练时的 Batch size (per device： 每个GPU的Size)
per_device_eval_batch_size  : 评价时的 Batch size (per device)
learning_rate               : 学习率
weight_decay                : 权重衰减，防止模型过拟合的技术。
num_train_epochs            : 训练 epoch 数
gradient_accumulation_steps : 累积多少个 mini-batch 的梯度后再进行一次参数更新。
lr_scheduler_type           : learning rate的调整策略，比如 linear, cosine

Deepspeed

zero_stage  : 这个对应者DeepSpeed工具中的zero方式，分别是0，1，2，3
offload     : ZeRO-Offload 通过利用主机CPU上的计算和内存资源来执行优化器，从而减少此类模型的GPU计算和内存需求。
local_rank  : 分布式训练时的一个变量，用于标识当前 GPU 设备的本地排名（本机排名，与global-rank不同）
gradient_checkpointing : 降低深度学习模型训练过程中内存消耗的技术

andere

seed        : 随机排序是的seed
output_dir  : 模型的存储目录

3 Grundkonzepte des verteilten Trainings

[Sehen Sie sich die Videoerklärung an]

args.local_rank
local_rank ist eine Variable, die während des verteilten Trainings verwendet wird, um den lokalen Rang des aktuellen GPU-Geräts zu identifizieren.

Wenn args.local_rank gleich -1 ist, bedeutet dies, dass der Code nicht in einer verteilten Umgebung ausgeführt wird und nur eine einzige GPU für das Training verwendet. Wenn args.local_rank nicht gleich -1 ist, bedeutet dies, dass der Code in einer verteilten Umgebung ausgeführt wird und dem aktuellen GPU-Gerät ein eindeutiger lokaler Rang zugewiesen wird. Der Code stellt das Gerät auf die angegebene GPU (torch.device("cuda", args.local_rank)) ein und initialisiert das verteilte Backend mithilfe des Funktionsaufrufs deepspeed.init_distributed().

Hinweis: In PyTorch gibt es auch die verteilte Initialisierungsmethode Torch.distributed.init_process_group(). Wenn Sie jedoch die DeepSpeed-Bibliothek verwenden, ersetzen Sie nicht deepspeed.init_distributed().

args.global_rank
Beim verteilten Training verfügt jeder Prozess über einen eindeutigen globalen Rang, der zur Identifizierung der Position des Prozesses in der verteilten Umgebung verwendet wird. Der globale Rang reicht von 0 bis world_size-1, wobei world_size die Gesamtzahl der Prozesse in der gesamten verteilten Umgebung ist.
In diesem Programm wird global_rank über Torch.distributed.get_rank() gelesen, und diese Funktion kann erst aufgerufen werden, nachdem das verteilte Backend initialisiert wurde.

Torch.distributed.barrier()
Torch.distributed.barrier() ist eine Synchronisierungsfunktion, die zum Synchronisieren des Status jedes Prozesses in einer verteilten Umgebung verwendet wird. Wenn diese Funktion aufgerufen wird, blockiert der Prozess und wartet, bis alle Prozesse diese Funktion aufgerufen haben. Anschließend wird die Blockierung aufgehoben und der folgende Code wird weiterhin ausgeführt.

Beim verteilten Training wird Torch.distributed.barrier() normalerweise verwendet, um die Gradientenaktualisierungen jedes Prozesses zu synchronisieren. Nachdem jeder Prozess eine Vorwärtsausbreitungs- und Rückwärtsausbreitungsrunde abgeschlossen hat, müssen sie ihre eigenen Farbverläufe synchronisieren und warten, bis andere Prozesse denselben Vorgang abgeschlossen haben, bevor sie mit der nächsten Aktualisierungsrunde fortfahren. Zu diesem Zeitpunkt können Sie die Funktion Torch.distributed.barrier () verwenden, um eine Synchronisierung zu erreichen.

Eine andere Verwendung besteht darin, dass während des parallelen Trainings von Modellparametern das Datenlesen nur auf der GPU mit local_rank 0 durchgeführt werden muss. Andere Prozesse verwenden Torch.distributed.barrier(), um zu blockieren und auf den Abschluss des Datenlesens zu warten.

3 Code: Datenbezogen

[Sehen Sie sich die Videoerklärung an]

Beim Training aktueller NLP-Modelle besteht eine gängige Praxis darin, zunächst Text in Token umzuwandeln. Token bezieht sich normalerweise auf ein Wort oder einen Teil eines Wortes. Bei der Konvertierung dieses Artikels in Token wird Tokenizer verwendet. Tokenizer wird anhand der Trainingsdaten berechnet und trainiert. Es gibt viele Tools zum Trainieren von Tokenisierern, beispielsweise das Satzstück von Google. Ein Beispiel für ein GPT-3-Token ist unten aufgeführt. Zum Beispiel:

Guten Morgen: Entspricht 2 Token, deren ID [11274, 3329] ist.
Guten Morgen: Entsprechend 5 Token lauten die IDs [33768, 102, 41468, 25001, 121]
Guten Morgen: Japanischer 6-Token, ID ist [2515, 232, 31676, 1792, 230, 29557]
1234567890: Entspricht 4 Token, nämlich 123, 45, 678, 90
xa: Entspricht 2 Token, nämlich x und a

Sie können die Token-Aufteilung über die OpenAI-Website erleben: https://platform.openai.com/tokenizer

Der beim Training im DS-Chat-Tool verwendete Tokenizer stammt aus dem vorab trainierten Modell. Dieser Code verwendet die AutoTokenizer-Klasse in der Hugging Face Transformers-Bibliothek, um den Tokenizer eines vorab trainierten Modells zu instanziieren. Die AutoTokenizer-Klasse kann den entsprechenden Tokenizer automatisch auswählen und laden und so die Schritte einer manuellen Auswahl vermeiden.

    tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, fast_tokenizer=True)
    tokenizer.pad_token = tokenizer.eos_token

Die Funktion AutoTokenizer.from_pretrained() verfügt über zwei erforderliche Parameter. model_name_or_path ist der Name oder Pfad des vorab trainierten Modells, z. B. „bert-base-uncased“ oder „/path/to/model/directory“. fast_tokenizer: ob der schnelle Tokenizer verwendet werden soll. Bei True wird der in Rust implementierte Tokenizer ausgewählt, der schneller ist; andernfalls wird der in Python implementierte Tokenizer verwendet. Der Standardwert ist True.

Datenvorbereitungsfunktion: create_prompt_dataset

    train_phase = 1
    train_dataset, eval_dataset = create_prompt_dataset(
        args.local_rank, args.data_path, args.data_split,
        args.data_output_path, train_phase, args.seed, tokenizer,
        args.max_seq_len)

Der Parameter „local_rank“ soll ermöglichen, dass grundlegende Verarbeitungen wie das Herunterladen von Daten nur auf der GPU mit einem lokalen Rang von 0 ausgeführt werden. Das heißt, Daten werden auf jedem Knoten nur einmal verarbeitet. data_output_path muss auf den lokalen Speicherpfad eingestellt werden, der zum Speichern lokaler Daten während des verteilten Trainings verwendet werden soll.

Dann gibt es noch den Initialisierungs-Sampler. Eine einzelne GPU verwendet RandomSampler und SequentialSampler, und die verteilte Verarbeitung verwendet DistributedSampler. Der Sampler wird hauptsächlich verwendet, um die Reihenfolge der Datenübernahme festzulegen. Beispielsweise kann eine Zufallsstichprobe verwendet werden, um die Robustheit des Modells zu verbessern.

    # DataLoaders creation:
    if args.local_rank == -1:
        train_sampler = RandomSampler(train_dataset)
        eval_sampler = SequentialSampler(eval_dataset)
    else:
        train_sampler = DistributedSampler(train_dataset)
        eval_sampler = DistributedSampler(eval_dataset)

Das Lesen der Daten erfolgt mit dem Standard-DataLoader von PyTorch. Mit Dataloader können Sie nicht nur den Probenehmer so einstellen, dass er die Probenahmemethode definiert, sondern auch automatisch eine Stapelverarbeitung durchführen und das Laden von Daten in mehreren Prozessen unterstützen.

    train_dataloader = DataLoader(train_dataset,
                                  collate_fn=default_data_collator,
                                  sampler=train_sampler,
                                  batch_size=args.per_device_train_batch_size)
    eval_dataloader = DataLoader(eval_dataset,
                                 collate_fn=default_data_collator,
                                 sampler=eval_sampler,
                                 batch_size=args.per_device_eval_batch_size)

4 Code: Modellbezogen

[Sehen Sie sich die Videoerklärung an]

Modellinitialisierung
Der folgende Code wird zum Initialisieren des Modells verwendet.

model = create_hf_model(AutoModelForCausalLM, args.model_name_or_path,
                        tokenizer, ds_config)

Unter diesen ist AutoModelForCausalLM eine Klasse in der Hugging Face Transformers-Bibliothek, die automatisch das entsprechende vorab trainierte Transformer-Modell auswählen und laden kann. Sie unterstützt eine Vielzahl vorab trainierter Transformer-Modelle, darunter GPT-2, GPT, CTRL, Transformer- XL, XLNet und XLM usw. . Wenn Sie diese Klasse verwenden, müssen Sie nur den Namen oder Pfad des Modells angeben, um das entsprechende Modell automatisch zu laden.

Den spezifischen Implementierungscode finden Sie unter: utils/model/model_utils.py.

LoRA
Wenn lora_dim auf größer als 0 eingestellt wird, wird die LoRA-Technologie zur Anpassung des Modells verwendet. Dadurch werden die Optimierungsparameter des Modells deutlich reduziert und die Effizienz der Optimierung verbessert. Unter normalen Umständen kann der Einsatz der LoRA-Technologie nicht nur die Anzahl der Parameter reduzieren, sondern auch die Leistung weiter verbessern. Dies liegt hauptsächlich daran, dass das Design des Engpassnetzwerks eine Überanpassung verhindern und dadurch die Robustheit des Modells verbessern kann.

    if args.lora_dim > 0:
        model = convert_linear_layer_to_lora(model, args.lora_module_name,
                                             args.lora_dim)
        if args.only_optimize_lora:
            model = only_optimize_lora_parameters(model)

Extrahieren Sie die Parameter, die optimiert werden müssen,optimierer_grouped_parameters

    # Split weights in two groups, one with weight decay and the other not.
    optimizer_grouped_parameters = get_optimizer_grouped_parameters(
        model, args.weight_decay)

    AdamOptimizer = DeepSpeedCPUAdam if args.offload else FusedAdam
    optimizer = AdamOptimizer(optimizer_grouped_parameters,
                              lr=args.learning_rate,
                              betas=(0.9, 0.95))

Im obigen Code wird die Funktion get_optimizer_grouped_parameters() verwendet, um die Gewichte in zwei Gruppen aufzuteilen, eine, bei der eine Gewichtsabnahme erforderlich ist, und die andere, bei der dies nicht der Fall ist. Diese Funktion unterscheidet zwischen Parametern, die eine Gewichtsabnahme erfordern, und Parametern, bei denen dies nicht der Fall ist, indem sie alle Parameter des Modells durchläuft und prüft, ob der Parametername spezielle Zeichenfolgen wie Bias oder LayerNorm enthält.

Erläuterung der Gründe für die Gruppierung: Im Allgemeinen betrachten wir Parameter, deren Parameternamen keine speziellen Zeichenfolgen wie Bias oder LayerNorm enthalten, als Parameter, die eine Gewichtsabschwächung anwenden müssen. Für diese Parameter ist es üblich, ihre Gewichtsmatrizen mit dem Gewichtsabfall-Hyperparameter zu multiplizieren, um ihr Gewicht zu reduzieren. Im Gegensatz dazu betrachten wir Parameter, deren Parameternamen spezielle Zeichenfolgen wie Bias oder LayerNorm enthalten, als Parameter, für die keine Gewichtsabnahme erforderlich ist. Dies liegt daran, dass die Bias- oder LayerNorm-Parameter normalerweise nur zum Versetzen oder Skalieren der Ausgabe anderer Ebenen verwendet werden und nicht die wahren Gewichtungsparameter. Durch die Aufteilung der Gewichte in zwei Gruppen und die Anwendung der Gewichtsabnahme bzw. die Nichtanwendung der Gewichtsabnahme können wir die Komplexität des Modells besser kontrollieren und dadurch die Generalisierungsleistung des Modells verbessern.

Stellen Sie dann den Optimizer-Optimierer ein und wählen Sie je nach Parameter den DeepSpeedCPUAdam- oder FusedAdam-Optimierer aus. Und einige Parameter übergeben, darunter Gruppierungsparameter, Lernrate und Betas.

Erläuterung des Adam-Optimierers: In der Transformers-Bibliothek von Hugging Face stehen zwei Adam-Optimierer zur Auswahl: FusedAdam und DeepSpeedCPUAdam. Es handelt sich bei allen um auf PyTorch implementierte Optimierer, die jedoch unterschiedliche Optimierungs- und Leistungsmerkmale auf unterschiedlicher Hardware aufweisen. FusedAdam ist ein Optimierer, der mithilfe der NVIDIA Apex-Bibliothek implementiert wird. Er unterstützt Training mit gemischter Präzision und kann gleichzeitig Steigungen und Gewichtsaktualisierungsvorgänge berechnen, wodurch die Trainingseffizienz verbessert wird. Der FusedAdam-Optimierer bietet eine bessere Leistung, wenn NVIDIA-GPUs verwendet werden, die CUDA unterstützen. DeepSpeedCPUAdam ist ein Optimierer auf der CPU, der Teil des DeepSpeed-Frameworks ist und verteiltes Training und Modellparallelisierung unterstützt. Der DeepSpeedCPUAdam-Optimierer bietet eine bessere Leistung bei Nutzung der CPU. Wenn args.offload im obigen Code True ist, bedeutet dies, dass die CPU-basierte Optimierung verwendet wird, sodass der DeepSpeedCPUAdam-Optimierer ausgewählt wird.

Legen Sie lr_scheduler fest

    num_update_steps_per_epoch = math.ceil(
        len(train_dataloader) / args.gradient_accumulation_steps)
    lr_scheduler = get_scheduler(
        name=args.lr_scheduler_type,
        optimizer=optimizer,
        num_warmup_steps=args.num_warmup_steps,
        num_training_steps=args.num_train_epochs * num_update_steps_per_epoch,
    )

lr_scheduler wird verwendet, um zu planen, wie lr während des Trainingsprozesses angepasst wird. lr_scheduler_type Scheduler-Typ, der verwendet wird, um zu beschreiben, wie sich lr ändert, z. B. LinearWarmup, CosineAnnealing usw. num_warmup_steps Die Anzahl der Aufwärmschritte gibt die Anzahl der Schritte im LR-Erhöhungsprozess in den frühen Phasen des Trainings an. Die Gesamtzahl der Trainingsschritte gibt an, wie oft das Modell insgesamt aktualisiert wird.

DS-Initialisierung

    model, optimizer, _, lr_scheduler = deepspeed.initialize(
        model=model,
        optimizer=optimizer,
        args=args,
        config=ds_config,
        lr_scheduler=lr_scheduler,
        dist_init_required=True)

Wenn Sie DeepSpeed zur Optimierung verwenden, müssen Sie die Funktion deepspeed.initialize() verwenden, um trainingsbezogene Komponenten wie Modell, Optimierer und Lernratenplaner zu initialisieren. Unter diesen sind Modell und Optimierer erforderliche Parameter, während andere Parameter optional sind.

Die Funktion deepspeed.initialize() prüft und optimiert die übergebenen Parameter und gibt Komponenten wie das neue Modell, den Optimierer und den Lernratenplaner zurück. Es passt beispielsweise automatisch die Einstellungen des Optimierers und der Gradientenakkumulation basierend auf den Trainingsparametereinstellungen und der Hardwarekonfiguration an und legt eine verteilte Trainingsstrategie für Modellgewichte fest. Der Parameter dist_init_required=True gibt an, ob DeepSpeed eine verteilte Trainingsinitialisierung erfordert.

DS-Konfigurationsdatei
Die Konfigurationsdatei enthält die relevanten Einstellungsinformationen, die für das DeepSpeed-Modelltraining erforderlich sind, und der Trainingsprozess kann durch Ändern hier angepasst werden. Hier sind die Einstellungen in utils/ds_utils.py:

ds_config = {
    "train_batch_size": GLOBAL_BATCH_SIZE,
    "train_micro_batch_size_per_gpu": MICRO_BATCH_SIZE,
    "steps_per_print": 10,
    "zero_optimization": {
        "stage": stage,
        "offload_param": {
            "device": device
        },
        "offload_optimizer": {
            "device": device
        },
        "stage3_param_persistence_threshold": 1e4,
        "stage3_max_live_parameters": 3e7,
        "stage3_prefetch_bucket_size": 3e7,
        "memory_efficient_linear": False
    },
    "fp16": {
        "enabled": True,
        "loss_scale_window": 100
    },
    "gradient_clipping": 1.0,
    "prescale_gradients": False,
    "wall_clock_breakdown": False,
    "hybrid_engine": {
        "enabled": enable_hybrid_engine,
        "inference_tp_size": inference_tp_size,
        "release_inference_cache": release_inference_cache,
        "pin_parameters": pin_parameters,
        "tp_gather_partition_size": tp_gather_partition_size,
    }
}

5 Code: Schulung

[Sehen Sie sich die Videoerklärung an]

Das Folgende ist der Implementierungscode des Trainingsteils. Es ist zu beachten, dass sich der Code des Trainingsteils nach der Verwendung von DS vom Standard-PyTorch-Code unterscheidet.

    for epoch in range(args.num_train_epochs):
        print_rank_0(
            f"Beginning of Epoch {epoch+1}/{args.num_train_epochs}, Total Micro Batches {len(train_dataloader)}",
            args.global_rank)
        model.train()
        for step, batch in enumerate(train_dataloader):
            batch = to_device(batch, device)
            outputs = model(**batch, use_cache=False)
            loss = outputs.loss
            model.backward(loss)
            model.step()

Zur **batchErklärung: Dieser Vorgang kann bequem einen Datenstapel an das Modell übergeben, wodurch die manuelle Aufteilung von Listen oder Tupeln vermieden wird, wodurch der Code präziser und lesbarer wird.

*Batch bedeutet, die Elemente in einem Listenobjekt-Batch in unabhängige Parameter aufzuteilen und sie an die Funktion oder Methode zu übergeben. Wenn Sie beispielsweise
batch = (input_ids, attention_mask, labels)
*batch verwenden, entspricht dies tatsächlich der Aufteilung dieser Tensorobjekte in unabhängige Parameter, dh:
model(*batch) äquivalent zu model(input_ids, attention_mask, labels)

**Batch bedeutet, einen Wörterbuchobjekt-Batch in unabhängige Parameter aufzuteilen und diese an Funktionen oder Methoden zu übergeben. Zum Beispiel:
batch = {'input_ids': input_ids, 'attention_mask': attention_mask, 'labels': labels}
model(**batch) entspricht
model(input_ids=input_ids, attention_mask=attention_mask, labels=labels)

6 Code: Auswertung

Diese Aufgabe bewertet das Modell nach Perplexität.

    # Evaluate perplexity on the validation set
    perplexity = evaluation(model, eval_dataloader)

7 Code: Speichern des Modells

[Sehen Sie sich die Videoerklärung an]

    if args.output_dir is not None:
        print_rank_0('saving the final model ...', args.global_rank)
        model = convert_lora_to_linear_layer(model)

        if args.global_rank == 0:
            save_hf_format(model, tokenizer, args)

        if args.zero_stage == 3:
            # For zero stage 3, each gpu only has a part of the model, so we need a special save function
            save_zero_three_model(model,
                                  args.global_rank,
                                  args.output_dir,
                                  zero_stage=args.zero_stage)

8 Prozesszusammenfassung: Modellfeinabstimmung mit DeepSpeed

Gemäß der obigen Analyse ist der gesamte Prozess der Feinabstimmung des Modells wie folgt:
Datenteil

Tokenizer lesen: Lesen Sie den Tokenizer aus dem vorab trainierten Modell
Daten train_dataset, eval_dataset lesen und verarbeiten
Train_sampler und eval_sampler festlegen
Train_dataloader und eval_dataloader festlegen (DataLoader verwenden)

Modellteil

Legen Sie die DeepSpeed-Konfigurationsparameter fest
Modell importieren und instanziieren
Optional: LoRA-Einstellungen
Bereiten Sie die Parameter vor, die optimiert werden müssen:optimierer_grouped_parameters
Optimierer einstellen
Legen Sie lr_scheduler fest
Deepspeed.initialize initialisieren

Abschnitt „Schulung und Bewertung“.

Beginnen Sie mit dem Training vorwärts, rückwärts und der Parameteraktualisierung
bewerten, testen
Modellspeicherung: Beachten Sie, dass ZeRO bei 3 separat verarbeitet werden muss.

häufiges Problem

F/A 1: Bei der Initialisierung des Modells wird dschf = HfDeepSpeedConfig(ds_config) definiert und später nicht aufgerufen.
Bei Verwendung von Null 3 müssen Sie dschf = HfDeepSpeedConfig(ds_config) festlegen.
Spezifische Anweisungen finden Sie unter:
DeepSpeed Integration
Frage/Antwort 2: Was ist ZeRO?
ZeRO (Zero Redundancy Optimizer) ist eine Optimierungstechnologie in der DeepSpeed-Bibliothek, die darauf ausgelegt ist, die Effizienz und Skalierbarkeit des groß angelegten Modelltrainings zu verbessern. Unter diesen ist ZeRO Offload eine Variante der ZeRO-Technologie, die Modellparameter auf der CPU speichern kann, wodurch die Belegung des GPU-Speichers während des Modelltrainings reduziert und Vorgänge wie Gradientenakkumulation, Gradientenkomprimierung und Kommunikation von Modellparametern beschleunigt werden. ZeRO 3 wird bei der Parallelisierung von Modellparametern für große Modelle verwendet.

Verweise

[1] GitHub – microsoft/DeepSpeedExamples: Beispielmodelle, die DeepSpeed verwenden
[2] LoRA (Low-Rank-Adaption): https://arxiv.org/abs/2106.09685