Die Referenz zur SageMaker Modellparallelbibliothek v2

• hybrid_shard_degree(Integer) — Gibt einen Grad der Shard-Parallelität an. Der Wert muss eine Ganzzahl zwischen und sein. 0 world_size Der Standardwert ist 0.

  • Wenn auf gesetzt0, wird auf die native PyTorch Implementierung und API im Skript zurückgegriffen, wenn der Wert 1 tensor_parallel_degree ist. Andernfalls berechnet es den größtmöglichen Wert auf der hybrid_shard_degree Grundlage von tensor_parallel_degree undworld_size. Wenn Sie auf die nativen PyTorch FSDP-Anwendungsfälle zurückgreifen und diese Strategie verwenden, verteilt sie FULL_SHARD sich auf den gesamten GPU-Cluster. Wenn HYBRID_SHARD oder _HYBRID_SHARD_ZERO2 war die Strategie, entspricht hybrid_shard_degree sie 8 Wenn die Tensorparallelität aktiviert ist, wird sie auf der Grundlage der überarbeiteten Version fragmentiert. hybrid_shard_degree

  • Wenn auf gesetzt1, wird auf die native PyTorch Implementierung und die API NO_SHARD im Skript zurückgegriffen, wenn der Wert 1 ist. tensor_parallel_degree Andernfalls entspricht es NO_SHARD innerhalb einer beliebigen Tensorparallelgruppe.

  • Wenn auf eine Ganzzahl zwischen 2 und gesetztworld_size, erfolgt das Sharding für die angegebene Anzahl von GPUs. Wenn Sie es nicht sharding_strategy im FSDP-Skript einrichten, wird es überschrieben. HYBRID_SHARD Wenn Sie festlegen_HYBRID_SHARD_ZERO2, wird das von sharding_strategy Ihnen angegebene verwendet.

• sm_activation_offloading(Boolean) — Gibt an, ob die Implementierung des SMP-Aktivierungsauslagers aktiviert werden soll. FallsFalse, wird beim Offloading die native Implementierung verwendet. PyTorch FallsTrue, wird die Implementierung des SMP-Aktivierungsauslagers verwendet. Sie müssen auch den PyTorch Aktivierungs-Offload-Wrapper (torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper) in Ihrem Skript verwenden. Weitere Informationen hierzu finden Sie unter Aktivierung, Entladung. Der Standardwert ist True.

• activation_loading_horizon(Integer) — Eine Ganzzahl, die den Typ des Aktivierungs-Offloading-Horizonts für FSDP angibt. Dies ist die maximale Anzahl von Ebenen mit Checkpoints oder Offloaded, deren Eingänge sich gleichzeitig im GPU-Speicher befinden können. Weitere Informationen hierzu finden Sie unter Aktivierung, Entladung. Der Eingabewert muss eine positive Ganzzahl sein. Der Standardwert ist 2.

• fsdp_cache_flush_warnings(Boolean) — Erkennt und warnt, wenn Cache-Leerungen im PyTorch Speichermanager auftreten, da sie die Rechenleistung beeinträchtigen können. Der Standardwert ist True.

• allow_empty_shards(Boolean) — Ob beim Sharden von Tensoren leere Shards zulässig sind, wenn der Tensor nicht teilbar ist. Dies ist eine experimentelle Lösung für Abstürze beim Checkpointing in bestimmten Szenarien. Wenn Sie dies deaktivieren, wird auf das ursprüngliche PyTorch Verhalten zurückgegriffen. Der Standardwert ist False.

• tensor_parallel_degree(Integer) — Gibt den Grad der Tensorparallelität an. Der Wert muss zwischen und liegen. 1 world_size Der Standardwert ist 1. Die Übergabe eines Werts größer als 1 aktiviert die Tensorparallelität nicht automatisch. Sie müssen auch die torch.sagemaker.transform API verwenden, um das Modell in Ihr Trainingsskript einzubinden. Weitere Informationen hierzu finden Sie unter Tensor-Parallelität.

