[Verarbeitung natürlicher Sprache] [Großes Modell] BLOOM Reasoning Tool-Test für große Sprachmodelle

Verwandter Blog
[Deep Learning] [Verteiltes Training] DeepSpeed: AllReduce und ZeRO-DP
[Verarbeitung natürlicher Sprache] [Großes Modell] BLOOM-Modellstruktur-Quellcode-Analyse (Standalone-Version)
[Verarbeitung natürlicher Sprache] [Großes Modell] Sehr ressourcenschonende Fein- Optimierung der LoRA- und BLOOM-LORA-Implementierungscodes für die Large-Model-Methode
[Deep Learning] [Distributed Training] Kollektiver Kommunikationsbetrieb und Pytorch-Beispiel
[Natural Language Processing] [Large Model] Chinchilla: Großes Sprachmodell mit optimaler Trainings- und Rechenauslastung
[Natural Language Processing] [Großes Modell] Großes Sprachmodell BLOOM Reasoning Tool Test
[Verarbeitung natürlicher Sprache] [Großes Modell] GLM-130B: ein zweisprachiges vorab trainiertes Open-Source-Sprachmodell
[Verarbeitung natürlicher Sprache] [Großes Modell] 8-Bit-Matrixmultiplikation für große Transformer Einführung in
die Verarbeitung natürlicher Sprache (Großes Modell) BLOOM: Ein 176B-Parameter und ein mehrsprachiges Open-Access-Modell.
Verarbeitung natürlicher Sprache (Serie ChatGPT) FLAN: Die Feinabstimmung des Sprachmodells ist ein Zero-Shot-Lerner. Verarbeitung natürlicher
Sprache (Verarbeitung natürlicher Sprache) ChatGPT Serie] Woher kommt die Intelligenz von ChatGPT?
[Verarbeitung natürlicher Sprache] [ChatGPT-Reihe] Entstehung großer Modelle

​Zum Prinzip von BLOOM siehe [Natural Language Processing] [Großes Modell] BLOOM: Ein mehrsprachiges Modell mit 176B Parametern und offenem Zugriff

BLOOM ist ein großes Modell, das von HuggingFace eingeführt wurde und dessen Parametervolumen 176 B erreicht (GPT-3 ist 175 B). Derzeit sind nur BLOOM und GLM-130B Open-Source-Großmodelle mit mehr als 100B-Parametern, die Chinesisch unterstützen können. Da HuggingFace das Entwicklungsunternehmen des berühmten Open-Source-Tools Transformers ist, werden viele Reasoning-Tools die Modelle in Transformers unterstützen.

​ Zwei Probleme bei der LLM-Argumentation (Large Language Model): (1) Eine einzelne Grafikkarte kann nicht das gesamte Modell aufnehmen; (2) Die Argumentationsgeschwindigkeit ist zu langsam. In diesem Artikel werden zunächst einige Tools und Codes für die Argumentation großer Modelle organisiert und lediglich die Argumentationsgeschwindigkeit getestet. Hier einige Hintergrundinformationen zu den Tests in diesem Artikel:

• Derzeit Februar 2023

• Verwenden Sie das 7B-Modell Bloom-7b1-mt

• 4 3090er (aber nur 2 3090er werden in der tatsächlichen Schlussfolgerung verwendet)

• Die Version des abhängigen Pakets

  transformers==4.26.0
  tensor-parallel==1.0.24
  deepspeed==0.7.7
  bminf==2.0.1
  

Null, Hilfsfunktionen

# utils.py
import numpy as np
  
from time import perf_counter

def measure_latency(model, tokenizer, payload, device, generation_args={
    
    }):
    input_ids = tokenizer(payload, return_tensors="pt").input_ids.to(device)
    latencies = []
    # 预热
    for _ in range(2):
        _ =  model.generate(input_ids, **generation_args)
    # 统计时间
    for _ in range(10):
        start_time = perf_counter()
        _ = model.generate(input_ids, **generation_args)
        latency = perf_counter() - start_time
        latencies.append(latency)
    # 计算统计量
    time_avg_ms = 1000 * np.mean(latencies) # 延时均值
    time_std_ms = 1000 * np.std(latencies) # 延时方差
    time_p95_ms = 1000 * np.percentile(latencies,95) # 延时的95分位数
    return f"P95延时 (ms) - {
      
      time_p95_ms}; 平均延时 (ms) - {
      
      time_avg_ms:.2f} +\- {
      
      time_std_ms:.2f};"

