SwissArmyTransformer

Einführung

sat ( SwissArmyTransformer ) ist eine flexible und leistungsstarke Bibliothek, um Ihre eigenen Transformatorvarianten zu entwickeln.

sat ist nach "Swiss Army Messer" benannt, was bedeutet, dass alle Modelle (z. B. Bert, GPT, T5, GLM, Cogview, Vit ...) den gleichen Backbone-Code teilen und vielseitige Verwendung mit einigen extra leichten Mischungen sorgen.

sat wird von deepspeed-ZeRO und Modellparallelität angetrieben, die darauf abzielt, große Modelle (100 m ~ 20b) für die Vorab- und Finetunen (100 m ~ 20b Parameter) zu liefern.

Installieren

    pip install SwissArmyTransformer

Merkmale

• Fügen Sie modell-agnostische Komponenten , z. B. Präfix-Tuning, in nur einer Zeile hinzu!

  • Die Präfix-Tuning (oder P-Tuning) verbessert die Finetuning durch Hinzufügen von trainierbaren Parametern in jeder Aufmerksamkeitsschicht. Es ist in unserer Bibliothek einfach, es auf ein GLM -Klassifizierungsmodell (oder ein anderes) Modell anzuwenden.

      class ClassificationModel ( GLMModel ): # can also be BertModel, RobertaModel, etc. 
          def __init__ ( self , args , transformer = None , ** kwargs ):
              super (). __init__ ( args , transformer = transformer , ** kwargs )
              self . add_mixin ( 'classification_head' , MLPHeadMixin ( args . hidden_size , 2048 , 1 ))
              # Arm an arbitrary model with Prefix-tuning with this line!
              self . add_mixin ( 'prefix-tuning' , PrefixTuningMixin ( args . num_layers , args . hidden_size // args . num_attention_heads , args . num_attention_heads , args . prefix_len ))

  • GPT und andere automatisch-regressive Modelle wirken während des Trainings und der Inferenz unterschiedlich. Während der Inferenz wird der Text Token-by-Token generiert, und wir müssen frühere Zustände zur Effizienz zwischenspeichern. Mit unserer LIB müssen Sie das Verhalten während des Trainings nur berücksichtigen (Lehrermotor) und es in ein zwischengespeichertes automatisch-regressives Modell durch Hinzufügen eines Mixins umwandeln:

      model , args = AutoModel . from_pretrained ( 'glm-10b-chinese' , args )
      model . add_mixin ( 'auto-regressive' , CachedAutoregressiveMixin ())
      # Generate a sequence with beam search
      from sat . generation . autoregressive_sampling import filling_sequence
      from sat . generation . sampling_strategies import BeamSearchStrategy
      output , * mems = filling_sequence ( model , input_seq ,
                      batch_size = args . batch_size ,
                      strategy = BeamSearchStrategy ( args . batch_size ))

• Erstellen Sie Ihr transformatorbasiertes Modell mit minimalen Codes . Wir haben GLM erwähnt, das sich nur vom Standardtransformator (Basemodel genannt) bei Positionsbettung (und Trainingsverlusten) unterscheidet. Wir müssen uns nur beim Codieren auf den zugehörigen Teil konzentrieren.

  Erweitern Sie die gesamte Definition:

   class BlockPositionEmbeddingMixin ( BaseMixin ):
      # Here define parameters for the mixin
      def __init__ ( self , max_sequence_length , hidden_size , init_method_std = 0.02 ):
          super ( BlockPositionEmbeddingMixin , self ). __init__ ()
          self . max_sequence_length = max_sequence_length
          self . hidden_size = hidden_size
          self . block_position_embeddings = torch . nn . Embedding ( max_sequence_length , hidden_size )
          torch . nn . init . normal_ ( self . block_position_embeddings . weight , mean = 0.0 , std = init_method_std )
      
      # Here define the method for the mixin
      def position_embedding_forward ( self , position_ids , ** kwargs ):
          position_ids , block_position_ids = position_ids [:, 0 ], position_ids [:, 1 ]
          position_embeddings = self . transformer . position_embeddings ( position_ids )
          block_position_embeddings = self . block_position_embeddings ( block_position_ids )
          return position_embeddings + block_position_embeddings
  
  class GLMModel ( BaseModel ):
      def __init__ ( self , args , transformer = None ):
          super (). __init__ ( args , transformer = transformer )
          self . add_mixin ( 'block_position_embedding' , 
              BlockPositionEmbeddingMixin ( args . max_sequence_length , args . hidden_size )
          ) # Add the mixin for GLM

• Umfassende Unterstützung für die Schulung . sat zielt darauf ab, die besten Praxis für Vorab- und Figunen zu liefern, bei denen Sie nur forward_step und create_dataset_function beenden müssen, jedoch mit Hyperparametern, um nützliche Trainingskonfigurationen zu ändern.

  • Erweitern Sie das Training auf mehrere GPUs oder Knoten, indem Sie --num_nodes , --num_gpus und eine einfache hostfile angeben.
  • Tiefen- und Modellparallelität.
  • Bessere Integration von Zero-2 und Aktivierungsprüfung.
  • Automatische Erweiterung und Mischungstrainingsdaten und memmap .
  • Unterstützung der Schulung von CogView2 und Cogvideo erfolgreich.
  • Die einzige Open-Source-Codebasis, die derzeit Figuning T5-10B für GPUs unterstützt.

Schnelle Tour

Die typischste Python -Datei, die Bert in SAT (für Inferenz) verwendet, ist wie folgt:

 # @File: inference_bert.py
from sat import get_args , get_tokenizer , AutoModel
# Parse args, initialize the environment. This is necessary.
args = get_args () 
# Automatically download and load model. Will also dump model-related hyperparameters to args.
model , args = AutoModel . from_pretrained ( 'bert-base-uncased' , args ) 
# Get the BertTokenizer according to args.tokenizer_type (automatically set).
tokenizer = get_tokenizer ( args ) 
# Here to use bert as you want!
# ...

Dann können wir den Code über ausführen

    SAT_HOME=/path/to/download python inference_bert.py --mode inference

Alle offiziell unterstützten Modellnamen sind in urls.py.

Zum Finetune oder voran einen Transformator ist auch extrem einfach!

 # @File: finetune_bert.py
from sat import get_args , get_tokenizer , AutoModel
from sat . model . mixins import MLPHeadMixin

def create_dataset_function ( path , args ):
    # Here to load the dataset
    # ...
    assert isinstance ( dataset , torch . utils . data . Dataset )
    return dataset

def forward_step ( data_iterator , model , args , timers ):
    inputs = next ( data_iterator ) # from the dataset of create_dataset_function.
    loss , * others = model ( inputs )
    return loss
    
# Parse args, initialize the environment. This is necessary.
args = get_args () 
model , args = AutoModel . from_pretrained ( 'bert-base-uncased' , args ) 
tokenizer = get_tokenizer ( args ) 
# Here to use bert as you want!
model . del_mixin ( 'bert-final' )
model . add_mixin ( 'classification_head' , MLPHeadMixin ( args . hidden_size , 2048 , 1 ))
# ONE LINE to train! 
# args already includes hyperparams such as lr, train-iters, zero-stage ...
training_main ( args , 
    model_cls = model , 
    forward_step_function = forward_step , # user define
    create_dataset_function = create_dataset_function # user define
)

Dann können wir den Code über ausführen

deepspeed --include localhost:0,1 finetune_bert.py 
    --experiment-name ftbert 
    --mode finetune --train-iters 1000 --save /path/to/save 
    --train-data /path/to/train --valid-data /path/to/valid 
    --lr 0.00002 --batch-size 8 --zero-stage 1 --fp16

Hier verwenden wir datenparallel unter gpus 0,1. Wir können das Training auch auf vielen miteinander verbundenen Maschinen über --hostfile /path/to/hostfile starten. Weitere Informationen finden Sie im Tutorial.

Um Ihr eigenes Modell zu schreiben, müssen Sie nur den Unterschied zwischen dem Standardtransformator berücksichtigen. Wenn Sie beispielsweise eine Idee haben, um die Aufmerksamkeitsoperation zu verbessern:

 from sat . model import BaseMixin
class MyAttention ( BaseMixin ):
    def __init__ ( self , hidden_size ):
        super ( MyAttention , self ). __init__ ()
        # MyAttention may needs some new params, e.g. a learnable alpha.
        self . learnable_alpha = torch . nn . Parameter ( torch . ones ( hidden_size ))
    
    # This is a hook function, the name `attention_fn` is special.
    def attention_fn ( q , k , v , mask , dropout = None , ** kwargs ):
        # Code for my attention.
        # ...
        return attention_results

Hier ist attention_fn eine Hakenfunktion, die die Standardaktion durch die neue Funktion ersetzt. Alle verfügbaren Haken finden Sie in Transformator_Defaults.py. Jetzt können wir add_mixin verwenden, um unsere Änderung auf alle Transformatoren wie Bert, Vit und CogView anzuwenden. Weitere Informationen finden Sie im Tutorial.

Tutorials

• Wie benutzt man in SAT gesammelte Modelle?
• Warum und wie trainiere ich Modelle im SAT?

Zitat

Derzeit haben wir kein Papier, sodass Sie uns nicht formell zitieren müssen! ~

Wenn dieses Projekt Ihre Forschung oder Ingenieurwesen hilft, verwenden Sie footnote{https://github.com/THUDM/SwissArmyTransformer} um uns zu erwähnen und SwissArmyTransformer gegenüber anderen zu empfehlen.

Das Tutorial für den Beitrag SAT ist unterwegs!

Das Projekt basiert auf (einem Benutzer von) Deepspeed, Megatron-LM und Huggingface-Transformatoren. Danke für ihre großartige Arbeit.