• expert_parallel_degree(Integer) — Gibt den Grad der Parallelität für Experten an. Der Wert muss zwischen 1 und liegen. world_size Der Standardwert ist 1. Wenn Sie einen Wert größer als 1 übergeben, wird Expertenparallelität nicht automatisch aktiviert. Stellen Sie sicher, dass Sie das MoE-Modell mit der torch.sagemaker.transform API in Ihr Trainingsskript integrieren.

• random_seed(Integer) — Eine Startzahl für zufällige Operationen in verteilten Modulen nach SMP-Tensorparallelismus oder Expertenparallelismus. Dieser Startwert wird zu den tensorparallelen oder expertenparallelen Rängen hinzugefügt, um den tatsächlichen Startwert für jeden Rang festzulegen. Es ist für jeden tensorparallelen und expertenparallelen Rang einzigartig. SMP v2 stellt sicher, dass die Zufallszahl, die über tensorparallele und expertenparallele Ränge generiert wird, den jeweiligen Fällen entspricht. non-tensor-parallelism non-expert-parallelism

• model(nn.Module) — Ein PyTorch Modell zum Umschließen und Anwenden der verzögerten Parameterinitialisierungsfunktion von SMP v2.

• init_method_using_config(Callable) — Wenn Sie die parallel Tensor-Implementierung von SMP v2 oder unterstützt verwendenHugging Face Transformer-Modelle, die mit der SMP-Tensorparallelität kompatibel sind, behalten Sie für diesen Parameter den Standardwert bei, der lautet. None Standardmäßig findet die DelayedParamIniter API heraus, wie das angegebene Modell korrekt initialisiert wird. Für alle anderen Modelle müssen Sie eine benutzerdefinierte Parameter-Initialisierungsfunktion erstellen und sie Ihrem Skript hinzufügen. Der folgende Codeausschnitt ist die init_method_using_config Standardfunktion, die SMP v2 für die implementiert hat. Hugging Face Transformer-Modelle, die mit der SMP-Tensorparallelität kompatibel sind Verwenden Sie den folgenden Codeausschnitt als Referenz, um Ihre eigene Initialisierungskonfigurationsfunktion zu erstellen, sie Ihrem Skript hinzuzufügen und sie an den Parameter der init_method_using_config SMP-API zu übergeben. DelayedParamIniter

  from torch.sagemaker.utils.module_utils import empty_module_params, move_buffers_to_device
  
  # Define a custom init config function.
  def custom_init_method_using_config(module):
      d = torch.cuda.current_device()
      empty_module_params(module, device=d)
      if isinstance(module, (nn.Linear, Conv1D)):
          module.weight.data.normal_(mean=0.0, std=config.initializer_range)
          if module.bias is not None:
              module.bias.data.zero_()
      elif isinstance(module, nn.Embedding):
          module.weight.data.normal_(mean=0.0, std=config.initializer_range)
          if module.padding_idx is not None:
              module.weight.data[module.padding_idx].zero_()
      elif isinstance(module, nn.LayerNorm):
          module.weight.data.fill_(1.0)
          module.bias.data.zero_()
      elif isinstance(module, LlamaRMSNorm):
          module.weight.data.fill_(1.0)
      move_buffers_to_device(module, device=d)
  
  delayed_initer = DelayedParamIniter(model, init_method_using_config=custom_init_method_using_config)

  Weitere Informationen zu den torch.sagemaker.module_util Funktionen im vorherigen Codeausschnitt finden Sie unter. torch.sagemakerFunktionen und Eigenschaften von Util

• verbose(Boolean) — Ob eine detailliertere Protokollierung während der Initialisierung und Validierung aktiviert werden soll. Der Standardwert ist False.

• get_param_init_fn()— Gibt die Parameterinitialisierungsfunktion zurück, die Sie an das param_init_fn Argument der FSDP-Wrapper-Klasse übergeben können. PyTorch

• get_post_param_init_fn()— Gibt die Parameterinitialisierungsfunktion zurück, die Sie an das post_param_init_fn Argument der FSDP-Wrapper-Klasse übergeben können. PyTorch Dies ist erforderlich, wenn Sie Gewichte im Modell gebunden haben. Das Modell muss die Methode implementierentie_weights. Weitere Informationen finden Sie in den Hinweisen zum gebundenen Gewicht inVerzögerte Parameterinitialisierung.