def infer(model, tokenizer, payload, device):
    input_ids = tokenizer(payload, return_tensors="pt").input_ids.to(device)
    logits = model.generate(input_ids, num_beams=1, max_length=512)
    out = tokenizer.decode(logits[0].tolist())
    return out

1. Ebenenparallelität

BLOOM wurde von Huggingface entwickelt und bietet daher Unterstützung in der Transformers-Bibliothek. Geben Sie insbesondere bei Verwendung from_pretraineddes geladenen Modells die Parameter an devce_map. Es teilt ein einzelnes großes Modell auf mehrere Karten auf, indem es verschiedene Schichten des Modells auf verschiedenen Grafikkarten platziert (die parallele Pipeline teilt auch die Schichten auf und trainiert das Modell dann im Pipeline-Stil) . Hier ist der Beispielcode für den Aufruf:

# layer_parallel_test.py
import os
import transformers

from utils import measure_latency, infer
from transformers import AutoTokenizer, AutoModelForCausalLM

transformers.logging.set_verbosity_error()
os.environ['CUDA_VISIBLE_DEVICES'] = "0,1"

def run():
    model_name = "bigscience/bloomz-7b1-mt"
    payload = """
    参考下面的文章，然后用与文章相同的语言回答问题： 段落：当细菌突破免疫系统的防御而开始增生时，疾病会由结核菌感染进展到症状明显的结核病。在原发型结核病 (占 1-5% 的比例)，这种现象会在感染刚开始的时候很快的发生。然而>多数人感染模式为潜伏结核感染，通常没有明显症状。在5-10%潜伏结合感染的案例中，这些休眠的细菌经常会在感染后数年的时间制造出活动的结核。 问题：What is the next stage after TB infection?
    """
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")
    model = model.eval()
    out = infer(model, tokenizer, payload, model.device)
    print("="*70+" 模型输入输出 "+"="*70)
    print(f"模型输入: {
      
      payload}")
    print(f"模型输出: {
      
      out}")
    print("\n\n"+"="*70+" 模型延时测试 "+"="*70)
    print(measure_latency(model, tokenizer, payload, model.device))
    print("\n\n"+"="*70+" 显存占用 "+"="*70)
    print(os.system("nvidia-smi"))

if __name__ == "__main__":
    run()
    pass

Die Verzögerungsergebnisse des Modells:

P95 Latenz (ms) – 118,402308691293; Durchschnittliche Latenz (ms) – 117,72 +- 0,58;

Speichernutzung:

2. Tensorparallelität

Tensorparallelität unterteilt die Matrixmultiplikation in Blöcke und spaltet dadurch große Matrizen in kleinere Matrizen auf, sodass unterschiedliche Matrizen auf unterschiedlichen Grafikkarten platziert werden können. (Die spezifischen Prinzipien werden in nachfolgenden Artikeln vorgestellt)

​ Dies wird mit dem Open-Source-Toolkit tensor_parallel erreicht.

# tensor_parallel_test.py
import os
import transformers
import tensor_parallel as tp

from utils import measure_latency, infer
from transformers import AutoTokenizer, AutoModelForCausalLM

transformers.logging.set_verbosity_error()
os.environ['CUDA_VISIBLE_DEVICES'] = "0,1"

def run():
    model_name = "bigscience/bloomz-7b1-mt"
    payload = """
    参考下面的文章，然后用与文章相同的语言回答问题： 段落：当细菌突破免疫系统的防御而开始增生时，疾病会由结核菌感染进展到症状明显的结核病。在原发型结核病 (占 1-5% 的比例)，这种现象会在感染刚开始的时候很快的发生。然而>多数人感染模式为潜伏结核感染，通常没有明显症状。在5-10%潜伏结合感染的案例中，这些休眠的细菌经常会在感染后数年的时间制造出活动的结核。 问题：What is the next stage after TB infection?
    """
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(model_name, low_cpu_mem_usage=True)
    model = tp.tensor_parallel(model, ["cuda:0", "cuda:1"])
    model = model.eval()
    out = infer(model, tokenizer, payload, model.device)
    print("="*70+" 模型输入输出 "+"="*70)
    print(f"模型输入: {
      
      payload}")
    print(f"模型输出: {
      
      out}")
    print("\n\n"+"="*70+" 模型延时测试 "+"="*70)
    print(measure_latency(model, tokenizer, payload, model.device))
    print("\n\n"+"="*70+" 显存占用 "+"="*70)
    print(os.system("nvidia-smi"))

