tensor_parallel Download - tensor_parallel Source Code Download

tensor_parallel

Anderer Quellcode

v2.0.0: Sharding refactoring

Herunterladen

Tensor_Parallel

CI -Status

Probieren Sie neue 40b LLMs -Demo in Kaggle

Führen Sie große Pytorch -Modelle auf mehreren GPUs in einer Codezeile mit potenziell linearer Geschwindigkeit aus.

 import transformers
import tensor_parallel as tp
tokenizer = transformers . AutoTokenizer . from_pretrained ( "facebook/opt-13b" )
model = transformers . AutoModelForCausalLM . from_pretrained ( "facebook/opt-13b" )  # use opt-125m for testing

model = tp . tensor_parallel ( model , [ "cuda:0" , "cuda:1" ])  # <- each GPU has half the weights

inputs = tokenizer ( "A cat sat" , return_tensors = "pt" )[ "input_ids" ]. to ( "cuda:0" )
outputs = model . generate ( inputs , num_beams = 5 )
print ( tokenizer . decode ( outputs [ 0 ])) # A cat sat on my lap for a few minutes ...

model ( input_ids = inputs , labels = inputs ). loss . backward ()  # training works as usual

Installation

Neueste stabile Version (empfohlen):

 pip install tensor_parallel

Blutungsrandversion:

 pip install https://github.com/BlackSamorez/tensor_parallel/archive/main.zip

Verwendung

Wickeln Sie einfach Ihr Pytorch -Modell mit tp.tensor_parallel und verwenden Sie es normal. Rufen Sie für die beste Speicher -Effizienz tp.tensor_parallel auf, während sich das Modell noch auf der CPU befindet.

Hier sind einige Anwendungsfälle:

examples/training_flan-t5-xl.ipynb -Fein-Tune-Full-Flan-T5-Modell zur Textübersicht
tensor_parallel int8 LLM - Adapter -Tuning Ein großes Sprachmodell mit LLM.8bit + Tensor_Parallel
TBA - Definieren der benutzerdefinierten Parallelitätsstrategie

Erweiterte Parameter zu tensor_parallel :

device_ids: List[device] - welche Geräte zu verwenden; Standardeinstellungen für alle verfügbaren GPUs
output_device: device - Modellausgaben haben dieses Gerät
tensor_parallel_config: tp.Config - Verwenden Sie die benutzerdefinierte Parallelitätsstrategie, siehe slicing_configs.py
distributed: bool - Wenn wahr, verwenden Sie Torch. Verteiltes Backend anstelle von Threading (erfordert torchrun ).
sharded: bool - Wenn wahr, finden Sie alle trainierbaren Parameter, die nicht durch die Parallelität des Tensors aufgeteilt wurden, und teilen Sie sie mit Null -3 -Algorithmus auf.
- Die Gewichte werden vor jedem Vorwärtspass zwischen GPUs aufgeteilt und neu angemältet
- Tl; dr verwendet dies beim Training, um doppelte Parameter zu vermeiden (standardmäßig aktiviert!)
- sharded_param_names: List[str] - Parameternamen, die auf diese Weise geschützt werden sollten, default = automatisch gefunden

Speichern des Modells

Um ein Modell so zu speichern, dass es im Kontext nicht tensor_parallel verwendet werden kann, sollten Sie eine save_tensor_parallel Context -Wrapper verwenden.

 import torch
import transformers
import tensor_parallel as tp

model = tp . tensor_parallel (
    transformers . AutoModelForCausalLM . from_pretrained ( "facebook/opt-13b" ), 
)

# A whole lot of trainig...

with tp . save_tensor_parallel ( model ):
    torch . save ( model . state_dict (), "/tmp/" )
    # or 
    model . save_pretrained ( "/tmp/" )

Ein solcher Code speichert ein Modell, als wäre er nie geteilt. Es funktioniert, indem es Modellteile während der Erstellung state_dict sammelt.

Speichereffizienter Versand

Um normalerweise ein tensor_parallel -Modell zu erstellen und zu versenden, benötigt man das gesamte Modell im Speicher. Dies kann problematisch sein, aber es gibt einen anderen Weg.

Es ist möglich, ein state_dict eines grundlegenden Modells in das entsprechende tensor_parallel state_dict zu konvertieren, indem er eine Helferfunktion convert_state_dict unterhielt. Der Zustandsdikt kann dann versandt und in das Modell geladen werden:

 import accelerate
import transformers