• count_num_params(module: nn.Module, *args: Tuple[nn.Parameter]) — Verfolgt, wie viele Parameter von der Parameterinitialisierungsfunktion initialisiert werden. Dies hilft bei der Implementierung der folgenden validate_params_and_buffers_inited Methode. Normalerweise müssen Sie diese Funktion nicht explizit aufrufen, da die validate_params_and_buffers_inited Methode diese Methode implizit im Backend aufruft.

• validate_params_and_buffers_inited(enabled: bool=True) — Dies ist ein Kontextmanager, mit dessen Hilfe überprüft werden kann, ob die Anzahl der initialisierten Parameter mit der Gesamtzahl der Parameter im Modell übereinstimmt. Außerdem wird überprüft, ob sich alle Parameter und Puffer jetzt auf GPU-Geräten statt auf Metageräten befinden. Es wird ausgelöstAssertionErrors, wenn diese Bedingungen nicht erfüllt sind. Dieser Kontextmanager ist nur optional und Sie müssen diesen Kontextmanager nicht verwenden, um Parameter zu initialisieren.

• smp_moe(Boolean) — Ob die SMP-Implementierung von MoE verwendet werden soll. Der Standardwert ist True.

• random_seed(Integer) — Eine Startzahl für die Zufallsoperationen in von Experten parallel verteilten Modulen. Dieser Startwert wird dem parallel Expertenrang hinzugefügt, um den tatsächlichen Startwert für jeden Rang festzulegen. Es ist für jeden parallel Expertenrang einzigartig. Der Standardwert ist 12345.

• moe_load_balancing(Zeichenfolge) — Geben Sie den Lastausgleichstyp des MoE-Routers an. Gültige Optionen sind aux_losssinkhorn,balanced, undnone. Der Standardwert ist sinkhorn.

• global_token_shuffle(Boolean) — Gibt an, ob Tokens zwischen EP-Rängen innerhalb derselben EP-Gruppe gemischt werden sollen. Der Standardwert ist False.

• moe_all_to_all_dispatcher(Boolean) — Ob der all-to-all Dispatcher für die Kommunikation in MoE verwendet werden soll. Der Standardwert ist True.

• moe_aux_loss_coeff(Float) — Ein Koeffizient für den Verlust des zusätzlichen Lastenausgleichs. Der Standardwert ist 0.001.

• moe_z_loss_coeff(Float) — Koeffizient für den Z-Verlust. Der Standardwert ist 0.001.

• attention_dropout_prob(float) — Die Abbrecherwahrscheinlichkeit, die auf Aufmerksamkeit angewendet werden soll. Der Standardwert ist 0.0.

• scale(float) — Wenn er bestanden wird, wird dieser Skalierungsfaktor für Softmax angewendet. Falls auf gesetzt None (was auch der Standardwert ist), ist 1 / sqrt(attention_head_size) der Skalierungsfaktor. Der Standardwert ist None.

• triton_flash_attention(bool) — Falls übergeben, wird die Triton-Implementierung von Flash Attention verwendet. Dies ist notwendig, um Attention with Linear Biases (ALiBi) zu unterstützen (siehe den folgenden use_alibi Parameter). Diese Version des Kernels unterstützt Dropout nicht. Der Standardwert ist False.