if __name__ == "__main__":
    run()
    pass

Die Verzögerungsergebnisse des Modells:

P95 Verzögerung (ms) – 91,34029923006892; Durchschnittliche Verzögerung (ms) – 90,66 +- 0,46;

Speichernutzung:

3. Modellquantifizierung

​Für das Prinzip siehe [Verarbeitung natürlicher Sprache] [Großes Modell] Einführung in die 8-Bit-Matrixmultiplikation für große Transformatoren .

Quantisierung ist eine gängige Modellkomprimierungstechnik. Die Kernidee besteht darin, Modellparameter von hoher Präzision in niedrige Präzision umzuwandeln. Bei Verwendung der 8-Bit-Quantisierung in BLOOM müssen from_pretrainedbeim Aufruf nur Parameter festgelegt werden load_in_8bit=True, device_map="auto".

(Hinweis: Wenn Bloom die Quantisierung implementiert, wird die Matrix danach aufgeteilt, ob sie den Schwellenwert überschreitet, und dann werden die Modellparameter unterhalb des Schwellenwerts quantisiert, was die Argumentationsgeschwindigkeit verlangsamt.)

# int8_test.py
import os
import transformers

from utils import measure_latency, infer
from transformers import AutoTokenizer, AutoModelForCausalLM

transformers.logging.set_verbosity_error()
os.environ['CUDA_VISIBLE_DEVICES'] = "0,1"

def run():
    model_name = "bigscience/bloomz-7b1-mt"
    payload = """
    参考下面的文章，然后用与文章相同的语言回答问题： 段落：当细菌突破免疫系统的防御而开始增生时，疾病会由结核菌感染进展到症状明显的结核病。在原发型结核病 (占 1-5% 的比例)，这种现象会在感染刚开始的时候很快的发生。然而>多数人感染模式为潜伏结核感染，通常没有明显症状。在5-10%潜伏结合感染的案例中，这些休眠的细菌经常会在感染后数年的时间制造出活动的结核。 问题：What is the next stage after TB infection?
    """
    max_memory_mapping = {
    
    0: "24GB", 1: "0GB"}
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(model_name, load_in_8bit=True, device_map="auto", max_memory=max_memory_mapping)
    model = model.eval()
    out = infer(model, tokenizer, payload, model.device)
    print("="*70+" 模型输入输出 "+"="*70)
    print(f"模型输入: {
      
      payload}")
    print(f"模型输出: {
      
      out}")
    print("\n\n"+"="*70+" 模型延时测试 "+"="*70)
    print(measure_latency(model, tokenizer, payload, model.device))
    print("\n\n"+"="*70+" 显存占用 "+"="*70)
    print(os.system("nvidia-smi"))

if __name__ == "__main__":
    run()
    pass

Die Verzögerungsergebnisse des Modells:

P95 Latenz (ms) – 147,89210632443428; Durchschnittliche Latenz (ms) – 143,30 +- 3,02;

Speichernutzung:

四、DeepSpeed-Inferenz

​ DeepSpeed-Inference ist eine Funktion der Benutzermodell-Inferenz im verteilten Trainingstool DeepSpeed.

# deepspeed_test.py
import os
import torch
import deepspeed
import transformers

from utils import measure_latency, infer
from transformers import AutoTokenizer, AutoModelForCausalLM

transformers.logging.set_verbosity_error()
os.environ['CUDA_VISIBLE_DEVICES'] = "0,1"

