tensor_parallel

tensor_parallelel

Experimente a nova demonstração 40B LLMS em Kaggle

Execute modelos grandes pytorch em várias GPUs em uma linha de código com aceleração potencialmente linear.

 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 

Instalação

Última versão estável (recomendada):

 pip install tensor_parallel

Versão de borda sangrando:

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

Uso

Basta embrulhar seu modelo pytorch com tp.tensor_parallel e usá -lo normalmente. Para obter a melhor eficiência da memória, ligue para tp.tensor_parallel enquanto o modelo ainda está na CPU.

Aqui estão alguns casos de uso:

• examples/training_flan-t5-xl.ipynb -Tune Full FLAN-T5 Modelo no resumo de texto
• tensor_parallel int8 LLM - ajuste um modelo de linguagem grande com llm.8bit + tensor_parallel
• TBA - Definindo estratégia de paralelismo personalizada

Parâmetros avançados para tensor_parallel :

• device_ids: List[device] - Quais dispositivos usarem; Padrões para todas as GPUs disponíveis
• output_device: device - as saídas do modelo terão este dispositivo
• tensor_parallel_config: tp.Config - Use a estratégia de paralelismo personalizada, consulte slicing_configs.py
• distributed: bool - Se verdadeiro, use back -end distribuído em vez de encadear (requer torchrun )
• sharded: bool - Se verdadeiro, encontre todos os parâmetros treináveis ​​que não foram divididos pelo paralelismo do tensor e dividi -los usando o algoritmo zero -3.
  • Os pesos serão divididos entre as GPUs e remontadas antes de cada passagem para a frente
  • Tl; dr use isso ao treinar para evitar parâmetros duplicados (ativados por padrão!)
  • sharded_param_names: List[str] - nomes de parâmetros que devem ser empurrados dessa maneira, padrão = encontrado automaticamente

Salvando o modelo

Para salvar um modelo de modo que ele possa ser usado em um contexto não tensor_parallel , você deve usar um wrapper de contexto save_tensor_parallel .

 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/" )

Esse código salva um modelo como se nunca tivesse sido dividido. Funciona coletando peças do modelo durante a criação state_dict .

Despacho eficiente de memória

Normalmente, normalmente para criar e despachar um modelo tensor_parallel , é necessário todo o modelo na memória. Isso pode ser problemático, mas há outra maneira.

É possível converter um state_dict de um modelo básico no tensor_parallel state_dict correspondente usando uma função auxiliar convert_state_dict . O ditado do estado pode então ser despachado e carregado no modelo:

 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 )

Com isso, não mais que uma parte do modelo precisa ser carregada na memória de uma só vez.

Perguntas frequentes

• P: Não tenho um servidor multi-GPU. Posso usar tensor_parallel no google colab?

• R: O COLAB tem uma única GPU, então não faz sentido no paralelismo do tensor. No entanto, Kaggle oferece dois T4 gratuitamente para todas as contas verificadas por telefone.

• P: O que é paralelismo tensor?

• R: Você dividiu os pesos de cada camada em partes, multiplica cada parte em uma GPU separada e depois coleta os resultados. Leia mais aqui

• P: Devo usar TensorParallel ou DataParallel ?

• R: TensorpAllallel para grandes modelos, Dataparallelal para os menores

• P: Como ele se compara com totalmente Dataparalel e zero?

• R: Zero é melhor se você puder se encaixar em um lote grande, o Tensorparallelal é melhor para pequenos lotes

Por que usar tensor_parallel ...

• VS DeepSpeed ​​e FairScale
  • DeepSpeed ​​tem muitas estratégias de paralelização, mas requer configuração cuidadosa
  • Tensor_parallel tem uma estratégia que funciona com 1 linha de código
  • Tensor_parallelel funciona em um caderno Jupyter
• vs megatronlm
  • Megatronlm tem um ótimo paralelismo tensor para uma arquitetura de modelo
  • Tensor_parallel tem um bom paralelismo para qualquer arquitetura
  • tensor_parallelal é muito mais fácil de instalar
• vs parallelfformers
  • Parallefformers é apenas inferência, o Tensor_parallelal suporta o treinamento
• vs alpa
  • ALPA é uma ferramenta poderosa para treinamento / inferência distribuída automática no JAX
  • Tensor_parallely funciona com pytorch
• vs Model.parallelize()
  • Ambos são fáceis de usar, ambos se encaixam em modelos grandes
  • Paralelize, uma GPU funciona por vez
  • Em Tensor_parallelal, as GPUs funcionam em paralelo

Em suma, use tensor_parallel para prototipagem rápida em uma única máquina. Use DeepSpeed+Megatron ou ALPA para treinos de um milhão de dólares.

Solução de problemas

Se você experimentar erros da NCCL ou penduramento aleatório, poderá ter alguns erros de código que não são exibidos corretamente. Para depurar esses erros, recomendamos reiniciar com export TENSOR_PARALLEL_USE_NATIVE=1 ou em um único dispositivo.

Se você encontrou um bug ou encontrou um problema, informe -o ao nosso rastreador de problemas. Faremos o possível para ajudar, mas pode levar algum tempo antes de chegarmos a isso. Crie problemas apenas se o seu problema estiver especificamente com tensor_parallel . Por exemplo, se você precisar de ajuda para instalar transformers ou otimizar seu código, procure -o em outro lugar.

Estilo de código

Usamos preto e isort para todas as solicitações de tração. Antes de comprometer seu código, basta executar black . && isort . E você ficará bem.

---