• use_alibi(bool) — Falls übergeben, aktiviert sie Attention with Linear Biases (ALiBi) unter Verwendung der bereitgestellten Maske. Wenn Sie A verwendenLiBi, benötigen Sie eine Aufmerksamkeitsmaske, die wie folgt vorbereitet ist. Der Standardwert ist False.

  def generate_alibi_attn_mask(attention_mask, batch_size, seq_length, 
      num_attention_heads, alibi_bias_max=8):
      device, dtype = attention_mask.device, attention_mask.dtype
      alibi_attention_mask = torch.zeros(
          1, num_attention_heads, 1, seq_length, dtype=dtype, device=device
      )
  
      alibi_bias = torch.arange(1 - seq_length, 1, dtype=dtype, device=device).view(
          1, 1, 1, seq_length
      )
      m = torch.arange(1, num_attention_heads + 1, dtype=dtype, device=device)
      m.mul_(alibi_bias_max / num_attention_heads)
      alibi_bias = alibi_bias * (1.0 / (2 ** m.view(1, num_attention_heads, 1, 1)))
  
      alibi_attention_mask.add_(alibi_bias)
      alibi_attention_mask = alibi_attention_mask[..., :seq_length, :seq_length]
      if attention_mask is not None and attention_mask.bool().any():
          alibi_attention_mask.masked_fill(
              attention_mask.bool().view(batch_size, 1, 1, seq_length), float("-inf")
          )
  
      return alibi_attention_mask

• forward(self, qkv, attn_mask=None, causal=False, cast_dtype=None, layout="b h s d")— Eine reguläre PyTorch Modulfunktion. Wenn a aufgerufen module(x) wird, führt SMP diese Funktion automatisch aus.

  • qkv— in torch.Tensor der folgenden Form: (batch_size x seqlen x (3 x num_heads) x head_size) oder(batch_size, (3 x num_heads) x seqlen x head_size), ein Tupel, von dem torch.Tensors jedes eine Form haben könnte(batch_size x seqlen x num_heads x head_size), oder. (batch_size x num_heads x seqlen x head_size) Basierend auf der Form muss ein geeignetes Layoutargument übergeben werden.

  • attn_mask— torch.Tensor der folgenden Form(batch_size x 1 x 1 x seqlen). Um diesen Parameter für die Aufmerksamkeitsmaske zu aktivieren, benötigt er triton_flash_attention=True unduse_alibi=True. Informationen zum Generieren einer Aufmerksamkeitsmaske mit dieser Methode finden Sie in den Codebeispielen unterFlashAttention. Der Standardwert ist None.

  • causal— Wenn dieser Wert auf gesetzt istFalse, was der Standardwert des Arguments ist, wird keine Maske angewendet. Wenn auf gesetztTrue, verwendet die forward Methode die untere dreieckige Standardmaske. Der Standardwert ist False.

  • cast_dtype— Wenn sie auf einen bestimmten Wert gesetzt istdtype, werden die qkv Tensoren auf den vorherigen Wert umgewandelt. dtype attn Dies ist nützlich für Implementierungen wie das GPT-NeoX-Modell von Hugging Face Transformer, das über und mit rotativen Einbettungen verfügtq. k fp32 Wenn auf gesetzt, wird kein Cast angewendet. None Der Standardwert ist None.

  • layout(string) — Verfügbare Werte sind b h s d oderb s h d. Dies sollte auf das Layout der übergebenen qkv Tensoren eingestellt werden, damit entsprechende Transformationen beantragt werden können. attn Der Standardwert ist b h s d.

• attention_dropout_prob(float) — Die Abbrecherwahrscheinlichkeit, die auf Aufmerksamkeit angewendet werden soll. Der Standardwert ist 0.0.

• scale(float) — Wenn er bestanden wird, wird dieser Skalierungsfaktor für Softmax angewendet. Wenn auf gesetztNone, 1 / sqrt(attention_head_size) wird er als Skalierungsfaktor verwendet. Der Standardwert ist None.

• forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d")— Eine reguläre PyTorch Modulfunktion. Wenn a aufgerufen module(x) wird, führt SMP diese Funktion automatisch aus.

  • q— torch.Tensor in der folgenden Form (batch_size x seqlen x num_heads x head_size) oder(batch_size x num_heads x seqlen x head_size). Basierend auf der Form muss ein geeignetes Layout-Argument übergeben werden.

  • kv— torch.Tensor der folgenden Form (batch_size x seqlen x (2 x num_heads) x head_size) oder(batch_size, (2 x num_heads) x seqlen x head_size), oder ein Tupel aus zwei torch.Tensor s, von denen jedes die Form (batch_size x seqlen x num_heads x head_size) oder haben kann. (batch_size x num_heads x seqlen x head_size) Basierend auf der Form muss auch ein entsprechendes layout Argument übergeben werden.

  • causal— Wenn dieser Wert auf gesetzt istFalse, was der Standardwert des Arguments ist, wird keine Maske angewendet. Wenn auf gesetztTrue, verwendet die forward Methode die untere dreieckige Standardmaske. Der Standardwert ist False.

  • cast_dtype— Wenn sie auf einen bestimmten Dtype gesetzt ist, werden die qkv Tensoren zuvor in diesen Dtype umgewandelt. attn Dies ist nützlich für Implementierungen wie Hugging Face Transformers GPT-Neox, das über rotatorische Einbettungen verfügt. q,k fp32 Wenn auf gesetzt, wird kein Cast angewendet. None Der Standardwert ist None.

  • layout (string) — Verfügbare Werte sind "b h s d" oder"b s h d". Dies sollte auf das Layout der übergebenen qkv Tensoren eingestellt werden, damit entsprechende Transformationen beantragt werden können. attn Der Standardwert ist "b h s d".

• config— Eine FlashAttention Konfiguration für das Lama-Modell.

• forward(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)

  • hidden_states(torch.Tensor) — Versteckte Zustände eines Tensors in Form von. (batch_size x seq_len x num_heads x head_size)

  • attention_mask(torch.LongTensor) — Maske, um zu vermeiden, dass Aufmerksamkeit auf das Auffüllen von Token-Indizes in Form von gerichtet wird. (batch_size x seqlen) Der Standardwert ist None.

  • position_ids(torch.LongTensor) — Wenn nichtNone, hat es die Form von(batch_size x seqlen), die Positionsindizes jedes Eingabesequenz-Tokens in den Positionseinbettungen anzugeben. Der Standardwert ist None.

  • past_key_value(Cache) — Vorberechnete versteckte Zustände (Schlüssel und Werte in den Selbstaufmerksamkeitsblöcken und in den Queraufmerksamkeitsblöcken). Der Standardwert ist None.

  • output_attentions(bool) — Gibt an, ob die Aufmerksamkeitstensoren aller Aufmerksamkeitsebenen zurückgegeben werden sollen. Der Standardwert ist False.

  • use_cache(bool) — Gibt an, ob Schlüsselwertstatus zurückgegeben past_key_values werden sollen. Der Standardwert ist False.

• model(torch.nn.Module) — Ein Modell Hugging Face Transformer-Modelle, die mit der SMP-Tensorparallelität kompatibel sind zur Transformation und Anwendung der Tensorparallelitätsfunktion der SMP-Bibliothek.

• device(torch.device) — Falls erfolgreich, wird auf diesem Gerät ein neues Modell erstellt. Wenn das ursprüngliche Modul einen Parameter auf dem Metagerät hat (sieheVerzögerte Parameterinitialisierung), dann wird das transformierte Modul auch auf dem Metagerät erstellt, wobei das hier übergebene Argument ignoriert wird. Der Standardwert ist None.

• dtype(torch.dtype) — Falls übergeben, wird dies als dtype-Kontextmanager für die Erstellung des Modells festgelegt und ein Modell mit diesem Dtype erstellt. Dies ist normalerweise unnötig, da wir das Modell mit erstellen wollen, fp32 wenn wir es verwendenMixedPrecision, und fp32 es ist der Standard-Dtype in. PyTorch Der Standardwert ist None.

• config(dict) — Dies ist ein Wörterbuch für die Konfiguration des SMP-Transformators. Der Standardwert ist None.