def run():
    model_name = "bigscience/bloomz-7b1-mt"
    payload = """
    参考下面的文章，然后用与文章相同的语言回答问题： 段落：当细菌突破免疫系统的防御而开始增生时，疾病会由结核菌感染进展到症状明显的结核病。在原发型结核病 (占 1-5% 的比例)，这种现象会在感染刚开始的时候很快的发生。然而>多数人感染模式为潜伏结核感染，通常没有明显症状。在5-10%潜伏结合感染的案例中，这些休眠的细菌经常会在感染后数年的时间制造出活动的结核。 问题：What is the next stage after TB infection?
    """
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16)
    model = deepspeed.init_inference(
            model=model,      # Transformers模型
            mp_size=2,        # 模型并行数量
            dtype=torch.float16, # 权重类型(fp16)
            replace_method="auto", # 让DS自动替换层
            replace_with_kernel_inject=True, # 使用kernel injector替换
            )
    out = infer(model, tokenizer, payload, model.module.device)
    print("="*70+" 模型输入输出 "+"="*70)
    print(f"模型输入: {
      
      payload}")
    print(f"模型输出: {
      
      out}")
    print("\n\n"+"="*70+" 模型延时测试 "+"="*70)
    print(measure_latency(model, tokenizer, payload, model.module.device))
    print("\n\n"+"="*70+" 显存占用 "+"="*70)
    print(os.system("nvidia-smi"))


if __name__ == "__main__":
    run()
    pass

Sie können hier Python nicht zum Automatisieren von Skripten verwenden. Sie müssen den folgenden Befehl verwenden:

deepspeed --num_gpus 2 --master_port 60000 deepspeed_test.py

Die Verzögerungsergebnisse des Modells:

P95 Latenz (ms) – 31,88958093523979; Durchschnittliche Latenz (ms) – 30,75 +- 0,64;

Speichernutzung:

5. BMInf

​BMInf kann ein komplettes Modell unter einer einzelnen Grafikkarte laden, aber die Inferenzgeschwindigkeit ist sehr langsam (sollte Offload-Technologie verwenden).

import os
import bminf
import transformers

from utils import measure_latency, infer
from transformers import AutoTokenizer, AutoModelForCausalLM

transformers.logging.set_verbosity_error()
os.environ['CUDA_VISIBLE_DEVICES'] = "0,1"

def run():
    model_name = "bigscience/bloomz-7b1-mt"
    payload = """
    参考下面的文章，然后用与文章相同的语言回答问题： 段落：当细菌突破免疫系统的防御而开始增生时，疾病会由结核菌感染进展到症状明显的结核病。在原发型结核病 (占 1-5% 的比例)，这种现象会在感染刚开始的时候很快的发生。然而>多数人感染模式为潜伏结核感染，通常没有明显症状。在5-10%潜伏结合感染的案例中，这些休眠的细菌经常会在感染后数年的时间制造出活动的结核。 问题：What is the next stage after TB infection?
    """
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(model_name, low_cpu_mem_usage=True)
    model = model.eval()
    model = bminf.wrapper(model, quantization=False, memory_limit=8 << 30)
    out = infer(model, tokenizer, payload, model.device)
    print("="*70+" 模型输入输出 "+"="*70)
    print(f"模型输入: {
      
      payload}")
    print(f"模型输出: {
      
      out}")
    print("\n\n"+"="*70+" 模型延时测试 "+"="*70)
    print(measure_latency(model, tokenizer, payload, model.device))
    print("\n\n"+"="*70+" 显存占用 "+"="*70)
    print(os.system("nvidia-smi"))

if __name__ == "__main__":
    run()
    pass

Die Verzögerungsergebnisse des Modells:

P95 Verzögerung (ms) – 719,2403690889478; Durchschnittliche Verzögerung (ms) – 719,05 +- 0,14;

Speichernutzung:

6. Fazit

• Die Geschwindigkeit von DeepSpeed-Inference ist am schnellsten;
• Die Tensorparallelität ist schneller als die integrierte Schichtparallelität.
• Obwohl die Geschwindigkeit der 8-Bit-Quantisierung langsamer ist, kann damit eine Einzelkarteninferenz realisiert werden.
• Obwohl BMInf am langsamsten ist, kann es Einzelkarten-Schlussfolgerungen durchführen, ohne dass die Modellgenauigkeit verloren geht.

veranschaulichen

• In diesem Artikel geht es nicht um die Best Practice dieser Argumentationstools, sondern lediglich um eine Auflistung und Darstellung der Verwendung dieser Tools.
• Diese Tools optimieren das Modellargumentieren aus verschiedenen Perspektiven. Wer mehr über die Implementierung erfahren möchte, kann den Quellcode lesen;