tensor_parallel

tensor_parallel

Pruebe una nueva demostración de 40B LLMS en Kaggle

Ejecute grandes modelos de pytorch en múltiples GPU en una línea de código con aceleración potencialmente lineal.

 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 

Instalación

Última versión estable (recomendado):

 pip install tensor_parallel

Versión de borde de sangrado:

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

Uso

Simplemente envuelva su modelo Pytorch con tp.tensor_parallel y úselo normalmente. Para la mejor eficiencia de memoria, llame tp.tensor_parallel mientras el modelo aún está en CPU.

Aquí hay algunos casos de uso:

• examples/training_flan-t5-xl.ipynb -modelo de flan-t5 completo en resumen de texto
• tensor_parallel int8 LLM - adaptador ajustando un modelo de lenguaje grande con llm.8bit + tensor_parallel
• TBA - Definición de la estrategia de paralelismo personalizado

Parámetros avanzados a tensor_parallel :

• device_ids: List[device] : qué dispositivos usar; predeterminado a todas las GPU disponibles
• output_device: device : las salidas del modelo tendrán este dispositivo
• tensor_parallel_config: tp.Config - Use estrategia de paralelismo personalizado, ver slicing_configs.py
• distributed: bool : si es cierto, use torch.distributed backend en lugar de enhebrar (requiere torchrun )
• sharded: bool : si es cierto, encuentre todos los parámetros entrenables que no estaban divididos por el paralelismo tensor y los dividen usando el algoritmo cero -3.
  • Los pesos se dividirán entre las GPU y se volverán a ensamblar antes de cada pase hacia adelante
  • Tl; dr usa esto cuando se capacite para evitar parámetros duplicados (¡habilitado de forma predeterminada!)
  • sharded_param_names: List[str] - nombres de parámetros que deben ser fragmentados de esta manera, predeterminado = encontrado automáticamente

Guardar el modelo

Para guardar un modelo de tal manera que pueda usarse en un contexto no tensor_parallel , debe usar un envoltorio 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/" )

Dicho código guarda un modelo como si nunca se dividiera. Funciona recopilando piezas del modelo durante la creación state_dict .

Envío de memoria eficiente

Normalmente, normalmente para crear y enviar un modelo tensor_parallel , uno necesita todo el modelo en la memoria. Esto puede ser problemático, pero hay otra forma.

Es posible convertir un state_dict de un modelo básico en el state_dict tensor_parallel correspondiente usando una función Helper convert_state_dict . El DICT del estado se puede enviar y cargar en el 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 )

Con esto, no se debe cargar en la memoria no más de una parte del modelo a la memoria.

Preguntas frecuentes

• P: No tengo un servidor multi-GPU. ¿Puedo usar tensor_parallel en Google Colab?

• R: Colab tiene una sola GPU, por lo que no tiene sentido el paralelismo tensor. Sin embargo, Kaggle ofrece dos T4 gratis para todas las cuentas verificadas por teléfono.

• P: ¿Qué es el paralelismo tensor?

• R: divide los pesos de cada capa en partes, multiplica cada parte en una GPU separada y luego recopila resultados. Leer más aquí

• P: ¿Debo usar TensorParallel o DataParallel ?

• R: TensorParallel para modelos grandes, DataParAllel para los más pequeños

• P: ¿Cómo se compara con Totalmente ShardedDataparallel y cero?

• R: Zero es mejor si puedes colocar un lote grande, TensorParallel es mejor para lotes pequeños

¿Por qué usar tensor_parallel ...

• VS Speed ​​y FairScale
  • Deepsed tiene muchas estrategias de paralelización, pero requiere una configuración cuidadosa
  • tensor_parallel tiene una estrategia que funciona con 1 línea de código
  • Tensor_parallel funciona en un cuaderno de Jupyter
• vs megatronlm
  • Megatronlm tiene un gran paralelismo tensor para una arquitectura modelo
  • tensor_parallel tiene un buen paralelismo para cualquier arquitectura
  • tensor_parallel es mucho más fácil de instalar
• vs paralleformers
  • ParallFormers es solo de inferencia, Tensor_parallel admite capacitación
• VS alpa
  • ALPA es una herramienta poderosa para la capacitación / inferencia distribuida automática en Jax
  • tensor_parallel funciona con pytorch
• VS Model.parallelize()
  • Ambos son fáciles de usar, ambos se ajustan a los modelos grandes
  • En paralelo, una GPU funciona a la vez
  • En tensor_parallel, las GPU funcionan en paralelo

En resumen, use tensor_parallel para prototipos rápidos en una sola máquina. Use Deepeed+Megatron o ALPA para carreras de entrenamiento de un millón de dólares.

Solución de problemas

Si experimenta errores de NCCL, o colgación aleatoria, puede tener algunos errores de código que no se muestran correctamente. Para depurar estos errores, recomendamos reiniciar con export TENSOR_PARALLEL_USE_NATIVE=1 o en un solo dispositivo.

Si encontró un error o encontró un problema, infórmelo a nuestro rastreador de problemas. Haremos todo lo posible para ayudar, pero puede llevar algo de tiempo antes de llegar a él. Cree problemas solo si su problema está específicamente con tensor_parallel . Por ejemplo, si necesita ayuda para instalar transformers u optimizar su código, busque en otro lugar.

Estilo de código

Usamos negro e isort para todas las solicitudes de extracción. Antes de cometer su código, simplemente ejecute black . && isort . Y estarás bien.

---