• load_state_dict_from_rank0(Boolean) — Standardmäßig erstellt dieses Modul eine neue Instanz des Modells mit neuen Gewichten. Wenn dieses Argument auf gesetzt istTrue, versucht SMP, das Zustandswörterbuch des PyTorch Originalmodells vom 0-ten Rang in ein transformiertes Modell für die Tensorparallelgruppe zu laden, zu der der 0-te Rang gehört. Wenn dies auf gesetzt istTrue, kann Rang 0 keine Parameter auf dem Metagerät haben. Nur die erste parallel Tensorgruppe füllt die Gewichte ab dem 0ten Rang nach diesem Transformationsaufruf auf. Sie müssen True im FSDP-Wrapper sync_module_states auf setzen, um diese Gewichte von der ersten parallel Tensorgruppe auf alle anderen Prozesse zu übertragen. Wenn diese Option aktiviert ist, lädt die SMP-Bibliothek das Statuswörterbuch aus dem Originalmodell. Die SMP-Bibliothek nimmt das Modell vor state_dict der Transformation, konvertiert es so, dass es der Struktur des transformierten Modells entspricht, splittert es für jeden tensorparallelen Rang, übermittelt diesen Zustand vom 0-ten Rang an andere Ränge in der tensorparallelen Gruppe, zu der der 0-te Rang gehört, und lädt ihn. Der Standardwert ist False.

Funktionen von torch.sagemaker

• torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None— Initialisiert den Trainingsjob mit SMP. PyTorch

• torch.sagemaker.is_initialized() -> bool— Prüft, ob der Trainingsjob mit SMP initialisiert ist. Wenn Sie PyTorch während der Initialisierung des Jobs mit SMP auf die native Version zurückgreifen, sind einige Eigenschaften nicht relevant und werden, wie in der folgenden Eigenschaftenliste angegebenNone, entsprechend.

• torch.sagemaker.utils.module_utils.empty_module_params(module: nn.Module, device: Optional[torch.device] = None, recurse: bool = False) -> nn.Module— Erzeugt leere Parameter für das angegebene Objekt, device falls vorhanden, und kann, falls angegeben, für alle verschachtelten Module rekursiv sein.

• torch.sagemaker.utils.module_utils.move_buffers_to_device(module: nn.Module, device: torch.device, recurse: bool = False) -> nn.Module— Verschiebt Modulpuffer in den angegebenen Bereich und kanndevice, falls angegeben, für alle verschachtelten Module rekursiv sein.

Eigenschaften

torch.sagemaker.stateenthält nach der Initialisierung von SMP mit mehrere nützliche Eigenschaften. torch.sagemaker.init

• torch.sagemaker.state.hybrid_shard_degree(int) — Der Grad der Parallelität von Shard-Daten, an den eine Kopie von Benutzereingaben in der SMP-Konfiguration übergeben wurde. torch.sagemaker.init() Weitere Informationen hierzu finden Sie unter Erste Schritte mit der SageMaker Modellparallelismus-Bibliothek v2.

• torch.sagemaker.state.rank(int) — Der globale Rang für das Gerät im Bereich von. [0, world_size)

• torch.sagemaker.state.rep_rank_process_group(torch.distributed.ProcessGroup) — Die Prozessgruppe, die alle Geräte mit demselben Replikationsrang umfasst. Beachten Sie den subtilen, aber grundlegenden Unterschied zutorch.sagemaker.state.tp_process_group. Wenn Sie auf die native Version zurückgreifen PyTorch, kehrt sie zurückNone.

• torch.sagemaker.state.tensor_parallel_degree(int) — Der Grad der Tensorparallelität, an den eine Kopie einer Benutzereingabe in der SMP-Konfiguration übergeben wurde. torch.sagemaker.init() Weitere Informationen hierzu finden Sie unter Erste Schritte mit der SageMaker Modellparallelismus-Bibliothek v2.

• torch.sagemaker.state.tp_size(int) — Ein Alias für. torch.sagemaker.state.tensor_parallel_degree

• torch.sagemaker.state.tp_rank(int) — Der Tensorparallelitätsrang für das Gerät im Bereich von[0, tp_size), bestimmt durch den Grad der Tensorparallelität und den Rangmechanismus.

• torch.sagemaker.state.tp_process_group(torch.distributed.ProcessGroup) — Die tensorparallele Prozessgruppe, die alle Geräte mit demselben Rang in anderen Dimensionen (z. B. Sharded Data Parallelität und Replikation), aber einzigartigen tensorparallelen Rängen umfasst. Wenn auf native Version zurückgegriffen wird, kehrt es zurück. PyTorch None

• torch.sagemaker.state.world_size(int) — Die Gesamtzahl der im Training verwendeten Geräte.