import tensor_parallel as tp

# Initialize a weightless tensor_parallel model from MyModel
with accelerate . init_empty_weights ():
    model = tp . TensorParallel (
        MyModel (),
        device_ids = [ 0 , 1 ] # and prepare it to be put on GPUs 0 and 1
    )

# Load partial state_dict for MyModel
state_dict = torch . load ( "my_model_part_1_of_5.bin" )

# Convert it into a tensor_parallel state_dict
tensor_parallel_state_dict = tp . convert_state_dict (
    state_dict ,
    tensor_parallel_config = model . tensor_parallel_config ,
    world_size = len ( model . devices ),
)

# Dispatch the partial state_dict (load_state_dict doesn't work with meta so here I use accelerate)
device_map = tp . infer_sharded_device_map ( model )
for param_name , param in state_dict . items ():
    module_name = param_name
    while len ( module_name ) > 0 and module_name not in device_map :
        module_name = "." . join ( module_name . split ( "." )[: - 1 ])
    param_device = device_map [ module_name ]
    accelerate . utils . set_module_tensor_to_device ( model , param_name , param_device , value = param )

Damit muss nicht mehr als ein Teil des Modells gleichzeitig in den Speicher geladen werden.

FAQ

F: Ich habe keinen Multi-GPU-Server. Kann ich Tensor_Parallel in Google Colab verwenden?
A: Colab hat eine einzelne GPU, daher hat es keinen Sinn für die Parallelität des Tensors. Kaggle bietet jedoch zwei T4 kostenlos für alle telefonischen Konten an.
F: Was ist die Parallelität des Tensors?
A: Sie teilen die Gewichte jeder Schicht in Teile auf, multiplizieren Sie jeden Teil auf einer separaten GPU und sammeln dann Ergebnisse. Lesen Sie hier mehr
F: Soll ich TensorParallel oder DataParallel verwenden?
A: Tensorparallel für große Modelle, dataparallel für kleinere
F: Wie ist es mit vollschärfenem Dataparallel und Null verglichen?
A: Null ist besser, wenn Sie eine große Charge einfügen können. Tensorparallel ist besser für kleine Chargen

Warum tensor_parallel verwenden ...

vs Deepspeed und Fairscale
- DeepSpeed hat viele Parallelisierungsstrategien, erfordert jedoch eine sorgfältige Konfiguration
- Tensor_Parallel hat eine Strategie, die mit 1 Codezeile funktioniert
- Tensor_Parallel funktioniert in einem Jupyter -Notizbuch
vs megatronlm
- Megatronlm hat eine große Tensor -Parallelität für eine Modellarchitektur
- Tensor_Parallel hat eine gute Parallelität für jede Architektur
- Tensor_Parallel ist viel einfacher zu installieren
vs Parallelformers
- ParallelfOmmers ist nur Inferenz, Tensor_Parallel unterstützt das Training
VS alpa
- ALPA ist ein leistungsstarkes Werkzeug für automatisch verteiltes Training / Inferenz in JAX
- Tensor_Parallel funktioniert mit Pytorch
vs Model.parallelize()
- Beide sind einfach zu bedienen, beide passen zu großen Modellen
- Parallelisiert arbeitet jeweils eine GPU
- In Tensor_Parallel arbeiten GPUs parallel

Kurz gesagt, verwenden Sie tensor_parallel , um ein schnelles Prototyping auf einer einzelnen Maschine zu erhalten. Verwenden Sie Deepspeed+Megatron oder ALPA für Millionen-Dollar-Trainingsläufe.

Fehlerbehebung

Wenn Sie NCCL -Fehler oder zufälliges Hängen haben, haben Sie möglicherweise einige Codefehler, die nicht ordnungsgemäß angezeigt werden. Um diese Fehler zu debuggen, empfehlen wir den Neustart mit export TENSOR_PARALLEL_USE_NATIVE=1 oder auf einem einzelnen Gerät.

Wenn Sie einen Fehler gefunden oder auf ein Problem gestoßen sind, melden Sie ihn bitte an unseren Ausgaber -Tracker. Wir werden unser Bestes tun, um zu helfen, aber es kann einige Zeit dauern, bis wir dazu kommen. Bitte erstellen Sie Probleme nur, wenn Ihr Problem speziell mit tensor_parallel ist. Wenn Sie beispielsweise Hilfe bei der Installation transformers oder zur Optimierung Ihres Codes benötigen, suchen Sie ihn bitte an anderer Stelle.