Add files using upload-large-folder tool

bigscience/bigscience/bigscience.py

@@ -0,0 +1 @@
+"""Main module."""

bigscience/data/oscar/cache/oscar/unshuffled_deduplicated_zh/1.0.0/84838bd49d2295f62008383b05620571535451d84545037bb94d6f3501651df2/oscar-train-00294-of-00532.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe5725828e3d7908305077200cd3b83eb22986dc47d0263189850b027c1a979d
+size 500890168

bigscience/evaluation/utilities/convert_results_to_json.py

@@ -0,0 +1,111 @@
+import json
+import math
+import os
+from argparse import ArgumentParser
+from os import listdir
+from os.path import isfile
+
+def get_args():
+    parser = ArgumentParser()
+    # --experiments tr3d-1B3-oscar-checkpoints,tr3e-1B3-c4-checkpoints,tr3m-1B3-pile-checkpoints
+    parser.add_argument('--experiment', type=str, required=True,
+                        help='Experiment we want to download.')
+    parser.add_argument('--result-dir', type=str, required=True,
+                        help='Result directory containing all results, and to store aggregated json results.')
+    parser.add_argument('--batch-size', type=int, default=512,
+                        help='Experiment training batch size.')
+    parser.add_argument('--sequence_length', type=int, default=2048,
+                        help='Experiment training sequence length.')
+    parser.add_argument('--rampup-batch-size', type=lambda s: tuple(int(item) for item in s.split(',')), default=(32, 32, 2_000_000),
+                        help='Experiment training batch size rampup.')
+    return parser.parse_args()
+
+def checkpoint_step_to_tokens(checkpoint_step, args) -> int:
+    def fn(checkpoint_step) -> int:
+        if not hasattr(checkpoint_step_to_tokens, "CACHE"):
+            checkpoint_step_to_tokens.CACHE = {}
+
+        BATCH_SIZE=args.batch_size
+        SEQUENCE_LENGTH=args.sequence_length
+        # Linear increase in terms of samples.
+        RAMPUP_BATCH_SIZE = args.rampup_batch_size
+
+        # Compute RAMPUP checkpoint_step
+        if not hasattr(checkpoint_step_to_tokens, "RAMPUP_OFFSET"):
+            initial_batch_size, increment_batch_size, sample_limit_for_rampup = RAMPUP_BATCH_SIZE
+            number_of_increments = (BATCH_SIZE - initial_batch_size) // increment_batch_size
+            assert (BATCH_SIZE - initial_batch_size) % increment_batch_size == 0
+
+            offset_step = 0
+            start_sample = 0
+            for incr in range(number_of_increments):
+                batch_size = initial_batch_size + incr * increment_batch_size
+                end_sample = int(math.ceil((incr + 1) * sample_limit_for_rampup / number_of_increments))
+                number_of_step_per_increment = int(math.ceil((end_sample - start_sample) / batch_size))
+                checkpoint_step_to_tokens.CACHE.update({
+                    offset_step + i: (start_sample + i * batch_size) * SEQUENCE_LENGTH
+                    for i in range(number_of_step_per_increment)
+                })
+                offset_step += number_of_step_per_increment
+                start_sample += number_of_step_per_increment * batch_size
+
+            checkpoint_step_to_tokens.CACHE[offset_step] = start_sample * SEQUENCE_LENGTH
+            checkpoint_step_to_tokens.RAMPUP_OFFSET = offset_step
+
+        if checkpoint_step in checkpoint_step_to_tokens.CACHE:
+            return checkpoint_step_to_tokens.CACHE[checkpoint_step]
+
+        number_steps_after_rampup = checkpoint_step - checkpoint_step_to_tokens.RAMPUP_OFFSET
+        assert number_steps_after_rampup >= 0
+
+        slope = BATCH_SIZE * SEQUENCE_LENGTH
+
+        checkpoint_step_to_tokens.CACHE[checkpoint_step] = \
+            checkpoint_step_to_tokens.CACHE[checkpoint_step_to_tokens.RAMPUP_OFFSET] + \
+            slope * number_steps_after_rampup
+        return checkpoint_step_to_tokens.CACHE[checkpoint_step]
+    return fn(checkpoint_step)
+
+def main():
+    args = get_args()
+    result_dir = args.result_dir
+    experiment = args.experiment
+
+    results_file_per_checkpoint = [
+        file
+        for file in listdir(result_dir)
+        if isfile(os.path.join(result_dir, file)) and file.startswith(experiment)
+    ]
+    checkpoint_steps = sorted([int(file.split("_")[-1].split(".json")[0]) for file in results_file_per_checkpoint])
+    absolute_paths = [f"{result_dir}/{experiment}_{checkpoint_step}.json" for checkpoint_step in checkpoint_steps]
+    # format = "{EXPERIMENT_NAME}_{CHECKPOINT_STEP}.json"
+    tokens = [checkpoint_step_to_tokens(checkpoint_step, args) for checkpoint_step in checkpoint_steps]
+
+    result_json = {}
+    for absolute_path in absolute_paths:
+        with open(absolute_path, 'r') as fi:
+            results = json.load(fi)["results"]
+
+        for task in results:
+            if task not in result_json:
+                result_json[task] = {}
+
+            for metric in results[task]:
+                if metric not in result_json[task]:
+                    result_json[task][metric] = []
+
+                result_json[task][metric].append(results[task][metric])
+
+    # check
+    for task in result_json:
+        assert len(tokens) == len(checkpoint_steps)
+        for metric in result_json[task]:
+            assert len(result_json[task][metric]) == len(checkpoint_steps)
+
+    output_path = os.path.join(result_dir, f"{experiment}_agg.json")
+    print(f"Printing results to {output_path}")
+    with open(output_path, 'w') as fo:
+        json.dump({"tokens": tokens, "checkpoints": checkpoint_steps, "results": result_json}, fo, indent=2)
+
+if __name__ == "__main__":
+    main()

bigscience/inference/README.md

@@ -0,0 +1,15 @@
+# Inference
+
+Notes on the plans to do inference with the pre-trained model
+
+# Large Model on limited hardware
+
+- inferencing and tinkering on a single host (150-200B model)
+
+Solution: We can do this with ZeRO-Infinity. Seems like @Shaden Smith already has the code to load the model parameters checkpoints from Megatron+DeepSpeed 3D to Megatron+ DeepSpeed ZeRO-Infinity. The remaining work is to add an inference only mode to ZeRO-Infinity that drops all the non-parameter states.
+
+Hardware Requirements : Would require about 500-1000 GB of memory (can be CPU, GPU or NVMe). Single Node with enough CPU or NVMe memory should work here.
+
+The single node can be as little as 4x 32GB-V100. It will be just slower than say, 8x 80GB-A100.
+
+Estimated Work: If all works as expected, 1-3 weeks based on bandwidth availability. Tuning for the best performance might another week or so, but that wont be blocking the availability of the functionality.

bigscience/inference/modeling_gpt2_alibi_prefix_lm.py

@@ -0,0 +1,1750 @@
+# coding=utf-8
+# Copyright 2018 The OpenAI Team Authors and HuggingFace Inc. team.
+# Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""PyTorch OpenAI GPT-2 model with AliBi."""
+
+## integrating some AliBi code from https://github.com/bigscience-workshop/Megatron-DeepSpeed/blob/c839a8aa30731f71b3738d56009be9668508e366/megatron/model/transformer.py
+# I am keeping the name of the classes as GPT2 because some of transformer's code like pipeline classes check class names in order to do things, and
+# creating a new class that have different names sometimes break things.
+
+import os
+import enum
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+import torch
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import CrossEntropyLoss, MSELoss
+
+from transformers.activations import ACT2FN
+from transformers.file_utils import (
+    ModelOutput,
+    add_code_sample_docstrings,
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    replace_return_docstrings,
+)
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPastAndCrossAttentions,
+    CausalLMOutputWithCrossAttentions,
+    SequenceClassifierOutputWithPast,
+    TokenClassifierOutput,
+)
+from transformers.modeling_utils import (
+    Conv1D,
+    PreTrainedModel,
+    SequenceSummary,
+    find_pruneable_heads_and_indices,
+    prune_conv1d_layer,
+)
+from transformers.utils import logging
+from transformers.utils.model_parallel_utils import assert_device_map, get_device_map
+from transformers.models.gpt2.configuration_gpt2 import GPT2Config
+
+from collections import OrderedDict
+from typing import Any, Mapping, Optional
+
+from transformers import PreTrainedTokenizer, TensorType, is_torch_available
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.onnx import OnnxConfigWithPast
+
+
+
+logger = logging.get_logger(__name__)
+
+GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP = {
+    "gpt2": "https://huggingface.co/gpt2/resolve/main/config.json",
+    "gpt2-medium": "https://huggingface.co/gpt2-medium/resolve/main/config.json",
+    "gpt2-large": "https://huggingface.co/gpt2-large/resolve/main/config.json",
+    "gpt2-xl": "https://huggingface.co/gpt2-xl/resolve/main/config.json",
+    "distilgpt2": "https://huggingface.co/distilgpt2/resolve/main/config.json",
+}
+
+PositionEmbeddingType_rotary = 1 # not implemented
+PositionEmbeddingType_absolute = 2
+PositionEmbeddingType_alibi = 3
+
+
+class GPT2Config(PretrainedConfig):
+    """
+    This is the configuration class to store the configuration of a :class:`~transformers.GPT2Model` or a
+    :class:`~transformers.TFGPT2Model`. It is used to instantiate a GPT-2 model according to the specified arguments,
+    defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration
+    to that of the GPT-2 `small <https://huggingface.co/gpt2>`__ architecture.
+    Configuration objects inherit from :class:`~transformers.PretrainedConfig` and can be used to control the model
+    outputs. Read the documentation from :class:`~transformers.PretrainedConfig` for more information.
+    Args:
+        vocab_size (:obj:`int`, `optional`, defaults to 50257):
+            Vocabulary size of the GPT-2 model. Defines the number of different tokens that can be represented by the
+            :obj:`inputs_ids` passed when calling :class:`~transformers.GPT2Model` or
+            :class:`~transformers.TFGPT2Model`.
+        n_positions (:obj:`int`, `optional`, defaults to 1024):
+            The maximum sequence length that this model might ever be used with. Typically set this to something large
+            just in case (e.g., 512 or 1024 or 2048).
+        n_ctx (:obj:`int`, `optional`, defaults to 1024):
+            Dimensionality of the causal mask (usually same as n_positions).
+        n_embd (:obj:`int`, `optional`, defaults to 768):
+            Dimensionality of the embeddings and hidden states.
+        n_layer (:obj:`int`, `optional`, defaults to 12):
+            Number of hidden layers in the Transformer encoder.
+        n_head (:obj:`int`, `optional`, defaults to 12):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        n_inner (:obj:`int`, `optional`, defaults to None):
+            Dimensionality of the inner feed-forward layers. :obj:`None` will set it to 4 times n_embd
+        activation_function (:obj:`str`, `optional`, defaults to :obj:`"gelu"`):
+            Activation function, to be selected in the list :obj:`["relu", "silu", "gelu", "tanh", "gelu_new"]`.
+        resid_pdrop (:obj:`float`, `optional`, defaults to 0.1):
+            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
+        embd_pdrop (:obj:`int`, `optional`, defaults to 0.1):
+            The dropout ratio for the embeddings.
+        attn_pdrop (:obj:`float`, `optional`, defaults to 0.1):
+            The dropout ratio for the attention.
+        layer_norm_epsilon (:obj:`float`, `optional`, defaults to 1e-5):
+            The epsilon to use in the layer normalization layers
+        initializer_range (:obj:`float`, `optional`, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        summary_type (:obj:`string`, `optional`, defaults to :obj:`"cls_index"`):
+            Argument used when doing sequence summary, used in the models :class:`~transformers.GPT2DoubleHeadsModel`
+            and :class:`~transformers.TFGPT2DoubleHeadsModel`.
+            Has to be one of the following options:
+                - :obj:`"last"`: Take the last token hidden state (like XLNet).
+                - :obj:`"first"`: Take the first token hidden state (like BERT).
+                - :obj:`"mean"`: Take the mean of all tokens hidden states.
+                - :obj:`"cls_index"`: Supply a Tensor of classification token position (like GPT/GPT-2).
+                - :obj:`"attn"`: Not implemented now, use multi-head attention.
+        summary_use_proj (:obj:`bool`, `optional`, defaults to :obj:`True`):
+            Argument used when doing sequence summary, used in the models :class:`~transformers.GPT2DoubleHeadsModel`
+            and :class:`~transformers.TFGPT2DoubleHeadsModel`.
+            Whether or not to add a projection after the vector extraction.
+        summary_activation (:obj:`str`, `optional`):
+            Argument used when doing sequence summary. Used in for the multiple choice head in
+            :class:`~transformers.GPT2DoubleHeadsModel`.
+            Pass :obj:`"tanh"` for a tanh activation to the output, any other value will result in no activation.
+        summary_proj_to_labels (:obj:`bool`, `optional`, defaults to :obj:`True`):
+            Argument used when doing sequence summary, used in the models :class:`~transformers.GPT2DoubleHeadsModel`
+            and :class:`~transformers.TFGPT2DoubleHeadsModel`.
+            Whether the projection outputs should have :obj:`config.num_labels` or :obj:`config.hidden_size` classes.
+        summary_first_dropout (:obj:`float`, `optional`, defaults to 0.1):
+            Argument used when doing sequence summary, used in the models :class:`~transformers.GPT2DoubleHeadsModel`
+            and :class:`~transformers.TFGPT2DoubleHeadsModel`.
+            The dropout ratio to be used after the projection and activation.
+        scale_attn_weights (:obj:`bool`, `optional`, defaults to :obj:`True`):
+            Scale attention weights by dividing by sqrt(hidden_size)..
+        use_cache (:obj:`bool`, `optional`, defaults to :obj:`True`):
+            Whether or not the model should return the last key/values attentions (not used by all models).
+    Example::
+        >>> from transformers import GPT2Model, GPT2Config
+        >>> # Initializing a GPT2 configuration
+        >>> configuration = GPT2Config()
+        >>> # Initializing a model from the configuration
+        >>> model = GPT2Model(configuration)
+        >>> # Accessing the model configuration
+        >>> configuration = model.config
+    """
+
+    model_type = "gpt2"
+    keys_to_ignore_at_inference = ["past_key_values"]
+    attribute_map = {
+        "hidden_size": "n_embd",
+        "max_position_embeddings": "n_positions",
+        "num_attention_heads": "n_head",
+        "num_hidden_layers": "n_layer",
+    }
+
+    def __init__(
+        self,
+        vocab_size=50257,
+        n_positions=1024,
+        n_ctx=1024,
+        n_embd=768,
+        n_layer=12,
+        n_head=12,
+        n_inner=None,
+        activation_function="gelu_new",
+        resid_pdrop=0.1,
+        embd_pdrop=0.1,
+        attn_pdrop=0.1,
+        layer_norm_epsilon=1e-5,
+        initializer_range=0.02,
+        summary_type="cls_index",
+        summary_use_proj=True,
+        summary_activation=None,
+        summary_proj_to_labels=True,
+        summary_first_dropout=0.1,
+        scale_attn_weights=True,
+        use_cache=True,
+        bos_token_id=50256,
+        eos_token_id=50256,
+        position_embedding_type=PositionEmbeddingType_absolute,
+        **kwargs
+    ):
+        self.vocab_size = vocab_size
+        self.n_ctx = n_ctx
+        self.n_positions = n_positions
+        self.n_embd = n_embd
+        self.n_layer = n_layer
+        self.n_head = n_head
+        self.n_inner = n_inner
+        self.activation_function = activation_function
+        self.resid_pdrop = resid_pdrop
+        self.embd_pdrop = embd_pdrop
+        self.attn_pdrop = attn_pdrop
+        self.layer_norm_epsilon = layer_norm_epsilon
+        self.initializer_range = initializer_range
+        self.summary_type = summary_type
+        self.summary_use_proj = summary_use_proj
+        self.summary_activation = summary_activation
+        self.summary_first_dropout = summary_first_dropout
+        self.summary_proj_to_labels = summary_proj_to_labels
+        self.scale_attn_weights = scale_attn_weights
+        self.use_cache = use_cache
+
+        self.bos_token_id = bos_token_id
+        self.eos_token_id = eos_token_id
+        self.position_embedding_type = position_embedding_type
+        super().__init__(bos_token_id=bos_token_id, eos_token_id=eos_token_id, **kwargs)
+
+
+class GPT2OnnxConfig(OnnxConfigWithPast):
+    @property
+    def inputs(self) -> Mapping[str, Mapping[int, str]]:
+        common_inputs = OrderedDict({"input_ids": {0: "batch"}})
+        if self.use_past:
+            for i in range(self._config.n_layer * 2):
+                common_inputs[f"past_key_values.{i}"] = {0: "batch", 2: "sequence"}
+
+            common_inputs["attention_mask"] = {0: "batch", 1: "sequence"}
+        else:
+            common_inputs["attention_mask"] = {0: "batch", 1: "sequence"}
+
+        return common_inputs
+
+    @property
+    def outputs(self) -> Mapping[str, Mapping[int, str]]:
+        common_outputs = OrderedDict({"last_hidden_state": {0: "batch", 1: "sequence"}})
+        if self.use_past:
+            for i in range(self._config.n_layer * 2):
+                common_outputs[f"present.{i}"] = {0: "batch", 2: "sequence"}
+
+            return common_outputs
+
+        return common_outputs
+
+    def generate_dummy_inputs(
+        self,
+        tokenizer: PreTrainedTokenizer,
+        batch_size: int = -1,
+        seq_length: int = -1,
+        is_pair: bool = False,
+        framework: Optional[TensorType] = None,
+    ) -> Mapping[str, Any]:
+        common_inputs = super().generate_dummy_inputs(tokenizer, batch_size, seq_length, is_pair, framework)
+
+        # We need to order the input in the way they appears in the forward()
+        ordered_inputs = OrderedDict({"input_ids": common_inputs["input_ids"]})
+
+        # Need to add the past_keys
+        if self.use_past:
+            if not is_torch_available():
+                raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
+            else:
+                import torch
+
+                batch = common_inputs["input_ids"].shape[0]
+                ordered_inputs["past_key_values"] = [
+                    (
+                        torch.zeros((batch, self._config.n_head, 1, self._config.hidden_size // self._config.n_head)),
+                        torch.zeros((batch, self._config.n_head, 1, self._config.hidden_size // self._config.n_head)),
+                    )
+                    for _ in range(self._config.n_layer)
+                ]
+
+        ordered_inputs["attention_mask"] = common_inputs["attention_mask"]
+        return ordered_inputs
+
+
+# need to change the checkpoints to be the bigscience checkpoints
+_CHECKPOINT_FOR_DOC = "gpt2"
+_CONFIG_FOR_DOC = "GPT2Config"
+_TOKENIZER_FOR_DOC = "GPT2Tokenizer"
+
+GPT2_PRETRAINED_MODEL_ARCHIVE_LIST = [
+    "gpt2",
+    "gpt2-medium",
+    "gpt2-large",
+    "gpt2-xl",
+    "distilgpt2",
+    # See all GPT-2 models at https://huggingface.co/models?filter=gpt2
+]
+
+
+
+
+def load_tf_weights_in_gpt2(model, config, gpt2_checkpoint_path):
+    """Load tf checkpoints in a pytorch model"""
+    try:
+        import re
+
+        import tensorflow as tf
+    except ImportError:
+        logger.error(
+            "Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see "
+            "https://www.tensorflow.org/install/ for installation instructions."
+        )
+        raise
+    tf_path = os.path.abspath(gpt2_checkpoint_path)
+    logger.info(f"Converting TensorFlow checkpoint from {tf_path}")
+    # Load weights from TF model
+    init_vars = tf.train.list_variables(tf_path)
+    names = []
+    arrays = []
+    for name, shape in init_vars:
+        logger.info(f"Loading TF weight {name} with shape {shape}")
+        array = tf.train.load_variable(tf_path, name)
+        names.append(name)
+        arrays.append(array.squeeze())
+
+    for name, array in zip(names, arrays):
+        name = name[6:]  # skip "model/"
+        name = name.split("/")
+        pointer = model
+        for m_name in name:
+            if re.fullmatch(r"[A-Za-z]+\d+", m_name):
+                scope_names = re.split(r"(\d+)", m_name)
+            else:
+                scope_names = [m_name]
+            if scope_names[0] == "w" or scope_names[0] == "g":
+                pointer = getattr(pointer, "weight")
+            elif scope_names[0] == "b":
+                pointer = getattr(pointer, "bias")
+            elif scope_names[0] == "wpe" or scope_names[0] == "wte":
+                pointer = getattr(pointer, scope_names[0])
+                pointer = getattr(pointer, "weight")
+            else:
+                pointer = getattr(pointer, scope_names[0])
+            if len(scope_names) >= 2:
+                num = int(scope_names[1])
+                pointer = pointer[num]
+        try:
+            assert (
+                pointer.shape == array.shape
+            ), f"Pointer shape {pointer.shape} and array shape {array.shape} mismatched"
+        except AssertionError as e:
+            e.args += (pointer.shape, array.shape)
+            raise
+        logger.info(f"Initialize PyTorch weight {name}")
+        pointer.data = torch.from_numpy(array)
+    return model
+
+
+class GPT2Attention(nn.Module):
+    def __init__(self, config, is_cross_attention=False):
+        super().__init__()
+
+        max_positions = config.max_position_embeddings
+        self.register_buffer(
+            "bias",
+            torch.tril(torch.ones((max_positions, max_positions), dtype=torch.uint8)).view(
+                1, 1, max_positions, max_positions
+            ),
+        )
+        self.register_buffer("masked_bias", torch.tensor(-1e4))
+
+        self.embed_dim = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.head_dim = self.embed_dim // self.num_heads
+        self.split_size = self.embed_dim
+        if self.head_dim * self.num_heads != self.embed_dim:
+            raise ValueError(
+                f"`embed_dim` must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`: {self.num_heads})."
+            )
+
+        self.scale_attn_weights = config.scale_attn_weights
+        self.is_cross_attention = is_cross_attention
+
+        if self.is_cross_attention:
+            self.c_attn = Conv1D(2 * self.embed_dim, self.embed_dim)
+            self.q_attn = Conv1D(self.embed_dim, self.embed_dim)
+        else:
+            self.c_attn = Conv1D(3 * self.embed_dim, self.embed_dim)
+        self.c_proj = Conv1D(self.embed_dim, self.embed_dim)
+
+        self.attn_dropout = nn.Dropout(config.attn_pdrop)
+        self.resid_dropout = nn.Dropout(config.resid_pdrop)
+
+        self.pruned_heads = set()
+        self.position_embedding_type = config.position_embedding_type
+
+    def prune_heads(self, heads):
+        if len(heads) == 0:
+            return
+        heads, index = find_pruneable_heads_and_indices(heads, self.num_heads, self.head_dim, self.pruned_heads)
+        index_attn = torch.cat([index, index + self.split_size, index + (2 * self.split_size)])
+
+        # Prune conv1d layers
+        self.c_attn = prune_conv1d_layer(self.c_attn, index_attn, dim=1)
+        self.c_proj = prune_conv1d_layer(self.c_proj, index, dim=0)
+
+        # Update hyper params
+        self.split_size = (self.split_size // self.num_heads) * (self.num_heads - len(heads))
+        self.num_heads = self.num_heads - len(heads)
+        self.pruned_heads = self.pruned_heads.union(heads)
+
+    def _attn(self, query, key, value, attention_mask=None, head_mask=None):
+        
+        # [b, np, sq, sk]
+        output_size = (query.size(1),
+                       query.size(2),
+                       query.size(0),
+                       key.size(0))
+        # preallocting result tensor: [b * np, sq, sk]
+        if alibi is None:
+            matmul_result = torch.empty(
+                output_size[0]*output_size[1],
+                output_size[2],
+                output_size[3],
+                dtype=query_layer.dtype,
+                device=torch.cuda.current_device())
+        else:
+            matmul_result = alibi[:output_size[0]*output_size[1], :, :output_size[3]]
+            
+        # [sq, b, np, hn] -> [sq, b * np, hn]
+        query = query.view(output_size[2],
+                                       output_size[0] * output_size[1], -1)
+        # [sk, b, np, hn] -> [sk, b * np, hn]
+        key = key.view(output_size[3],
+                                   output_size[0] * output_size[1], -1)
+        # Raw attention scores. [b * np, sq, sk]
+        attn_weights = torch.baddbmm(
+            matmul_result,
+            query_layer.transpose(0, 1),   # [b * np, sq, hn]
+            key_layer.transpose(0, 1).transpose(-1, -2),  # [b * np, hn, sk]
+            beta=0.0 if alibi is None else 1.0, alpha=(1.0/self.norm_factor))
+        
+        #attn_weights = torch.matmul(query, key.transpose(-1, -2))
+
+        # change view to [b, np, sq, sk]
+        attn_weights = attn_weights.view(*output_size)
+
+        # do we need this scaling. does the alpha do the scaling as above?
+        if self.scale_attn_weights:
+            attn_weights = attn_weights / (float(value.size(-1)) ** 0.5)
+
+        if not self.is_cross_attention:
+            # if only "normal" attention layer implements causal mask
+            query_length, key_length = query.size(-2), key.size(-2)
+            causal_mask = self.bias[:, :, key_length - query_length : key_length, :key_length].bool()
+            attn_weights = torch.where(causal_mask, attn_weights, self.masked_bias.to(attn_weights.dtype))
+
+        if attention_mask is not None:
+            # Apply the attention mask
+            attn_weights = attn_weights + attention_mask
+
+        attn_weights = nn.Softmax(dim=-1)(attn_weights)
+        attn_weights = self.attn_dropout(attn_weights)
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            attn_weights = attn_weights * head_mask
+
+        attn_output = torch.matmul(attn_weights, value)
+
+        return attn_output, attn_weights
+
+    def _split_heads(self, tensor, num_heads, attn_head_size):
+        """
+        Splits hidden_size dim into attn_head_size and num_heads
+        """
+        new_shape = tensor.size()[:-1] + (num_heads, attn_head_size)
+        tensor = tensor.view(*new_shape)
+        return tensor.permute(0, 2, 1, 3)  # (batch, head, seq_length, head_features)
+
+    def _merge_heads(self, tensor, num_heads, attn_head_size):
+        """
+        Merges attn_head_size dim and num_attn_heads dim into hidden_size
+        """
+        tensor = tensor.permute(0, 2, 1, 3).contiguous()
+        new_shape = tensor.size()[:-2] + (num_heads * attn_head_size,)
+        return tensor.view(new_shape)
+
+    def forward(
+        self,
+        hidden_states,
+        layer_past=None,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        alibi=None,
+        use_cache=False,
+        output_attentions=False,
+        
+    ):
+        if encoder_hidden_states is not None:
+            if not hasattr(self, "q_attn"):
+                raise ValueError(
+                    "If class is used as cross attention, the weights `q_attn` have to be defined. "
+                    "Please make sure to instantiate class with `GPT2Attention(..., is_cross_attention=True)`."
+                )
+
+            query = self.q_attn(hidden_states)
+            key, value = self.c_attn(encoder_hidden_states).split(self.split_size, dim=2)
+            attention_mask = encoder_attention_mask
+        else:
+            query, key, value = self.c_attn(hidden_states).split(self.split_size, dim=2)
+
+        query = self._split_heads(query, self.num_heads, self.head_dim)
+        key = self._split_heads(key, self.num_heads, self.head_dim)
+        value = self._split_heads(value, self.num_heads, self.head_dim)
+
+        if layer_past is not None:
+            past_key, past_value = layer_past
+            key = torch.cat((past_key, key), dim=-2)
+            value = torch.cat((past_value, value), dim=-2)
+
+        if use_cache is True:
+            present = (key, value)
+        else:
+            present = None
+
+        attn_output, attn_weights = self._attn(query, key, value, attention_mask, head_mask)
+
+        attn_output = self._merge_heads(attn_output, self.num_heads, self.head_dim)
+        attn_output = self.c_proj(attn_output)
+        attn_output = self.resid_dropout(attn_output)
+
+        outputs = (attn_output, present)
+        if output_attentions:
+            outputs += (attn_weights,)
+
+        return outputs  # a, present, (attentions)
+
+
+class GPT2MLP(nn.Module):
+    def __init__(self, intermediate_size, config):
+        super().__init__()
+        embed_dim = config.hidden_size
+        self.c_fc = Conv1D(intermediate_size, embed_dim)
+        self.c_proj = Conv1D(embed_dim, intermediate_size)
+        self.act = ACT2FN[config.activation_function]
+        self.dropout = nn.Dropout(config.resid_pdrop)
+
+    def forward(self, hidden_states):
+        hidden_states = self.c_fc(hidden_states)
+        hidden_states = self.act(hidden_states)
+        hidden_states = self.c_proj(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        return hidden_states
+
+
+class GPT2Block(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        hidden_size = config.hidden_size
+        inner_dim = config.n_inner if config.n_inner is not None else 4 * hidden_size
+
+        self.ln_1 = nn.LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
+        self.attn = GPT2Attention(config)
+        self.ln_2 = nn.LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
+
+        if config.add_cross_attention:
+            self.crossattention = GPT2Attention(config, is_cross_attention=True)
+            self.ln_cross_attn = nn.LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
+
+        self.mlp = GPT2MLP(inner_dim, config)
+
+    def forward(
+        self,
+        hidden_states,
+        layer_past=None,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        alibi=None,
+        use_cache=False,
+        output_attentions=False,
+    ):
+        residual = hidden_states
+        hidden_states = self.ln_1(hidden_states)
+        attn_outputs = self.attn(
+            hidden_states,
+            layer_past=layer_past,
+            attention_mask=attention_mask,
+            head_mask=head_mask,
+            alibi=alibi,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+        )
+        attn_output = attn_outputs[0]  # output_attn: a, present, (attentions)
+        outputs = attn_outputs[1:]
+        # residual connection
+        hidden_states = attn_output + residual
+
+        if encoder_hidden_states is not None:
+            # add one self-attention block for cross-attention
+            if not hasattr(self, "crossattention"):
+                raise ValueError(
+                    f"If `encoder_hidden_states` are passed, {self} has to be instantiated with "
+                    "cross-attention layers by setting `config.add_cross_attention=True`"
+                )
+            residual = hidden_states
+            hidden_states = self.ln_cross_attn(hidden_states)
+            cross_attn_outputs = self.crossattention(
+                hidden_states,
+                attention_mask=attention_mask,
+                head_mask=head_mask,
+                encoder_hidden_states=encoder_hidden_states,
+                encoder_attention_mask=encoder_attention_mask,
+                alibi=alibi,
+                output_attentions=output_attentions,
+            )
+            attn_output = cross_attn_outputs[0]
+            # residual connection
+            hidden_states = residual + attn_output
+            outputs = outputs + cross_attn_outputs[2:]  # add cross attentions if we output attention weights
+
+        residual = hidden_states
+        hidden_states = self.ln_2(hidden_states)
+        feed_forward_hidden_states = self.mlp(hidden_states)
+        # residual connection
+        hidden_states = residual + feed_forward_hidden_states
+
+        if use_cache:
+            outputs = (hidden_states,) + outputs
+        else:
+            outputs = (hidden_states,) + outputs[1:]
+
+        return outputs  # hidden_states, present, (attentions, cross_attentions)
+
+
+class GPT2PreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = GPT2Config
+    load_tf_weights = load_tf_weights_in_gpt2
+    base_model_prefix = "transformer"
+    is_parallelizable = True
+    supports_gradient_checkpointing = True
+
+    def __init__(self, *inputs, **kwargs):
+        super().__init__(*inputs, **kwargs)
+
+            
+    def _init_weights(self, module):
+        """Initialize the weights."""
+        if isinstance(module, (nn.Linear, Conv1D)):
+            # Slightly different from the TF version which uses truncated_normal for initialization
+            # cf https://github.com/pytorch/pytorch/pull/5617
+            module.weight.data.normal_(mean=0.0, std=self.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=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+
+    def _set_gradient_checkpointing(self, module, value=False):
+        if isinstance(module, GPT2Model):
+            module.gradient_checkpointing = value
+
+
+
+@dataclass
+class GPT2DoubleHeadsModelOutput(ModelOutput):
+    """
+    Base class for outputs of models predicting if two sentences are consecutive or not.
+
+    Args:
+        loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when ``labels`` is provided):
+            Language modeling loss.
+        mc_loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when :obj:`mc_labels` is provided):
+            Multiple choice classification loss.
+        logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, num_choices, sequence_length, config.vocab_size)`):
+            Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+        mc_logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, num_choices)`):
+            Prediction scores of the multiple choice classification head (scores for each choice before SoftMax).
+        past_key_values (:obj:`Tuple[Tuple[torch.Tensor]]`, `optional`, returned when ``use_cache=True`` is passed or when ``config.use_cache=True``):
+            Tuple of length :obj:`config.n_layers`, containing tuples of tensors of shape :obj:`(batch_size, num_heads,
+            sequence_length, embed_size_per_head)`).
+
+            Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
+            :obj:`past_key_values` input) to speed up sequential decoding.
+        hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``):
+            Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
+            of shape :obj:`(batch_size, sequence_length, hidden_size)`.
+
+            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
+        attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``):
+            Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape :obj:`(batch_size, num_heads,
+            sequence_length, sequence_length)`.
+
+            GPT2Attentions weights after the attention softmax, used to compute the weighted average in the
+            self-attention heads.
+    """
+
+    loss: Optional[torch.FloatTensor] = None
+    mc_loss: Optional[torch.FloatTensor] = None
+    logits: torch.FloatTensor = None
+    mc_logits: torch.FloatTensor = None
+    past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None
+    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+    attentions: Optional[Tuple[torch.FloatTensor]] = None
+
+
+GPT2_START_DOCSTRING = r"""
+
+    This model inherits from :class:`~transformers.PreTrainedModel`. Check the superclass documentation for the generic
+    methods the library implements for all its model (such as downloading or saving, resizing the input embeddings,
+    pruning heads etc.)
+
+    This model is also a PyTorch `torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>`__
+    subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to
+    general usage and behavior.
+
+    Parameters:
+        config (:class:`~transformers.GPT2Config`): Model configuration class with all the parameters of the model.
+            Initializing with a config file does not load the weights associated with the model, only the
+            configuration. Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model
+            weights.
+"""
+
+GPT2_INPUTS_DOCSTRING = r"""
+    Args:
+        input_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, input_ids_length)`):
+            :obj:`input_ids_length` = ``sequence_length`` if :obj:`past_key_values` is ``None`` else
+            ``past_key_values[0][0].shape[-2]`` (``sequence_length`` of input past key value states). Indices of input
+            sequence tokens in the vocabulary.
+
+            If :obj:`past_key_values` is used, only ``input_ids`` that do not have their past calculated should be
+            passed as ``input_ids``.
+
+            Indices can be obtained using :class:`~transformers.GPT2Tokenizer`. See
+            :meth:`transformers.PreTrainedTokenizer.encode` and :meth:`transformers.PreTrainedTokenizer.__call__` for
+            details.
+
+            `What are input IDs? <../glossary.html#input-ids>`__
+        past_key_values (:obj:`Tuple[Tuple[torch.Tensor]]` of length :obj:`config.n_layers`):
+            Contains precomputed hidden-states (key and values in the attention blocks) as computed by the model (see
+            :obj:`past_key_values` output below). Can be used to speed up sequential decoding. The ``input_ids`` which
+            have their past given to this model should not be passed as ``input_ids`` as they have already been
+            computed.
+        attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
+            Mask to avoid performing attention on padding token indices. Mask values selected in ``[0, 1]``:
+
+            - 1 for tokens that are **not masked**,
+            - 0 for tokens that are **masked**.
+
+            `What are attention masks? <../glossary.html#attention-mask>`__
+        token_type_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, input_ids_length)`, `optional`):
+            Segment token indices to indicate first and second portions of the inputs. Indices are selected in ``[0,
+            1]``:
+
+            - 0 corresponds to a `sentence A` token,
+            - 1 corresponds to a `sentence B` token.
+
+            `What are token type IDs? <../glossary.html#token-type-ids>`_
+        position_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
+            Indices of positions of each input sequence tokens in the position embeddings. Selected in the range ``[0,
+            config.max_position_embeddings - 1]``.
+
+            `What are position IDs? <../glossary.html#position-ids>`_
+        head_mask (:obj:`torch.FloatTensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`):
+            Mask to nullify selected heads of the self-attention modules. Mask values selected in ``[0, 1]``:
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+
+        inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
+            Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation.
+            This is useful if you want more control over how to convert :obj:`input_ids` indices into associated
+            vectors than the model's internal embedding lookup matrix.
+
+            If :obj:`past_key_values` is used, optionally only the last :obj:`inputs_embeds` have to be input (see
+            :obj:`past_key_values`).
+        use_cache (:obj:`bool`, `optional`):
+            If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up
+            decoding (see :obj:`past_key_values`).
+        output_attentions (:obj:`bool`, `optional`):
+            Whether or not to return the attentions tensors of all attention layers. See ``attentions`` under returned
+            tensors for more detail.
+        output_hidden_states (:obj:`bool`, `optional`):
+            Whether or not to return the hidden states of all layers. See ``hidden_states`` under returned tensors for
+            more detail.
+        return_dict (:obj:`bool`, `optional`):
+            Whether or not to return a :class:`~transformers.file_utils.ModelOutput` instead of a plain tuple.
+"""
+PARALLELIZE_DOCSTRING = r"""
+    This is an experimental feature and is a subject to change at a moment's notice.
+
+    Uses a device map to distribute attention modules of the model across several devices. If no device map is given,
+    it will evenly distribute blocks across all devices.
+
+    Args:
+        device_map (:obj:`Dict[int, list]`, optional, defaults to None):
+            A dictionary that maps attention modules to devices. Note that the embedding module and LMHead are always
+            automatically mapped to the first device (for esoteric reasons). That means that the first device should
+            have fewer attention modules mapped to it than other devices. For reference, the gpt2 models have the
+            following number of attention modules:
+
+                - gpt2: 12
+                - gpt2-medium: 24
+                - gpt2-large: 36
+                - gpt2-xl: 48
+
+    Example::
+
+            # Here is an example of a device map on a machine with 4 GPUs using gpt2-xl, which has a total of 48 attention modules:
+            model = GPT2LMHeadModel.from_pretrained('gpt2-xl')
+            device_map = {0: [0, 1, 2, 3, 4, 5, 6, 7, 8],
+
+                          1: [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21],
+                          2: [22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34],
+                          3: [35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]}
+            model.parallelize(device_map)
+"""
+DEPARALLELIZE_DOCSTRING = r"""
+    Moves the model to cpu from a model parallel state.
+
+    Example::
+
+        # On a 4 GPU machine with gpt2-large:
+        model = GPT2LMHeadModel.from_pretrained('gpt2-large')
+        device_map = {0: [0, 1, 2, 3, 4, 5, 6, 7],
+
+                    1: [8, 9, 10, 11, 12, 13, 14, 15],
+                    2: [16, 17, 18, 19, 20, 21, 22, 23],
+                    3: [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]}
+        model.parallelize(device_map) # Splits the model across several devices
+        model.deparallelize() # Put the model back on cpu and cleans memory by calling torch.cuda.empty_cache()
+"""
+
+
+@add_start_docstrings(
+    "The bare GPT2 Model transformer outputting raw hidden-states without any specific head on top.",
+    GPT2_START_DOCSTRING,
+)
+class GPT2Model(GPT2PreTrainedModel):
+    _keys_to_ignore_on_load_missing = ["attn.masked_bias"]
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.embed_dim = config.hidden_size
+
+        self.wte = nn.Embedding(config.vocab_size, self.embed_dim)
+        self.wpe = nn.Embedding(config.max_position_embeddings, self.embed_dim)
+
+        self.drop = nn.Dropout(config.embd_pdrop)
+        self.h = nn.ModuleList([GPT2Block(config) for _ in range(config.num_hidden_layers)])
+        self.ln_f = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_epsilon)
+
+        self.init_weights()
+
+        # Model parallel
+        self.model_parallel = False
+        self.device_map = None
+        self.gradient_checkpointing = False
+        config = kwargs.get('config',inputs[0])
+        if args.position_embedding_type == PositionEmbeddingType_alibi:
+            self.alibi = self._build_alibi_tensor(args.seq_length, args.num_attention_heads, args.micro_batch_size).to(torch.cuda.current_device())
+            if args.params_dtype == torch.float16:
+                self.alibi = self.alibi.to(torch.float16)
+            elif args.params_dtype == torch.bfloat16:
+                self.alibi = self.alibi.to(torch.bfloat16)
+        else:
+            self.alibi = None
+
+    @staticmethod
+    def _build_alibi_tensor(max_seq_len, num_attention_heads, batch_size):
+        # Based on https://github.com/ofirpress/attention_with_linear_biases/blob/a35aaca144e0eb6b789dfcb46784c4b8e31b7983/fairseq/models/transformer.py#L742
+        """Returns tensor shaped (batch_size * num_attention_heads, 1, max_seq_len)"""
+        def get_slopes(n):
+            def get_slopes_power_of_2(n):
+                start = (2 ** (-2 ** -(math.log2(n) - 3)))
+                ratio = start
+                return [start * ratio ** i for i in range(n)]
+
+            if math.log2(n).is_integer():
+                return get_slopes_power_of_2(n)
+            else:
+                closest_power_of_2 = 2 ** math.floor(math.log2(n))
+                return get_slopes_power_of_2(closest_power_of_2) + get_slopes(2 * closest_power_of_2)[0::2][
+                                                                   :n - closest_power_of_2]
+        slopes = torch.Tensor(get_slopes(num_attention_heads))
+        alibi = slopes.unsqueeze(1).unsqueeze(1) * torch.arange(max_seq_len).unsqueeze(0).unsqueeze(0).expand(num_attention_heads, -1, -1)
+        alibi = alibi.repeat(batch_size, 1, 1)
+        return alibi
+
+
+    @add_start_docstrings(PARALLELIZE_DOCSTRING)
+    def parallelize(self, device_map=None):
+        # Check validity of device_map
+        self.device_map = (
+            get_device_map(len(self.h), range(torch.cuda.device_count())) if device_map is None else device_map
+        )
+        assert_device_map(self.device_map, len(self.h))
+        self.model_parallel = True
+        self.first_device = "cpu" if "cpu" in self.device_map.keys() else "cuda:" + str(min(self.device_map.keys()))
+        self.last_device = "cuda:" + str(max(self.device_map.keys()))
+        self.wte = self.wte.to(self.first_device)
+        self.wpe = self.wpe.to(self.first_device)
+        # Load onto devices
+        for k, v in self.device_map.items():
+            for block in v:
+                cuda_device = "cuda:" + str(k)
+                self.h[block] = self.h[block].to(cuda_device)
+        # ln_f to last
+        self.ln_f = self.ln_f.to(self.last_device)
+
+    @add_start_docstrings(DEPARALLELIZE_DOCSTRING)
+    def deparallelize(self):
+        self.model_parallel = False
+        self.device_map = None
+        self.first_device = "cpu"
+        self.last_device = "cpu"
+        self.wte = self.wte.to("cpu")
+        self.wpe = self.wpe.to("cpu")
+        for index in range(len(self.h)):
+            self.h[index] = self.h[index].to("cpu")
+        self.ln_f = self.ln_f.to("cpu")
+        torch.cuda.empty_cache()
+
+    def get_input_embeddings(self):
+        return self.wte
+
+    def set_input_embeddings(self, new_embeddings):
+        self.wte = new_embeddings
+
+    def _prune_heads(self, heads_to_prune):
+        """
+        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer}
+        """
+        for layer, heads in heads_to_prune.items():
+            self.h[layer].attn.prune_heads(heads)
+
+    @add_start_docstrings_to_model_forward(GPT2_INPUTS_DOCSTRING)
+    @add_code_sample_docstrings(
+        tokenizer_class=_TOKENIZER_FOR_DOC,
+        checkpoint=_CHECKPOINT_FOR_DOC,
+        output_type=BaseModelOutputWithPastAndCrossAttentions,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids=None,
+        past_key_values=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        prefix_lm_token_id = None
+    ):
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            input_shape = input_ids.size()
+            input_ids = input_ids.view(-1, input_shape[-1])
+            batch_size = input_ids.shape[0]
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+            batch_size = inputs_embeds.shape[0]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        device = input_ids.device if input_ids is not None else inputs_embeds.device
+
+        if token_type_ids is not None:
+            token_type_ids = token_type_ids.view(-1, input_shape[-1])
+        if position_ids is not None:
+            position_ids = position_ids.view(-1, input_shape[-1])
+
+        if past_key_values is None:
+            past_length = 0
+            past_key_values = tuple([None] * len(self.h))
+        else:
+            past_length = past_key_values[0][0].size(-2)
+        if position_ids is None:
+            position_ids = torch.arange(past_length, input_shape[-1] + past_length, dtype=torch.long, device=device)
+            position_ids = position_ids.unsqueeze(0).view(-1, input_shape[-1])
+
+        # GPT2Attention mask.
+        if attention_mask is not None:
+            if batch_size <= 0:
+                raise ValueError("batch_size has to be defined and > 0")
+            attention_mask = attention_mask.view(batch_size, -1)
+            # do prefix_lm masking if we have input_ids. We find the prefix_lm_toke_id token as the prefix_lm boundry.
+            if prefix_lm_token_id is not None and input_ids is not None:
+                for attention_mask_row, input_ids_row in zip(attention_mask, input_ids): # do this in the bs dimension
+                    attention_mask_row[: (input_ids_row == prefix_lm_token_id).nonzero(as_tuple=True)[0], :] = 1.0 # is this right?
+                
+            # We create a 3D attention mask from a 2D tensor mask.
+            # Sizes are [batch_size, 1, 1, to_seq_length]
+            # So we can broadcast to [batch_size, num_heads, from_seq_length, to_seq_length]
+            # this attention mask is more simple than the triangular masking of causal attention
+            # used in OpenAI GPT, we just need to prepare the broadcast dimension here.
+            attention_mask = attention_mask[:, None, None, :]
+
+            # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
+            # masked positions, this operation will create a tensor which is 0.0 for
+            # positions we want to attend and -10000.0 for masked positions.
+            # Since we are adding it to the raw scores before the softmax, this is
+            # effectively the same as removing these entirely.
+            attention_mask = attention_mask.to(dtype=self.dtype)  # fp16 compatibility
+            attention_mask = (1.0 - attention_mask) * -10000.0
+
+        # If a 2D ou 3D attention mask is provided for the cross-attention
+        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
+        if self.config.add_cross_attention and encoder_hidden_states is not None:
+            encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
+            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
+            if encoder_attention_mask is None:
+                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
+            encoder_attention_mask = self.invert_attention_mask(encoder_attention_mask)
+        else:
+            encoder_attention_mask = None
+
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # head_mask has shape n_layer x batch x n_heads x N x N
+        head_mask = self.get_head_mask(head_mask, self.config.n_layer)
+
+        if inputs_embeds is None:
+            inputs_embeds = self.wte(input_ids)
+        position_embeds = self.wpe(position_ids)
+        hidden_states = inputs_embeds + position_embeds
+
+        if token_type_ids is not None:
+            token_type_embeds = self.wte(token_type_ids)
+            hidden_states = hidden_states + token_type_embeds
+
+        hidden_states = self.drop(hidden_states)
+
+        output_shape = input_shape + (hidden_states.size(-1),)
+
+        presents = () if use_cache else None
+        all_self_attentions = () if output_attentions else None
+        all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None
+        all_hidden_states = () if output_hidden_states else None
+        for i, (block, layer_past) in enumerate(zip(self.h, past_key_values)):
+
+            # Model parallel
+            if self.model_parallel:
+                torch.cuda.set_device(hidden_states.device)
+                # Ensure layer_past is on same device as hidden_states (might not be correct)
+                if layer_past is not None:
+                    layer_past = tuple(past_state.to(hidden_states.device) for past_state in layer_past)
+                # Ensure that attention_mask is always on the same device as hidden_states
+                if attention_mask is not None:
+                    attention_mask = attention_mask.to(hidden_states.device)
+                if isinstance(head_mask, torch.Tensor):
+                    head_mask = head_mask.to(hidden_states.device)
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            if self.gradient_checkpointing and self.training:
+
+                if use_cache:
+                    logger.warning(
+                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+                    )
+                    use_cache = False
+
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        # None for past_key_value
+                        return module(*inputs, use_cache, output_attentions)
+
+                    return custom_forward
+
+                outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(block),
+                    hidden_states,
+                    None,
+                    attention_mask,
+                    head_mask[i],
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                    self.alibi
+                )
+            else:
+                outputs = block(
+                    hidden_states,
+                    layer_past=layer_past,
+                    attention_mask=attention_mask,
+                    head_mask=head_mask[i],
+                    encoder_hidden_states=encoder_hidden_states,
+                    encoder_attention_mask=encoder_attention_mask,
+                    use_cache=use_cache,
+                    output_attentions=output_attentions,
+                    alibi=self.alibi
+                )
+
+            hidden_states = outputs[0]
+            if use_cache is True:
+                presents = presents + (outputs[1],)
+
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (outputs[2 if use_cache else 1],)
+                if self.config.add_cross_attention:
+                    all_cross_attentions = all_cross_attentions + (outputs[3 if use_cache else 2],)
+
+            # Model Parallel: If it's the last layer for that device, put things on the next device
+            if self.model_parallel:
+                for k, v in self.device_map.items():
+                    if i == v[-1] and "cuda:" + str(k) != self.last_device:
+                        hidden_states = hidden_states.to("cuda:" + str(k + 1))
+
+        hidden_states = self.ln_f(hidden_states)
+
+        hidden_states = hidden_states.view(*output_shape)
+        # Add last hidden state
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(
+                v
+                for v in [hidden_states, presents, all_hidden_states, all_self_attentions, all_cross_attentions]
+                if v is not None
+            )
+
+        return BaseModelOutputWithPastAndCrossAttentions(
+            last_hidden_state=hidden_states,
+            past_key_values=presents,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+            cross_attentions=all_cross_attentions,
+        )
+
+
+@add_start_docstrings(
+    """
+    The GPT2 Model transformer with a language modeling head on top (linear layer with weights tied to the input
+    embeddings).
+    """,
+    GPT2_START_DOCSTRING,
+)
+class GPT2LMHeadModel(GPT2PreTrainedModel):
+    _keys_to_ignore_on_load_missing = [r"attn.masked_bias", r"attn.bias", r"lm_head.weight"]
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.transformer = GPT2Model(config)
+        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+
+        self.init_weights()
+
+        # Model parallel
+        self.model_parallel = False
+        self.device_map = None
+
+    @add_start_docstrings(PARALLELIZE_DOCSTRING)
+    def parallelize(self, device_map=None):
+        self.device_map = (
+            get_device_map(len(self.transformer.h), range(torch.cuda.device_count()))
+            if device_map is None
+            else device_map
+        )
+        assert_device_map(self.device_map, len(self.transformer.h))
+        self.transformer.parallelize(self.device_map)
+        self.lm_head = self.lm_head.to(self.transformer.first_device)
+        self.model_parallel = True
+
+    @add_start_docstrings(DEPARALLELIZE_DOCSTRING)
+    def deparallelize(self):
+        self.transformer.deparallelize()
+        self.transformer = self.transformer.to("cpu")
+        self.lm_head = self.lm_head.to("cpu")
+        self.model_parallel = False
+        torch.cuda.empty_cache()
+
+    def get_output_embeddings(self):
+        return self.lm_head
+
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head = new_embeddings
+
+    def prepare_inputs_for_generation(self, input_ids, past=None, **kwargs):
+        token_type_ids = kwargs.get("token_type_ids", None)
+        # only last token for inputs_ids if past is defined in kwargs
+        if past:
+            input_ids = input_ids[:, -1].unsqueeze(-1)
+            if token_type_ids is not None:
+                token_type_ids = token_type_ids[:, -1].unsqueeze(-1)
+
+        attention_mask = kwargs.get("attention_mask", None)
+        position_ids = kwargs.get("position_ids", None)
+
+        if attention_mask is not None and position_ids is None:
+            # create position_ids on the fly for batch generation
+            position_ids = attention_mask.long().cumsum(-1) - 1
+            position_ids.masked_fill_(attention_mask == 0, 1)
+            if past:
+                position_ids = position_ids[:, -1].unsqueeze(-1)
+        else:
+            position_ids = None
+        return {
+            "input_ids": input_ids,
+            "past_key_values": past,
+            "use_cache": kwargs.get("use_cache"),
+            "position_ids": position_ids,
+            "attention_mask": attention_mask,
+            "token_type_ids": token_type_ids,
+        }
+
+    @add_start_docstrings_to_model_forward(GPT2_INPUTS_DOCSTRING)
+    @add_code_sample_docstrings(
+        tokenizer_class=_TOKENIZER_FOR_DOC,
+        checkpoint=_CHECKPOINT_FOR_DOC,
+        output_type=CausalLMOutputWithCrossAttentions,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids=None,
+        past_key_values=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        labels=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        r"""
+        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
+            Labels for language modeling. Note that the labels **are shifted** inside the model, i.e. you can set
+            ``labels = input_ids`` Indices are selected in ``[-100, 0, ..., config.vocab_size]`` All labels set to
+            ``-100`` are ignored (masked), the loss is only computed for labels in ``[0, ..., config.vocab_size]``
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        transformer_outputs = self.transformer(
+            input_ids,
+            past_key_values=past_key_values,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        hidden_states = transformer_outputs[0]
+
+        # Set device for model parallelism
+        if self.model_parallel:
+            torch.cuda.set_device(self.transformer.first_device)
+            hidden_states = hidden_states.to(self.lm_head.weight.device)
+
+        lm_logits = self.lm_head(hidden_states)
+
+        loss = None
+        if labels is not None:
+            # Shift so that tokens < n predict n
+            shift_logits = lm_logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            # Flatten the tokens
+            loss_fct = CrossEntropyLoss()
+            loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
+
+        if not return_dict:
+            output = (lm_logits,) + transformer_outputs[1:]
+            return ((loss,) + output) if loss is not None else output
+
+        return CausalLMOutputWithCrossAttentions(
+            loss=loss,
+            logits=lm_logits,
+            past_key_values=transformer_outputs.past_key_values,
+            hidden_states=transformer_outputs.hidden_states,
+            attentions=transformer_outputs.attentions,
+            cross_attentions=transformer_outputs.cross_attentions,
+        )
+
+    @staticmethod
+    def _reorder_cache(past: Tuple[Tuple[torch.Tensor]], beam_idx: torch.Tensor) -> Tuple[Tuple[torch.Tensor]]:
+        """
+        This function is used to re-order the :obj:`past_key_values` cache if
+        :meth:`~transformers.PreTrainedModel.beam_search` or :meth:`~transformers.PreTrainedModel.beam_sample` is
+        called. This is required to match :obj:`past_key_values` with the correct beam_idx at every generation step.
+        """
+        return tuple(
+            tuple(past_state.index_select(0, beam_idx.to(past_state.device)) for past_state in layer_past)
+            for layer_past in past
+        )
+
+
+@add_start_docstrings(
+    """
+The GPT2 Model transformer with a language modeling and a multiple-choice classification head on top e.g. for
+RocStories/SWAG tasks. The two heads are two linear layers. The language modeling head has its weights tied to the
+input embeddings, the classification head takes as input the input of a specified classification token index in the
+input sequence).
+""",
+    GPT2_START_DOCSTRING,
+)
+class GPT2DoubleHeadsModel(GPT2PreTrainedModel):
+    _keys_to_ignore_on_load_missing = [r"attn.masked_bias", r"attn.bias", r"lm_head.weight"]
+
+    def __init__(self, config):
+        super().__init__(config)
+        config.num_labels = 1
+        self.transformer = GPT2Model(config)
+        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+        self.multiple_choice_head = SequenceSummary(config)
+
+        self.init_weights()
+
+        # Model parallel
+        self.model_parallel = False
+        self.device_map = None
+
+    @add_start_docstrings(PARALLELIZE_DOCSTRING)
+    def parallelize(self, device_map=None):
+        self.device_map = (
+            get_device_map(len(self.transformer.h), range(torch.cuda.device_count()))
+            if device_map is None
+            else device_map
+        )
+        assert_device_map(self.device_map, len(self.transformer.h))
+        self.transformer.parallelize(self.device_map)
+        self.lm_head = self.lm_head.to(self.transformer.first_device)
+        self.multiple_choice_head = self.multiple_choice_head.to(self.transformer.first_device)
+        self.model_parallel = True
+
+    @add_start_docstrings(DEPARALLELIZE_DOCSTRING)
+    def deparallelize(self):
+        self.transformer.deparallelize()
+        self.transformer = self.transformer.to("cpu")
+        self.lm_head = self.lm_head.to("cpu")
+        self.multiple_choice_head = self.multiple_choice_head.to("cpu")
+        self.model_parallel = False
+        torch.cuda.empty_cache()
+
+    def get_output_embeddings(self):
+        return self.lm_head
+
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head = new_embeddings
+
+    def prepare_inputs_for_generation(self, input_ids, past=None, **kwargs):
+        token_type_ids = kwargs.get("token_type_ids", None)
+        # only last token for inputs_ids if past is defined in kwargs
+        if past:
+            input_ids = input_ids[:, -1].unsqueeze(-1)
+            if token_type_ids is not None:
+                token_type_ids = token_type_ids[:, -1].unsqueeze(-1)
+
+        attention_mask = kwargs.get("attention_mask", None)
+        position_ids = kwargs.get("position_ids", None)
+
+        if attention_mask is not None and position_ids is None:
+            # create position_ids on the fly for batch generation
+            position_ids = attention_mask.long().cumsum(-1) - 1
+            position_ids.masked_fill_(attention_mask == 0, 1)
+            if past:
+                position_ids = position_ids[:, -1].unsqueeze(-1)
+        else:
+            position_ids = None
+
+        return {
+            "input_ids": input_ids,
+            "past_key_values": past,
+            "use_cache": kwargs.get("use_cache"),
+            "position_ids": position_ids,
+            "attention_mask": attention_mask,
+            "token_type_ids": token_type_ids,
+        }
+
+    @add_start_docstrings_to_model_forward(GPT2_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=GPT2DoubleHeadsModelOutput, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        input_ids=None,
+        past_key_values=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        mc_token_ids=None,
+        labels=None,
+        mc_labels=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs,
+    ):
+        r"""
+        mc_token_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, num_choices)`, `optional`, default to index of the last token of the input):
+            Index of the classification token in each input sequence. Selected in the range ``[0, input_ids.size(-1) -
+            1[``.
+        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
+            Labels for language modeling. Note that the labels **are shifted** inside the model, i.e. you can set
+            ``labels = input_ids`` Indices are selected in ``[-100, 0, ..., config.vocab_size - 1]`` All labels set to
+            ``-100`` are ignored (masked), the loss is only computed for labels in ``[0, ..., config.vocab_size - 1]``
+        mc_labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size)`, `optional`):
+            Labels for computing the multiple choice classification loss. Indices should be in ``[0, ...,
+            num_choices]`` where `num_choices` is the size of the second dimension of the input tensors. (see
+            `input_ids` above)
+
+        Return:
+
+        Example::
+
+            >>> import torch
+            >>> from transformers import GPT2Tokenizer, GPT2DoubleHeadsModel
+
+            >>> tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
+            >>> model = GPT2DoubleHeadsModel.from_pretrained('gpt2')
+
+            >>> # Add a [CLS] to the vocabulary (we should train it also!)
+            >>> num_added_tokens = tokenizer.add_special_tokens({'cls_token': '[CLS]'})
+
+            >>> embedding_layer = model.resize_token_embeddings(len(tokenizer))  # Update the model embeddings with the new vocabulary size
+
+            >>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
+            >>> encoded_choices = [tokenizer.encode(s) for s in choices]
+            >>> cls_token_location = [tokens.index(tokenizer.cls_token_id) for tokens in encoded_choices]
+
+            >>> input_ids = torch.tensor(encoded_choices).unsqueeze(0)  # Batch size: 1, number of choices: 2
+            >>> mc_token_ids = torch.tensor([cls_token_location])  # Batch size: 1
+
+            >>> outputs = model(input_ids, mc_token_ids=mc_token_ids)
+            >>> lm_logits = outputs.logits
+            >>> mc_logits = outputs.mc_logits
+
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        transformer_outputs = self.transformer(
+            input_ids,
+            past_key_values=past_key_values,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        hidden_states = transformer_outputs[0]
+
+        # Set device for model parallelism
+        if self.model_parallel:
+            torch.cuda.set_device(self.transformer.first_device)
+            hidden_states = hidden_states.to(self.lm_head.weight.device)
+
+        lm_logits = self.lm_head(hidden_states)
+        mc_logits = self.multiple_choice_head(hidden_states, mc_token_ids).squeeze(-1)
+
+        mc_loss = None
+        if mc_labels is not None:
+            loss_fct = CrossEntropyLoss()
+            mc_loss = loss_fct(mc_logits.view(-1, mc_logits.size(-1)), mc_labels.view(-1))
+        lm_loss = None
+        if labels is not None:
+            shift_logits = lm_logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            loss_fct = CrossEntropyLoss()
+            lm_loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
+
+        if not return_dict:
+            output = (lm_logits, mc_logits) + transformer_outputs[1:]
+            if mc_loss is not None:
+                output = (mc_loss,) + output
+            return ((lm_loss,) + output) if lm_loss is not None else output
+
+        return GPT2DoubleHeadsModelOutput(
+            loss=lm_loss,
+            mc_loss=mc_loss,
+            logits=lm_logits,
+            mc_logits=mc_logits,
+            past_key_values=transformer_outputs.past_key_values,
+            hidden_states=transformer_outputs.hidden_states,
+            attentions=transformer_outputs.attentions,
+        )
+
+    @staticmethod
+    def _reorder_cache(past: Tuple[Tuple[torch.Tensor]], beam_idx: torch.Tensor) -> Tuple[Tuple[torch.Tensor]]:
+        """
+        This function is used to re-order the :obj:`past_key_values` cache if
+        :meth:`~transformers.PreTrainedModel.beam_search` or :meth:`~transformers.PreTrainedModel.beam_sample` is
+        called. This is required to match :obj:`past_key_values` with the correct beam_idx at every generation step.
+        """
+        return tuple(
+            tuple(past_state.index_select(0, beam_idx.to(past_state.device)) for past_state in layer_past)
+            for layer_past in past
+        )
+
+
+@add_start_docstrings(
+    """
+    The GPT2 Model transformer with a sequence classification head on top (linear layer).
+
+    :class:`~transformers.GPT2ForSequenceClassification` uses the last token in order to do the classification, as
+    other causal models (e.g. GPT-1) do.
+
+    Since it does classification on the last token, it requires to know the position of the last token. If a
+    :obj:`pad_token_id` is defined in the configuration, it finds the last token that is not a padding token in each
+    row. If no :obj:`pad_token_id` is defined, it simply takes the last value in each row of the batch. Since it cannot
+    guess the padding tokens when :obj:`inputs_embeds` are passed instead of :obj:`input_ids`, it does the same (take
+    the last value in each row of the batch).
+    """,
+    GPT2_START_DOCSTRING,
+)
+class GPT2ForSequenceClassification(GPT2PreTrainedModel):
+    _keys_to_ignore_on_load_missing = [r"h\.\d+\.attn\.masked_bias", r"lm_head\.weight"]
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.transformer = GPT2Model(config)
+        self.score = nn.Linear(config.n_embd, self.num_labels, bias=False)
+
+        self.init_weights()
+
+        # Model parallel
+        self.model_parallel = False
+        self.device_map = None
+
+    @add_start_docstrings_to_model_forward(GPT2_INPUTS_DOCSTRING)
+    @add_code_sample_docstrings(
+        tokenizer_class=_TOKENIZER_FOR_DOC,
+        checkpoint="microsoft/DialogRPT-updown",
+        output_type=SequenceClassifierOutputWithPast,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids=None,
+        past_key_values=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        r"""
+        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
+            Labels for computing the sequence classification/regression loss. Indices should be in :obj:`[0, ...,
+            config.num_labels - 1]`. If :obj:`config.num_labels == 1` a regression loss is computed (Mean-Square loss),
+            If :obj:`config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        transformer_outputs = self.transformer(
+            input_ids,
+            past_key_values=past_key_values,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        hidden_states = transformer_outputs[0]
+        logits = self.score(hidden_states)
+
+        if input_ids is not None:
+            batch_size, sequence_length = input_ids.shape[:2]
+        else:
+            batch_size, sequence_length = inputs_embeds.shape[:2]
+
+        assert (
+            self.config.pad_token_id is not None or batch_size == 1
+        ), "Cannot handle batch sizes > 1 if no padding token is defined."
+        if self.config.pad_token_id is None:
+            sequence_lengths = -1
+        else:
+            if input_ids is not None:
+                sequence_lengths = torch.ne(input_ids, self.config.pad_token_id).sum(-1) - 1
+            else:
+                sequence_lengths = -1
+                logger.warning(
+                    f"{self.__class__.__name__} will not detect padding tokens in `inputs_embeds`. Results may be "
+                    f"unexpected if using padding tokens in conjunction with `inputs_embeds.`"
+                )
+
+        pooled_logits = logits[range(batch_size), sequence_lengths]
+
+        loss = None
+        if labels is not None:
+            if self.num_labels == 1:
+                #  We are doing regression
+                loss_fct = MSELoss()
+                loss = loss_fct(pooled_logits.view(-1), labels.to(self.dtype).view(-1))
+            else:
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(pooled_logits.view(-1, self.num_labels), labels.view(-1))
+
+        if not return_dict:
+            output = (pooled_logits,) + transformer_outputs[1:]
+            return ((loss,) + output) if loss is not None else output
+
+        return SequenceClassifierOutputWithPast(
+            loss=loss,
+            logits=pooled_logits,
+            past_key_values=transformer_outputs.past_key_values,
+            hidden_states=transformer_outputs.hidden_states,
+            attentions=transformer_outputs.attentions,
+        )
+
+
+@add_start_docstrings(
+    """
+    GPT2 Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for
+    Named-Entity-Recognition (NER) tasks.
+    """,
+    GPT2_START_DOCSTRING,
+)
+class GPT2ForTokenClassification(GPT2PreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+
+        self.transformer = GPT2Model(config)
+        if hasattr(config, "classifier_dropout") and config.classifier_dropout is not None:
+            classifier_dropout = config.classifier_dropout
+        elif hasattr(config, "hidden_dropout") and config.hidden_dropout is not None:
+            classifier_dropout = config.hidden_dropout
+        else:
+            classifier_dropout = 0.1
+        self.dropout = nn.Dropout(classifier_dropout)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+        self.init_weights()
+
+        # Model parallel
+        self.model_parallel = False
+        self.device_map = None
+
+    @add_start_docstrings_to_model_forward(GPT2_INPUTS_DOCSTRING)
+    @add_code_sample_docstrings(
+        tokenizer_class=_TOKENIZER_FOR_DOC,
+        checkpoint="microsoft/DialogRPT-updown",
+        output_type=TokenClassifierOutput,
+        config_class=_CONFIG_FOR_DOC,
+    )
+    def forward(
+        self,
+        input_ids=None,
+        past_key_values=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+    ):
+        r"""
+        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`):
+            Labels for computing the sequence classification/regression loss. Indices should be in :obj:`[0, ...,
+            config.num_labels - 1]`. If :obj:`config.num_labels == 1` a regression loss is computed (Mean-Square loss),
+            If :obj:`config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        transformer_outputs = self.transformer(
+            input_ids,
+            past_key_values=past_key_values,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        hidden_states = transformer_outputs[0]
+        hidden_states = self.dropout(hidden_states)
+        logits = self.classifier(hidden_states)
+
+        loss = None
+        if labels is not None:
+            loss_fct = CrossEntropyLoss()
+            # Only keep active parts of the loss
+            if attention_mask is not None:
+                active_loss = attention_mask.view(-1) == 1
+                active_logits = logits.view(-1, self.num_labels)
+                active_labels = torch.where(
+                    active_loss, labels.view(-1), torch.tensor(loss_fct.ignore_index).type_as(labels)
+                )
+                loss = loss_fct(active_logits, active_labels)
+            else:
+                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+
+        if not return_dict:
+            output = (logits,) + transformer_outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return TokenClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=transformer_outputs.hidden_states,
+            attentions=transformer_outputs.attentions,
+        )

bigscience/jz/.gitignore

@@ -0,0 +1,133 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Slurm job output and error
+*.err
+*.out

bigscience/jz/README.md

@@ -0,0 +1,27 @@
+# jay-z
+
+Jean Zay aka JZ pronounced "Jay-Z"
+
+This section of the repo is all about how things are done on JZ.
+
+Main documents:
+
+- [Compute Resources](./compute-resources.md)
+- [JZ Specs](./hpc-specs.md)
+- [Framework-specific notes](./frameworks/)
+- [Model-specific Instructions](./archs/)
+
+Code:
+- [Work Env and Setup](./envs/README.md)
+- [SLURM scripts](./scripts/)
+- [Config files](./configs/)
+
+Tools:
+- [SLURM HowTo](./slurm/)
+- [Various Tools](./tools/)
+
+General JZ Docs:
+
+- HF Internal: https://github.com/huggingface/conf/wiki/JZ
+- Official: http://www.idris.fr/eng/jean-zay/
+- Collaborative doc: https://jean-zay-doc.readthedocs.io/en/latest/

bigscience/jz/compute-resources.md

@@ -0,0 +1,190 @@
+# Compute Resources
+
+## Login Instance
+
+This is the shell you get into when ssh'ng from outside
+
+- Networked (except ssh to outside)
+- 1 core per user
+- 5 GB of RAM per user
+- 30 min of CPU time per process
+
+## Pre/post processing Instance
+
+Activated with `--partition=prepost`
+
+- Networked
+- only 4 nodes
+- 2 to 20 hours
+- No limitations of the login shell
+- 1x V100-16GB
+- The computing hours are not deducted from your allocation
+
+to request:
+```
+srun --pty --partition=prepost --account=six@cpu --nodes=1 --ntasks=1 --cpus-per-task=10  --hint=nomultithread --time=1:00:00 bash --rcfile $six_ALL_CCFRWORK/start-prod
+```
+
+or to work interactively there, `srun` into the box (though no control which of the 4 you get):
+
+```
+srun -p prepost -A six@cpu --time=20:00:00 --pty bash
+```
+
+To choose a specific box (if some are too overload by other users), one could ssh directly to that partition via:
+```
+ssh jean-zay-pp          # from inside
+ssh jean-zay-pp.idris.fr # from outside
+```
+There are 4 boxes, so `jean-zay-pp1`, ..., `jean-zay-pp4`. It's possible that larger numbers have less users, but not necessarily.
+
+In this case there is no need to do SLURM.
+
+But in this approach only 30min will be given before any running process will be killed. Just like the login shell. I think the only difference is more CPU usage is given here before the process is killed than on the login shell.
+
+Note: `--partition=compil` too has internet, but can't ssh there.
+
+In general the `compil` partition is usually less busy than `prepost`.
+
+
+## GPU Instances
+
+- No network to outside world
+- 160 GB of usable memory. The memory allocation is 4 GB per reserved CPU core if hyperthreading is deactivated (`--hint=nomultithread`). So max per node is `--cpus-per-task=40`
+
+To select this type of partition use `--account=six@gpu`.
+
+
+## CPU Instances
+
+- All cpus of the same partition are the same
+- Different partitions are likely to have different cpus
+
+For example on `gpu_p1` partitions (4x v100-32gb)
+
+```
+$ lscpu | grep name
+Model name:          Intel(R) Xeon(R) Gold 6248 CPU @ 2.50GHz
+```
+
+To select this type of partition use `--account=six@cpu`.
+
+
+## Quotas
+
+Group/project (`six`):
+
+- `$six_ALL_CCFRSCRATCH` - 400TB / ??? inodes fastest (full SSD),  →  files removed after 30 days without access
+- `$six_ALL_CCFRWORK` - 25TB / 500k inodes (slower than SCRATCH) → sources, constantly used input/output files
+- `$six_ALL_CCFRSTORE` - 100TB / 100k inodes (slow) → for long term storage in tar files (very few inodes!)
+- `/gpfsssd/worksf/projects/rech/six/commun/` - 1TB / 3M inodes → for conda and python git clones that take tens of thousands of inodes
+
+Personal:
+
+- `$HOME` - 3GB / 150k inodes (for small files)
+- `$SCRATCH` - fastest (full SSD), no quota, files removed after 30 days without access
+- `$WORK` - Shared with the `$six_ALL_CCFRWORK` quota, that is `du -sh $six_ALL_CCFRWORK/..`
+- `$STORE` - Shared with the  `$six_ALL_CCFRSTORE` quota, that is `du -sh $six_ALL_CCFRSTORE/..`
+
+Note that WORK and STORE group quotas of the project include all project's users' WORK and STORE usage correspondingly.
+
+[Detailed information](http://www.idris.fr/eng/jean-zay/cpu/jean-zay-cpu-calculateurs-disques-eng.html)
+
+Checking usage:
+```
+idrquota -m # $HOME @ user
+idrquota -s -p six # $STORE @ shared (this is updated every 30min)
+idrquota -w -p six # $WORK @ shared
+```
+
+
+if you prefer it the easy way here is an alias to add to `~/.bashrc`:
+```
+alias dfi=' \
+echo \"*** Total \(six\) ***\"; \
+idrquota -w -p six; \
+idrquota -s -p six; \
+echo SCRATCH: $(du -hs /gpfsscratch/rech/six/ | cut -f1) \(out of 400TB\); \
+echo WORKSF: $(du -hs /gpfsssd/worksf/projects/rech/six | cut -f1) \(out of 2TB\); \
+echo WORKSF: $(du -hs --inodes /gpfsssd/worksf/projects/rech/six | cut -f1) inodes \(out of 3M\); \
+echo; \
+echo \"*** Personal ***\"; \
+idrquota -m; \
+echo WORK: $(du -hs $WORK | cut -f1); \
+echo WORK: $(du -hs --inodes $WORK | cut -f1) inodes; \
+echo STORE: $(du -hs $STORE | cut -f1); \
+echo STORE: $(du -hs --inodes $STORE | cut -f1) inodes; \
+echo SCRATCH: $(du -hs $SCRATCH | cut -f1); \
+echo SCRATCH: $(du -hs --inodes $SCRATCH | cut -f1) inodes; \
+'
+```
+This includes the report on usage of personal WORK and SCRATCH partitions.
+
+
+
+## Directories
+
+- `$six_ALL_CCFRSCRATCH` - for checkpoints - make sure to copy important ones to WORK or tarball to STORE
+- `$six_ALL_CCFRWORK` - for everything else
+- `$six_ALL_CCFRSTORE` - for long term storage in tar files (very few inodes!)
+- `/gpfsssd/worksf/projects/rech/six/commun/` - for conda and python git clones that take tens of thousands of inodes - it's a small partition with a huge number of inodes. 1TB and 3M inodes.
+XXX: update this and above once env var was created.
+
+
+More specifically:
+
+- `$six_ALL_CCFRWORK/cache_dir` - `CACHE_DIR` points here
+- `$six_ALL_CCFRWORK/checkpoints` - symlink to `$six_ALL_CCFRWORK/checkpoints` - point slurm scripts here
+- `$six_ALL_CCFRWORK/code` - clones of repos we use as source (`transformers`, `megatron-lm`, etc.)
+- `$six_ALL_CCFRWORK/conda` - our production conda environment
+- `$six_ALL_CCFRWORK/datasets` - cached datasets (normally under `~/.cache/huggingface/datasets`)
+- `$six_ALL_CCFRWORK/datasets-custom` - Manually created datasets are here (do not delete these - some take many hours to build):
+- `$six_ALL_CCFRWORK/downloads` -  (normally under `~/.cache/huggingface/downloads`)
+- `$six_ALL_CCFRWORK/envs` - custom scripts to create easy to use environments
+- `$six_ALL_CCFRWORK/models-custom` - manually created or converted models
+- `$six_ALL_CCFRWORK/modules` -  (normally under `~/.cache/huggingface/modules`)
+
+
+
+## Diagnosing the Lack of Disc Space
+
+To help diagnose the situations when we are short of disc space here are some tools:
+
+Useful commands:
+
+* Get current dir's sub-dir usage breakdown sorted by highest usage first:
+```
+du -ahd1 | sort -rh
+```
+
+* Check that users don't consume too much of their personal `$WORK` space, which goes towards the total WORK space limit.
+
+```
+du -ahd1 $six_ALL_CCFRWORK/.. | sort -rh
+```
+
+
+## Efficient tar-balling to STORE
+
+When short on space you don't want to create large tarballs in the WORK dir, instead tar directly to the destination, e.g.
+
+e.g. w/o gzip since we already have arrow binary files
+
+```
+mkdir -p $six_ALL_CCFRSTORE/datasets
+cd $six_ALL_CCFRWORK/datasets
+tar -cvf $six_ALL_CCFRSTORE/datasets/openwebtext.tar openwebtext
+```
+
+
+e.g. w/ gzip for non-binary data
+```
+tar -czvf $six_ALL_CCFRSTORE/datasets/openwebtext.tgz openwebtext
+```
+
+If the file is large and takes some resources to build, `tar` will get killed, in such case you can't do it from the login instance and have to use one of the beefier instances. e.g.:
+```
+srun --pty --nodes=1 --ntasks=1 -A six@cpu --cpus-per-task=40 --hint=nomultithread --time=2:00:00 bash --rcfile $six_ALL_CCFRWORK/start-prod
+tar ...
+```
+and if that's not enough do a slurm job

bigscience/jz/configs/dec_only_t5/decoder_only_t5-large.json

@@ -0,0 +1,22 @@
+{
+    "architectures": [
+      "DecoderOnlyT5LMHeadModel"
+    ],
+    "d_ff": 5120,
+    "d_kv": 64,
+    "d_model": 1280,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": true,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "decoder_only_t5",
+    "num_heads": 20,
+    "num_layers": 36,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+  }

bigscience/jz/configs/dec_only_t5/decoder_only_t5-medium.json

@@ -0,0 +1,22 @@
+{
+    "architectures": [
+      "DecoderOnlyT5LMHeadModel"
+    ],
+    "d_ff": 4096,
+    "d_kv": 64,
+    "d_model": 1024,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": true,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "decoder_only_t5",
+    "num_heads": 16,
+    "num_layers": 24,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+  }

bigscience/jz/configs/dec_only_t5/decoder_only_t5-small.json

@@ -0,0 +1,22 @@
+{
+    "architectures": [
+      "DecoderOnlyT5LMHeadModel"
+    ],
+    "d_ff": 3072,
+    "d_kv": 64,
+    "d_model": 768,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": false,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "decoder_only_t5",
+    "num_heads": 12,
+    "num_layers": 12,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+  }

bigscience/jz/envs/README.md

@@ -0,0 +1,662 @@
+# Work Environment Info
+
+
+## Users and Accounts
+
+**Accounts:**
+
+- `six` - the BigScience allocation - our main allocation
+- `ajs` - original dynamic access allocations - use it if you can as we still have resources there - but it will give low priority on scheduling - hence use primarily for jobs that can be bumped down in the queue for a few days.
+
+To switch to `six` as the main project:
+```
+idrproj -d six
+```
+and logout/login.
+
+Check which projects one belongs to: `idrproj`
+
+**Users:**
+
+Use `idracct six` to see which username belongs to which real person.
+
+
+## First time setup
+
+Make sure that your `~/.bashrc` is executed on login by creating if you don't already have `~/.bash_profile` with contents:
+
+```
+# if running bash
+if [ -n "$BASH_VERSION" ]; then
+    # include .bashrc if it exists
+    if [ -f "$HOME/.bashrc" ]; then
+        . "$HOME/.bashrc"
+    fi
+fi
+```
+
+It of course could have other contents, but make sure the above is there.
+
+Now add this to your `~/.bashrc` and run `bash` for the changes to take effect.
+
+```
+# ~/.bashrc: executed by bash(1) for non-login shells.
+[[ $- != *i* ]] && return
+
+# Log in with correct group - relevant to all users as we have multiple groups we belong to
+if [[ $(id -gn) != "six" ]]
+then
+    newgrp six
+    exit
+fi
+
+# start production environment:
+# this loads modules, conda and sets all the relevant env vars
+alias start-prod="source $six_ALL_CCFRWORK/start-prod"
+
+# our production conda env is here:
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+
+# SLURM / Account specific settings
+
+# share dirs/files with the group
+umask 0007
+
+# specific caches
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export DATASETS_CUSTOM=$six_ALL_CCFRWORK/datasets-custom
+
+# shortcut
+export PROD=$six_ALL_CCFRWORK
+
+# handy shortcuts
+alias myjobs="squeue -u `whoami`"
+
+# our shared conda base
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+```
+
+note: wrt `newgrp six` - if you want to use it elsewhere and not `~/.bashrc` you may use this `newgrp - six` syntax instead, but don't use it in `~/.bashrc` or it will break many things.
+
+Also since most of our work is at `$six_ALL_CCFRWORK` you may want to add symlinks:
+```
+ln -s $six_ALL_CCFRWORK ~/prod
+ln -s $six_ALL_CCFRSCRATCH ~/prod-scratch
+ln -s $six_ALL_CCFRSTORE ~/prod-store
+ln -s /gpfsssd/worksf/projects/rech/six/commun ~/prod-worksf
+```
+and then you can quickly `cd` there w/o needing to type too much, and with the shortcut `$PROD` env var you now you can do one of 2 ways:
+```
+cd ~/prod
+cd $PROD
+```
+
+Some users prefer to use the env vars, so let's try to not expect the symlinks to be there for everybody.
+
+If you intend to use `gsutil`, add the following lines:
+
+```
+if [ -f '/gpfsssd/worksf/projects/rech/six/commun/lib/google-cloud-sdk/path.bash.inc' ]; then . '/gpfsssd/worksf/projects/rech/six/commun/lib/google-cloud-sdk/path.bash.inc'; fi
+if [ -f '/gpfsssd/worksf/projects/rech/six/commun/lib/google-cloud-sdk/completion.bash.inc' ]; then . '/gpfsssd/worksf/projects/rech/six/commun/lib/google-cloud-sdk/completion.bash.inc'; fi
+```
+
+Without them, `gsutil` on Jean Zay fails with a hard-to-debug `TypeError: argument should be integer or bytes-like object, not 'str'` error.
+
+## Production environment
+
+In order to use the production environment, run:
+
+```
+start-prod
+```
+which will:
+- setup env vars
+- configure nice git-prompt with lots of useful info built in
+- load the right `module`s
+- activate our custom production conda environment which has everything in it
+
+so basically use it when running production scripts.
+
+The alias should have been set in `~/.bashrc` as instructed above.
+
+Note: the fancy [bash-git-prompt](https://github.com/magicmonty/bash-git-prompt) tells you which conda env you are in, and then which branch your are in and a ton of useful git enfo, and it was extended to tell you whether you're in the login instance (prefix `0-1`) or whether you're on a GPU instance where it then shows something like `4-40` - the 2 numbers stand for `${SLURM_NNODES}-${SLURM_CPUS_PER_TASK}` - so you know what `srun` configuration you're logged into (or the login shell where you get no nodes, with 0 gpus and 1 cpu hence `0-1`).
+
+The production conda env `hf-prod` is too set up already, so you don't need to do anything, but here are some details on how it was done should you want to know.
+
+Our production shared conda env is at `$six_ALL_CCFRWORK/conda`, you can make it visible by either doing this one:
+```
+conda config --append envs_dirs $six_ALL_CCFRWORK/conda
+```
+which will add this path to `~/.condarc` or use:
+```
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+```
+in your `~/.bashrc`.
+
+You can use it for anything but please don't install anything into it (unless coordinating with others), as we want this to be a reliable environment for all to share.
+
+Additionally you will most likely will want to do:
+
+```
+mv ~/.conda ~/.conda-old
+ln -s $six_ALL_CCFRWORK/.conda ~/.conda
+```
+
+because otherwise conda will try to use your HOME dir which is only 3GB-large. You can then nuke `~/.conda-old` or move it elsewhere.
+
+
+
+
+## Creating production conda env
+
+**Do not run any of the instructions in this section**. Please co-ordinate any changes to this environment on #bigscience-jz on slack since many users use it for their experiments. If you want to create your custom conda env, please read the following sections instead.
+
+If the production environment got broken, here is how it can be re-built.
+
+This should be done on a login instance, since we need the network.
+
+```
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+
+conda create -y -n hf-prod python=3.8
+conda activate hf-prod
+
+# pt-1.10.1 / cuda 11.3
+conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch
+pip install deepspeed
+
+cd $six_ALL_CCFRWORK/code/transformers
+pip install -e .[dev]
+
+cd $six_ALL_CCFRWORK/code/Megatron-DeepSpeed
+pip install -r requirements.txt
+
+cd $six_ALL_CCFRWORK/code/deepspeed
+./build.sh
+
+# to build custom tokenizers make sure that if run on JZ your `~/.cargo/config.toml` contains the following:
+[net]
+git-fetch-with-cli = true
+
+# if needed first:
+# git clone https://github.com/huggingface/tokenizers $six_ALL_CCFRWORK/code/tokenizers
+cd $six_ALL_CCFRWORK/code/tokenizers
+git checkout bigscience_fork
+module load rust
+pip install setuptools_rust
+pip install -e bindings/python
+```
+
+while we are going to override some of these with our custom installs, we first install these normally to get all the dependencies right.
+
+Then finally to build apex you need a non-login instance since it is very demanding on resources and such build on the login instance will get killed:
+
+```
+srun --pty -A six@cpu --qos=qos_cpu-dev --nodes=1 --ntasks=1 --cpus-per-task=10 --hint=nomultithread --time=60 bash --rcfile $six_ALL_CCFRWORK/start-prod
+cd $six_ALL_CCFRWORK/code/apex
+./build.sh
+```
+Note: if using a no-gpu instance to build `apex` it will warn that it can't detect any GPUs but will cross-compile for several archs. But you could also tell it to build for V100 and A100 explicitly by simply adding the desired archs:
+
+```
+TORCH_CUDA_ARCH_LIST="7.0 8.0" pip install ...
+```
+
+## Personal environment
+
+You can use these dirs, which are your private spaces:
+
+- `$WORK`
+- `$SCRATCH`
+- `$STORE`
+
+So you probably want to mimic the production env,
+
+We also agreed to use
+
+```
+ln -s $WORK ~/user
+ln -s $SCRATCH ~/user-scratch
+ln -s $STORE ~/user-store
+```
+and then you can quickly `cd` there w/o needing to type too much:
+```
+cd ~/user
+```
+
+Since we are going to use `~/user/...` in scripts, it now should be possible to re-use our scripts w/o modifying them. To change the script to use the production setup, it'll be just `s/user/prod/`.
+
+
+
+## Custom private conda env
+
+First follow the instructions for [Production environment](production-environment) which should have already set up most things to make it very easy to add your custom conda env.
+
+If wanting to work with variations of packages, create your own conda env, e.g. env `stas`:
+
+```
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+
+conda create -y -n stas python=3.8
+conda activate stas
+conda install pytorch torchvision cudatoolkit=11.3 -c pytorch-lts -c nvidia
+pip install deepspeed
+
+cd ~/user/code/transformers
+pip install -e .[dev]
+
+cd ~/user/code/Megatron-Deepspeed
+pip install -r requirements.txt
+
+cd ~/user/code/deepspeed
+./build.sh
+
+cd ~/user/code/apex
+./build.sh
+```
+
+See a special note on how to build apex in [Creating production conda env](creating-production-conda-env).
+
+
+## Login node
+
+If the login node is heavily used by someone, one can switch to another node
+
+`host jean-zay.idris.fr` will tell you which login nodes are currently in the alias
+
+if the DNS round robin doesn't send you to another login node, you can target a specific login node (`jean-zayN.idris.fr` , with N from 1 to 5, though some might not be available so using the alias is always better)
+
+
+## Dealing with running out of disc space
+
+Find out where disc space is used up:
+```
+du -ahd1 $six_ALL_CCFRWORK  | sort -rh
+du -ahd1 $six_ALL_CCFRSTORE | sort -rh
+```
+
+Find out where inodes are used up:
+```
+du -ahd1 --inodes $six_ALL_CCFRWORK | sort -rh
+du -ahd1 --inodes $six_ALL_CCFRSTORE | sort -rh
+```
+
+Some busy git clones can be pruned of unused files with: `git gc`, e.g. to prune a dir with multiple-clones as sub-dirs:
+
+```
+cd $six_ALL_CCFRWORK/code
+du -hs .
+du -hs --inodes .
+find . -mindepth 1 -maxdepth 1 -type d -exec bash -c "cd '{}' && git gc" +
+du -hs .
+du -hs --inodes .
+```
+
+## Finding things
+
+Our WORK is indexed by mlocate, after adding this alias:
+```
+alias locate="/usr/bin/locate -d $ALL_CCFRWORK/lib/mlocate/work.db:$ALL_CCFRWORK/lib/mlocate/worksf.db"
+```
+You can now do:
+```
+locate -i megatron
+```
+(remove `-i` if you want case-sensitive search)
+
+the index is being updated by `$six_ALL_CCFRWORK/bin/mlocate-update` in a crontab job in `$six_ALL_CCFRWORK/cron/cron.daily/mlocate-update.slurm`.
+
+For more details on the emulated crontab job see: [crontab](../crontab/README.md).
+
+
+## Syncing the perms
+
+We use `umask 0007` in `~/.bashrc` to get the shared dirs have `g+rwx` perms, so that we can all operate on those, but it doesn't always help. When a tarball is extracted it will often retain the original perms on the files, so if those didn't have `w` for the group it'll remain as such. Therefore occasionally and especially after installing a new dataset please run:
+
+We also need `g+s` on dirs, so that new dirs and files created in the sub-dir get created with the same group as the parent dir (e.g. important when `scp`-ing from outside, but also in many other cases).
+
+Then note that `chgrp` removes the sgid bit,  as it has to be restored immediately, so do not run it alone!
+
+For some reason group perms go wrong at times. We need all files to be `g+wrxs` (dirs), `g+rw` (files), `six` (group name), so here is how to fix things back to normal:
+
+```
+find $six_ALL_CCFRWORK    -user `whoami` -type d ! \( -readable -executable \) -prune -o -type d -execdir chgrp six {} + , -execdir chmod g+rwxs {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+find $six_ALL_CCFRWORK    -user `whoami` -type d ! \( -readable -executable \) -prune -o -type f -execdir chgrp six {} + , -execdir chmod g+rw {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+find /gpfsssd/worksf/projects/rech/six/commun    -user `whoami` -type d ! \( -readable -executable \) -prune -o -type d -execdir chgrp six {} + , -execdir chmod g+rwxs {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+find /gpfsssd/worksf/projects/rech/six/commun    -user `whoami` -type d ! \( -readable -executable \) -prune -o -type f -execdir chgrp six {} + , -execdir chmod g+rw {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+find $six_ALL_CCFRSCRATCH -user `whoami` -type d ! \( -readable -executable \) -prune -o -type d -execdir chgrp six {} + , -execdir chmod g+rwxs {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+find $six_ALL_CCFRSCRATCH -user `whoami` -type d ! \( -readable -executable \) -prune -o -type f -execdir chgrp six {} + , -execdir chmod g+rw {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+find $six_ALL_CCFRSTORE   -user `whoami` -type d ! \( -readable -executable \) -prune -o -type d -execdir chgrp six {} + , -execdir chmod g+rwxs {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+find $six_ALL_CCFRSTORE   -user `whoami` -type d ! \( -readable -executable \) -prune -o -type f -execdir chgrp six {} + , -execdir chmod g+rw {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+```
+
+If somehow we lost the sgid bit on some dirs, to restore just those:
+```
+find $six_ALL_CCFRWORK    -user `whoami` -type d ! \( -readable -executable \) -prune -o -type d -execdir chmod g+s {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+find /gpfsssd/worksf/projects/rech/six/commun    -user `whoami` -type d ! \( -readable -executable \) -prune -o -type d -execdir chmod g+s {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+find $six_ALL_CCFRSCRATCH -user `whoami` -type d ! \( -readable -executable \) -prune -o -type d -execdir chmod g+s {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+find $six_ALL_CCFRSTORE   -user `whoami` -type d ! \( -readable -executable \) -prune -o -type d -execdir chmod g+s {} + 2>&1 | egrep -v "(Operation not permitted|cannot operate on dangling symlink)"
+```
+albeit, the set of commands above should have already done the right thing, as they include `g+rwxs`.
+
+
+
+## Activate production script
+
+This can be safely added at the beginning of slurm scripts:
+
+```
+source $six_ALL_CCFRWORK/start-prod
+```
+
+And if you made the symlink from your `$HOME`, interactively it's easier to remember to type:
+
+```
+source $six_ALL_CCFRWORK/start-prod
+```
+
+
+
+## Building things from source
+
+
+The building should happen on a beefy instance - or things just get killed
+
+Normally use the free `-p compil` partition:
+
+```
+srun --pty -A six@cpu -p compil --hint=nomultithread --time=60 bash --rcfile $six_ALL_CCFRWORK/start-prod
+```
+
+if it doesn't yield use `idrsrv` ones by adding `-c 10` (10 cpu cores)
+```
+srun --pty -A six@cpu -p compil -c 10 --hint=nomultithread --time=60 bash --rcfile $six_ALL_CCFRWORK/start-prod
+```
+
+but if it has to be really fast, use a dedicated instance with pre-allocated cpu cores:
+```
+srun --pty -A six@cpu --nodes=1 --ntasks=1 --cpus-per-task=10 --hint=nomultithread --time=60 bash --rcfile $six_ALL_CCFRWORK/start-prod
+```
+
+same with 1 gpu if the build env requires one (neither `apex` nor `deepspeed` require one):
+```
+srun --pty -A six@gpu --nodes=1 --ntasks=1 --cpus-per-task=10 --gres=gpu:1 --hint=nomultithread --time=60 bash --rcfile $six_ALL_CCFRWORK/start-prod
+```
+
+`/tmp` is tiny on gpu instances, at least apex needs a big `/tmp` folder:
+
+
+Quick instructions (detailed listing follow):
+
+```
+export TMPDIR=$six_ALL_CCFRWORK/tmp
+mkdir -p $TMPDIR
+
+cd $six_ALL_CCFRWORK/code/deepspeed
+./build.sh
+
+cd $six_ALL_CCFRWORK/code/apex
+./build.sh
+```
+
+
+### deepspeed
+
+
+To pre-build deepspeed (as compared to have it built via JIT at runtime):
+
+```
+export TMPDIR=$six_ALL_CCFRWORK/tmp
+mkdir -p $TMPDIR
+cd $six_ALL_CCFRWORK/code/deepspeed
+./build.sh
+```
+
+what's in the build:
+```
+$ cat build.sh
+#!/bin/bash
+
+rm -rf build
+
+time TORCH_CUDA_ARCH_LIST="7.0 8.0" DS_BUILD_CPU_ADAM=1 DS_BUILD_UTILS=1 pip install -e . --global-option="build_ext" --global-option="-j8" --no-cache -v --disable-pip-version-check 2>&1 | tee build.log
+```
+
+### apex
+
+To build apex (needed by megatron-lm):
+
+build:
+```
+cd $six_ALL_CCFRWORK/code/apex
+./build.sh
+```
+
+what's in the build:
+```
+$ cat build.sh
+#!/bin/bash
+
+pip install --global-option="--cpp_ext" --global-option="--cuda_ext" --no-cache -v --disable-pip-version-check .  2>&1 | tee build.log
+```
+
+Note that since we are using pt/cuda-11.1 and JZ has cuda-11.2, apex won't build unless we skip the version check (which is totally not necessary - things work just fine), so should you reset the clone and removed the local patch, you can restore it with this diff: https://github.com/NVIDIA/apex/issues/988#issuecomment-726343453
+
+
+
+## Aliases
+
+```
+# autogenerate the hostfile for deepspeed
+# 1. deals with: SLURM_JOB_NODELIST in either of 2 formats:
+# r10i1n8,r10i2n0
+# r10i1n[7-8]
+# 2. and relies on SLURM_STEP_GPUS=0,1,2... to get how many gpu slots per node
+#
+# usage:
+# makehostfile > hostfile
+function makehostfile() {
+perl -e '$slots=split /,/, $ENV{"SLURM_STEP_GPUS"};
+$slots=4 if $slots==0; # workaround 4 gpu machines
+while ($ENV{"SLURM_JOB_NODELIST"} =~ m/(\w+)(?:\[([\d-,]+)\])?,?/msg) {
+$b=$1; $s=$2||q[""]; $s=~s/-/../g;
+print map { "$b$_ slots=$slots\n" } eval $s }'
+}
+```
+
+```
+# auto-extract the master node's address from: SLURM_JOB_NODELIST1 which may contain r10i1n3,r10i1n[5-8],r10i1n7
+# so here we want r10i1n3
+function get_master_address() {
+perl -le '$_=$ENV{"SLURM_JOB_NODELIST"}; s/,.*//; s/-.*//; s/\[//; print'
+}
+```
+
+Better solutions for the same as above:
+
+```
+# autogenerate the hostfile for deepspeed
+# 1. deals with: SLURM_JOB_NODELIST in either of 2 formats:
+# r10i1n8,r10i2n0
+# r10i1n[7-8]
+# 2. and relies on SLURM_STEP_GPUS=0,1,2... to get how many gpu slots per node
+#
+# usage:
+# makehostfile > hostfile
+function makehostfile() {
+perl -e '$slots=split /,/, $ENV{"SLURM_STEP_GPUS"};
+$slots=8 if $slots==0; # workaround 8 gpu machines
+@nodes = split /\n/, qx[scontrol show hostnames $ENV{"SLURM_JOB_NODELIST"}];
+print map { "$b$_ slots=$slots\n" } @nodes'
+}
+```
+
+```
+# auto-extract the master node's address from: SLURM_JOB_NODELIST1 which may contain r10i1n3,r10i1n[5-8],r10i1n7
+# so here we want r10i1n3
+function get_master_address() {
+echo $(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+}
+```
+
+
+## Troubleshooting
+
+### pip install
+
+If it's trying to install into your local `~/.local` folder it's because `pip` is in that `$PATH` before
+`$six_ALL_CCFRWORK/conda/hf-prod/bin/` - push the last one to be first - or best don't install any python things locally - use conda for that. Check with `which pip` - it should be under `$six_ALL_CCFRWORK/conda/hf-prod/bin/pip`.
+
+
+
+### Running `py-spy` diagnostics on multiple nodes at once
+
+To do some monitoring of multiple nodes running an `srun` job:
+
+(This is just an example of starting a job, most of the time it'll be running already:
+```
+cd ~/prod/code/tr8b-104B/bigscience/train/tr11-200B-ml/
+
+salloc --partition=gpu_p5 --constraint=a100 --nodes=48 --ntasks-per-node=1 --cpus-per-task=64 --hint=nomultithread --gres=gpu:8 --time 20:00:00 --account=six@a100
+
+bash 200B-n40-bf16-mono.slurm
+```
+
+Then in another shell:
+
+```
+squeue -u `whoami` -o "%.16i %.9P %.26j %.8T %.10M %.8l %.6D %.20S %R"
+srun --overlap --jobid=1729333 --gres=gpu:0 --nodes=48 --tasks-per-node=1 --output=trace-%N.out sh -c 'source $six_ALL_CCFRWORK/start-prod; pgrep -P $(pgrep -o python) | xargs -I {} py-spy dump --pid {}' || echo "failed"
+```
+
+This will create a log file per node, e.g. `trace-jean-zay-iam52.out` which will contain the output of the command on that node.
+
+Notes:
+- adjust `--jobid` to the desired job (output of `squeue`). If using a job array and the job id looks like `1728318_2` first translate the virtual JobId into an actual JobID:
+```
+scontrol show job 1728318_2 | perl -nle 'm/JobId=(\d+)/ && print $1'
+```
+- adjust `--nodes=48` to match the same setting as the original `salloc` or `srun` command
+- `--overlap` allows a new job to run on nodes allocated by another job.
+
+`py-spy`-specific notes:
+
+- run the command via `sh`. It may be possible to run `bash`, but I run into `py-spy: Permission denied` - it shouldn't need `sudo` but something in my bash dotfile triggers this problem, even though it doesn't happen if I run bash interactively.
+- `pgrep -P $(pgrep -o python)` will give the immediate children of the launcher - 8 processes per node on A100 - which is what we want most of the time.
+- if you want all children and grandchildren (e.g. dataloader helpers) - can be hundreds of processes! then use just `pgrep python`
+
+
+
+#### using ds_ssh
+
+It's a bit tricky and doesn't work for `py-spy` (see notes in the section above - it seems to do with `bash`'s dotfiles).
+
+
+```
+salloc --partition=gpu_p5 --constraint=a100 --nodes=2 --ntasks-per-node=1 --cpus-per-task=64 --hint=nomultithread --gres=gpu:8 --time 20:00:00 --account=six@a100
+```
+
+```
+bash 20B-n2-fp16.slurm
+```
+
+```
+function makehostfile() {
+perl -e '$slots=split /,/, $ENV{"SLURM_STEP_GPUS"};
+$slots=8 if $slots==0; # workaround 8 gpu machines
+@nodes = split /\n/, qx[scontrol show hostnames $ENV{"SLURM_JOB_NODELIST"}];
+print map { "$b$_ slots=$slots\n" } @nodes'
+}
+makehostfile > hostfile
+```
+
+```
+ds_ssh -f hostfile "source ~/.pdshrc; nvidia-smi"
+```
+
+the tricky part is to get the remote env loaded, I have a mostly ok hack, but which doesn't work for `py-spy` - something is wrong in the env.
+
+So the special env-loading file is:
+```
+$ cat ~/.pdshrc
+
+source /etc/profile.d/z_modules.sh;
+
+#source ~/.bashrc
+
+module purge
+#module load pytorch-gpu/py3/1.8.1
+module load nvtop git git-lfs github-cli mc
+
+# specific caches
+
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export DATASETS_CUSTOM=$six_ALL_CCFRWORK/datasets-custom
+
+### CONDA ###
+
+# >>> conda initialize >>>
+# !! Contents within this block are managed by 'conda init' !!
+__conda_setup="$('/gpfslocalsup/pub/anaconda-py3/2020.02/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
+if [ $? -eq 0 ]; then
+    eval "$__conda_setup"
+else
+    if [ -f "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh" ]; then
+        . "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh"
+    else
+        export PATH="/gpfslocalsup/pub/anaconda-py3/2020.02/bin:$PATH"
+    fi
+fi
+unset __conda_setup
+# <<< conda initialize <<<
+
+conda activate base
+conda activate /gpfswork/rech/six/commun/conda/py38-pt111
+```
+
+`ds_ssh` uses pdsh behind the scenes.
+
+Note that `py-spy` works just fine when actually ssh'ed to the compute node:
+
+```
+ps aux | grep python | egrep -v '(srun|grep)' | grep `whoami` | awk '{print $2}' | xargs -I {} py-spy dump --pid {}
+```
+
+#### using pdsh
+
+To access just one running node it's simpler to just use `pdsh` directly.
+
+```
+pdsh -w jean-zay-iam01 "source ~/.pdshrc; nvidia-smi"
+```
+
+
+## Older info
+
+Probably of no use any longer, but still here in case it is needed (might move to another file).
+
+## Local resources
+
+For your own personal explorations you can either create your own `conda` envr or use your local python, which has a few of issues, but it allows you to continue using JZ's pytorch `module`.
+
+`pip install` installs into `$HOME/.local/lib/python3.7/site-packages`, however system-wide packages may take precedence. For example to do `develop` install of transformers use this workaround:
+```
+git clone https://github.com/huggingface/transformers
+cd transformers
+pip install --user --no-use-pep517 -e .
+```
+
+May still have to override `PYTHONPATH=$WORK/hf/transformers-master/src` (edit to wherever your clone is) if you want to emulate `develop` build. Test:
+```
+export PYTHONPATH=$WORK/hf/transformers-master/src
+python -c "import transformers; print(transformers.__version__)"
+# 4.6.0.dev0
+```
+
+See [`envs`](./envs) for instructions on how to build conda and packages

bigscience/jz/envs/apex/build.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+pip install --global-option="--cpp_ext" --global-option="--cuda_ext" --no-cache -v --disable-pip-version-check .  2>&1 | tee build.log
+

bigscience/jz/envs/deepspeed/build.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+rm -rf build
+
+time TORCH_CUDA_ARCH_LIST="7.0" DS_BUILD_CPU_ADAM=1 DS_BUILD_FUSED_ADAM=1 DS_BUILD_FUSED_LAMB=1 DS_BUILD_TRANSFORMER=1 DS_BUILD_STOCHASTIC_TRANSFORMER=1 DS_BUILD_UTILS=1 pip install -e . --global-option="build_ext" --global-option="-j8" --no-cache -v --disable-pip-version-check 2>&1 | tee build.log
+
+# time TORCH_CUDA_ARCH_LIST="7.0" DS_BUILD_OPS=1 pip install -e . --global-option="build_ext" --global-option="-j8" --no-cache -v --disable-pip-version-check 2>&1 | tee build.log

bigscience/jz/envs/start-prod

@@ -0,0 +1,60 @@
+# This is a python production script for JZ
+#
+# Activate with:
+#
+# source ./start-prod
+#
+#
+
+# if this session isn't run via a login shell, which is the case when running a
+# command which is not shell via ssh, the bash function `module` will be missing.
+# so work around it by emulating part of the login shell that loads modules environment
+# if [ -z $(type -t module) ]
+# then
+#    . /etc/profile.d/z_modules.sh
+# fi
+module purge
+module load pytorch-gpu/py3/1.8.1
+module load nvtop git git-lfs github-cli mc
+
+# git prompt
+export GIT_PROMPT_ONLY_IN_REPO=0;
+export GIT_PROMPT_THEME="JZPRod"
+source $six_ALL_CCFRWORK/envs/.bash-git-prompt/gitprompt.sh
+
+# We are using common disk spaces for datasets, caches, and experiment dumps:
+#
+#- Code, cache and datasets -> `$six_ALL_CCFRWORK/cache_dir` and ``$six_ALL_CCFRWORK/datasets`
+#- Experiment dumps -> `$six_ALL_CCFRWORK/experiments`
+
+# specific caches
+
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+
+#export PYTHONPATH=$WORK/hf/transformers-master/src
+
+export DATASETS_CUSTOM=$six_ALL_CCFRWORK/datasets-custom
+
+### CONDA ###
+
+# >>> conda initialize >>>
+# !! Contents within this block are managed by 'conda init' !!
+__conda_setup="$('/gpfslocalsup/pub/anaconda-py3/2020.02/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
+if [ $? -eq 0 ]; then
+    eval "$__conda_setup"
+else
+    if [ -f "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh" ]; then
+        . "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh"
+    else
+        export PATH="/gpfslocalsup/pub/anaconda-py3/2020.02/bin:$PATH"
+    fi
+fi
+unset __conda_setup
+# <<< conda initialize <<<
+
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+conda activate base
+conda activate hf-prod

bigscience/jz/envs/start-user

@@ -0,0 +1,59 @@
+# user env start script
+
+# replace stas with the name of your conda env in this script
+
+# if this session isn't run via a login shell, which is the case when running a
+# command which is not shell via ssh, the bash function `module` will be missing.
+# so work around it by emulating part of the login shell that loads modules environment
+#if [ -z $(type -t module) ]
+#then
+#   . /etc/profile.d/z_modules.sh
+#fi
+module purge
+module load pytorch-gpu/py3/1.8.1
+module load nvtop git git-lfs github-cli mc
+
+# git prompt
+export GIT_PROMPT_ONLY_IN_REPO=0;
+export GIT_PROMPT_THEME="JZPRod"
+source $six_ALL_CCFRWORK/envs/.bash-git-prompt/gitprompt.sh
+
+# We are using common disk spaces for datasets, caches, and experiment dumps:
+#
+#- Code, cache and datasets -> `$six_ALL_CCFRWORK/cache_dir` and ``$ALL_CCFRWORK/datasets`
+#- Experiment dumps -> `$six_ALL_CCFRWORK/EXPERIMENTS`
+
+# specific caches
+
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+
+#export PYTHONPATH=$WORK/hf/transformers-master/src
+
+export DATASETS_CUSTOM=$six_ALL_CCFRWORK/datasets-custom
+
+
+
+
+### CONDA ###
+
+# >>> conda initialize >>>
+# !! Contents within this block are managed by 'conda init' !!
+__conda_setup="$('/gpfslocalsup/pub/anaconda-py3/2020.02/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
+if [ $? -eq 0 ]; then
+    eval "$__conda_setup"
+else
+    if [ -f "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh" ]; then
+        . "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh"
+    else
+        export PATH="/gpfslocalsup/pub/anaconda-py3/2020.02/bin:$PATH"
+    fi
+fi
+unset __conda_setup
+# <<< conda initialize <<<
+
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+conda activate base
+conda activate stas

bigscience/jz/envs/workarounds.md

@@ -0,0 +1,8 @@
+# Workarounds
+
+## Missing certificates
+
+Sometimes, some certificates can be missing. It's possible to point to our own local versions of the certificates. You can simply copy them to `$six_ALL_CCFRWORK/etc/ssl/certs/` or any other relevant folder:
+```bash
+export CURL_CA_BUNDLE=$six_ALL_CCFRWORK/etc/ssl/certs/ca-certificates.crt
+```

bigscience/jz/frameworks/deepspeed.md

@@ -0,0 +1,105 @@
+# Deepspeed notes
+
+A lot of these collected from chats with Samyam, Shaden and Olatunji
+
+## Should I use the `deepspeed` launcher under slurm.
+
+No, it won't work.
+
+Instead use:
+```
+python -u -m torch.distributed.launch \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --master_addr $MASTER_ADDR \
+    --master_port $MASTER_PORT \
+    --node_rank $SLURM_PROCID \
+    ....
+```
+
+## on 8 gpus I get now: `data_parallel_size: 8, parameter_parallel_size: 8`
+
+In this case seeing that the DP and parameter parallel size match means ZeRO will partition across all gpus
+
+## Memory estimates
+
+As each node has about 160GB of memory, the model size you can run with Z2-Offload is about 8-10B parameters per node. Each of those parameters will require 4 bytes for fp32 momentum, variance, and parameters, gradients so a total of 16 bytes per parameter, for a total of about 160 GB.
+
+
+# Pipeline + ZeRO
+
+If you're using PP, you'll want to use ZeRO stage 0 or 1.  Pipeline parallelism does weird things with gradients that does not play nicely with Z2+. We assert that when using DS' pipeline parallelism, but I think it's more wild west with Megatron's PP implementation.
+
+```
+train_batch_size=$(($WORLD_SIZE*$MICRO_BATCH_SIZE*$gradient_accumulation_steps))
+```
+
+You want to scale by DP size instead of WORLD_SIZE. Let me write down a bit about batch sizes:
+
+
+# Megatron + Deepspeed
+
+
+The `batch_size` in our Megatron scripts is the same thing as micro-batch size. That's the size of each batch of data that comes off the data loader and goes through the various kernels. That's usually what you think of when you talk about batch size (then multiplied by the size of data parallelism)
+
+Megatron updated their terminology to match DeepSpeed once they added PP support, which adds the concept of gradient accumulation. Before that, there was no grad accumulation and so the global batch size was assumed to be `DP * batch_size`.
+
+So thinking in terms the three axes of parallelism:
+
+* Each pipeline processes a `gradient_accumulation_steps` (gas) number of micro-batches per training step. There are as many pipelines as the data parallel dimension, so the global batch size of each training step is `microbatch * gas * DP`
+* Megatron's model parallelism (renamed to tensor model parallelism) is not in the above formula. You can think of it as splitting batches across the MP group.
+
+A bit on the various batch size parameters and performance:
+
+Increasing micro-batch size increases the arithmetic intensity of individual kernels, increasing throughput and also the memory pressure from activations.
+
+Increasing the gradient accumulation steps decreases the bubble overheads of pipeline parallelism. For DeepSpeed's PP algorithm, if you set `gas=8*PP` you should get 90% pipeline efficiency. Theoretical pipeline efficiency is:
+
+```
+efficiency = gas / (gas + PP - 1)
+```
+
+Increasing gas relative to PP will asymptotically approach 100% efficiency as you shrink the pipeline bubble overhead.
+
+PyTorch's PP implementation is based on the GPipe algorithm, which still has a clear divide between forward/backward passes:
+
+![gpipe](images/gpipe.png)
+
+Their docs use both chunks/microbatch terminology. I'll use 'mb' for short. The key thing to note is that all the forward passes are done first, then all the backward passes. That means that the pipeline memory overheads (eg., activations from each mb) are kept around and scale linearly with the number of chunks. Since you increase the number of chunks to decrease PP overheads, you pay a linearly increasing memory cost to improve throughput.
+
+DeepSpeed's pipeline parallelism takes another approach, in which the forward/backward passes for different mbs are done in parallel.
+
+![deepspeed pipe](images/deepspeed-pipe.png)
+
+After each backward pass completes, the gradient is accumulated into a single gradient buffer and the corresponding activations are freed. The number of mbs in flight at any time is bounded by the dimension of pipeline parallelism, not the number of gradient accumulation steps (same thing as chunks). That means that you can still increase the gas to improve efficiency, but memory overheads stay constant and only scale with the number of pipeline stages.
+
+Say you split a model across 20 pipeline stages and want 90% PP efficiency... the GPipe approach will need about 8x more memory for activations because each microbatch has to be kept around until all of the backward passes begin.
+
+Activation checkpointing of course reduces activation memory for both, but this applies even with checkpointing each layer. There are also pipeline overheads in which you store the input/output for each mb to pass to the adjacent stages
+
+Though let me add, when I'm tuning perf for PP+DP I usually increase the gas first to get rid of the pipeline bubble overhead. Then you can increase the microbatch size to improve efficiency of individual kernels
+
+
+
+## Tuning experiments
+
+
+Shaden's approach:
+
+- Fix MICRO_BATCH_SIZE=1 until you're set with the model configuration.
+- Use TP_SIZE=GPUS_PER_NODE
+- If using PP, use PP_SIZE=NNODES and PP_CHUNKS at about 8*PP_SIZE. Larger that that won't hurt if you can spare a larger batch size, but there are diminishing returns. PP_CHUNKS=16*PP_SIZE increases efficiency to 94% for example (vs 90%).
+- Increase layer/hidden until you can't 
+. Load balance is important here, you want the number of layers to be divisible by PP_SIZE. Otherwise the entire pipeline slows down
+- You can go back at the end and try to increase MICRO_BATCH_SIZE if you have leftover memory for larger activations. Sometimes I can increase to 2 and get higher throughput
+
+
+Samyam's approach:
+
+- try to tune up the max micro-bs on 1 node model scaled down to a few layers (Same hidden size)
+- experiment in the range of 16 to 64 to get the highest tflops
+- how efficient it's running w/o communications
+- fit on a single node
+- could turn off optimizer step - no communications between gpus
+- one more hyper param to experiment with:
+  tiled - turn it on - overlapping communication improvement

bigscience/jz/frameworks/megatron-lm.md

@@ -0,0 +1,92 @@
+# Megatron-LM Notes and Nuances
+
+
+## Configuration
+
+- Data Parallel: `data-parallel-size = world_size / (pipeline_model_parallel_size * tensor_model_parallel_size)`
+   By default, `pipeline_model_parallel_size=`` and `tensor_model_parallel_size=1`
+
+
+## Troubleshooting
+
+- if megatron hangs in:
+
+```
+>>> done with dataset index builder. Compilation time: 0.107 seconds
+> compiling and loading fused kernels ...
+```
+do:
+```
+rm megatron/fused_kernels/build/lock
+```
+and restart.
+
+
+## General Performance Notes
+
+NVIDIA paper: https://arxiv.org/abs/2104.04473v2
+
+- they used 80GB A100s with 312TFlops/gpu (and achieved about 50% of that in the largest model/batch size (163TFlops)
+
+- we are using 32GB V100s with 125TFlops/gpu
+
+- The DGX-2 clusters used by NVIDIA have 300GBps intra-node connections and 800Gbps inter-node connections
+
+- JZ on the other hand has 50GBps intra-node connections and 400Gbps inter-node connections.
+
+and the rest of the hardware is less powerful (so if we reach about 35-50TFlops that would be fantastic)
+
+Their main scaling table:
+
+- model parallel size = tensor model parallel * pipeline model parallel
+
+where tensor parallel is 8 at the most
+
+So for example for 76B it says MP=32, which means 8 * 4 - so `PP_size=4` and `TP_size=8`
+
+Basically use tensor model parallelism within a node, then use pipeline model parallelism for larger models
+- So if MP size <= 8, tensor MP = MP size, pipeline MP = 1
+- Otherwise, tensor MP = 8, pipeline MP = (MP size // 8 )
+
+DataParallel isn't not in the table, it's:
+
+DP = (total number of GPUs // MP size)
+
+Here is the main table from the paper with added breakdown of TP/PP/DP:
+
+|       |       |        |     |    |    |    |     |      |       |        |        |        |        |
+| ---:  | ----: | -----: | --: | -: | -: | -: | --: | ---: |  ---: | -----: |  ----: |  ----: | -----: |
+| Model | Atten | Hidden | Lay | TP | PP | DP |  MP | GPUs | Micro | Global | TFlops | TFlops | PFlops |
+| size  | heads |   size | ers |    |    |    |     |      |    BS |     BS |   /GPU |      % | Aggreg |
+| 1.7B  |    24 |   2304 |  24 |  1 |  1 | 32 |   1 |   32 |    16 |    512 |    137 |    44% |    4.4 |
+| 3.6B  |    32 |   3072 |  30 |  2 |  1 | 32 |   2 |   64 |    16 |    512 |    138 |    44% |    8.8 |
+| 7.5B  |    32 |   4096 |  36 |  4 |  1 | 32 |   4 |  128 |    16 |    512 |    142 |    46% |   18.2 |
+| 18B   |    48 |   6144 |  40 |  8 |  1 | 32 |   8 |  256 |     8 |   1024 |    135 |    43% |   34.6 |
+| 39B   |    64 |   8192 |  48 |  8 |  2 | 32 |  16 |  512 |     4 |   1536 |    138 |    44% |   70.8 |
+| 76B   |    80 |  10240 |  60 |  8 |  4 | 32 |  32 | 1024 |     2 |   1792 |    140 |    45% |  143.8 |
+| 145B  |    96 |  12288 |  80 |  8 |  8 | 24 |  64 | 1536 |     2 |   2304 |    148 |    47% |  227.1 |
+| 310B  |   128 |  16384 |  96 |  8 | 16 | 15 | 128 | 1920 |     1 |   2160 |    155 |    50% |  297.4 |
+| 530B  |   128 |  20480 | 105 |  8 | 35 |  9 | 280 | 2520 |     1 |   2520 |    163 |    52% |  410.2 |
+| 1T    |   160 |  25600 | 128 |  8 | 64 |  6 | 512 | 3072 |     1 |   3072 |    163 |    52% |  502.0 |
+|       |       |        |     |    |    |    |     |      |       |        |        |        |        |
+
+
+## TODO
+
+Notes from Jared - to sort:
+
+- batch size
+
+`--global-batch-size` leads to automatic gradient accumulation, so for example on 4-gpu node with:
+
+with only 4-way data parallel using a micro batch size of 16 and global batch size of 2048 it's going to do gradient accumulation on 32 batches for each iteration.
+
+so probably best not to use this argument, unless it's thought through.
+
+--micro-batch-size is always the smallest "batch size", it's what gets sent through the model.
+
+--global-batch-size will default to micro batch size * data parallelism unless specified. With the default value there will be no gradient accumulation. If specified, gradient accumulation will happen to reach the global batch size. The "chunks" you talk about above for PP we see as just gradient accumulation. Without gradient accumulation PP is very inefficient with no overlap of executing the different stages. So the more micro-batches that get accumulated, or the large the global batch size, the more efficient PP will be.
+We discussed a lot about how best to expose that in arguments and decided most of the time we care about the micro batch size and the global batch size and don't want to do the math to figure out the number of microbatches done to get to the global batch size. Especially since we will sometimes have a dynamic global batch size
+
+So bottom line under PP number of micro-batches == gradient accumulation
+# Megatron-LM notes

bigscience/jz/hpc-specs.md

@@ -0,0 +1,38 @@
+# Specs of Jean Zay
+
+- 261 nodes, with V100 32 GB GPUs: total 1044 GPUs
+- 351 nodes, with V100 16 GB GPUs: total 1404 GPUs
+
+## Disc Partitions
+
+- `$HOME` - 3GB for small files
+- `$WORK` - 5TB / 500k inodes → sources, input/output files
+- `$SCRATCH` - fastest (full SSD), 400TB our quota (total 2PB), files auto-removed after 30 days without access
+- `$STORE` - for long term storage in tar files (very few inodes!)
+
+## Shared Filesystem
+
+- GPFS filesystem (Spectrum Scale)
+
+- `$SCRATCH` - is SSD with theoretical bandwidth of at least 300 GB/s, probably more with the 2PB extension
+- other partitions are slower discs
+
+## Network Topology
+
+V100 32GB GPU are `r6i[4-7]n[0-8],r[7-9]i[0-7]n[0-8],r14i7n[0-8]`
+
+They are mostly grouped together but that doesn't really mean that the switches are completely independent from the rest of the network.
+
+Due to the hypercube topology used on JZ reaching two nodes on different racks might use intermediate hops on other racks. e.g. communications between nodes on r6 and r7 might go through switches on r3 or r8 depending of the targeted nodes.
+
+## JZ3
+
+coming in Jan 2022:
+
+- GPUs: 416 A100 80GB GPUs (52 nodes of 8 gpus each)
+- 8 GPUs per node Using NVLink 4 inter-gpu connects, 4 OmniPath links
+- CPU: AMD
+- CPU memory: 512GB per node
+- Inter-node connect: Omni-Path Architecture (OPA)
+- NCCL-communications network: a fully dedicated subnet
+- Disc IO network: shared network with other types of nodes

bigscience/jz/scripts/custom_callbacks.py

@@ -0,0 +1,95 @@
+import os
+
+from transformers import TrainerCallback, is_tensorboard_available
+from transformers.integrations import rewrite_logs
+
+
+class LogFlosCallback(TrainerCallback):
+    """
+    A :class:`~transformers.TrainerCallback` that adds current flos to every log.
+    """
+
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        logs["total_flos"] = state.total_flos
+
+
+class TensorBoardFloIndexedCallback(TrainerCallback):
+    """
+    A :class:`~transformers.TrainerCallback` that sends the logs to `TensorBoard
+    <https://www.tensorflow.org/tensorboard>`__.
+
+    Args:
+        tb_writer (:obj:`SummaryWriter`, `optional`):
+            The writer to use. Will instantiate one if not set.
+    """
+
+    def __init__(self, tb_writer=None):
+        has_tensorboard = is_tensorboard_available()
+        assert (
+            has_tensorboard
+        ), "TensorBoardCallback requires tensorboard to be installed. Either update your PyTorch version or install tensorboardX."
+        if has_tensorboard:
+            try:
+                from torch.utils.tensorboard import SummaryWriter  # noqa: F401
+
+                self._SummaryWriter = SummaryWriter
+            except ImportError:
+                try:
+                    from tensorboardX import SummaryWriter
+
+                    self._SummaryWriter = SummaryWriter
+                except ImportError:
+                    self._SummaryWriter = None
+        else:
+            self._SummaryWriter = None
+        self.tb_writer = tb_writer
+
+    def _init_summary_writer(self, args, log_dir=None):
+        log_dir = log_dir or args.logging_dir
+        if self._SummaryWriter is not None:
+            self.tb_writer = self._SummaryWriter(log_dir=log_dir)
+
+    def on_train_begin(self, args, state, control, **kwargs):
+        if not state.is_world_process_zero:
+            return
+
+        log_dir = None
+
+        if state.is_hyper_param_search:
+            trial_name = state.trial_name
+            if trial_name is not None:
+                log_dir = os.path.join(args.logging_dir, trial_name)
+
+        self._init_summary_writer(args, log_dir)
+
+        if self.tb_writer is not None:
+            self.tb_writer.add_text("args", args.to_json_string())
+            if "model" in kwargs:
+                model = kwargs["model"]
+                if hasattr(model, "config") and model.config is not None:
+                    model_config_json = model.config.to_json_string()
+                    self.tb_writer.add_text("model_config", model_config_json)
+            # Version of TensorBoard coming from tensorboardX does not have this method.
+            if hasattr(self.tb_writer, "add_hparams"):
+                self.tb_writer.add_hparams(args.to_sanitized_dict(), metric_dict={})
+
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        if not state.is_world_process_zero:
+            return
+
+        if self.tb_writer is None:
+            self._init_summary_writer(args)
+
+        if self.tb_writer is not None:
+            logs = rewrite_logs(logs)
+            self.tb_writer.add_scalar("Conversion/x steps - y flos", state.total_flos, state.global_step)
+            self.tb_writer.add_scalar("Conversion/x flos - y steps", state.global_step, state.total_flos)
+            for k, v in logs.items():
+                if isinstance(v, (int, float)):
+                    self.tb_writer.add_scalar(f"Flos/{k}", v, state.total_flos)
+                    self.tb_writer.add_scalar(f"Steps/{k}", v, state.global_step)
+            self.tb_writer.flush()
+
+    def on_train_end(self, args, state, control, **kwargs):
+        if self.tb_writer:
+            self.tb_writer.close()

bigscience/jz/scripts/run_clm.py

@@ -0,0 +1,520 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2020 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tuning the library models for causal language modeling (GPT, GPT-2, CTRL, ...) on a text file or a dataset.
+
+Here is the full list of checkpoints on the hub that can be fine-tuned by this script:
+https://huggingface.co/models?filter=causal-lm
+"""
+# You can also adapt this script on your own causal language modeling task. Pointers for this are left as comments.
+
+import logging
+import math
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch.distributed
+from datasets import load_dataset
+
+import transformers
+from transformers import (
+    CONFIG_MAPPING,
+    MODEL_FOR_CAUSAL_LM_MAPPING,
+    AutoConfig,
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+    default_data_collator,
+    set_seed,
+)
+from transformers.testing_utils import CaptureLogger
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version
+
+### I very much dislike this solution. `run_clm.py` should probably be at the root, or install as an editable package.
+import os
+currentdir = os.path.dirname(os.path.realpath(__file__))
+parentdir = os.path.dirname(currentdir)
+sys.path.append(parentdir)
+###
+
+from models.decoder_only_t5 import DecoderOnlyT5Config, DecoderOnlyT5LMHeadModel
+
+CONFIG_MAPPING["decoder_only_t5"] = DecoderOnlyT5Config
+MODEL_FOR_CAUSAL_LM_MAPPING[DecoderOnlyT5Config] = DecoderOnlyT5LMHeadModel
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+from custom_callbacks import LogFlosCallback, TensorBoardFloIndexedCallback
+
+check_min_version("4.6.0.dev0")
+
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s - %(process)d - %(name)s - %(message)s",
+    datefmt="%m/%d/%Y %H:%M:%S",
+    level=logging.INFO,
+)
+logger = logging.getLogger(__name__)
+
+
+MODEL_CONFIG_CLASSES = list(MODEL_FOR_CAUSAL_LM_MAPPING.keys())
+MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
+    """
+
+    model_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The model checkpoint for weights initialization."
+            "Don't set if you want to train a model from scratch."
+        },
+    )
+    model_type: Optional[str] = field(
+        default=None,
+        metadata={"help": "If training from scratch, pass a model type from the list: " + ", ".join(MODEL_TYPES)},
+    )
+    config_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"},
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."},
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."},
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+            "with private models)."
+        },
+    )
+
+
+@dataclass
+class ConfigArguments:
+    """
+    Arguments defining the new model we're about to train when training from scratch
+    """
+
+    n_ctx: Optional[int] = field(default=1024, metadata={"help": "Dimensionality of the causal mask"})
+    n_embd: Optional[int] = field(
+        default=768, metadata={"help": "Dimensionality of the embeddings and hidden states."}
+    )
+    n_layer: Optional[int] = field(default=12, metadata={"help": "Number of hidden layers."})
+    n_head: Optional[int] = field(default=12, metadata={"help": "Number of attention heads for each attention layer."})
+    n_inner: Optional[int] = field(default=None, metadata={"help": "Dimensionality of the inner feed-forward layers."})
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    sanity: bool = field(
+        default=False, metadata={"help": "Only use fraction of the dataset"}
+    )
+    dataset_name: Optional[str] = field(
+        default=None, metadata={"help": "The name of the dataset to use (via the datasets library)."}
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
+    )
+    train_file: Optional[str] = field(default=None, metadata={"help": "The input training data file (a text file)."})
+    validation_file: Optional[str] = field(
+        default=None,
+        metadata={"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."},
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of training examples to this "
+            "value if set."
+        },
+    )
+    max_val_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of validation examples to this "
+            "value if set."
+        },
+    )
+
+    block_size: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "Optional input sequence length after tokenization. "
+            "The training dataset will be truncated in block of this size for training. "
+            "Default to the model max input length for single sentence inputs (take into account special tokens)."
+        },
+    )
+    overwrite_cache: bool = field(
+        default=False, metadata={"help": "Overwrite the cached training and evaluation sets"}
+    )
+    validation_split_percentage: Optional[int] = field(
+        default=5,
+        metadata={
+            "help": "The percentage of the train set used as validation set in case there's no validation split"
+        },
+    )
+    preprocessing_num_workers: Optional[int] = field(
+        default=None,
+        metadata={"help": "The number of processes to use for the preprocessing."},
+    )
+
+    def __post_init__(self):
+        if self.dataset_name is None and self.train_file is None and self.validation_file is None:
+            raise ValueError("Need either a dataset name or a training/validation file.")
+        else:
+            if self.train_file is not None:
+                extension = self.train_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`train_file` should be a csv, a json or a txt file."
+            if self.validation_file is not None:
+                extension = self.validation_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`validation_file` should be a csv, a json or a txt file."
+
+
+def main():
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments, ConfigArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args, config_args = parser.parse_json_file(
+            json_file=os.path.abspath(sys.argv[1])
+        )
+    else:
+        model_args, data_args, training_args, config_args = parser.parse_args_into_dataclasses()
+
+    # Detecting last checkpoint.
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif last_checkpoint is not None:
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s -   %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        + f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+        transformers.utils.logging.enable_default_handler()
+        transformers.utils.logging.enable_explicit_format()
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below)
+    # or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/
+    # (the dataset will be downloaded automatically from the datasets Hub).
+    #
+    # For CSV/JSON files, this script will use the column called 'text' or the first column if no column called
+    # 'text' is found. You can easily tweak this behavior (see below).
+    #
+    # In distributed training, the load_dataset function guarantee that only one local process can concurrently
+    # download the dataset.
+    if data_args.dataset_name is not None:
+        # Downloading and loading a dataset from the hub.
+        datasets = load_dataset(data_args.dataset_name, data_args.dataset_config_name, keep_in_memory=False, cache_dir=model_args.cache_dir)
+        if "validation" not in datasets.keys():
+            datasets["validation"] = load_dataset(
+                data_args.dataset_name,
+                data_args.dataset_config_name,
+                split=f"train[:{data_args.validation_split_percentage}%]",
+                keep_in_memory=False,
+                cache_dir=model_args.cache_dir
+            )
+            datasets["train"] = load_dataset(
+                data_args.dataset_name,
+                data_args.dataset_config_name,
+                split=f"train[{data_args.validation_split_percentage}%:]",
+                keep_in_memory=False,
+                cache_dir=model_args.cache_dir
+            )
+    else:
+        data_files = {}
+        if data_args.train_file is not None:
+            data_files["train"] = data_args.train_file
+        if data_args.validation_file is not None:
+            data_files["validation"] = data_args.validation_file
+        extension = (
+            data_args.train_file.split(".")[-1]
+            if data_args.train_file is not None
+            else data_args.validation_file.split(".")[-1]
+        )
+        if extension == "txt":
+            extension = "text"
+        datasets = load_dataset(extension, data_files=data_files, keep_in_memory=False, cache_dir=model_args.cache_dir)
+    if data_args.sanity:
+        datasets["train"] = datasets["train"].shard(100, index=0, contiguous=True)
+    # See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at
+    # https://huggingface.co/docs/datasets/loading_datasets.html.
+
+    # Load pretrained model and tokenizer
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    # download model & vocab.
+
+    config_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.config_name:
+        config = AutoConfig.from_pretrained(model_args.config_name, **config_kwargs)
+    elif model_args.model_name_or_path:
+        config = AutoConfig.from_pretrained(model_args.model_name_or_path, **config_kwargs)
+    else:
+        config = CONFIG_MAPPING[model_args.model_type](**vars(config_args), **config_kwargs)
+        logger.warning("You are instantiating a new config instance from scratch.")
+
+    tokenizer_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "use_fast": model_args.use_fast_tokenizer,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.tokenizer_name, **tokenizer_kwargs)
+    elif model_args.model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, **tokenizer_kwargs)
+    else:
+        raise ValueError(
+            "You are instantiating a new tokenizer from scratch. This is not supported by this script."
+            "You can do it from another script, save it, and load it from here, using --tokenizer_name."
+        )
+
+    if model_args.model_name_or_path:
+        model = AutoModelForCausalLM.from_pretrained(
+            model_args.model_name_or_path,
+            from_tf=bool(".ckpt" in model_args.model_name_or_path),
+            config=config,
+            cache_dir=model_args.cache_dir,
+            revision=model_args.model_revision,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+    else:
+        logger.info("Training new model from scratch")
+        model = AutoModelForCausalLM.from_config(config)
+
+    model.resize_token_embeddings(len(tokenizer))
+
+    # Preprocessing the datasets.
+    # First we tokenize all the texts.
+    if training_args.do_train:
+        column_names = datasets["train"].column_names
+    else:
+        column_names = datasets["validation"].column_names
+    text_column_name = "text" if "text" in column_names else column_names[0]
+
+    # since this will be pickled to avoid _LazyModule error in Hasher force logger loading before tokenize_function
+    tok_logger = transformers.utils.logging.get_logger("transformers.tokenization_utils_base")
+
+    datasets = datasets.shuffle()
+    def tokenize_function(examples):
+        with CaptureLogger(tok_logger) as cl:
+            output = tokenizer(examples[text_column_name])
+        # clm input could be much much longer than block_size
+        if "Token indices sequence length is longer than the" in cl.out:
+            tok_logger.warning(
+                "^^^^^^^^^^^^^^^^ Please ignore the warning above - this long input will be chunked into smaller bits before being passed to the model."
+            )
+        return output
+
+    # Ensures only the main process does dataset pre-processing; the other ones will load the `map` cache
+    if not is_main_process(training_args.local_rank):
+        print("waiting for main process to execute mapping")
+        torch.distributed.barrier()
+
+    logger.info("Mapping dataset to tokenized dataset.",)
+    tokenized_datasets = datasets.map(
+        tokenize_function,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        remove_columns=column_names,
+        load_from_cache_file=not data_args.overwrite_cache,
+        keep_in_memory=False
+    )
+
+    if data_args.block_size is None:
+        block_size = tokenizer.model_max_length
+        if block_size > 1024:
+            logger.warning(
+                f"The tokenizer picked seems to have a very large `model_max_length` ({tokenizer.model_max_length}). "
+                "Picking 1024 instead. You can change that default value by passing --block_size xxx."
+            )
+            block_size = 1024
+    else:
+        if data_args.block_size > tokenizer.model_max_length:
+            logger.warning(
+                f"The block_size passed ({data_args.block_size}) is larger than the maximum length for the model"
+                f"({tokenizer.model_max_length}). Using block_size={tokenizer.model_max_length}."
+            )
+        # block_size = min(data_args.block_size, tokenizer.model_max_length)
+        block_size = data_args.block_size
+
+    # Main data processing function that will concatenate all texts from our dataset and generate chunks of block_size.
+    def group_texts(examples):
+        # Concatenate all texts.
+        concatenated_examples = {k: sum(examples[k], []) for k in examples.keys()}
+        total_length = len(concatenated_examples[list(examples.keys())[0]])
+        # We drop the small remainder, we could add padding if the model supported it instead of this drop, you can
+        # customize this part to your needs.
+        total_length = (total_length // block_size) * block_size
+        # Split by chunks of max_len.
+        result = {
+            k: [t[i : i + block_size] for i in range(0, total_length, block_size)]
+            for k, t in concatenated_examples.items()
+        }
+        result["labels"] = result["input_ids"].copy()
+        return result
+
+    # Note that with `batched=True`, this map processes 1,000 texts together, so group_texts throws away a remainder
+    # for each of those groups of 1,000 texts. You can adjust that batch_size here but a higher value might be slower
+    # to preprocess.
+    #
+    # To speed up this part, we use multiprocessing. See the documentation of the map method for more information:
+    # https://huggingface.co/docs/datasets/package_reference/main_classes.html#datasets.Dataset.map
+
+    logger.info("Chunking tokenized dataset.")
+    lm_datasets = tokenized_datasets.map(
+        group_texts,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        load_from_cache_file=not data_args.overwrite_cache,
+        keep_in_memory=False
+    )
+
+    # Now the other ones can catch up.
+    if training_args.local_rank != -1 and is_main_process(training_args.local_rank):
+        print("loading results from main process")
+        torch.distributed.barrier()
+
+    if training_args.do_train:
+        if "train" not in tokenized_datasets:
+            raise ValueError("--do_train requires a train dataset")
+        train_dataset = lm_datasets["train"]
+        if data_args.max_train_samples is not None:
+            train_dataset = train_dataset.select(range(data_args.max_train_samples))
+
+    if training_args.do_eval:
+        if "validation" not in tokenized_datasets:
+            cutoff = data_args.validation_split_percentage * len(lm_datasets["train"]) // 100
+            train_dataset = lm_datasets["train"].select(range(cutoff, len(lm_datasets["train"])))
+            eval_dataset = lm_datasets["train"].select(range(cutoff))
+        else:
+            eval_dataset = lm_datasets["validation"]
+        if data_args.max_val_samples is not None:
+            eval_dataset = eval_dataset.select(range(data_args.max_val_samples))
+
+
+    # Initialize our Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset if training_args.do_train else None,
+        eval_dataset=eval_dataset if training_args.do_eval else None,
+        tokenizer=tokenizer,
+        # Data collator will default to DataCollatorWithPadding, so we change it.
+        data_collator=default_data_collator,
+        callbacks=[LogFlosCallback, TensorBoardFloIndexedCallback]
+    )
+
+    # Training
+    if training_args.do_train:
+        checkpoint = None
+        if training_args.resume_from_checkpoint is not None:
+            checkpoint = training_args.resume_from_checkpoint
+        elif last_checkpoint is not None:
+            checkpoint = last_checkpoint
+
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the tokenizer too for easy upload
+
+        metrics = train_result.metrics
+
+        max_train_samples = (
+            data_args.max_train_samples if data_args.max_train_samples is not None else len(train_dataset)
+        )
+        metrics["train_samples"] = min(max_train_samples, len(train_dataset))
+
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # Evaluation
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+
+        metrics = trainer.evaluate()
+
+        metrics["eval_samples"] = len(eval_dataset)
+        perplexity = math.exp(metrics["eval_loss"])
+        metrics["perplexity"] = perplexity
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+
+def _mp_fn(index):
+    # For xla_spawn (TPUs)
+    main()
+
+
+if __name__ == "__main__":
+    main()

bigscience/jz/scripts/run_clm_prompted.py

@@ -0,0 +1,534 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2020 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Prompted version of run_clm.
+"""
+# You can also adapt this script on your own causal language modeling task. Pointers for this are left as comments.
+
+import logging
+import math
+import os
+import sys
+from dataclasses import dataclass, field
+import torch
+from typing import Optional, Dict, List, Union
+
+from datasets import load_dataset, load_from_disk
+
+import transformers
+from transformers import (
+    CONFIG_MAPPING,
+    MODEL_FOR_CAUSAL_LM_MAPPING,
+    AutoConfig,
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+    default_data_collator,
+    set_seed,
+)
+from transformers.testing_utils import CaptureLogger
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version
+from transformers.file_utils import PaddingStrategy
+from transformers.tokenization_utils_base import PreTrainedTokenizerBase
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+check_min_version("4.6.0.dev0")
+
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s - %(process)d - %(name)s - %(message)s",
+    datefmt="%m/%d/%Y %H:%M:%S",
+    level=logging.INFO,
+)
+logger = logging.getLogger(__name__)
+
+
+MODEL_CONFIG_CLASSES = list(MODEL_FOR_CAUSAL_LM_MAPPING.keys())
+MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)
+
+@dataclass
+class MyDataCollatorWithPadding:
+    """
+    Custom version of `DataCollatorWithPadding`.
+    """
+
+    tokenizer: PreTrainedTokenizerBase
+    padding: Union[bool, str, PaddingStrategy] = True
+    max_length: Optional[int] = None
+    pad_to_multiple_of: Optional[int] = None
+
+    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:
+        batch = self.tokenizer.pad(
+            features,
+            padding=self.padding,
+            max_length=self.max_length,
+            pad_to_multiple_of=self.pad_to_multiple_of,
+        )
+        if "label" in batch:
+            batch["labels"] = batch["label"]
+            del batch["label"]
+        if "label_ids" in batch:
+            batch["labels"] = batch["label_ids"]
+            del batch["label_ids"]
+        # Padding labels
+        max_l = len(batch["input_ids"][0])
+        result = []
+        for i in batch["labels"]:
+            result.append(i + [-100]*(max_l - len(i)))
+        batch["labels"] = result
+        for k, v in batch.items():
+            batch[k] = torch.tensor(v)
+        return batch
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
+    """
+
+    model_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The model checkpoint for weights initialization."
+            "Don't set if you want to train a model from scratch."
+        },
+    )
+    model_type: Optional[str] = field(
+        default=None,
+        metadata={"help": "If training from scratch, pass a model type from the list: " + ", ".join(MODEL_TYPES)},
+    )
+    config_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"},
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."},
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."},
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+            "with private models)."
+        },
+    )
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    dataset_name: Optional[str] = field(
+        default=None, metadata={"help": "The name of the dataset to use (via the datasets library)."}
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
+    )
+    train_file: Optional[str] = field(default=None, metadata={"help": "The input training data file (a text file)."})
+    validation_file: Optional[str] = field(
+        default=None,
+        metadata={"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."},
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of training examples to this "
+            "value if set."
+        },
+    )
+    max_val_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of validation examples to this "
+            "value if set."
+        },
+    )
+
+    block_size: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "Optional input sequence length after tokenization. "
+            "The training dataset will be truncated in block of this size for training. "
+            "Default to the model max input length for single sentence inputs (take into account special tokens)."
+        },
+    )
+    overwrite_cache: bool = field(
+        default=False, metadata={"help": "Overwrite the cached training and evaluation sets"}
+    )
+    validation_split_percentage: Optional[int] = field(
+        default=5,
+        metadata={
+            "help": "The percentage of the train set used as validation set in case there's no validation split"
+        },
+    )
+    preprocessing_num_workers: Optional[int] = field(
+        default=None,
+        metadata={"help": "The number of processes to use for the preprocessing."},
+    )
+
+    def __post_init__(self):
+        if self.dataset_name is None and self.train_file is None and self.validation_file is None:
+            raise ValueError("Need either a dataset name or a training/validation file.")
+        else:
+            if self.train_file is not None:
+                extension = self.train_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`train_file` should be a csv, a json or a txt file."
+            if self.validation_file is not None:
+                extension = self.validation_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`validation_file` should be a csv, a json or a txt file."
+
+
+def main():
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    # Detecting last checkpoint.
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif last_checkpoint is not None:
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s -   %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        + f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+        transformers.utils.logging.enable_default_handler()
+        transformers.utils.logging.enable_explicit_format()
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below)
+    # or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/
+    # (the dataset will be downloaded automatically from the datasets Hub).
+    #
+    # For CSV/JSON files, this script will use the column called 'text' or the first column if no column called
+    # 'text' is found. You can easily tweak this behavior (see below).
+    #
+    # In distributed training, the load_dataset function guarantee that only one local process can concurrently
+    # download the dataset.
+    # if data_args.dataset_name is not None:
+    #     # Downloading and loading a dataset from the hub.
+    #     datasets = load_dataset(data_args.dataset_name, data_args.dataset_config_name)
+    #     if "validation" not in datasets.keys():
+    #         datasets["validation"] = load_dataset(
+    #             data_args.dataset_name,
+    #             data_args.dataset_config_name,
+    #             split=f"train[:{data_args.validation_split_percentage}%]",
+    #         )
+    #         datasets["train"] = load_dataset(
+    #             data_args.dataset_name,
+    #             data_args.dataset_config_name,
+    #             split=f"train[{data_args.validation_split_percentage}%:]",
+    #         )
+    # else:
+    #     data_files = {}
+    #     if data_args.train_file is not None:
+    #         data_files["train"] = data_args.train_file
+    #     if data_args.validation_file is not None:
+    #         data_files["validation"] = data_args.validation_file
+    #     extension = (
+    #         data_args.train_file.split(".")[-1]
+    #         if data_args.train_file is not None
+    #         else data_args.validation_file.split(".")[-1]
+    #     )
+    #     if extension == "txt":
+    #         extension = "text"
+    #     datasets = load_dataset(extension, data_files=data_files)
+    datasets = load_from_disk(dataset_path=data_args.dataset_name)
+    # See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at
+    # https://huggingface.co/docs/datasets/loading_datasets.html.
+
+    # Load pretrained model and tokenizer
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    # download model & vocab.
+
+    config_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.config_name:
+        config = AutoConfig.from_pretrained(model_args.config_name, **config_kwargs)
+    elif model_args.model_name_or_path:
+        config = AutoConfig.from_pretrained(model_args.model_name_or_path, **config_kwargs)
+    else:
+        config = CONFIG_MAPPING[model_args.model_type]()
+        logger.warning("You are instantiating a new config instance from scratch.")
+
+    tokenizer_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "use_fast": model_args.use_fast_tokenizer,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.tokenizer_name, **tokenizer_kwargs)
+    elif model_args.model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, **tokenizer_kwargs)
+    else:
+        raise ValueError(
+            "You are instantiating a new tokenizer from scratch. This is not supported by this script."
+            "You can do it from another script, save it, and load it from here, using --tokenizer_name."
+        )
+    if tokenizer.pad_token_id is None and tokenizer.eos_token_id is not None:
+        logger.warning(f"Setting `pad_token_id` to `eos_token_id`:{tokenizer.eos_token_id}.")
+        tokenizer.pad_token = tokenizer.eos_token
+
+    if model_args.model_name_or_path:
+        model = AutoModelForCausalLM.from_pretrained(
+            model_args.model_name_or_path,
+            from_tf=bool(".ckpt" in model_args.model_name_or_path),
+            config=config,
+            cache_dir=model_args.cache_dir,
+            revision=model_args.model_revision,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+    else:
+        logger.info("Training new model from scratch")
+        model = AutoModelForCausalLM.from_config(config)
+
+    model.resize_token_embeddings(len(tokenizer))
+
+    # Preprocessing the datasets.
+    # First we tokenize all the texts.
+    if training_args.do_train:
+        column_names = datasets["train"].column_names
+    else:
+        column_names = datasets["validation"].column_names
+    text_column_name = "text" if "text" in column_names else column_names[0]
+
+    def tokenize_function(examples):
+        def tok_f_ids(string):
+            return tokenizer(string, return_attention_mask=False)["input_ids"]
+
+        texts, texts_a, texts_b = [], [], []
+
+        unprompted_texts = examples["text"]
+        prompting_instances = examples["prompting_instances"]
+
+        for ump_text, ppt_instances in zip(unprompted_texts, prompting_instances):
+            if ppt_instances:
+                for i, p, o in zip(ppt_instances["input"], ppt_instances["prompt"], ppt_instances["output"]):
+                    texts.append([])
+                    texts_a.append(
+                        tok_f_ids(i) \
+                        + [tokenizer.eos_token_id] \
+                        + tok_f_ids(p) \
+                        + [tokenizer.eos_token_id]
+                    )
+                    texts_b.append(tok_f_ids(o))
+            else:
+                texts.append(tok_f_ids(ump_text))
+                texts_a.append([])
+                texts_b.append([])
+        return {
+            "text_full": texts,
+            "text_a": texts_a,
+            "text_b": texts_b,
+        }
+
+    datasets = datasets.shuffle()
+    logger.info("Mapping dataset to tokenized dataset.",)
+    tokenized_datasets = datasets.map(
+        tokenize_function,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        remove_columns=column_names,
+        load_from_cache_file=not data_args.overwrite_cache,
+    )
+
+    if data_args.block_size is None:
+        block_size = tokenizer.model_max_length
+        if block_size > 1024:
+            logger.warning(
+                f"The tokenizer picked seems to have a very large `model_max_length` ({tokenizer.model_max_length}). "
+                "Picking 1024 instead. You can change that default value by passing --block_size xxx."
+            )
+            block_size = 1024
+    else:
+        if data_args.block_size > tokenizer.model_max_length:
+            logger.warning(
+                f"The block_size passed ({data_args.block_size}) is larger than the maximum length for the model"
+                f"({tokenizer.model_max_length}). Using block_size={tokenizer.model_max_length}."
+            )
+        block_size = min(data_args.block_size, tokenizer.model_max_length)
+
+    # Main data processing function that will concatenate all texts from our dataset and generate chunks of block_size.
+    def group_texts(examples):
+        texts = examples["text_full"]
+        texts_a = examples["text_a"]
+        texts_b = examples["text_b"]
+
+        result = {
+            "input_ids": [],
+            "labels": [],
+            "attention_mask": [],
+            "length": [],
+        }
+        n = int(block_size/2)
+        for t, t_a, t_b in zip(texts, texts_a, texts_b):
+            if t == []:
+                cut_t_a = t_a[-n:]
+                cut_t_b = t_b[:n]
+                if len(cut_t_b) < 20:
+                    continue
+                result["input_ids"].append(cut_t_a + cut_t_b)
+                result["labels"].append([-100]*len(cut_t_a) + cut_t_b)
+            else:
+                total_length = len(t)
+                total_length = (total_length // block_size) * block_size
+                for i in range (0, total_length, block_size):
+                    sub_seq = t[i : i + block_size]
+                    result["input_ids"].append(sub_seq)
+                    result["labels"].append(sub_seq)
+        for i in result["labels"]:
+            result["attention_mask"].append([1]*len(i))
+            result["length"].append(len(i))
+        return result
+
+    # Note that with `batched=True`, this map processes 1,000 texts together, so group_texts throws away a remainder
+    # for each of those groups of 1,000 texts. You can adjust that batch_size here but a higher value might be slower
+    # to preprocess.
+    #
+    # To speed up this part, we use multiprocessing. See the documentation of the map method for more information:
+    # https://huggingface.co/docs/datasets/package_reference/main_classes.html#datasets.Dataset.map
+
+    logger.info("Chunking tokenized dataset.")
+    lm_datasets = tokenized_datasets.map(
+        group_texts,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        remove_columns=tokenized_datasets["train"].column_names,
+        load_from_cache_file=not data_args.overwrite_cache,
+    )
+
+    if training_args.do_train:
+        if "train" not in tokenized_datasets:
+            raise ValueError("--do_train requires a train dataset")
+        train_dataset = lm_datasets["train"]
+        if data_args.max_train_samples is not None:
+            train_dataset = train_dataset.select(range(data_args.max_train_samples))
+
+    if training_args.do_eval:
+        if "validation" not in tokenized_datasets:
+            raise ValueError("--do_eval requires a validation dataset")
+        eval_dataset = lm_datasets["validation"]
+        if data_args.max_val_samples is not None:
+            eval_dataset = eval_dataset.select(range(data_args.max_val_samples))
+
+    # Initialize our Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset if training_args.do_train else None,
+        eval_dataset=eval_dataset if training_args.do_eval else None,
+        tokenizer=tokenizer,
+        # Data collator will default to DataCollatorWithPadding, so we change it.
+        data_collator=MyDataCollatorWithPadding(tokenizer=tokenizer, padding=True),
+    )
+
+    # Training
+    if training_args.do_train:
+        if last_checkpoint is not None:
+            checkpoint = last_checkpoint
+        elif model_args.model_name_or_path is not None and os.path.isdir(model_args.model_name_or_path):
+            checkpoint = model_args.model_name_or_path
+        else:
+            checkpoint = None
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the tokenizer too for easy upload
+
+        metrics = train_result.metrics
+
+        max_train_samples = (
+            data_args.max_train_samples if data_args.max_train_samples is not None else len(train_dataset)
+        )
+        metrics["train_samples"] = min(max_train_samples, len(train_dataset))
+
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # Evaluation
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+
+        metrics = trainer.evaluate()
+
+        max_val_samples = data_args.max_val_samples if data_args.max_val_samples is not None else len(eval_dataset)
+        metrics["eval_samples"] = min(max_val_samples, len(eval_dataset))
+        perplexity = math.exp(metrics["eval_loss"])
+        metrics["perplexity"] = perplexity
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+
+def _mp_fn(index):
+    # For xla_spawn (TPUs)
+    main()
+
+
+if __name__ == "__main__":
+    main()

bigscience/jz/scripts/run_text2text.py

@@ -0,0 +1,514 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2020 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tune a text-to-text model (T5, BART, ...) on a text file or dataset.
+"""
+
+import logging
+import math
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch.distributed
+from datasets import load_dataset
+
+import transformers
+from transformers import (
+    CONFIG_MAPPING,
+    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
+    AutoConfig,
+    AutoModelForSeq2SeqLM,
+    AutoTokenizer,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+    default_data_collator,
+    set_seed,
+)
+from transformers.testing_utils import CaptureLogger
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version
+
+### I very much dislike this solution. `run_clm.py` should probably be at the root, or install as an editable package.
+import os
+currentdir = os.path.dirname(os.path.realpath(__file__))
+parentdir = os.path.dirname(currentdir)
+sys.path.append(parentdir)
+###
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+from custom_callbacks import LogFlosCallback, TensorBoardFloIndexedCallback
+
+check_min_version("4.6.0.dev0")
+
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s - %(process)d - %(name)s - %(message)s",
+    datefmt="%m/%d/%Y %H:%M:%S",
+    level=logging.INFO,
+)
+logger = logging.getLogger(__name__)
+
+
+MODEL_CONFIG_CLASSES = list(MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING.keys())
+MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
+    """
+
+    model_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The model checkpoint for weights initialization."
+            "Don't set if you want to train a model from scratch."
+        },
+    )
+    model_type: Optional[str] = field(
+        default=None,
+        metadata={"help": "If training from scratch, pass a model type from the list: " + ", ".join(MODEL_TYPES)},
+    )
+    config_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"},
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."},
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."},
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+            "with private models)."
+        },
+    )
+
+
+@dataclass
+class ConfigArguments:
+    """
+    Arguments defining the new model we're about to train when training from scratch
+    """
+
+    n_ctx: Optional[int] = field(default=1024, metadata={"help": "Dimensionality of the causal mask"})
+    n_embd: Optional[int] = field(
+        default=768, metadata={"help": "Dimensionality of the embeddings and hidden states."}
+    )
+    n_layer: Optional[int] = field(default=12, metadata={"help": "Number of hidden layers."})
+    n_head: Optional[int] = field(default=12, metadata={"help": "Number of attention heads for each attention layer."})
+    n_inner: Optional[int] = field(default=None, metadata={"help": "Dimensionality of the inner feed-forward layers."})
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    sanity: bool = field(
+        default=False, metadata={"help": "Only use fraction of the dataset"}
+    )
+    dataset_name: Optional[str] = field(
+        default=None, metadata={"help": "The name of the dataset to use (via the datasets library)."}
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
+    )
+    train_file: Optional[str] = field(default=None, metadata={"help": "The input training data file (a text file)."})
+    validation_file: Optional[str] = field(
+        default=None,
+        metadata={"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."},
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of training examples to this "
+            "value if set."
+        },
+    )
+    max_val_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of validation examples to this "
+            "value if set."
+        },
+    )
+
+    block_size: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "Optional input sequence length after tokenization. "
+            "The training dataset will be truncated in block of this size for training. "
+            "Default to the model max input length for single sentence inputs (take into account special tokens)."
+        },
+    )
+    overwrite_cache: bool = field(
+        default=False, metadata={"help": "Overwrite the cached training and evaluation sets"}
+    )
+    validation_split_percentage: Optional[int] = field(
+        default=5,
+        metadata={
+            "help": "The percentage of the train set used as validation set in case there's no validation split"
+        },
+    )
+    preprocessing_num_workers: Optional[int] = field(
+        default=None,
+        metadata={"help": "The number of processes to use for the preprocessing."},
+    )
+
+    def __post_init__(self):
+        if self.dataset_name is None and self.train_file is None and self.validation_file is None:
+            raise ValueError("Need either a dataset name or a training/validation file.")
+        else:
+            if self.train_file is not None:
+                extension = self.train_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`train_file` should be a csv, a json or a txt file."
+            if self.validation_file is not None:
+                extension = self.validation_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`validation_file` should be a csv, a json or a txt file."
+
+
+def main():
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments, ConfigArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args, config_args = parser.parse_json_file(
+            json_file=os.path.abspath(sys.argv[1])
+        )
+    else:
+        model_args, data_args, training_args, config_args = parser.parse_args_into_dataclasses()
+
+    # Detecting last checkpoint.
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif last_checkpoint is not None:
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s -   %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        + f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+        transformers.utils.logging.enable_default_handler()
+        transformers.utils.logging.enable_explicit_format()
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below)
+    # or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/
+    # (the dataset will be downloaded automatically from the datasets Hub).
+    #
+    # For CSV/JSON files, this script will use the column called 'text' or the first column if no column called
+    # 'text' is found. You can easily tweak this behavior (see below).
+    #
+    # In distributed training, the load_dataset function guarantee that only one local process can concurrently
+    # download the dataset.
+    if data_args.dataset_name is not None:
+        # Downloading and loading a dataset from the hub.
+        datasets = load_dataset(data_args.dataset_name, data_args.dataset_config_name, keep_in_memory=False, cache_dir=model_args.cache_dir)
+        if "validation" not in datasets.keys():
+            datasets["validation"] = load_dataset(
+                data_args.dataset_name,
+                data_args.dataset_config_name,
+                split=f"train[:{data_args.validation_split_percentage}%]",
+                keep_in_memory=False,
+                cache_dir=model_args.cache_dir
+            )
+            datasets["train"] = load_dataset(
+                data_args.dataset_name,
+                data_args.dataset_config_name,
+                split=f"train[{data_args.validation_split_percentage}%:]",
+                keep_in_memory=False,
+                cache_dir=model_args.cache_dir
+            )
+    else:
+        data_files = {}
+        if data_args.train_file is not None:
+            data_files["train"] = data_args.train_file
+        if data_args.validation_file is not None:
+            data_files["validation"] = data_args.validation_file
+        extension = (
+            data_args.train_file.split(".")[-1]
+            if data_args.train_file is not None
+            else data_args.validation_file.split(".")[-1]
+        )
+        if extension == "txt":
+            extension = "text"
+        datasets = load_dataset(extension, data_files=data_files, keep_in_memory=False, cache_dir=model_args.cache_dir)
+    if data_args.sanity:
+        datasets["train"] = datasets["train"].shard(100, index=0, contiguous=True)
+    # See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at
+    # https://huggingface.co/docs/datasets/loading_datasets.html.
+
+    # Load pretrained model and tokenizer
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    # download model & vocab.
+
+    config_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.config_name:
+        config = AutoConfig.from_pretrained(model_args.config_name, **config_kwargs)
+    elif model_args.model_name_or_path:
+        config = AutoConfig.from_pretrained(model_args.model_name_or_path, **config_kwargs)
+    else:
+        config = CONFIG_MAPPING[model_args.model_type](**vars(config_args), **config_kwargs)
+        logger.warning("You are instantiating a new config instance from scratch.")
+
+    tokenizer_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "use_fast": model_args.use_fast_tokenizer,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.tokenizer_name, **tokenizer_kwargs)
+    elif model_args.model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, **tokenizer_kwargs)
+    else:
+        raise ValueError(
+            "You are instantiating a new tokenizer from scratch. This is not supported by this script."
+            "You can do it from another script, save it, and load it from here, using --tokenizer_name."
+        )
+
+    if model_args.model_name_or_path:
+        model = AutoModelForSeq2SeqLM.from_pretrained(
+            model_args.model_name_or_path,
+            from_tf=bool(".ckpt" in model_args.model_name_or_path),
+            config=config,
+            cache_dir=model_args.cache_dir,
+            revision=model_args.model_revision,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+    else:
+        logger.info("Training new model from scratch")
+        model = AutoModelForSeq2SeqLM.from_config(config)
+
+    model.resize_token_embeddings(len(tokenizer))
+
+    # Preprocessing the datasets.
+    # First we tokenize all the texts.
+    if training_args.do_train:
+        column_names = datasets["train"].column_names
+    else:
+        column_names = datasets["validation"].column_names
+    text_column_name = "text" if "text" in column_names else column_names[0]
+
+    # since this will be pickled to avoid _LazyModule error in Hasher force logger loading before tokenize_function
+    tok_logger = transformers.utils.logging.get_logger("transformers.tokenization_utils_base")
+
+    datasets = datasets.shuffle()
+    def tokenize_function(examples):
+        with CaptureLogger(tok_logger) as cl:
+            output = tokenizer(examples[text_column_name])
+        # clm input could be much much longer than block_size
+        if "Token indices sequence length is longer than the" in cl.out:
+            tok_logger.warning(
+                "^^^^^^^^^^^^^^^^ Please ignore the warning above - this long input will be chunked into smaller bits before being passed to the model."
+            )
+        return output
+
+    # Ensures only the main process does dataset pre-processing; the other ones will load the `map` cache
+    if not is_main_process(training_args.local_rank):
+        print("waiting for main process to execute mapping")
+        torch.distributed.barrier()
+
+    logger.info("Mapping dataset to tokenized dataset.",)
+    tokenized_datasets = datasets.map(
+        tokenize_function,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        remove_columns=column_names,
+        load_from_cache_file=not data_args.overwrite_cache,
+        keep_in_memory=False
+    )
+
+    if data_args.block_size is None:
+        block_size = tokenizer.model_max_length
+        if block_size > 1024:
+            logger.warning(
+                f"The tokenizer picked seems to have a very large `model_max_length` ({tokenizer.model_max_length}). "
+                "Picking 1024 instead. You can change that default value by passing --block_size xxx."
+            )
+            block_size = 1024
+    else:
+        if data_args.block_size > tokenizer.model_max_length:
+            logger.warning(
+                f"The block_size passed ({data_args.block_size}) is larger than the maximum length for the model"
+                f"({tokenizer.model_max_length}). Using block_size={tokenizer.model_max_length}."
+            )
+        block_size = min(data_args.block_size, tokenizer.model_max_length)
+
+    # Main data processing function that will concatenate all texts from our dataset and generate chunks of block_size.
+    def group_texts(examples):
+        # Concatenate all texts.
+        concatenated_examples = {k: sum(examples[k], []) for k in examples.keys()}
+        total_length = len(concatenated_examples[list(examples.keys())[0]])
+        # We drop the small remainder, we could add padding if the model supported it instead of this drop, you can
+        # customize this part to your needs.
+        total_length = (total_length // (2 * block_size)) * 2 * block_size
+        # Split by chunks of max_len.
+        result = {
+            k: [t[i : i + block_size] for i in range(0, total_length, 2*block_size)]
+            for k, t in concatenated_examples.items()
+        }
+        result["labels"] = [
+            concatenated_examples['input_ids'][i : i + block_size]
+            for i in range(block_size, total_length, 2*block_size)
+        ]
+        return result
+
+    # Note that with `batched=True`, this map processes 1,000 texts together, so group_texts throws away a remainder
+    # for each of those groups of 1,000 texts. You can adjust that batch_size here but a higher value might be slower
+    # to preprocess.
+    #
+    # To speed up this part, we use multiprocessing. See the documentation of the map method for more information:
+    # https://huggingface.co/docs/datasets/package_reference/main_classes.html#datasets.Dataset.map
+
+    logger.info("Chunking tokenized dataset.")
+    lm_datasets = tokenized_datasets.map(
+        group_texts,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        load_from_cache_file=not data_args.overwrite_cache,
+        keep_in_memory=False
+    )
+
+    # Now the other ones can catch up.
+    if training_args.local_rank != -1 and is_main_process(training_args.local_rank):
+        print("loading results from main process")
+        torch.distributed.barrier()
+
+    if training_args.do_train:
+        if "train" not in tokenized_datasets:
+            raise ValueError("--do_train requires a train dataset")
+        train_dataset = lm_datasets["train"]
+        if data_args.max_train_samples is not None:
+            train_dataset = train_dataset.select(range(data_args.max_train_samples))
+
+    if training_args.do_eval:
+        if "validation" not in tokenized_datasets:
+            cutoff = data_args.validation_split_percentage * len(lm_datasets["train"]) // 100
+            train_dataset = lm_datasets["train"].select(range(cutoff, len(lm_datasets["train"])))
+            eval_dataset = lm_datasets["train"].select(range(cutoff))
+        else:
+            eval_dataset = lm_datasets["validation"]
+        if data_args.max_val_samples is not None:
+            eval_dataset = eval_dataset.select(range(data_args.max_val_samples))
+
+
+    # Initialize our Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset if training_args.do_train else None,
+        eval_dataset=eval_dataset if training_args.do_eval else None,
+        tokenizer=tokenizer,
+        # Data collator will default to DataCollatorWithPadding, so we change it.
+        data_collator=default_data_collator,
+        callbacks=[LogFlosCallback, TensorBoardFloIndexedCallback]
+    )
+
+    # Training
+    if training_args.do_train:
+        checkpoint = None
+        if training_args.resume_from_checkpoint is not None:
+            checkpoint = training_args.resume_from_checkpoint
+        elif last_checkpoint is not None:
+            checkpoint = last_checkpoint
+
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the tokenizer too for easy upload
+
+        metrics = train_result.metrics
+
+        max_train_samples = (
+            data_args.max_train_samples if data_args.max_train_samples is not None else len(train_dataset)
+        )
+        metrics["train_samples"] = min(max_train_samples, len(train_dataset))
+
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # Evaluation
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+
+        metrics = trainer.evaluate()
+
+        max_val_samples = data_args.max_val_samples if data_args.max_val_samples is not None else len(eval_dataset)
+        metrics["eval_samples"] = min(max_val_samples, len(eval_dataset))
+        perplexity = math.exp(metrics["eval_loss"])
+        metrics["perplexity"] = perplexity
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+
+def _mp_fn(index):
+    # For xla_spawn (TPUs)
+    main()
+
+
+if __name__ == "__main__":
+    main()

bigscience/jz/slurm/README.md

@@ -0,0 +1,861 @@
+# SLURM How To
+
+
+## Partitions
+
+All types of nodes have 40 CPU cores per node, unless specified differently.
+
+GPU-nodes: `--account=six@gpu`
+
+- `-p gpu_p1`: 4x v100-32GB
+- `-p gpu_p2`: 8x v100-32GB
+- `-p gpu_p3`: 4x v100-16GB
+- `-p gpu_p4`: 8x A100-40GB / 48 CPU cores (only 3 nodes)
+- `-p prepost`: 1x V100-16GB + network
+
+Combos:
+
+- `-p gpu_p13` - all 4x nodes combined - i.e. when either 16GB or 32GB will do
+
+CPU-only nodes: `--account=six@cpu`
+
+- `-p cpu_p1`:  up to 100h: this is the default partition for `--account=six@cpu`
+only 20h by default, add `--qos=qos_cpu-t4` to use 100h (only available if no more than 4 nodes are used).
+
+**Important: having `#SBATCH --gres=gpu:0` in a slurm file forces gpu allocations as well, ignoring the account specification. So remove those**
+
+The following CPU-only partitions time on which isn't deducted from allocation:
+
+- `-p prepost`: up to 20h - for pre/post-processing + has internet!
+- `-p visu`:    up to 4h  - for visualization
+- `-p archive`: up to 20h - for archiving
+- `-p compil`:  up to 20h - for compilation + has internet!
+
+
+**Constraints**:
+
+- `-C v100-16g` # to select nodes having v100 GPUs with 16 GB of memory (same as `-p gpu_p3`)
+- `-C v100-32g` # to select nodes having v100 GPUs with 32 GB of memory (same as `-p gpu_p1`)
+
+If your job can run on both types of GPUs, we recommend not to specify any constraints as it will reduce the waiting time of your jobs before resources are available for the execution.
+
+Special reservation constraint - if a special reservation is made, e.g., `huggingface1`, activate it with: `--reservation=huggingface1`.
+
+**Long running jobs**:
+
+Normal GPU jobs can do max `--time=20:00:00`, for longer jobs up to 100h use `--qos=qos_gpu-t4`. Limit 16 GPUs.
+
+Note: the given node could be already heavily used by any other random users.
+
+Normal CPU jobs can do max `--time=100:00:00` (only `-p cpu_p1`, other partitions 20h)
+
+Full details per parition type
+
+- CPU: http://www.idris.fr/eng/jean-zay/cpu/jean-zay-cpu-exec_partition_slurm-eng.html and
+http://www.idris.fr/eng/jean-zay/cpu/jean-zay-cpu-exec_alloc-mem-eng.html
+- GPU: http://www.idris.fr/eng/jean-zay/gpu/jean-zay-gpu-exec_partition_slurm-eng.html
+
+
+To see all available partitions and their total/idle status:
+
+```
+sinfo
+```
+
+## Priorities
+
+- `--qos=qos_gpu-t3` 20h / 512gpus (default priority)
+- `--qos=qos_gpu-t4` 100h / 16gpus - long runnning slow jobs - e.g. preprocessing
+- `--qos=qos_gpu-dev`  2h / 32gpus - this is for getting allocation much faster - for dev work!
+
+
+Full info: http://www.idris.fr/eng/jean-zay/gpu/jean-zay-gpu-exec_partition_slurm-eng.html
+
+
+**Important**: when running non-primary training jobs please use: `--nice=10000` in the slurm instructions to allow the main job to get highest priority. But only if you're using  `-C v100-32g` (`-p gpu_p1`). For other type of nodes there is no need to.
+
+Detailed explanation: using `--nice=10000` for the test jobs should work fine as long as you use the same QoS as the production jobs (`qos_gpu-t3`, if you use the `qos_gpu-dev` partition then the test jobs will always have higher priority). The nice value is chosen so that it always cancels the age factor, since the fairshare is common to all your jobs it should be enough to ensure that jobs with `--nice=10000` always have a lower priority than your other jobs with the same QoS. Since the age factor is only 3% of the priority, it should hurt the priority too much compared to other users. (edited)
+
+
+**How the job priority is computed**
+
+Currently on Jean Zay:
+
+1. 69.4% of the priority depends directly on the chosen QoS
+2. 27.8% is the "fairshare" (see `idr_compuse` for the value)
+3. and only 2.8% is the job age in queue
+
+
+
+## Consumption report
+
+
+Run:
+```
+idr_compuse
+```
+
+This provides a report on how heavily we use our allocations. When they are over-consumed we get a lower priority in the scheduler.
+
+
+## Wait time for resource granting
+
+```
+squeue -u `whoami` --start
+```
+will show when any pending jobs are scheduled to start.
+
+They may start sooner if others cancel their reservations before the end of the reservation.
+
+
+
+## Request allocation via dependency
+
+To schedule a new job when one more of the currently scheduled job ends (regardless of whether it still running or not started yet), use the dependency mechanism, by telling `sbatch` to start the new job once the currently running job succeeds, using:
+
+```
+sbatch --dependency=CURRENTLY_RUNNING_JOB_ID tr1-13B-round1.slurm
+```
+
+Using `--dependency` may lead to shorter wait times that using `--begin`, since if the time passed to `--begin` allows even for a few minutes of delay since the stopping of the last job, the scheduler may already start some other jobs even if their priority is lower than our job. That's because the scheduler ignores any jobs with `--begin` until the specified time arrives.
+
+
+## Make allocations at a scheduled time
+
+To postpone making the allocation for a given time, use:
+```
+salloc --begin HH:MM MM/DD/YY
+```
+
+Same for `sbatch`.
+
+It will simply put the job into the queue at the requested time, as if you were to execute this command at this time. If resources are available at that time, the allocation will be given right away. Otherwise it'll be queued up.
+
+Sometimes the relative begin time is useful. And other formats can be used. Examples:
+
+```
+--begin now+2hours
+--begin=16:00
+--begin=now+1hour
+--begin=now+60  # seconds by default
+--begin=2010-01-20T12:34:00
+```
+
+the time-units can be `seconds` (default), `minutes`, `hours`, `days`, or `weeks`:
+
+## Preallocated node without time 60min limit
+
+This is very useful for running repetitive interactive experiments - so one doesn't need to wait for an allocation to progress. so the strategy is to allocate the resources once for an extended period of time and then running interactive `srun` jobs using this allocation.
+
+set `--time` to the desired window (e.g. 6h):
+```
+salloc --account=six@gpu --nodes=1 --ntasks-per-node=1 --cpus-per-task=40 --gres=gpu:4 --hint=nomultithread --time=6:00:00 bash
+salloc: Pending job allocation 1732778
+salloc: job 1732778 queued and waiting for resources
+salloc: job 1732778 has been allocated resources
+salloc: Granted job allocation 1732778
+```
+now use this reserved node to run a job multiple times, by passing the job id of `salloc`:
+```
+srun --jobid $SLURM_JOBID --pty bash --rcfile $six_ALL_CCFRWORK/start-prod
+```
+if run from inside `bash` started via `salloc`. But it can be started from another shell, but then explicitly set `--jobid`.
+
+if this `srun` job timed out or manually exited, you can re-start it again in this same reserved node.
+
+`srun` can, of course, call the real training command directly and not just `bash`.
+
+Important: when allocating a single node, the allocated shell is not on the node (it never is). You have to find out the hostname of the node (reports when giving the allocation or via `squeue` and `ssh` to it.
+
+When finished, to release the resources, either exit the shell started in `salloc` or `scancel JOBID`.
+
+This reserved node will be counted towards hours usage the whole time it's allocated, so release as soon as done with it.
+
+To get just the CPUs instances :
+
+```
+salloc --account=six@cpu --nodes=1 --ntasks=1 --cpus-per-task=10 --hint=nomultithread --time=6:00:00 bash
+```
+edit `--cpus-per-task` if more cpu cores are needed.
+
+Actually, if this is just one node, then it's even easier to not use `salloc` but to use `srun` in the first place, which will both allocate and give you the shell to use:
+```
+srun  --account=six@gpu  --pty --nodes=1 --ntasks=1 --cpus-per-task=40 --gres=gpu:4 --hint=nomultithread --time=60 bash --rcfile $six_ALL_CCFRWORK/start-prod
+```
+
+And to use a cpu-only node:
+```
+srun --account=six@cpu --pty --nodes=1 --ntasks=1 --cpus-per-task=40 --hint=nomultithread --time=6:00:00 bash --rcfile $six_ALL_CCFRWORK/start-prod
+```
+The `--rcfile` part is optional if you want to pre-run something.
+
+
+With A100s, it's:
+
+w/o gpus:
+```
+srun --pty --partition=gpu_p5 --constraint=a100 --nodes=1 --ntasks-per-node=1 --cpus-per-task=64 --hint=nomultithread --gres=gpu:0 --time=6:00:00 --account=six@a100 bash --rcfile $six_ALL_CCFRWORK/start-prod
+```
+w/ gpus:
+```
+srun --pty --partition=gpu_p5 --constraint=a100 --nodes=1 --ntasks-per-node=1 --cpus-per-task=64 --hint=nomultithread --gres=gpu:8 --time=6:00:00 --account=six@a100 bash --rcfile $six_ALL_CCFRWORK/start-prod
+```
+
+
+## Re-use allocation
+
+e.g. when wanting to run various jobs on identical node allocation.
+
+In one shell:
+```
+salloc --account=six@gpu --constraint=v100-32g --nodes=16 --ntasks=16 --cpus-per-task=40 --gres=gpu:4 --hint=nomultithread --time=3:00:00 bash --rcfile $six_ALL_CCFRWORK/start-prod
+echo $SLURM_JOBID
+```
+
+In another shell:
+```
+export SLURM_JOBID=<JOB ID FROM ABOVE>
+srun --jobid=$SLURM_JOBID ...
+```
+
+You may need to set `--gres=gpu:0` to run some diagnostics job on the nodes. For example, let's check shared memory of all the hosts:
+```
+srun --jobid 631078 --gres=gpu:0 bash -c 'echo $(hostname) $(df -h | grep shm)'
+```
+
+## Signal the running jobs to finish
+
+Since each SLURM run has a limited time span, it can be configured to send a signal of choice to the program a desired amount of time before the end of the allocated time.
+```
+--signal=[[R][B]:]<sig_num>[@<sig_time>]
+```
+TODO: need to experiment with this to help training finish gracefully and not start a new cycle after saving the last checkpoint.
+
+
+
+## Detailed job info
+
+While most useful information is preset in various `SLURM_*` env vars, sometimes the info is missing. In such cases use:
+```
+scontrol show -d job $SLURM_JOB_ID
+```
+and then parse out what's needed.
+
+
+For a job that finished its run use:
+```
+sacct -j JOBID
+```
+
+e.g. with more details, depending on the partition:
+```
+sacct -u `whoami` -A six@a100 -ojobid,start,end,state,exitcode --format nodelist%300  -j JOBID
+sacct -u `whoami` -A six@gpu -ojobid,start,end,state,exitcode --format nodelist%300  -j JOBID
+```
+
+
+
+## show my jobs
+
+```
+squeue -u `whoami`
+```
+
+
+by job id:
+```
+squeue -j JOBID
+```
+
+group's jobs (probably won't include the non-account partitions), including all users is probably better
+
+```
+squeue --account=six@gpu,six@cpu
+```
+
+group's jobs including all `six`'s users:
+
+```
+squeue --user=$(getent group six | cut -d: -f4)
+
+```
+
+## Aliases
+
+Handy aliases
+
+```
+alias myjobs="squeue -u `whoami`"
+alias groupjobs="squeue --user=$(getent group six | cut -d: -f4)"
+alias myjobs-pending="squeue -u `whoami` --start"
+alias idle-nodes="sinfo -p gpu_p13 -o '%A'"
+```
+
+more informative all-in-one myjobs that includes the projected start time for pending jobs and requested time limit:
+
+```
+alias myjobs='squeue -u `whoami` -o "%.16i %.9P %.26j %.8T %.10M %.8l %.6D %.20S %R"'
+alias groupjobs='squeue -u $(getent group six | cut -d: -f4) -o "%.16i %u %.9P %.26j %.8T %.10M %.8l %.6D %.20S %R"'
+```
+
+
+
+## Zombies
+
+If there are any zombies left behind across nodes, send one command to kill them all.
+
+```
+srun pkill python
+```
+
+## Detailed Access to SLURM Accounting
+
+`sacct` displays accounting data for all jobs and job steps in the Slurm job accounting log or Slurm database.
+
+So this is a great tool for analysing past events.
+
+For example, to see which nodes were used to run recent gpu jobs:
+
+```
+sacct -u `whoami` -A six@gpu -ojobid,start,end,state,exitcode --format nodelist%300
+```
+
+`%300` here tells it to use a 300 char width for the output, so that it's not truncated.
+
+See `man sacct` for more fields and info fields.
+
+
+
+## Queue
+
+
+### Cancel job
+
+To cancel a job:
+```
+scancel [jobid]
+```
+
+To cancel all of your jobs:
+```
+scancel -u <userid>
+```
+
+To cancel all of your jobs on a specific partition:
+```
+scancel -u <userid> -p <partition>
+```
+
+### Tips
+
+- if you see that `salloc`'ed interactive job is scheduled to run much later than you need, try to cancel the job and ask for shorter period - often there might be a closer window for a shorter time allocation.
+
+
+## Logging
+
+If we need to separate logs to different log files per node add `%N` (for short hostname) so that we have:
+
+```
+#SBATCH --output=%x-%j-%N.out
+```
+
+That way we can tell if a specific node misbehaves - e.g. has a corrupt GPU. This is because currently pytorch doesn't log which node / gpu rank triggered an exception.
+
+Hoping it'll be a built-in feature of pytorch https://github.com/pytorch/pytorch/issues/63174 and then one won't need to make things complicated on the logging side.
+
+
+## Show the state of nodes
+```
+sinfo -p PARTITION
+```
+
+Very useful command is:
+```
+sinfo -s
+```
+
+and look for the main stat, e.g.:
+
+```
+NODES(A/I/O/T) "allocated/idle/other/total".
+597/0/15/612
+```
+So here 597 out of 612 nodes are allocated. 0 idle and 15 are not available for whatever other reasons.
+
+```
+sinfo -p gpu_p1 -o "%A"
+```
+
+gives:
+```
+NODES(A/I)
+236/24
+```
+
+so you can see if any nodes are available on the 4x v100-32g partition (`gpu_p1`)
+
+To check each specific partition:
+
+```
+sinfo -p gpu_p1 -o "%A"
+sinfo -p gpu_p2 -o "%A"
+sinfo -p gpu_p3 -o "%A"
+sinfo -p gpu_p13 -o "%A"
+```
+
+See the table at the top of this document for which partition is which.
+
+
+## Job arrays
+
+
+To run a sequence of jobs, so that the next slurm job is scheduled as soon as the currently running one is over in 20h we use a job array.
+
+Let's start with just 10 such jobs:
+
+```
+sbatch --array=1-10%1 array-test.slurm
+```
+
+`%1` limits the number of simultaneously running tasks from this job array to 1. Without it it will try to run all the jobs at once, which we may want sometimes (in which case remove %1), but when training we need one job at a time.
+
+Alternatively, as always this param can be part of the script:
+```
+#SBATCH --array=1-10%1
+```
+
+Here is toy slurm script, which can be used to see how it works:
+
+```
+#!/bin/bash
+#SBATCH --job-name=array-test
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=1            # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time 00:02:00              # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --error=%x-%j.out            # error file name (same to watch just one file)
+#SBATCH --account=six@cpu
+#SBATCH -p prepost
+
+echo $SLURM_JOB_ID
+echo "I am job ${SLURM_ARRAY_JOB_ID}_${SLURM_ARRAY_TASK_ID}"
+date
+sleep 10
+date
+```
+
+Note `$SLURM_ARRAY_JOB_ID` is the same as `$SLURM_JOB_ID`, and `$SLURM_ARRAY_TASK_ID` is the index of the job.
+
+To see the jobs running:
+```
+$ squeue -u `whoami` -o "%.10i %.9P %.26j %.8T %.10M %.6D %.20S %R"
+     JOBID PARTITION                       NAME    STATE       TIME  NODES           START_TIME NODELIST(REASON)
+591970_[2-   prepost                 array-test  PENDING       0:00      1  2021-07-28T20:01:06 (JobArrayTaskLimit)
+```
+now job 2 is running.
+
+To cancel the whole array, cancel the job id as normal (the number before `_`):
+```
+scancel 591970
+```
+
+To cancel a specific job:
+```
+scancel 591970_2
+```
+
+If it's important to have the log-file contain the array id, add `%A_%a`:
+
+```
+#SBATCH --output=%x-%j.%A_%a.log
+```
+
+More details https://slurm.schedmd.com/job_array.html
+
+
+## Job Array Trains and their Suspend and Release
+
+In this recipe we accomplish 2 things:
+
+1. Allow modification to the next job's slurm script
+2. Allow suspending and resuming job arrays w/o losing the place in the queue when not being ready to continue running a job
+
+SLURM is a very unforgiving environment where a small mistake can cost days of waiting time. But there are strategies to mitigate some of this harshness.
+
+SLURM jobs have a concept of "age" in the queue which besides project priority governs when a job gets scheduled to run. If your have just scheduled a new job it has no "age" and will normally be put to run last compared to jobs that have entered the queue earlier. Unless of course this new job comes from a high priority project in which case it'll progress faster.
+
+So here is how one can keep the "age" and not lose it when needing to fix something in the running script or for example to switch over to another script.
+
+The idea is this:
+
+1. `sbatch` a long job array, e.g., `-array=1-50%1`
+2. inside the slurm script don't have any code other than `source another-script.slurm` - so now you can modify the target script or symlink to another script before the next job starts
+3. if you need to stop the job array train - don't cancel it, but suspend it without losing your place in a queue
+4. when ready to continue - unsuspend the job array - only the time while it was suspended is not counted towards its age, but all the previous age is retained.
+
+The only limitation of this recipe is that you can't change the number of nodes, time and hardware and partition constraints once the job array was launched.
+
+Here is an example:
+
+Create a job script:
+
+```
+$ cat train-64n.slurm
+#!/bin/bash
+#SBATCH --job-name=tr8-104B
+#SBATCH --constraint=v100-32g
+#SBATCH --nodes=64
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:4                 # number of gpus
+#SBATCH --time 20:00:00              # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@gpu
+
+source tr8-104B-64.slurm
+```
+Start it as:
+```
+sbatch --array=1-50%1 train-64.slurm
+```
+
+Now you can easily edit `tr8-104B-64.slurm` before the next job run and either let the current job finish if it's desired or if you need to abort it, just kill the currently running job, e.g. `1557903_5` (not job array `1557903`) and have the train pick up where it left, but with the edited script.
+
+The nice thing is that this requires no changes to the original script (`tr8-104B-64.slurm` in this example), and the latter can still be started on its own.
+
+Now, what if something is wrong and you need 10min or 10h to fix something. In this case we suspend the train using:
+
+```
+scontrol hold <jobid>
+```
+
+with <jobid> being either a "normal" job, the id of a job array or the id for a job array step
+
+and then when ready to continue release the job:
+
+```
+scontrol release <jobid>
+```
+
+
+## Troubleshooting
+
+
+### Kill Switch
+
+Since SLURM doesn't allow one user to kill another user's SLURM job or cancel a job array, we need a way to be able to have the program abort itself quickly in situations where one user started a job and has gone away and the group needs to restart it. For example, this is needed when a model gets started by someone in North America, and while they are asleep, someone in Europe may need to handle a problem with the training and can't wait for the submitter of the job to wake up.
+
+So we had a kill-switch feature implemented in Megatron-Deepspeed. When a file gets created at a pre-determined location, the software will stop its run. Instead of trying to implement a complex thread that will run only one of the dozens of nodes, we simply added a check in 2 strategic locations:
+
+1. startup - to deal with job arrays
+2. before each iteration of the train loop - to deal with the current run
+
+Since multiple jobs use the same Megatron-Deepspeed repo clone this kill switch can't be hardcoded, and thus each job needs to "arm" the kill switch and must use a unique path so that unintentionally other instances won't get killed.
+
+To arm:
+
+```
+python pretrain_gpt.py ... --kill-switch-path /tmp/kill-switch-tr11-200B-exp1
+```
+
+To trigger:
+```
+touch /tmp/kill-switch-tr11-200B-exp1
+```
+
+To deactivate and let new instances of a job run normally:
+
+```
+rm  /tmp/kill-switch-tr11-200B-exp1
+```
+
+### Mismatching nodes number
+
+If the pytorch launcher fails it often means that the number of SLURM nodes and the launcher nodes are mismatching, e.g.:
+
+```
+grep -ir nodes= tr123-test.slurm
+#SBATCH --nodes=40
+NNODES=64
+```
+
+This won't work. They have to match.
+
+You can add a sanity check to your script:
+
+```
+#!/bin/bash
+#SBATCH --job-name=test-mismatch
+#SBATCH --constraint=v100-16g
+#SBATCH --nodes=2
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:4                 # number of gpus
+#SBATCH --time 0:05:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@gpu
+
+[...]
+
+NNODES=2
+
+# sanity check for having NNODES and `#SBATCH --nodes` match, assuming you use NNODES variable
+if [ "$NNODES" != "$SLURM_NNODES" ]; then
+    echo "Misconfigured script: NNODES=$NNODES != SLURM_NNODES=$SLURM_NNODES"
+    exit 1
+fi
+
+[...]
+```
+
+or you could just do:
+
+```bash
+#SBATCH --nodes=2
+[...]
+NNODES=$SLURM_NNODES
+```
+
+and then it will always be correct
+
+
+
+### Find faulty nodes and exclude them
+
+Sometimes a node is broken, which prevents one from training, especially since restarting the job often hits the same set of nodes. So one needs to be able to isolate the bad node(s) and exclude it from `sbatch`.
+
+To find a faulty node, write a small script that reports back the status of the desired check.
+
+For example to test if cuda is available on all nodes:
+```
+python -c 'import torch, socket; print(f"{socket.gethostname()}: {torch.cuda.is_available()}")'
+```
+
+and to only report the nodes that fail:
+```
+python -c 'import torch, socket; torch.cuda.is_available() or print(f"Broken node: {socket.gethostname()}") '
+```
+
+Of course, the issue could be different - e.g. gpu can't allocate memory, so change the test script to do a small allocation on cuda. Here is one way:
+
+```
+python -c "import torch; torch.ones(1000,1000).cuda()"
+```
+
+But since we need to run the test script on all nodes and not just the first node, the slurm script needs to run it via `srun`. So our first diagnostics script can be written as:
+
+```
+srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+```
+
+I slightly changed it, due to an issue with quotes.
+
+You can always convert the one liner into a real script and then there is no issue with quotes.
+
+```
+$ cat << EOT >> test-nodes.py
+#!/usr/bin/env python
+import torch, socket
+print(socket.gethostname(), torch.cuda.is_available())
+EOT
+$ chmod a+x ./test-nodes.py
+```
+
+Now let's create a driver slurm script. Use a few minutes time for this test so that SLURM yields it faster:
+```
+#!/bin/bash
+#SBATCH --job-name=test-nodes
+#SBATCH --partition=gpu_p13
+#SBATCH --nodes=4
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:4                 # number of gpus
+#SBATCH --time 0:05:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@gpu
+
+source $six_ALL_CCFRWORK/start-prod
+srun --jobid $SLURM_JOBID ./test-nodes.py
+```
+Once it runs check the logs to see if any reported `False`, those are the nodes you want to exclude.
+
+Now once the faulty node(s) is found, feed it to `sbatch`:
+```
+sbatch --exclude=hostname1,hostname2 ...
+```
+and `sbatch` will exclude the bad nodes from the allocation.
+
+Additionally please report the faulty nodes to `[email protected]` so that they reboot the machine.
+
+Here are a few more situations and how to find the bad nodes in those cases:
+
+### Broken NCCL
+
+If you're testing something that requires distributed setup, it's a bit more complex. Here is a slurm script that tests that NCCL works. It sets up NCCL and checks that barrier works:
+
+```
+#!/bin/bash
+#SBATCH --job-name=test-nodes-nccl
+#SBATCH --partition=gpu_p13
+#SBATCH --nodes=2
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:4                 # number of gpus
+#SBATCH --time 0:05:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@gpu
+
+source $six_ALL_CCFRWORK/start-prod
+
+NNODES=2
+
+GPUS_PER_NODE=4
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6000
+
+export LAUNCHER="python -u -m torch.distributed.launch \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --master_addr $MASTER_ADDR \
+    --master_port $MASTER_PORT \
+    "
+
+export SCRIPT=test-nodes-nccl.py
+
+cat << EOT > $SCRIPT
+#!/usr/bin/env python
+import torch.distributed as dist
+import torch
+import socket
+import os
+import fcntl
+
+def printflock(*msgs):
+    """ print """
+    with open(__file__, "r") as fh:
+        fcntl.flock(fh, fcntl.LOCK_EX)
+        try:
+            print(*msgs)
+        finally:
+            fcntl.flock(fh, fcntl.LOCK_UN)
+
+local_rank = int(os.environ["LOCAL_RANK"])
+torch.cuda.set_device(local_rank)
+dist.init_process_group("nccl")
+header = f"{socket.gethostname()}-{local_rank}"
+try:
+    dist.barrier()
+    printflock(f"{header}: NCCL {torch.cuda.nccl.version()} is OK")
+except:
+    printflock(f"{header}: NCCL {torch.cuda.nccl.version()} is broken")
+    raise
+EOT
+
+echo $LAUNCHER --node_rank $SLURM_PROCID $SCRIPT
+
+srun --jobid $SLURM_JOBID bash -c '$LAUNCHER --node_rank $SLURM_PROCID $SCRIPT'
+```
+The script uses `printflock` to solve the interleaved print outputs issue.
+
+
+### GPU Memory Check
+
+
+This tests if each GPU on the allocated nodes can successfully allocate 77Gb (e.g. to test 80GB A100s) (have to subtract a few GBs for cuda kernels).
+
+
+```python
+import torch, os
+import time
+import socket
+hostname = socket.gethostname()
+
+local_rank = int(os.environ["LOCAL_RANK"]);
+
+gbs = 77
+try:
+    torch.ones((gbs*2**28)).cuda(local_rank).contiguous() # alloc on cpu, then move to gpu
+    print(f"{local_rank} {hostname} is OK")
+except:
+    print(f"{local_rank} {hostname} failed to allocate {gbs}GB DRAM")
+    pass
+
+time.sleep(5)
+
+
+```
+
+
+### Broken Network
+
+Yet another issue with a node is when its network is broken and other nodes fail to connect to it.
+
+You're likely to experience it with an error similar to:
+```
+work = default_pg.barrier(opts=opts)
+RuntimeError: NCCL error in: /opt/conda/conda-bld/pytorch_1616554793803/work/torch/lib/c10d/ProcessGroupNCCL.cpp:825, unhandled system error, NCCL version 2.7.8
+ncclSystemError: System call (socket, malloc, munmap, etc) failed.
+```
+Here is how to debug this issue:
+
+1. Add:
+```
+export NCCL_DEBUG=INFO
+```
+before the `srun` command and re-run your slurm script.
+
+2. Now study the logs. If you find:
+```
+r11i6n2:486514:486651 [1] include/socket.h:403 NCCL WARN Connect to 10.148.3.247<56821> failed : Connection refused
+```
+Let's see which node refuses to accept connections. We get the IP address from the error above and reverse resolve it to its name:
+```
+nslookup 10.148.3.247
+247.3.148.10.in-addr.arpa       name = r10i6n5.ib0.xa.idris.fr.
+```
+
+Add `--exclude=r10i6n5` to your `sbatch` command and report it to JZ admins.
+
+
+### Run py-spy or any other monitor program across all nodes
+
+When dealing with hanging, here is how to automatically log `py-spy` traces for each process.
+
+Of course, this same process can be used to run some command for all nodes of a given job. i.e. it can be used to run something during the normal run - e.g. dump all the memory usage in each process via `nvidia-smi` or whatever other program is needed to be run.
+
+
+
+```
+cd ~/prod/code/tr8b-104B/bigscience/train/tr11-200B-ml/
+
+salloc --partition=gpu_p5 --constraint=a100 --nodes=40 --ntasks-per-node=1 --cpus-per-task=64 --hint=nomultithread --gres=gpu:8 --time 20:00:00 --account=six@a100
+
+bash 200B-n40-bf16-mono.slurm
+```
+
+In another shell get the JOBID for the above `salloc`:
+```
+squeue -u `whoami` -o "%.16i %.9P %.26j %.8T %.10M %.8l %.6D %.20S %R"
+```
+adjust jobid per above and the nodes count (XXX: probably can remove `--nodes=40` altogether and rely on `salloc` config):
+```
+srun --jobid=2180718 --gres=gpu:0 --nodes=40 --tasks-per-node=1 --output=trace-%N.out sh -c 'ps aux | grep python | egrep -v "grep|srun" | grep `whoami` | awk "{print \$2}" | xargs -I {} py-spy dump --native --pid {}' || echo "failed"
+```
+now all `py-spy` traces go into the `trace-$nodename.out` files under `cwd`.
+
+The key is to use `--gres=gpu:0` or otherwise the 2nd `srun` will block waiting for the first one to release the gpus.
+
+Also the assumption is that some conda env that has `py-spy` installed got activated in `~/.bashrc`. If yours doesn't already do that, add the instruction to load the env to the above command, before the `py-spy` command - it'll fail to find it otherwise.
+
+Don't forget to manually release the allocation when this process is done.
+
+
+## TODO
+
+absorb more goodies from here: https://ubccr.freshdesk.com/support/solutions/articles/5000686861-how-do-i-check-the-status-of-my-job-s-

bigscience/jz/slurm/hf-ds-gpt2-multi-node.slurm

@@ -0,0 +1,67 @@
+#!/bin/bash
+#SBATCH --job-name=hf_ds_gpt2_multi_node
+#SBATCH --nodes=2
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:4                 # number of gpus
+#SBATCH --time 20:00:00              # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out          # output file name
+#SBATCH --error=%x-%j.out           # error file name (same to watch just one file)
+#SBATCH --account=six@gpu
+
+GPUS_PER_NODE=4
+NNODES=$SLURM_JOB_NUM_NODES
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-prod
+
+cd $six_ALL_CCFRWORK/code/transformers
+export PYTHONPATH=$six_ALL_CCFRWORK/code/transformers
+
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=13370
+
+export LAUNCHER=" \
+    python -u -m torch.distributed.launch \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --master_addr $MASTER_ADDR \
+    --master_port $MASTER_PORT \
+    "
+
+MODEL=$six_ALL_CCFRWORK/models-custom/megatron-gpt2/megatron-gpt2-345m
+DATASET="stas/openwebtext-10k"
+
+export CMD=" \
+    `pwd`/examples/pytorch/language-modeling/run_clm.py \
+    --model_name_or_path $MODEL \
+    --dataset_name $DATASET \
+    --output_dir output_dir \
+    --overwrite_output_dir \
+    --do_train \
+    --do_eval \
+    --max_train_samples 1000 \
+    --max_eval_samples 200 \
+    --per_device_train_batch_size 4 \
+    --per_device_eval_batch_size 4 \
+    --num_train_epochs 1 \
+    --warmup_steps 8 \
+    --block_size 64 \
+    --fp16 \
+    --report_to none \
+    --deepspeed tests/deepspeed/ds_config_zero2.json \
+    "
+
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export PYTHONPATH=src
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# to debug - add echo (it exits and prints what it would have launched)
+srun bash -c '$LAUNCHER --node_rank $SLURM_PROCID $CMD'

bigscience/jz/slurm/meg-gpt2-multi-node.slurm

@@ -0,0 +1,86 @@
+#!/bin/bash
+#SBATCH --job-name=meg_gpt2_multi_node
+#SBATCH --nodes=2
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:4                 # number of gpus
+#SBATCH --time 20:00:00              # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --error=%x-%j.out            # error file name (same to watch just one file)
+#SBATCH --account=six@gpu
+
+GPUS_PER_NODE=4
+NNODES=$SLURM_JOB_NUM_NODES
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-prod
+
+cd $six_ALL_CCFRWORK/code/megatron-lm
+
+CHECKPOINT_PATH=$six_ALL_CCFRWORK/models-custom/megatron-gpt2/megatron_lm_345m_v0.0/release
+VOCAB_FILE=$CHECKPOINT_PATH/gpt2-vocab.json
+MERGE_FILE=$CHECKPOINT_PATH/gpt2-merges.txt
+DATA_PATH=$six_ALL_CCFRWORK/datasets-custom/openwebtext-10k/meg-gpt2_text_document
+SAVE_CHECKPOINT_PATH=$six_ALL_CCFRWORK/checkpoints/gpt2
+
+MASTER_ADDR=`hostname`
+MASTER_PORT=13370
+
+#    --train-iters 100000 \
+#    --lr-decay-iters 320000 \
+GPT_ARGS=" \
+    --num-layers 24 \
+    --hidden-size 1024 \
+    --num-attention-heads 16 \
+    --seq-length 1024 \
+    --max-position-embeddings 1024 \
+    --micro-batch-size 4 \
+    --global-batch-size 16 \
+    --lr 0.00015 \
+    --lr-decay-style cosine \
+    --min-lr 1.0e-5 \
+    --finetune \
+    --train-iters 1000 \
+    --lr-decay-iters 800 \
+    --lr-warmup-fraction .01 \
+    --weight-decay 1e-2 \
+    --clip-grad 1.0 \
+    --vocab-file $VOCAB_FILE \
+    --merge-file $MERGE_FILE \
+    --fp16 \
+    --checkpoint-activations \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 10 \
+    --save-interval 500 \
+    --eval-interval 100 \
+    --eval-iters 10 \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.launch \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --master_addr $MASTER_ADDR \
+    --master_port $MASTER_PORT \
+    "
+
+export CMD=" \
+    `pwd`/pretrain_gpt.py \
+    --tensor-model-parallel-size 2 \
+    --pipeline-model-parallel-size 2 \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $SAVE_CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --data-path $DATA_PATH \
+    --data-impl mmap \
+    --split 949,50,1 \
+    --distributed-backend nccl \
+    "
+
+# to debug - add echo (it exits and prints what it would have launched)
+srun bash -c '$LAUNCHER --node_rank $SLURM_PROCID $CMD'

bigscience/jz/slurm/multi-node-launcher3.slurm

@@ -0,0 +1,100 @@
+# This version I haven't quite figured out - the job hangs on the master host - probably misconfigured megatron-lm launching command
+# this script I found here https://www.glue.umd.edu/hpcc/help/software/pytorch.html
+# did some mods to it
+
+#!/bin/bash
+#SBATCH --job-name=megatron_multi_node
+#SBATCH --nodes=2
+#SBATCH --ntasks-per-node=4
+#SBATCH --hint=nomultithread
+#SBATCH --gres=gpu:4
+#SBATCH --time 00:30:00
+#SBATCH --output=%x_%j.out
+#SBATCH --output=%x-%j.out
+#SBATCH --account=six@gpu
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-prod
+
+cd $six_ALL_CCFRWORK/code/megatron-lm
+
+CHECKPOINT_PATH=$six_ALL_CCFRWORK/models-custom/megatron-gpt2/megatron_lm_345m_v0.0/release/
+VOCAB_FILE=$CHECKPOINT_PATH/gpt2-vocab.json
+MERGE_FILE=$CHECKPOINT_PATH/gpt2-merges.txt
+DATA_PATH=$six_ALL_CCFRWORK/datasets-custom/openwebtext-10k/meg-gpt2_text_document
+SAVE_CHECKPOINT_PATH=data/checkpoints
+
+GPUS_PER_NODE=4
+NNODES=2
+
+MASTER_ADDR=`/bin/hostname -s`
+SLAVES=`scontrol show hostnames $SLURM_JOB_NODELIST | grep -v $MASTER_ADDR`
+#Make sure this node (MASTER) comes first
+HOSTLIST="$MASTER_ADDR $SLAVES"
+
+MASTER_PORT=12345
+#`ss -tan | awk '{print $4}' | cut -d':' -f2 | \
+#        grep "[2-9][0-9]\{3,3\}" | grep -v "[0-9]\{5,5\}" | \
+#        sort | uniq | shuf | head -1`
+
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+
+#    --train-iters 100000 \
+#    --lr-decay-iters 320000 \
+GPT_ARGS=" \
+    --num-layers 24 \
+    --hidden-size 1024 \
+    --num-attention-heads 16 \
+    --seq-length 1024 \
+    --max-position-embeddings 1024 \
+    --micro-batch-size 4 \
+    --global-batch-size 16 \
+    --lr 0.00015 \
+    --lr-decay-style cosine \
+    --min-lr 1.0e-5 \
+    --finetune \
+    --train-iters 1000 \
+    --lr-decay-iters 800 \
+    --lr-warmup-fraction .01 \
+    --weight-decay 1e-2 \
+    --clip-grad 1.0 \
+    --vocab-file $VOCAB_FILE \
+    --merge-file $MERGE_FILE \
+    --fp16 \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 10 \
+    --save-interval 500 \
+    --eval-interval 100 \
+    --eval-iters 10 \
+    --checkpoint-activations \
+    "
+
+#Launch the pytorch processes, first on master (first in $HOSTLIST) then
+#on the slaves
+NODE_RANK=0
+for node in $HOSTLIST; do
+    ssh -q $node \
+        python -m torch.distributed.launch \
+            --nproc_per_node $GPUS_PER_NODE \
+            --nnodes $NNODES \
+            --node_rank $NODE_RANK \
+            --master_addr $MASTER_ADDR \
+            --master_port $MASTER_PORT \
+            `pwd`/pretrain_gpt.py \
+            --tensor-model-parallel-size 2 \
+            --pipeline-model-parallel-size 2 \
+            $GPT_ARGS \
+            $OUTPUT_ARGS \
+            --save $SAVE_CHECKPOINT_PATH \
+            --load $CHECKPOINT_PATH \
+            --data-path $DATA_PATH \
+            --data-impl mmap \
+            --split 949,50,1 \
+            --distributed-backend nccl
+    NODE_RANK=$((NODE_RANK+1))
+done
+wait

bigscience/jz/slurm/openwebtext-jsonl-to-meg-gpt2.slurm

@@ -0,0 +1,25 @@
+#!/bin/bash
+#SBATCH --job-name=openwebtext-jsonl-to-meg-gpt2 # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@cpu
+#SBATCH --partition=cpu_p1
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-prod
+
+cd $six_ALL_CCFRWORK/code/megatron-lm
+python tools/preprocess_data.py \
+       --input $six_ALL_CCFRWORK/datasets-custom/openwebtext/openwebtext.jsonl \
+       --output-prefix $six_ALL_CCFRWORK/datasets-custom/openwebtext/meg-gpt2 \
+       --vocab data/gpt2-vocab.json \
+       --dataset-impl mmap \
+       --tokenizer-type GPT2BPETokenizer \
+       --merge-file data/gpt2-merges.txt \
+       --append-eod \
+       --workers 8

bigscience/jz/slurm/openwebtext-jsonl-to-meg-t5.slurm

@@ -0,0 +1,24 @@
+#!/bin/bash
+#SBATCH --job-name=openwebtext-jsonl-to-meg-t5   # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@cpu
+#SBATCH --partition=cpu_p1
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-prod
+
+cd $six_ALL_CCFRWORK/code/megatron-lm
+python tools/preprocess_data.py \
+       --input $six_ALL_CCFRWORK/datasets-custom/openwebtext/openwebtext.jsonl \
+       --output-prefix $six_ALL_CCFRWORK/datasets-custom/openwebtext/meg-t5 \
+       --vocab $six_ALL_CCFRWORK/datasets-custom/vocabs/bert-large-uncased-vocab.txt \
+       --dataset-impl mmap \
+       --tokenizer-type BertWordPieceLowerCase \
+       --split-sentences \
+       --workers 8

bigscience/jz/slurms_scripts/README.md

@@ -0,0 +1,16 @@
+# Slurm scripts
+
+Mainly here as indicative. Adapt to current traning.
+
+- `cpu.slurm` -> for data preprocessing
+- `gpu.slurm` -> arguments are adapted to maximize the gpu mem of the 8 32GB GPU requested
+
+
+
+
+We are using common disk spaces for datasets, caches and experiment dumps:
+
+
+- Experiment dumps -> `$six_ALL_CCFRWORK/experiments`
+
+`SCRATCH` disk spaces are wiped regularly (wiping every file that was not accessed in the past 30 days) so we have S3 buckets (https://console.cloud.google.com/storage/browser/bigscience-experiments and https://console.cloud.google.com/storage/browser/bigscience-datasets) as shared storage that is accessible from JZ but from others instances too.

bigscience/jz/slurms_scripts/multi_node_deconlyt5.slurm

@@ -0,0 +1,76 @@
+#!/bin/bash
+#SBATCH --job-name=deconlyt5
+#SBATCH --qos=qos_gpu-t4
+#SBATCH --nodes=32
+#SBATCH --ntasks-per-node=1                  # number of MP tasks
+#SBATCH --gres=gpu:8                # number of GPUs per node
+#SBATCH -C v100-32g
+#SBATCH --cpus-per-task=40            # number of cores per tasks
+#SBATCH --hint=nomultithread          # we get physical cores not logical
+#SBATCH --time=50:00:00              # maximum execution time (HH:MM:SS)
+#SBATCH --output=%j.out               # output file name
+#SBATCH --error=%j.out                # error file name (same to watch just one file)
+#SBATCH --account=six@gpu
+#SBATCH --mail-type=ALL
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_JOB_NUM_NODES
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-prod
+
+cd $six_ALL_CCFRWORK/code/transformers
+export PYTHONPATH=$six_ALL_CCFRWORK/code/transformers
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export PYTHONPATH=src
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=13370
+
+export LAUNCHER=" \
+    python -u -m torch.distributed.launch \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --master_addr $MASTER_ADDR \
+    --master_port $MASTER_PORT \
+    "
+
+DATASET=openwebtext
+LOGG_FREQUENCY=125
+SAVE_FREQUENCY=250
+EVAL_FREQUENCY=1000
+SERIALIZATION_DIR=${ALL_CCFRSCRATCH}/experiments/dec_only_t5-xl-multinode
+LOGGING_DIR=${ALL_CCFRSCRATCH}/tensorboard/dec_only_t5-xl-multinode
+
+export CMD=" \
+    ${SCRATCH}/code/bigscience/jz/scripts/run_clm.py \
+    --deepspeed ${six_ALL_CCFRWORK/code/bigscience/jz/configs/deepspeed/ds_zero3.json \
+    --model_type decoder_only_t5 \
+    --tokenizer_name t5-small \
+    --config_name ${six_ALL_CCFRWORK/code/bigscience/jz/configs/dec_only_t5/decoder_only_t5-xl.json \
+    --dataset_name ${DATASET} --block_size 1024 \
+    --preprocessing_num_workers 76 \
+    --do_train --do_eval \
+    --max_steps 34000 \
+    --per_device_train_batch_size 1 --gradient_accumulation_steps 2 \
+    --per_device_eval_batch_size 1 \
+    --learning_rate 6e-4 \
+    --adam_beta1 0.9 --adam_beta2 0.95 --weight_decay 0.1 \
+    --warmup_steps 800 \
+    --max_grad_norm 1.0 \
+    --output_dir ${SERIALIZATION_DIR} --overwrite_output_dir \
+    --report_to tensorboard \
+    --logging_strategy steps --logging_first_step --logging_dir ${LOGGING_DIR} --logging_steps ${LOGG_FREQUENCY} \
+    --eval_steps ${EVAL_FREQUENCY} --evaluation_strategy steps --max_val_samples 10000 \
+    --save_strategy steps --save_steps ${SAVE_FREQUENCY} --save_total_limit 200
+    "
+
+# to debug - add echo (it exits and prints what it would have launched)
+srun bash -c '$LAUNCHER --node_rank $SLURM_PROCID $CMD'

bigscience/jz/slurms_scripts/preprocess_deconlyt5.slurm

@@ -0,0 +1,52 @@
+#!/bin/bash
+#SBATCH --job-name=preprocessdeconlyt5
+#SBATCH --ntasks=1                    # number of MP tasks
+#SBATCH --constraint=v100-16g
+#SBATCH --gres=gpu:1                  # number of GPUs per node
+#SBATCH --cpus-per-task=40            # number of cores per tasks
+#SBATCH --hint=nomultithread          # we get physical cores not logical
+#SBATCH --qos=qos_gpu-t4              # t4 enables 100H trainings
+#SBATCH --time=40:00:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out               # output file name
+#SBATCH --error=%x-%j.out                # error file name (same to watch just one file)
+#SBATCH --account=six@gpu             # It's kind of stupid but we don't have pure CPU allocation with eha.
+#SBATCH --mail-type=ALL
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-prod
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+DATASET=openwebtext
+LOGG_FREQUENCY=500
+SAVE_FREQUENCY=500
+EVAL_FREQUENCY=100000
+SERIALIZATION_DIR=${eha_ALL_CCFRSCRATCH}/experiments/t5openwebtextpreprocess
+LOGGING_DIR=${eha_ALL_CCFRSCRATCH}/tensorboard/t5openwebtextpreprocess
+
+python ${six_ALL_CCFRWORK/code/bigscience/jz/scripts/run_clm.py \
+  --model_type decoder_only_t5 \
+  --tokenizer_name t5-small \
+  --config_name ${six_ALL_CCFRWORK/code/bigscience/jz/configs/dec_only_t5/decoder_only_t5-tiny.json \
+  --dataset_name ${DATASET} --block_size 1024 \
+  --preprocessing_num_workers 76 \
+  --do_train --do_eval \
+  --max_steps 1 \
+  --max_val_samples 10 \
+  --per_device_train_batch_size 1 --gradient_accumulation_steps 1 \
+  --per_device_eval_batch_size 1 \
+  --per_device_eval_batch_size 1 \
+  --learning_rate 6e-4 \
+  --adam_beta1 0.9 --adam_beta2 0.95 --weight_decay 0.1 \
+  --warmup_steps 800 \
+  --max_grad_norm 1.0 \
+  --output_dir ${SERIALIZATION_DIR} --overwrite_output_dir \
+  --report_to tensorboard \
+  --logging_strategy steps --logging_first_step --logging_dir ${LOGGING_DIR} --logging_steps ${LOGG_FREQUENCY} \
+  --eval_steps ${EVAL_FREQUENCY} --evaluation_strategy steps \
+  --save_strategy steps --save_steps ${SAVE_FREQUENCY} --save_total_limit 200

bigscience/jz/tools/diagnostics.md

@@ -0,0 +1,28 @@
+# Tools for diagnostics of training problems
+
+
+## Hanging processes
+
+
+To track down the culprit of a hung process dumping the stack traces of the training processes.
+```
+pgrep -f pretrain_gpt | xargs -i /path/to/py-spy dump --pid {} > /networked/path/unique/for/node
+```
+
+Given the dumps of a hung 3D trainer, the node with issues usually get stuck in a different part of the training pipeline. Pipelines with no issues will be waiting at an all-reduce before step, whereas the problematic pipeline usually hangs somewhere in the training microbatches. We often see the pipeline-adjacent processes stuck on a pipe send/recv from the problematic node(s).
+
+If `py-spy` isn't already installed, do:
+```
+pip install py-spy
+```
+
+
+## Malfunctioning GPUs
+
+Usually these require a reboot as once a problem happens on a hardware level, the recovery is not possible w/o a reboot.
+
+For example if a GPU can't allocate memory because it has a hardware issue, as simple test could be:
+
+```
+python -c "import torch; torch.ones(1).cuda()"
+```

bigscience/jz/tools/google-cloud-sdk.md

@@ -0,0 +1,57 @@
+# google-cloud-sdk
+
+Installed in `$six_ALL_CCFRWORK/lib/google-cloud-sdk` following the linux installation instructions [here](https://cloud.google.com/sdk/docs/install?hl=en).
+
+To activate add to your `~/.bashrc`:
+
+```
+if [ -f '/gpfsssd/worksf/projects/rech/six/commun/lib/google-cloud-sdk/path.bash.inc' ]; then . '/gpfsssd/worksf/projects/rech/six/commun/lib/google-cloud-sdk/path.bash.inc'; fi
+if [ -f '/gpfsssd/worksf/projects/rech/six/commun/lib/google-cloud-sdk/completion.bash.inc' ]; then . '/gpfsssd/worksf/projects/rech/six/commun/lib/google-cloud-sdk/completion.bash.inc'; fi
+
+```
+
+and restart `bash`.
+
+# Downloading from the `bigscience` bucket
+
+Go to the location to download, e.g.:
+`https://console.cloud.google.com/storage/browser/bigscience/mc4_preprocessing?pageState=(%22StorageObjectListTable%22:(%22f%22:%22%255B%255D%22))`
+
+Select dirs to download and click on 'Download` and it will give instructions to download all the dirs using `gsutil`, e.g.:
+
+```
+gsutil -m cp -r \
+  "gs://bigscience/mc4_sampled_raw/am/" \
+  "gs://bigscience/mc4_sampled_raw/ar/" \
+  .
+```
+
+To debug add `-d`.
+
+To download a single file, go to the file's page, e.g.:
+
+https://console.cloud.google.com/storage/browser/_details/bigscience/mc4_preprocessing/en/train_text_document_1.bin
+
+and it'll have the `gsutil URI` entry, in this case:  `gs://bigscience/mc4_preprocessing/en/train_text_document_1.bin` which you then feed to `gsutil`:
+
+```
+gsutil -m cp "gs://bigscience/mc4_preprocessing/en/train_text_document_1.bin" .
+```
+
+rsync might be a better way to sync files when they are large and the client keeps on crashing, example:
+```
+gsutil -m rsync -r "gs://bigscience/mc4_preprocessing" mc4_preprocessing
+```
+note that `gsutil` keeps track of what it failed to do and tries to re-do it even if you manually fetched a large file and inserted it into the right location, it'll ignore its appearance, will delete it and will attempt to fetch it a new. Not really great `rsync` feature, if you're used to the normal `rsync(1)` tool.
+
+## moving multiple folders
+
+
+`gsutil mv` is supposed to support globbing, but it doesn't. so here is a poor man's workaround:
+
+e.g. to move `"gs://bigscience-backups/tr1-13B/global_step*"` to  `"gs://bigscience-backups/tr1-13B/checkpoints-bak/"`
+
+```
+for x in `gsutil ls "gs://bigscience-backups/tr1-13B"`; do y=$(basename -- "$x");echo gsutil mv ${x} gs://bigscience-backups/tr1-13B/checkpoints-bak/${y}; done > cmd
+```
+edit `cmd` to your liking to remove any folders that shouldn't be moved. surely can be further improved to filter out the wanted pattern, but the principle is clear.

bigscience/jz/tools/monitoring.md

@@ -0,0 +1,10 @@
+# Monitoring
+
+## nvtop
+
+A nice alternative to `watch -n1 nvidia-smi`
+
+```
+module load nvtop
+nvtop
+```

bigscience/jz/tools/tensorboard.md

@@ -0,0 +1,13 @@
+# Tensorboard
+
+Jean Zay has a specific procedure to check tensorboard logs detailed [here](http://www.idris.fr/eng/jean-zay/pre-post/jean-zay-jupyter-notebook-eng.html). It essentially boils down to:
+```bash
+module load tensorflow-gpu/py3/2.3.0 # You can use your own env or other JZ existing envs
+jupyter tensorboard enable --user
+idrjup
+```
+Please note that you need to connect from the declared IP adress.
+
+# Potential errors
+
+On Jupyter, if you run into an *Invalid credentials* error, or a *Jupyter tensorboard extension error*, as suggested by Rémi Lacroix, you can remove the `~/.jupyter` folder (command: `rm -rf ~/.jupyter`) and restart the procedure from scratch. In particular, make sure you re-activate the tensorboard plugin for your user: `jupyter tensorboard enable --user`. It generally fixes that kind of problems.

bigscience/tools/README.md

@@ -0,0 +1,87 @@
+## Instrumenting your run
+We assume you're following the structure of the [arch-and-scaling template](https://github.com/bigscience-workshop/bigscience/blob/master/train/arch-and-scaling-template.slurm)
+Go to https://huggingface.co/ and create two models (currently, under your icon on the top right/new model)
+- <YOUR_MODEL_NAME>-checkpoints
+- <YOUR_MODEL_NAME>-logs
+in your output path (DATA_OUTPUT_PATH in the arch-and-scaling template), `git clone` the logs repo and rename the folder to `logs` (mv `<YOUR_MODEL_NAME>-logs` `logs`)
+
+## How to synch your logs with the hub
+`python tools/hub-sync.py --repo-path <DATA_OUTPUT_PATH>/logs/tensorboard/ --patterns "*tfevent*"`
+
+## How to synch your checkpoints with the hub
+Latest version of what was used in [training 1](https://github.com/bigscience-workshop/bigscience/tree/master/train/tr1-13B-base).
+
+Go to your `checkpoints` folder, which should contain a bunch of `global_stepXXXXXX` folders. Open a long running interactive shell:
+```
+srun -p compil --cpus-per-task=40 -A six@cpu --time=6:00:00 --pty bash
+```
+then convert:
+
+```
+time find * -maxdepth 0 -type d -name "global_step*" -exec $six_ALL_CCFRWORK/code/Megatron-DeepSpeed/tools/convert_checkpoint/deepspeed_to_transformers.py --input_folder {} --output_folder ../hf-fixed/{} \;
+```
+to prepare the target dir:
+
+```
+#git -c http.extraHeader="Authorization: Basic " clone https://huggingface.co/bigscience/<YOUR_REPO>/
+cd YOUR_REPO
+huggingface-cli lfs-enable-largefiles .
+git config --unset user.email
+~/prod/code/bigscience/tools/hub-sync.py --repo-path . --patterns '*bogus*'
+```
+We are going to put each checkpoint into its own branch with the same name.
+- If you have added tokenizer files:
+
+```
+mv ../hf_fixed/global_step* .
+time find * -maxdepth 0 -type d -name "global_step*" -exec git checkout main \; -exec git checkout -b {} \; -exec mv {}/config.json . \; -exec mv {}/pytorch_model.bin . \; -exec git add config.json pytorch_model.bin <TOKENIZER_FILES> \; -exec git commit -m "add {}" \; -exec git push --set-upstream origin {} \; --exec mv config.json {}/ --exec mv pytorch_model.bin {}/;
+git checkout main
+```
+- If you just want to add the checkpoints, without tokenizer files:
+
+```
+mv ../hf_fixed/global_step* .
+time find * -maxdepth 0 -type d -name "global_step*" -exec git checkout main \; -exec git checkout -b {} \; -exec mv {}/config.json . \; -exec mv {}/pytorch_model.bin . \; -exec git add config.json pytorch_model.bin \; -exec git commit -m "add {}" \; -exec git push --set-upstream origin {} \; --exec mv config.json {}/ --exec mv pytorch_model.bin {}/
+git checkout main
+```
+- If you want to add tokenizer files later:
+
+```
+time find * -maxdepth 0 -type d -name "global_step*" -exec git checkout main \; -exec git checkout {} \; -exec git add <TOKENIZER_FILES> \; -exec git commit -m "add {}" \; -exec git push --set-upstream origin {} \;
+git checkout main
+```
+## Fast branch switching in case you messed up and want to fix all your checkpoints
+What you want is `export GIT_LFS_SKIP_SMUDGE=1`. 
+Here's an example that changes the activation function in the `config.json` files for each branch:
+```
+export GIT_LFS_SKIP_SMUDGE=1
+git clone https://huggingface.co/bigscience/tr3e-1B3-c4-checkpoints
+cd tr3e-1B3-c4-checkpoints
+~/prod/code/bigscience/tools/hub-sync.py --repo-path . --patterns '*bogus*'
+set +H
+git branch -a | sort -V | perl -lne 'm|(global_step\d+)| && print qx[git checkout $1; perl -pi -e "s/gelu(?!_)/gelu_fast/" $1/config.json; git commit -m "gelu_fast is the correct activation_function" .; git push --set-upstream origin $1]'
+export GIT_LFS_SKIP_SMUDGE=0
+```
+And an example that fixes checkpoints in the old format (contained within a `global_step` subfolder, no tokenizer files) to be compatible with `from_pretrained`:
+```
+export GIT_LFS_SKIP_SMUDGE=1
+my_callback () {
+  INDEX=${1}
+  BRANCH=${2}
+  if [[ $BRANCH == origin/global_step* ]];
+  then
+    git checkout "${BRANCH:7}"
+    git mv "${BRANCH:7}"/* .
+    cp ../gpt2_tokenizer/tokenizer.json .
+    git add tokenizer.json
+    git commit -m "fixed checkpoints to be from_pretrained-compatible"
+    git push
+  fi
+}
+get_branches () {
+  git branch --all --format='%(refname:short)'
+}
+# mapfile -t -C my_callback -c 1 BRANCHES < <( get_branches ) # if you want the branches that were sent to mapfile in a new array as well
+# echo "${BRANCHES[@]}"
+mapfile -t -C my_callback -c 1 < <( get_branches )
+```

bigscience/tools/fixing_checkpoints_for_from_pretrained.sh

@@ -0,0 +1,21 @@
+my_callback () {
+  INDEX=${1}
+  BRANCH=${2}
+  if [[ $BRANCH == origin/global_step* ]];
+  then
+    git checkout "${BRANCH:7}"
+    git mv "${BRANCH:7}"/* .
+    cp ../gpt2_tokenizer/tokenizer.json .
+    git add tokenizer.json
+    git commit -m "fixed checkpoints to be from_pretrained-compatible"
+    git push
+  fi
+}
+get_branches () {
+  git branch --all --format='%(refname:short)'
+}
+# mapfile -t -C my_callback -c 1 BRANCHES < <( get_branches ) # if you want the branches that were sent to mapfile in a new array as well
+# echo "${BRANCHES[@]}"
+
+export GIT_LFS_SKIP_SMUDGE=1
+mapfile -t -C my_callback -c 1 < <( get_branches )

bigscience/tools/fs-watchdog.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python
+
+#
+# This tool alerts on the status of the filesystem - when it's getting close to running out of disk space or inodes on various partitions at JZ
+#
+# Example:
+#
+# fs-watchdog.py
+#
+
+import argparse
+import re
+import smtplib
+import socket
+import subprocess
+import sys
+
+SLURM_GROUP_NAME = "six"
+
+# this needs to be an actual email subscribed to [email protected]
+FROM_ADDR = "[email protected]"
+TO_ADDRS = ["[email protected]", "[email protected]"] # wants a list
+
+def send_email(subject, body):
+    message = f"""\
+From: {FROM_ADDR}
+To: {", ".join(TO_ADDRS)}
+Subject: {subject}
+
+{body}
+"""
+
+    server = smtplib.SMTP("localhost")
+    #server.set_debuglevel(3)  # uncomment if need to debug
+    server.sendmail(FROM_ADDR, TO_ADDRS, message)
+    server.quit()
+
+def send_email_alert(msg):
+
+    subject = f"[ALERT] JZ filesystem is getting close to being full"
+    body = f"""
+***ALERT: One or more partitions at JZ are getting close to being full! Alert someone at Eng WG***
+
+{msg}
+
+Please reply to this email once the issue has been taken care of, or if you are in the process of doing that, should new alerts be sent again.
+
+If unsure what to do, please post in the #bigscience-engineering slack channel.
+
+"""
+
+    send_email(subject, body)
+
+def check_running_on_jean_zay():
+    fqdn = socket.getfqdn()
+    # sometimes it gives fqdn, other times it doesn't, so try to use both patterns
+    if not ("idris.fr" in fqdn or "idrsrv" in fqdn):
+        raise ValueError("This script relies on JZ's specific environment and won't work elsewhere. "
+        f"You're attempting to run it on '{fqdn}'.")
+
+def run_cmd(cmd, check=True):
+    try:
+        git_status = subprocess.run(
+            cmd,
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            check=check,
+            encoding="utf-8",
+        ).stdout.strip()
+    except subprocess.CalledProcessError as exc:
+        raise EnvironmentError(exc.stderr)
+
+    return git_status
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-d", "--debug", action='store_true', help="enable debug")
+    parser.add_argument("--no-email", action='store_true', help="do not email alerts")
+    return parser.parse_args()
+
+def main():
+
+    check_running_on_jean_zay()
+    args = get_args()
+
+    alerts = []
+    def analyse_partition_bytes(partition_name, partition_path, hard_limit_bytes, alert_bytes_threshold):
+        soft_limit_bytes = hard_limit_bytes * alert_bytes_threshold
+        cmd = f"du -bs {partition_path}"
+        response = run_cmd(cmd.split(), check=False) # du could report partial errors for wrong perms
+        size_bytes = int(response.split()[0])
+        if args.debug:
+            print(f"{partition_name} bytes: {size_bytes}")
+
+        if size_bytes > soft_limit_bytes:
+            current_usage_percent = 100*size_bytes/hard_limit_bytes
+            alerts.append(f"{partition_name} is at {current_usage_percent:.2f}% bytes usage ({size_bytes/2**30:.2f}GB/{hard_limit_bytes/2**30:.2f}GB)")
+            alerts.append("")
+
+    def analyse_partition_inodes(partition_name, partition_path, hard_limit_inodes, alert_inodes_threshold):
+        soft_limit_inodes = hard_limit_inodes * alert_inodes_threshold
+        cmd = f"du -s -BK --inodes {partition_path}"
+        response = run_cmd(cmd.split(), check=False) # du could report partial errors for wrong perms
+        size_inodes = int(response.split()[0])
+        if args.debug:
+            print(f"{partition_name} Inodes: {size_inodes}")
+
+        if size_inodes > soft_limit_inodes:
+            current_usage_percent = 100*size_inodes/hard_limit_inodes
+            alerts.append(f"{partition_name} is at {current_usage_percent:.2f}% inodes usage ({size_inodes/2**10:.2f}K/{hard_limit_inodes/2**10:.2f}K)")
+            alerts.append("")
+
+    def analyse_partition_idrquota(partition_name, partition_flag, alert_bytes_threshold, alert_inodes_threshold):
+        cmd = f"idrquota {partition_flag} -p {SLURM_GROUP_NAME}"
+        response = run_cmd(cmd.split())
+        match = re.findall(' \(([\d\.]+)%\)', response)
+        if match:
+            bytes_percent, inodes_percent = [float(x) for x in match]
+        else:
+            raise ValueError(f"{cmd} failed")
+        if args.debug:
+            print(f"{partition_name} bytes: {bytes_percent}%")
+            print(f"{partition_name} inodes: {inodes_percent}%")
+
+        msg = []
+        if bytes_percent/100 > alert_bytes_threshold:
+            msg.append(f"{partition_name} is at {bytes_percent:.2f}% bytes usage")
+
+        if inodes_percent/100 > alert_inodes_threshold:
+            msg.append(f"{partition_name} is at {inodes_percent:.2f}% inodes usage")
+
+        if len(msg) > 0:
+            alerts.extend(msg)
+            alerts.append(response)
+            alerts.append("")
+
+    def analyse_shared_disk(partition_name, alert_bytes_threshold):
+        partition_name_2_disk = {
+            "SCRATCH": "gpfsssd",
+            "WORK": "gpfsdswork",
+            "STORE": "gpfsdsstore"
+        }
+        cmd = "df"
+        response = run_cmd(cmd.split())
+        disk_metas = response.split("\n")
+        column_names = disk_metas[0].split()
+        disk_meta = [disk_meta_.split() for disk_meta_ in disk_metas if disk_meta_.startswith(partition_name_2_disk[partition_name])][0]
+        disk_meta = {column_name: value for column_name, value in zip(column_names, disk_meta)}
+
+        # default `df` counts uses 1024-byte units, and `1024 == 2 ** 10`
+        available_disk_left = int(disk_meta["Available"]) * 2 ** 10
+        if available_disk_left < alert_bytes_threshold:
+            alerts.append(f"Shared {partition_name} has {available_disk_left/2**40:.2f}TB left")
+            alerts.append("")
+
+    # WORK and STORE partitions stats can be accessed much faster through `idrquota`, and it already
+    # includes the quota info
+    analyse_partition_idrquota(partition_name="WORK", partition_flag="-w", alert_bytes_threshold=0.85, alert_inodes_threshold=0.85)
+    analyse_partition_idrquota(partition_name="STORE", partition_flag="-s", alert_bytes_threshold=0.85, alert_inodes_threshold=0.85)
+
+    # SCRATCH - check only bytes w/ a hard quota of 400TB - alert on lower threshold than other
+    # partitions due to it filling up at a faster rate (dumping huge checkpoints)
+    analyse_partition_bytes(partition_name="SCRATCH", partition_path="/gpfsssd/scratch/rech/six/", hard_limit_bytes=400*2**40, alert_bytes_threshold=0.75)
+    # Actually SCRATCH is shared with everyone and we should monitor the output of `df -h | grep gpfsssd`
+    # Check that there's still 40TB left
+    analyse_shared_disk("SCRATCH", 100 * 2 ** 40)
+
+    # WORKSF - check both bytes and inodes w/ hard quotas of 2TB / 3M
+    analyse_partition_bytes(partition_name="WORKSF", partition_path="/gpfsssd/worksf/projects/rech/six/", hard_limit_bytes=2*2**40, alert_bytes_threshold=0.85)
+    analyse_partition_inodes(partition_name="WORKSF", partition_path="/gpfsssd/worksf/projects/rech/six/", hard_limit_inodes=3*10**6, alert_inodes_threshold=0.85)
+
+    if len(alerts) > 0 :
+        print(f"[ALERT] JZ filesystem is getting close to being full")
+        msg = "\n".join(alerts)
+        print(msg)
+
+        if not args.no_email:
+            send_email_alert(msg)
+    else:
+        print("All partitions are in a good standing")
+
+if __name__ == "__main__":
+
+    main()

bigscience/tools/fs-watchdog.slurm

@@ -0,0 +1,23 @@
+#!/bin/bash
+#SBATCH --job-name=fs-watchdog       # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=2:00:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --partition=compil
+#SBATCH --account=six@cpu
+
+set -e
+
+echo "START TIME: $(date)"
+
+source $six_ALL_CCFRWORK/start-prod
+
+echo "running partition watchdog"
+
+BIG_SCIENCE_REPO_PATH=$six_ALL_CCFRWORK/code/tr11-176B-ml/bigscience
+
+$BIG_SCIENCE_REPO_PATH/tools/fs-watchdog.py
+
+echo "END TIME: $(date)"

bigscience/tools/hub-auth.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+
+# creates a local auth token file which can then be safely used by other programs without leaking
+# the password in public git
+
+import getpass
+import json
+from pathlib import Path
+from huggingface_hub import HfApi
+
+HUB_DATA_PATH_SHARED = "/gpfsdswork/projects/rech/six/commun/auth/.hub_info.json"
+#HUB_DATA_PATH = Path(__file__).resolve().parent / ".hub_info.json"
+
+username = input("Hub username: ")
+password = getpass.getpass("Hub password: ")
+email = input("Hub email: ")
+auth_token = HfApi().login(username=username, password=password)
+
+data = dict(username=username, email=email, auth_token=auth_token)
+#print(data)
+
+with open(HUB_DATA_PATH_SHARED, 'w') as f:
+    json.dump(data, f)

bigscience/tools/hub-sync.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python
+
+#
+# This tool automatically pushes newly added and modified files into the hub repo, if they match the
+# provided one or more patterns.
+#
+# If the program fails to run the first time make sure to run `hub-auth.py` to authenticate and save
+# the token, and user name/email locally which will then be used by this program to alter the config
+# of the target repo to automatically commit as the user you authenticated with. This is needed when
+# pushing as someone else, which is the case here, as we want the software to always work and not
+# depend on the developer's git setup.
+#
+# Example:
+#
+# hub-sync.py --repo-path /hf/Megatron-DeepSpeed-master/output_dir/tensorboard/ --patterns '*tfevents*'
+#
+# multiple patterns can be passed
+
+import argparse
+import io
+import json
+import os
+import re
+import subprocess
+import sys
+
+from collections import defaultdict
+from fnmatch import fnmatch
+from huggingface_hub import HfApi, HfFolder, Repository
+from pathlib import Path
+from typing import List, Optional, Union
+
+# normally using a globally shared hub data, but can override it with the local token if need be
+HUB_DATA_PATH_SHARED = "/gpfsdswork/projects/rech/six/commun/auth/.hub_info.json"
+# for now disabling local, since it leads to outdated auth tokens
+HUB_DATA_PATH_LOCAL = Path(__file__).resolve().parent / ".hub_info.json"
+
+HUB_AUTH_TOKEN_PATH = "/gpfsdswork/projects/rech/six/commun/auth/.hub_auth"
+
+# map https://git-scm.com/docs/git-status#_short_format
+#
+
+#     ' ' = unmodified
+#     M = modified
+#     A = added
+#     D = deleted
+#     R = renamed
+#     C = copied
+#     U = updated but unmerged
+
+# X          Y     Meaning
+# -------------------------------------------------
+# 	 [AMD]   not updated
+# M        [ MD]   updated in index
+# A        [ MD]   added to index
+# D                deleted from index
+# R        [ MD]   renamed in index
+# C        [ MD]   copied in index
+# [MARC]           index and work tree matches
+# [ MARC]     M    work tree changed since index
+# [ MARC]     D    deleted in work tree
+# [ D]        R    renamed in work tree
+# [ D]        C    copied in work tree
+# -------------------------------------------------
+# D           D    unmerged, both deleted
+# A           U    unmerged, added by us
+# U           D    unmerged, deleted by them
+# U           A    unmerged, added by them
+# D           U    unmerged, deleted by us
+# A           A    unmerged, both added
+# U           U    unmerged, both modified
+# -------------------------------------------------
+# ?           ?    untracked
+# !           !    ignored
+
+git_status_lookup = {
+    "?": "untracked",
+    "M": "modified",
+    "A": "added",
+    "D": "deleted",
+    "R": "renamed",
+    "C": "copied",
+    "U": "updated_unmerged",
+}
+
+def get_git_files_by_status(local_dir):
+    try:
+        git_status = subprocess.run(
+            ["git", "status", "-s"],
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            check=True,
+            encoding="utf-8",
+            cwd=local_dir,
+        ).stdout.strip()
+    except subprocess.CalledProcessError as exc:
+        raise EnvironmentError(exc.stderr)
+
+    if len(git_status) == 0:
+        return {}
+
+    file_statuses = [status.strip() for status in git_status.split("\n")]
+
+    # create a dict of lists for each long key in git_status_lookup
+    files = defaultdict(list)
+    for l in file_statuses:
+        k, v = l.split(' ', 1)
+        k = k.strip()[0] # get first column
+        # remap to sensible name
+        k = git_status_lookup.get(k, "unknown")
+        files[k].append(v)
+
+    #print(files)
+
+    return files
+
+
+# XXX: this should be PR'ed into https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/repository.py
+# after adjusting the API self, self.local_dir
+def get_untracked_files(local_dir) -> List[str]:
+    """
+    Returns a list of untracked files in the working directory
+    """
+    key = "untracked"
+    files_by_status = get_git_files_by_status(local_dir)
+    return files_by_status[key] if key in files_by_status else []
+
+def get_modified_files(local_dir) -> List[str]:
+    """
+    Returns a list of modified files in the working directory
+    """
+    key = "modified"
+    files_by_status = get_git_files_by_status(local_dir)
+    return files_by_status[key] if key in files_by_status else []
+
+
+def get_new_and_modified_files(local_dir) -> List[str]:
+    """
+    Returns a list of untracked and modified files in the working directory recursively.
+    It will include relative path for files under sub-dirs that are untracked.
+    """
+
+    try:
+        cmd = "git ls-files --modified --others --exclude-standard".split()
+        output = subprocess.run(
+            cmd,
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            check=True,
+            encoding="utf-8",
+            cwd=local_dir,
+        ).stdout.strip()
+    except subprocess.CalledProcessError as exc:
+        raise EnvironmentError(exc.stderr)
+
+    if len(output) == 0:
+        return []
+
+    return [f.strip() for f in output.split("\n")]
+
+
+def run_cmd(cmd, local_dir):
+    try:
+        git_status = subprocess.run(
+            cmd,
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            check=True,
+            encoding="utf-8",
+            cwd=local_dir,
+        ).stdout.strip()
+    except subprocess.CalledProcessError as exc:
+        raise EnvironmentError(exc.stderr)
+
+    return git_status
+
+
+def hub_config_repo(hub_data, local_dir):
+
+    # if we have the bot user email set, that means we have done this process already
+    # but some users don't have any `user.email` set, so recover gracefully if that's the case
+    try:
+        cmd = f"git config user.email"
+        email = run_cmd(cmd.split(), local_dir)
+        if len(email) > 0 and email == hub_data['email']:
+            return
+    except:
+        pass
+
+    print(f"* Detected a new clone. Setting it up for {hub_data['username']}")
+
+    # to work as another user we need
+    # 1. their user.email ( but also user.name is required but can be anything)
+    cmd = f"git config user.email {hub_data['email']}"
+    run_cmd(cmd.split(), local_dir)
+    cmd = f"git config user.name {hub_data['username']}"
+    run_cmd(cmd.split(), local_dir)
+
+    # 2. pre-auth the repo
+    # a. get url
+    cmd = "git remote get-url origin"
+    url = run_cmd(cmd.split(), local_dir)
+
+    # b. extract just the huggingface.co/app-test-user/test-tensorboard part
+    repo_part_url = re.sub(r'https.*(?=huggingface)', '', url, 0, re.M)
+    cmd = f"git remote set-url origin --push https://{hub_data['username']}:{hub_data['auth_token']}@{repo_part_url}"
+    run_cmd(cmd.split(), local_dir)
+
+
+def get_hub_data():
+    """
+    To simplify the setup of different projects we use a common hug info data file at HUB_DATA_PATH_SHARED.
+
+    But if desired it can be overriden with a local data file at HUB_DATA_PATH_LOCAL
+    """
+
+    # if os.path.isfile(HUB_DATA_PATH_LOCAL):
+    #     hub_data_path = HUB_DATA_PATH_LOCAL
+    if os.path.isfile(HUB_DATA_PATH_SHARED):
+        hub_data_path = HUB_DATA_PATH_SHARED
+    else:
+        raise FileNotFoundError(f"Couldn't locate {HUB_DATA_PATH_SHARED}. "
+                                "Please run hub-auth.py first")
+
+    with io.open(hub_data_path, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--patterns", nargs='+', default=None, required=True, type=str, help="one or more patterns of files to match to add to the hub - make sure to quote those!")
+    parser.add_argument("--repo-path", type=str, required=True, help="path to the already cloned repo")
+    parser.add_argument("-d", "--debug", action='store_true', help="enable debug")
+    return parser.parse_args()
+
+def main():
+
+    args = get_args()
+
+    if not (os.path.isdir(args.repo_path) and os.path.isdir(f"{args.repo_path}/.git")):
+        raise FileNotFoundError(f"Directory '{args.repo_path}' either doesn't exist or it's not a git clone directory. "
+                                "Clone the desired repo first to '{args.repo_path}'.")
+
+    if len(args.patterns) == 0:
+        raise ValueError("At least one --pattern is required.")
+
+    print(f"* Processing {args.repo_path}")
+
+    if args.debug:
+        print(f"Tracking {len(args.patterns)} patterns:")
+        print(''.join(f"- {x}\n" for x in args.patterns))
+
+    hub_data = get_hub_data()
+    repo = Repository(args.repo_path)
+
+    hub_config_repo(hub_data, local_dir=args.repo_path)
+
+    files_dict = get_git_files_by_status(args.repo_path)
+
+    # we want untracked and modified files
+    uncommitted_files = get_new_and_modified_files(args.repo_path)
+
+    total_to_commit = 0
+    if len(uncommitted_files) > 0:
+        print(f"* Found {len(uncommitted_files)} uncommitted files:")
+        if args.debug:
+            print(''.join(f"- {f}\n" for f in uncommitted_files))
+
+        for pattern in args.patterns:
+
+            # *** new and modified files ***
+            # check that these are the files that match the pattern passed to git_add
+            uncommitted_files_matched = [f for f in uncommitted_files if fnmatch(f, pattern)]
+            print(f"* Found {len(uncommitted_files_matched)} uncommitted files matching pattern: {pattern}:")
+
+            if args.debug:
+                print(''.join(f"- {f}\n" for f in uncommitted_files_matched))
+
+            if len(uncommitted_files_matched) > 0:
+                total_to_commit += len(uncommitted_files_matched)
+
+                # # auto_lfs_track requires huggingface-hub-0.0.15, but transformers forces 0.0.12
+                repo.git_add(pattern=pattern) # , auto_lfs_track=True)
+                repo.git_commit(commit_message="new data")
+
+    if total_to_commit:
+        print(f"* Pushing {total_to_commit} files")
+        repo.git_push()
+        print("* Pushed")
+    else:
+        print("* Detected no new or modified files. Nothing to push.")
+
+
+if __name__ == "__main__":
+
+    main()

bigscience/tools/slurm-status.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python
+
+#
+# This tool reports on the status of the job - whether it's running or scheduled and various other
+# useful data
+#
+# Example:
+#
+# slurm-status.py --job-name tr1-13B-round3
+#
+
+import argparse
+import io
+import json
+import os
+import re
+import shlex
+import smtplib
+import socket
+import subprocess
+import sys
+from datetime import datetime, timedelta
+
+SLURM_GROUP_NAME = "six"
+
+# this needs to be an actual email subscribed to [email protected]
+FROM_ADDR = "[email protected]"
+TO_ADDRS = ["[email protected]", "[email protected]"] # wants a list
+
+def send_email(subject, body):
+    message = f"""\
+From: {FROM_ADDR}
+To: {", ".join(TO_ADDRS)}
+Subject: {subject}
+
+{body}
+"""
+
+    server = smtplib.SMTP("localhost")
+    #server.set_debuglevel(3)  # uncomment if need to debug
+    server.sendmail(FROM_ADDR, TO_ADDRS, message)
+    server.quit()
+
+def send_email_alert_job_not_scheduled(job_name):
+
+    subject = f"[ALERT] {job_name} is neither running nor scheduled to run"
+    body = f"""
+***ALERT: {job_name} is neither RUNNING nor SCHEDULED! Alert someone at Eng WG***
+
+Please reply to this email once the issue has been taken care of, or if you are in the process of doing that, should new alerts be sent again.
+
+If unsure what to do, please post in the #bigscience-engineering slack channel.
+
+*** Useful info ***
+
+On call info: https://github.com/bigscience-workshop/bigscience/tree/master/train/tr1-13B-base#on-call
+Training logs: https://github.com/bigscience-workshop/bigscience/tree/master/train/tr1-13B-base#watching-the-training-logs
+Launching training: https://github.com/bigscience-workshop/bigscience/tree/master/train/tr1-13B-base#training-scripts
+"""
+
+    send_email(subject, body)
+
+def check_running_on_jean_zay():
+    fqdn = socket.getfqdn()
+    # sometimes it gives fqdn, other times it doesn't, so try to use both patterns
+    if not ("idris.fr" in fqdn or "idrsrv" in fqdn):
+        raise ValueError("This script relies on JZ's specific environment and won't work elsewhere. "
+        f"You're attempting to run it on '{fqdn}'.")
+
+def run_cmd(cmd):
+    try:
+        git_status = subprocess.run(
+            cmd,
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            check=True,
+            encoding="utf-8",
+        ).stdout.strip()
+    except subprocess.CalledProcessError as exc:
+        raise EnvironmentError(exc.stderr)
+
+    return git_status
+
+
+def get_slurm_group_status():
+    # we need to monitor slurm jobs of the whole group six, since the slurm job could be owned by
+    # any user in that group
+    cmd = f"getent group {SLURM_GROUP_NAME}"
+    getent = run_cmd(cmd.split())
+    # sample output: six:*:3015222:foo,bar,tar
+    usernames = getent.split(':')[-1]
+
+    # get all the scheduled and running jobs
+    # use shlex to split correctly and not on whitespace
+    cmd = f'squeue --user={usernames} -o "%.16i %.9P %.40j %.8T %.10M %.6D %.20S %R"'
+    data = run_cmd(shlex.split(cmd))
+    lines = [line.strip() for line in data.split("\n")]
+    return lines
+
+
+def get_remaining_time(time_str):
+    """
+    slurm style time_str = "2021-08-06T15:23:46"
+    """
+
+    delta = datetime.strptime(time_str, "%Y-%m-%dT%H:%M:%S") - datetime.now()
+    # round micsecs
+    delta -= timedelta(microseconds=delta.microseconds)
+    return delta
+
+
+def get_preamble():
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    # add a string that is easy to grep for:
+    return f"[{timestamp}] PULSE:"
+
+
+def process_job(jobid, partition, name, state, time, nodes, start_time, notes):
+
+    job_on_partition = f"{jobid} on '{partition}' partition"
+    preamble = get_preamble()
+
+    if state == "RUNNING":
+        print(f"{preamble} {name} is running for {time} since {start_time} ({job_on_partition} ({notes})")
+    elif state == "PENDING":
+        if start_time == "N/A":
+            if notes == "(JobArrayTaskLimit)":
+                print(f"{preamble} {name} is waiting for the previous Job Array job to finish before scheduling a new one ({job_on_partition})")
+            elif notes == "(Dependency)":
+                print(f"{preamble} {name} is waiting for the previous job to finish before scheduling a new one using the dependency mechanism ({job_on_partition})")
+            else:
+                print(f"{preamble} {name} is waiting to be scheduled ({job_on_partition})")
+        else:
+            remaining_wait_time = get_remaining_time(start_time)
+            print(f"{preamble} {name} is scheduled to start in {remaining_wait_time} (at {start_time}) ({job_on_partition})")
+
+        return True
+    else:
+        # Check that we don't get some 3rd state
+        print(f"{preamble} {name} is unknown - fix me: (at {start_time}) ({job_on_partition}) ({notes})")
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--job-name", type=str, required=True, help="slurm job name")
+    parser.add_argument("-d", "--debug", action='store_true', help="enable debug")
+    parser.add_argument("--no-email", action='store_true', help="do not email alerts")
+    return parser.parse_args()
+
+
+def main():
+
+    check_running_on_jean_zay()
+
+    args = get_args()
+    status_lines = get_slurm_group_status()
+
+    in_the_system = False
+    for l in status_lines:
+        #print(f"l=[{l}]")
+
+        # XXX: apparently some jobs can be run w/o name and break the split() call, so match our
+        # name first and then split
+        if args.job_name in l:
+            jobid, partition, name, state, time, nodes, start_time, notes = l.split(None, 7)
+            #print("-".join([jobid, partition, name, state, time, nodes, start_time, notes]))
+            # XXX: add support for regex matching so partial name can be provided
+            if name == args.job_name:
+                in_the_system = True
+                process_job(jobid, partition, name, state, time, nodes, start_time, notes)
+
+    if not in_the_system:
+        preamble = get_preamble()
+        print(f"{preamble} ***ALERT: {args.job_name} is not RUNNING or SCHEDULED! Alert someone at Eng WG***")
+        if not args.no_email:
+            send_email_alert_job_not_scheduled(args.job_name)
+
+
+if __name__ == "__main__":
+
+    main()

bigscience/train/tr1-13B-base/README.md

@@ -0,0 +1,850 @@
+# Train 1 - 13B - unmodified Megatron gpt2 - baseline
+
+
+## Task
+
+Auto-regressive objective using regular Megatron-LM GPT2 language model
+
+## Environment
+
+To launch the environment use [start-tr1-13B](./start-tr1-13B)
+
+```
+source $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B
+```
+
+We are using the following branches specific to this training:
+
+- `$six_ALL_CCFRWORK/code/tr1-13B/Megatron-DeepSpeed-tr1-13B` a frozen `tr1-13B` branch - can cherry pick from `main` if need be.
+- `$six_ALL_CCFRWORK/code/tr1-13B/DeepSpeed-big-science` - a mostly frozen `big-science` branch - under Deepspeed's team control - so it may also require a specific SHA if something gets broken upstream.
+
+
+How the environment was built:
+```
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+
+conda create -y -n tr1-13B python=3.8
+conda activate tr1-13B
+conda install pytorch==1.8.1 torchvision cudatoolkit=10.2 -c pytorch -y
+pip install deepspeed
+pip install tensorboard
+
+mkdir $six_ALL_CCFRWORK/code/tr1-13B
+
+cd $six_ALL_CCFRWORK/code/tr1-13B
+git clone https://github.com/bigscience-workshop/bigscience
+
+cd $six_ALL_CCFRWORK/code/tr1-13B
+git clone https://github.com/huggingface/transformers
+cd transformers
+pip install -e .
+
+cd $six_ALL_CCFRWORK/code/tr1-13B
+git clone https://github.com/bigscience-workshop/Megatron-DeepSpeed Megatron-DeepSpeed-tr1-13B
+cd Megatron-DeepSpeed-tr1-13B
+git checkout tr1-13B
+pip install -r requirements.txt
+pip install -e .
+mkdir data
+cd data
+wget https://s3.amazonaws.com/models.huggingface.co/bert/gpt2-vocab.json
+wget https://s3.amazonaws.com/models.huggingface.co/bert/gpt2-merges.txt
+```
+
+`apex` and `deepspeed` build require an instance w/ beefy cpu and internet (unless cloned beforehand), so continue on the `prepost` partition:
+
+```
+ssh jean-zay-pp
+conda activate tr1-13B
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+
+cd $six_ALL_CCFRWORK/code/tr1-13B
+git clone https://github.com/microsoft/DeepSpeed DeepSpeed-big-science
+cd DeepSpeed-big-science
+git checkout big-science
+rm -rf build
+TORCH_CUDA_ARCH_LIST="7.0" DS_BUILD_CPU_ADAM=1 DS_BUILD_AIO=1 DS_BUILD_UTILS=1 pip install -e . --global-option="build_ext" --global-option="-j8" --no-cache -v --disable-pip-version-check 2>&1 | tee build.log
+
+cd $six_ALL_CCFRWORK/code/tr1-13B
+git clone https://github.com/NVIDIA/apex
+cd apex
+pip install --global-option="--cpp_ext" --global-option="--cuda_ext" --no-cache -v --disable-pip-version-check .  2>&1 | tee build.log
+
+#cp $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B ...
+
+```
+
+
+## Architecture
+
+Config:
+
+```
+NLAYERS=40
+NHIDDEN=5120
+NHEADS=32
+FFN_HIDDEN_SIZE=20480
+
+#    --ffn_hidden_size $FFN_HIDDEN_SIZE \
+GPT_ARGS=" \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --ffn-hidden-size $FFN_HIDDEN_SIZE \
+    --num-attention-heads $NHEADS \
+    [...]
+    "
+```
+
+Sanity check:
+```
+$ VOCAB_SIZE=50257 NLAYERS=40 NHIDDEN=5120 NHEADS=32 SEQ_LEN=2048; python -c "h=$NHIDDEN; l=$NLAYERS; s=$SEQ_LEN; v=$VOCAB_SIZE; print(f'Model size: {(l * (12*h**2 + 13*h) + (v * h) + (s * h) ) / 10**9 :.0f}B')"
+Model size: 13B
+```
+
+
+
+## Sequence Length
+
+Default Megatron-LM language model with 2048 tokens sequence length
+
+```
+SEQ_LEN=2048
+
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+
+```
+
+
+## Global batch size
+
+GBS = Global Batch Size
+
+Use a schedule:
+
+- start from 32k tokens (gbs=16)
+- increase linearly to 2048k (gbs=1024) over 5M samples (for a total of ~10B tokens / 5k steps)
+- then continue at 2048k  (gbs=1024) for 145M samples (290B tokens / 145K steps)
+
+Total: 300B tokens (150K steps)
+
+Note: the training script wasn't updated when we flipped seqlen/gbs from 1024/2048 to 2048/1024, so we are currently planning to train for 300K steps (samples) and 600B tokens. But since longer doesn't impact anything, we will just stop at half the time. I updated the document to use the right 150K number so we don't repeat this mistake in the next training.
+
+syntax:
+```
+--rampup-batch-size <start batch size>  <batch size increment> <ramp-up samples>
+```
+
+At seqlen 2048 (1k tokens is bs=1), we get:
+
+```
+    --rampup-batch-size 16 16 5_000_000 \
+    --global-batch-size 1024 \
+```
+
+This means it will start with global batch size 16 and over 63 (`(1024-16)/16`) intervals will increase the
+batch size by 16 linearly to 1024.
+
+79365 (`5_000_000/63`) is the number of samples before the next GBS increment. That is we run at GBS=16 for 79365 samples, or 4960 steps (`79365/16`). Then we run at GBS=32 for 79365 samples, or 2480 steps. Then 1653 steps at GBS=48, 1240 at GBS=64, etc....
+
+Notes:
+* `--rampup-batch-size` requires the use of `--train-samples` and can't be used with `--train-iters`.
+* global batch size has to be divisible by micro-batch-size * DP_SIZE
+
+Important:  the software will fail if GBS is not divisible by `MBS * DP_SIZE`.
+Though Jared's recommendation is to use MBS=1 and then it's much easier to match GBS/DP_SIZE even at GBS=16.
+
+`DP_SIZE=$NNODES*$GPUS_PER_NODE/($PP_SIZE*$TP_SIZE)`
+
+Since the increments are in GBS=16, we can do only DP_SIZE=16, which means that at most we can use 32 nodes (`32*4/(4*2)=16`).
+
+Once GBS reaches 1024, we can use up to 8192 GPUs (1024*2*4), so we will be able to switch to 64 nodes or may be even 128 nodes (4 gpus each). We can't use any number of nodes between 64 and 128 though, because the number has to be 2**X. So 96 nodes won't work, because it has a multiplier of 3 there.
+
+
+
+
+## Checkpoints
+
+We need the checkpoints:
+
+1. in order to be able to resume the training when the training is prematurely stopped for whatever reason.
+2. In addition a special saving schedule has been requested by the interpretabity group.
+
+Because there are 3 different schedules, and Megatron-LM has only fixed checkpoint saving schedule, we will need 3 different run scripts, to be launched in a sequence, each starting once the previous has finished.
+
+1. steps 1-100 - 10 checkpoints, interval 10 steps
+2. steps 101-1000 - 50 checkpoints, interval 18 steps
+3. steps 1001-150K - 100+ checkpoints, interval 1500 steps
+4. if still needed, can continue with schedule 3
+
+note: the interoperability study doesn't care for checkpoints in the range of 1k-20k, so we only save those to be able to restart the training.
+
+It'd have been
+```
+ROUND=1
+if   [[ ${ROUND} == 1 ]]; then TRAIN_ITER=100    SAVE_INTERVAL=10
+elif [[ ${ROUND} == 2 ]]; then TRAIN_ITER=1000   SAVE_INTERVAL=18
+elif [[ ${ROUND} == 3 ]]; then TRAIN_ITER=150000 SAVE_INTERVAL=1500
+else echo "invalid ROUND: $ROUND"
+fi
+    --train-iter $TRAIN_ITER  \
+    --save-interval $SAVE_INTERVAL  \
+```
+
+Unfortunately, `--rampup-batch-size` can't work with `--train-iter` and we have to use `--train-samples` instead. It has to be fixed through all of trainings and can't be changed, otherwise resume from checkpoint will break.
+
+So the only thing left is to use `--exit-interval` which is in steps.
+
+Which gives us the three rounds:
+
+```
+ROUND=1
+if   [[ ${ROUND} == 1 ]]; then EXIT_INTERVAL=100 SAVE_INTERVAL=10
+elif [[ ${ROUND} == 2 ]]; then EXIT_INTERVAL=900 SAVE_INTERVAL=18
+elif [[ ${ROUND} == 3 ]]; then                   SAVE_INTERVAL=1500
+else echo "invalid ROUND: $ROUND"
+fi
+
+    --train-samples 150_000_000 \
+    --exit-interval $EXIT_INTERVAL \
+    --save-interval $SAVE_INTERVAL  \
+```
+
+`--exit-interval` counts steps only for the current run, regardless of previous steps. So to stop at effective step 1000, the second round we tell it to exit at 900 (the first round did the first 100).
+
+And unfortunately, this proved to be not supported by Megatron-LM either at the moment. There are a few possible ways to approach this:
+
+1. One approach is to simply use 3 independent trainings, while using the same `--seed ` and just have `--exit_interval` as above. Though after each training moving the checkpoints away.
+
+2.
+XXX: Also megatron code could be extended to implement `--exit-samples` - so sample-based exit strategy
+
+3. Yet another approach is to do it manually. Kill the training after 100, and then restart and kill after 900 iterations, while changing the save interval, and manually fixing up the `checkpoints/latest` to point to the correct checkpoint - since the manual killing might have a few extra checkpoints. So the recipe to follow:
+
+```
+ROUND=1
+if   [[ ${ROUND} == 1 ]]; then SAVE_INTERVAL=10
+elif [[ ${ROUND} == 2 ]]; then SAVE_INTERVAL=18
+elif [[ ${ROUND} == 3 ]]; then SAVE_INTERVAL=1500
+else echo "invalid ROUND: $ROUND"
+fi
+
+    --train-samples 150_000_000 \
+    --save-interval $SAVE_INTERVAL  \
+```
+
+(could also do it with 3 parallel jobs by using the same seed!)
+
+```
+--seed 42
+```
+
+Therefore do this manually:
+
+0.
+* delete the old checkpoints `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints`
+
+1.
+
+* set to `ROUND=1`
+* `sbatch tr1-13B-round1.slurm`
+* run for 100+ steps
+* scancel the job
+* clean up `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints` to remove any checkpoints beyond 100
+* make sure `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints/latest` contains 100
+
+
+2.
+
+* set to `ROUND=2`
+* `sbatch tr1-13B-round1.slurm`
+* run for the additional 900+ steps (it's incremental, so the script already knows it started at 100)
+* scancel the job
+* clean up `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints` to remove any checkpoints beyond 1000
+* make sure `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints/latest` contains 1000
+
+
+3.
+
+* set to `ROUND=3`
+* `sbatch tr1-13B-round1.slurm`
+* run normally
+
+
+
+Because it'd be potentially too demanding to export TBs of data and the intended users might not be even able to download all that data, most likely we will need to run the interpretabity post-analysis experiments on JZ and send the reports to those who need the reports.
+
+Megatron-LM resumes from the most recent checkpoint by default. Does it need the exact path or does it auto-discover the latest checkpoint by default.
+
+```
+--load path_to_check_point \
+```
+
+
+Remi suggests 100TB on SCRATCH shouldn't be a problem.
+
+
+
+
+
+## Optimizer
+
+- AdamW,  β1=0.9, β2=0.999 eps=1e−8
+- learning rate:
+   * peak=1e-4
+   * warmup over 2000 steps
+   * cosine decay for learning rate down to 10% of its value, over 260B tokens (after 260 billion tokens, training continues at 10% of the original learning rate)
+- clipping by global norm of 1 (as in GPT-3)
+- weight decay of 0.1
+
+We need lr-decay in samples, so tokens2samples = 260B / 2048 = 126_953_125
+
+We need lr-warmup in samples, so doing the math again as in checkpoints
+
+2000=160*12+80
+
+so we will get to 2000 in 216_320 samples `16*160*12*(12+1)/2+16*13*80`
+
+
+
+```
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.999 \
+    --adam-eps 1e-8 \
+    --lr 1e-4 \
+    --min-lr 1e-5 \
+    --lr-decay-style cosine \
+    --lr-decay-samples 126_953_125 \
+    --lr-warmup-samples 216_320 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-1 \
+```
+
+
+## Logging
+
+
+For now enable all tensorboard features, later we might decide to not log it all.
+
+We are logging:
+
+- lr (enabled by default)
+- bs (enabled)
+- loss (always)
+- loss-scale (log_loss) (enabled by default)
+- grad-norm (always)
+- num-zeros (always)
+- param-norm (always)
+- timers (enabled)
+- validation loss (always)
+- validation ppl (perplexity) (enabled)
+
+almost all of these are also logged as a comparison to consumed_train_samples
+
+XXX: nice to have:
+- throughput - Tflops/gpu or tokens
+
+
+**Tensorboard config**:
+
+```
+TENSORBOARD_PATH=$DATA_OUTPUT_PATH/tensorboard
+
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+```
+
+**CodeCarbon config**:
+
+```
+CODECARBON_PATH=$DATA_OUTPUT_PATH/codecarbon
+
+    --codecarbon-dir $CODECARBON_PATH \
+```
+
+
+
+**Training logs**
+
+All training logs are piped into `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/logs/main_log.txt`.
+
+
+## Exporting
+
+Before starting training create cloned git repos to where output data will go.
+
+The last 4 should all be git repo clones
+```
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints
+TENSORBOARD_PATH=$DATA_OUTPUT_PATH/tensorboard
+CODECARBON_PATH=$DATA_OUTPUT_PATH/codecarbon
+LOGS_PATH=$DATA_OUTPUT_PATH/logs
+```
+
+I created 4 repos at https://huggingface.co/bigscience/ and now we can clone those as the dirs data will be output into:
+
+```
+cd $six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+git clone https://huggingface.co/bigscience/tr1-13B-checkpoints checkpoints
+git clone https://huggingface.co/bigscience/tr1-13B-tensorboard tensorboard
+git clone https://huggingface.co/bigscience/tr1-13B-codecarbon codecarbon
+git clone https://huggingface.co/bigscience/tr1-13B-logs logs
+```
+
+If this is your first time running git-lfs on this system, you need to init it once:
+```
+module load git-lfs
+git lfs install
+```
+
+Most of the data types we are going to sync will be large or huge, and most are already lfs-tracked by default, so no setup is required. Except our log file which too can grow large, so we need to set it up:
+
+```
+cd logs
+git-lfs track *.txt
+git commit -m "large text files" .gitattributes
+git push
+```
+
+### Cronjobs to auto-sync the hub
+
+Now we just need a cronjob to automatically do for each type of data to export:
+
+```
+cd checkpoints
+git add */*.pt
+git commit -am "new data"
+git push
+```
+
+This job is performed automatically by `hub-sync.py`. For full details see: [Automated upload to the hub](../../data/export.md#automated-upload-to-the-hub).
+
+**Weights checkpoints**
+
+Currently, we aren't exporting checkpoints.
+
+**Tensorboard**
+
+Here is the slurm script to sync the tensorboard data: [tr1-13B-hub-sync-tensorboard.slurm](./tr1-13B-hub-sync-tensorboard.slurm)
+
+**CodeCarbon**
+
+Currently the feature is not enabled, so there is nothing to log.
+
+**Log of logs**
+
+Let's also create a log of logs. We will pipe all the logs in there and also the various status reports - e.g. while SLURM is queued the training and it's not running.
+
+Here is the slurm script to sync the raw logs data: [tr1-13B-hub-sync-logs.slurm](./tr1-13B-hub-sync-logs.slurm)
+
+The main source of logs is the training scripts. The logs are gathered via
+```
+$CMD ... 2>&1 | tee -a $LOGS_PATH/main_log.txt
+```
+in the training slurm script.
+
+XXX: we could also add various other diagnostics appended to the main log file. e.g. shared memory, etc.
+
+
+
+
+## Deepspeed config
+
+Using Deepspeed's activation checkpointing to use a lot less GPU memory
+
+```
+    --deepspeed-activation-checkpointing \
+```
+
+Possible extras:
+
+- Enabling `"contiguous_memory_optimization": true,` can help to reduce memory fragmentation, but it requiressetting `number_checkpoints`. This should be set to be equal to number of transformer blocks per pipeline stage times the number of pipeline parallel stage. Samyam says: Full disclaimer: I have only used this with ZeRO but not with pipeline parallelism. But by setting the number_checkpoints as described, it should work for PP too. The benefit of using it is usually only apparent when running very close to the memory limit.
+
+
+
+## Dataset
+
+- Full 304.2M version (529GB) : `$six_ALL_CCFRWORK/datasets-custom/oscar-en`
+- Tiny 10K version (56M): `$six_ALL_CCFRWORK/datasets-custom/oscar-en-10k`
+
+We are using English-only subset of [the OSCAR dataset](https://huggingface.co/datasets/oscar) with full documents (*not* individual sentences).
+
+We have about 300M records in 1.2TB of jsonl data (about 3/4 of which are smaller than 1K tokens), which amounts to about 280B tokens (estimated at about 4.5chars/word).
+
+Megatron's preprocessing tool indexes everything and then at training time the Dataloader serves chunks of the desired fixed sequence length (2048 tokens in our case).
+
+For more information on the pre-processing process and various estimations see: [OSCAR](../../data/oscar/README.md).
+
+
+
+## Dealing with 20h SLURM limit
+
+First, let's ensure we save a checkpoint just before SLURM kills the job
+
+Let's try 19:50 1190=60*20-10
+
+```
+    --exit-duration-in-mins 1190 \
+```
+
+For the bigger models 10min might not be long enoug to finish an iteration (assume the limit hits right as one starts) and write out a checkpoint.
+
+Then we need to figure out how to schedule the next slurm job as soon as the currently running one is over in 20h.
+
+We will use job arrays, to solve this. Let's start with just 10 such jobs:
+
+```
+sbatch --array=1-10%1 tr1-13B-round1.slurm
+```
+
+`%1` limits the number of simultaneously running tasks from this job array to 1, since we want them to run in a sequence.
+
+Alternatively, as always this param can be part of the script:
+```
+#SBATCH --array=1-10%1
+```
+
+## Crontab
+
+JZ doesn't have a user-accessible crontab facility, so we have to emulate it with a self-restarting slurm job that polls some dir for new jobs to run. For full details on how this works please see [Crontab Jobs](../../jz/crontab/).
+
+But to use it simply put your slurm scripts into either:
+```
+$six_ALL_CCFRWORK/cron/cron.hourly
+$six_ALL_CCFRWORK/cron/cron.daily
+```
+
+and the jobs will be run on hourly or daily basis. This is similar to Linux's `/etc/cron.*` setup. Except the jobs aren't guaranteed to start on the hour, but should be around that time.
+
+Currently we have:
+
+```
+ls -1 $six_ALL_CCFRWORK/cron/cron.hourly/*slurm
+tr1-13B-hub-sync-logs.slurm
+tr1-13B-hub-sync-tensorboard.slurm
+tr1-13B-slurm-status.slurm
+```
+
+The first 2 sync log files to the hub and the last one monitors the health of the training and alerts of any problems.
+
+
+## Estimated run time
+
+Best case scenario when training 24/7 on 64 nodes with 4 gpus each:
+```
+$ python -c 'Btokens=300; Bmodel=13; n_gpus=256; Tflops=45; \
+print(f"{Btokens*1e9*8*Bmodel*1e9/(n_gpus*Tflops*1e12*60*60*24):0.2f} days")'
+31.35 days
+```
+
+You will find the detailed explanation of the estimation formula [here](../../math/README.md#estimate-model-training-time).
+
+The training was much slower in the first 10k steps because of the batch size rampup, where the pipeline was very inefficient.
+
+And then we were only able to use 20h slurm jobs, with unpredictable gaps of wait time in between (1-30 hours!), so it's impossible to predict when the finish line will be finished.
+
+
+## Memory usage
+
+During training currently we use 256GB (8x 32GB gpus) per each full replica (TP=2 + PP=4), the rest are ZeRO-DP. So if we throw x times more GPUs we just speed things up by having more 2-node replicas.
+The required memory breakdown:
+
+1. 4B for fp32 weights
+2. 2B for fp16 weights
+3. 8B for optimizer states.
+4. 4B for gradients (we don't save these in the checkpoint)
+5. plus memory for activations and temps, which total majorly depends on the seqlen and mini batch size - and since we use activation checkpointing this memory need is quite small.
+
+Total: 234GB (18*13) plus activations and temps memory. So we are close to 256GB here.
+
+Activation memory would have been much much bigger if it weren't for activation checkpointing.
+
+
+## Checkpoint Back Up
+
+To copy multiple checkpoints excluding optimizer states. First move the desired checkpoints to back up to some dedicated dir, e.g. `tr1-13B-round2/checkpoints`, then copy just the needed files:
+
+```
+srun -p prepost  -A six@cpu --time=20:00:00 --pty bash
+mkdir to-upload
+rsync -acvhu --no-compress --info=progress2 --exclude "zero*pt" tr1-13B-round2/checkpoints/ to-upload
+```
+
+then to back those up:
+
+```
+cp -arun $six_ALL_CCFRSCRATCH/checkpoints/to-upload/* $six_ALL_CCFRSTORE/checkpoints/tr1-13B
+```
+
+
+**Final checkpoint with optimizer states:**
+
+```
+mkdir $six_ALL_CCFRSTORE/checkpoints/tr1-13B-with-optim
+cp -arun $six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints/global_step168000 $six_ALL_CCFRSTORE/checkpoints/tr1-13B-with-optim/
+```
+
+This is the final checkpoint, that can be resumed from at will:
+
+```
+$six_ALL_CCFRSTORE/checkpoints/tr1-13B-with-optim/global_step168000
+```
+
+Here is the corresponding log:
+```
+ iteration   168000/  311541 | consumed samples:    153013584 | elapsed time per iteration (ms): 13248.2 | learning rate: 1.000E-05 | global batch size:  1024 | lm loss: 2.376641E+00 | loss scale: 131072.0 | grad norm: 19767.052 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+--------------------------------------------------------------------------------------------------
+ validation loss at iteration 168000 | lm loss value: 2.342049E+00 | lm loss PPL: 1.040253E+01 |
+--------------------------------------------------------------------------------------------------
+```
+
+## Checkpoint Conversion and Upload
+
+
+**Important**: there was a bug in the converter on the transformers side, so we need this fix:
+https://github.com/huggingface/transformers/pull/13735
+if it's not merged yet, install this branch first. If it's already merged just make sure you use `transformers@master` - XXX: I will update the script to require a specific version once a new version of transformers is released.
+
+
+Open a long running interactive shell:
+```
+srun -p compil --cpus-per-task=40 -A six@cpu --time=6:00:00 --pty bash
+```
+then convert:
+
+```
+cd $six_ALL_CCFRSCRATCH/checkpoints/to-upload
+time find * -maxdepth 0 -type d -name "global_step*" -exec $six_ALL_CCFRWORK/code/Megatron-DeepSpeed/tools/convert_checkpoint/deepspeed_to_transformers.py --input_folder {} --output_folder hf-fixed/{} \;
+```
+
+It takes about 100sec per 26GB checkpoint.
+
+The results will be all under `hf/`.
+
+Now to uploading to the hub.
+
+Prepare the target dir:
+
+```
+#git -c http.extraHeader="Authorization: Basic " clone https://huggingface.co/bigscience/tr1-13B-checkpoints/
+
+cd tr1-13B-checkpoints
+
+
+huggingface-cli lfs-enable-largefiles .
+
+git config --unset user.email
+~/prod/code/bigscience/tools/hub-sync.py --repo-path . --patterns '*bogus*'
+```
+We are going to put each checkpoint into its own branch with the same name.
+
+```
+mv ../hf/global_step* .
+time find * -maxdepth 0 -type d -name "global_step*" -exec git checkout main \; -exec git checkout -b {} \; -exec git add {} \; -exec git commit -m "add {}" \; -exec git push --set-upstream origin {} \;
+git checkout main
+```
+
+Fixing up failed pushes / verifying that all pushes went through, re-pushing if needed
+
+```
+git branch | perl -lne 'm|(global_step\d+)| && print qx[git checkout $1; git push --set-upstream origin $1]'
+```
+
+If `git push` fails re-run with: `GIT_TRACE=1 GIT_TRANSFER_TRACE=1 GIT_CURL_VERBOSE=1 git push` to see what the actual error is.
+
+
+OK, the branch-per-checkpoint hub repo proved to be very difficult to upload and even more so using it after the upload.
+
+So let's try GCS bucket:
+
+```
+gcloud auth login
+gcloud config set project bigscience
+gsutil cp -r hf-fixed/* gs://bigscience-backups/tr1-13B/checkpoints/
+
+```
+or via rsync:
+```
+gsutil -m rsync -r hf-fixed/* gs://bigscience-backups/tr1-13B/checkpoints/
+```
+
+```
+start-prod
+cd /gpfsssd/scratch/rech/six/commun/checkpoints/to-upload/
+gsutil -m rsync -r hf-fixed1/* gs://bigscience-backups/tr1-13B/checkpoints/
+
+```
+
+or if needed to speed up the upload via multiple parallel copies open 2 `srun` instances and in one:
+```
+gsutil cp -r hf-fixed1/* gs://bigscience-backups/tr1-13B/checkpoints/
+```
+and in another:
+```
+gsutil cp -r hf-fixed2/* gs://bigscience-backups/tr1-13B/checkpoints/
+```
+
+can't use `rsync` with multiple sources - can only rsync a single dir.
+
+Later fixing `config.json` to include the correct `gelu_fast` activation correction and rsyncing the GCS bucket.
+
+(moved all the hf-fixed sub-dirs into a new folder `checkpoints`)
+
+```
+start-prod
+cd /gpfsssd/scratch/rech/six/commun/checkpoints/to-upload/
+perl -pi -e 's|gelu|gelu_fast|' checkpoints/*/config.json
+gsutil -m rsync -x ".*bin$" -r checkpoints gs://bigscience-backups/tr1-13B/checkpoints
+```
+this is really fast since we exclude the checkpoint files (`-x ".*bin$"`)
+
+
+## Other backups
+
+Logs:
+
+```
+mkdir $six_ALL_CCFRSTORE/checkpoints/tr1-13B-logs/
+tar -zcvf $six_ALL_CCFRSTORE/checkpoints/tr1-13B-logs/tensorboard.tgz $six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/tensorboard
+tar -zcvf $six_ALL_CCFRSTORE/checkpoints/tr1-13B-logs/logs.tgz $six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/logs
+```
+
+note: codecarbon wasn't ready during this training, so nothing to back up there.
+
+
+## Exports
+
+- GCS https://console.cloud.google.com/storage/browser/bigscience
+- The Hub https://huggingface.co/bigscience
+
+
+## Training scripts
+
+The training script is:
+
+- [tr1-13B-round1.slurm](./tr1-13B-round1.slurm)
+
+We also have:
+
+- [tr1-13B-short.slurm](./tr1-13B-short.slurm)
+
+which is a very small model to do quick testing and debug, but otherwise the same as the main script.
+
+The scripts are located at:
+
+```
+cd $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base
+```
+
+When no jobs are scheduled, currently we launch the main training script using:
+
+```
+sbatch --array=1-5%1 tr1-13B-round1.slurm
+```
+This will schedule 5 20h-trainings which will run one at a time, once the scheduler yields to the request, with unknown wait time in between each job.
+
+If there is a job running already, **do not use the above command** as we can't have 2 trainings overlap. If there is a training already running you can:
+
+1. either tell `sbatch` to start the new job once the currently running job succeeds, using:
+
+```
+sbatch --dependency=CURRENTLY_RUNNING_JOB_ID --array=1-5%1 tr1-13B-round1.slurm
+```
+
+Where `CURRENTLY_RUNNING_JOB_ID` is the job being reported running. For example if the report of the last job is:
+```
+[2021-08-16 22:08:01] tr1-13B-round3 is running for 18:15:59 since 2021-08-16T03:52:02 (711114_4 on 'gpu_p13' partition (r7i4n[1-7],r7i7n[1-8],r8i0n0,r8i5n[3-8],r8i6n[0-8],r9i0n8,r9i1n[0-8],r9i2n[7-8],r9i3n[0-8],r9i4n[0-8],r9i5n[0-2])
+```
+then the currently running job ID is `711114_4`. You can also gather the same info about the current scheduler status using `squeue`:
+
+```
+squeue --user=$(getent group six | cut -d: -f4) | grep tr1-13B
+```
+
+2. you could also see how much time is left before the current job finished (based on training log files) and then pass that many hours to `sbatch`. For example, if the job has **less** than 2 hours to run, but more than 1 hour, you want to launch it `now+2hours` from now:
+
+```
+sbatch --begin now+2hours --array=1-5%1 tr1-13B-round1.slurm
+```
+
+Using `--dependency` may lead to shorter wait times, since if the time passed to `--begin` allows even for a few minutes of delay since the stopping of the last job, the scheduler may already start some other jobs even if their priority is lower than our job. That's because the scheduler ignores any jobs with `--begin` until the specified time arrives.
+
+
+## On Call
+
+When a person is on call, they need to watch that the training is either running or scheduled to run. If neither is happening they need to schedule a new training. When this situation occurs the log file will report:
+
+```
+***ALERT: tr1-13B-round3.slurm is not RUNNING or SCHEDULED! Alert someone at Eng WG***
+```
+
+An email alert is sent as well to `[email protected]`.
+
+
+The next section explains how to watch the logs.
+
+
+Other than waiting for the watchdog which runs once an hour, one can immediately see if anything is scheduled with:
+
+```
+$six_ALL_CCFRWORK/code/tr1-13B/bigscience/tools/slurm-status.py --job-name tr1-13B-round3
+```
+
+If for some reason the training is not scheduled or running, to schedule a new training:
+
+```
+cd $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base
+sbatch --array=1-5%1 tr1-13B-round1.slurm
+```
+
+This will schedule a job array of 5 jobs of 20h each, so if all goes well, that's at least 4 days of not needing to do anything other than being on the lookout for potential crashes.
+
+XXX: need a troubleshooting section, but elsewhere in the document that is not this training specific.
+
+1. if one of the nodes gets a corrupted gpu, and the training crashes there is a risk that the next job in the training will get allocated the same node, in which case it'll crash again. We need a method to identify which node is corrupted, report that to [email protected] so they know to fix it and exclude this node from the slurm job by adding a list of nodes to exclude as following:
+
+```
+sbatch --exclude=r7i5n2,r7i5n6 ...
+```
+but we currently have no way to identify which node is faulty. I think if we switch to pt-1.9.0 or higher where torch elastic replaces the usual launcher. Or we have to use dedicated log files per node via: `#SBATCH --output=%x-%j-%N.out`.
+
+
+## Watching the training logs
+
+On JZ:
+```
+tail -f $six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/logs/main_log.txt
+```
+
+Outside of JZ:
+```
+perl -e '$u=shift; $b=0; while(1){($e)=qx[curl -sI $u]=~/content-length: (\d+)/; \
+print qx[curl -sr $b-$e -L $u] if $e>$b; $b=$e; sleep 300}' \
+https://huggingface.co/bigscience/tr1-13B-logs/resolve/main/main_log.txt
+```
+Currently the updates happen hourly, so this is a delayed version of `tail -f`.
+
+
+## CodeCarbon
+
+
+CodeCarbon wasn't ready until the training was over so we only did an additional 10h run to measure with and the to extrapolate to the whole training.
+
+https://huggingface.co/bigscience/tr1-13B-codecarbon
+
+This set of records captures the startup time and 2499 iterations in 2 records per gpu, since there was also an intermediary checkpoint saved half-way and we flush the CC records on each checkpoint saving.
+
+The training had 168000 iterations. Therefore multiply the reported data by 67. This would be quite approximate since we were using 16 nodes when doing the ramp up, then 64 and only the last 3 weeks 128 nodes.
+
+Caveat emptor: I'm not sure whether CC-reports overlap since each report is per gpu and I think they may be measuring the same thing, other than the gpu itself. So this requires research.
+
+Each csv file contains a report for a single gpu/process. There are 512 reports.
+
+
+## Extras

bigscience/train/tr1-13B-base/chronicles.md

@@ -0,0 +1,425 @@
+# tr1-13B Chronicles
+
+Notes on the training progress with a particular focus on any encountered problems and their diagnosis and solutions/prevention.
+
+To follow the training progress charts, see: [tensorboard](https://huggingface.co/bigscience/tr1-13B-tensorboard/tensorboard).
+
+To follow the raw training logs see: [logs](https://huggingface.co/bigscience/tr1-13B-logs/).
+
+
+## Round1 SAVE_INTERVAL=10
+
+NNODES=16
+
+saved checkpoint each 10 steps
+
+`$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/tr1-13B-round1/checkpoints`
+
+10 checkpoints (Every 10 steps 1-100) - 4TB
+
+## Round2 SAVE_INTERVAL=18
+
+NNODES=16
+
+moved the round1's checkpoints away
+
+rerun from scratch with the same seed
+
+saved checkpoint each 18 steps
+
+`$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/tr1-13B-round2/checkpoints`
+
+51 checkpoints (Every 18 steps 101-1000) - 20TB
+
+
+## Round3 SAVE_INTERVAL=1500 NNODES=16
+
+NNODES=16
+
+moved the round2's checkpoints away
+
+rerun from scratch with the same seed
+
+saved checkpoint each 1500 steps
+
+I did the full re-run because otherwise I couldn't separate the tensorboard logs - it is not possible to restart from a checkpoing using `TRAIN_ITER` or `EXIT_INTERVAL` which is not fixed.
+
+now we started uploading tensorboard logs
+
+
+## Round3 SAVE_INTERVAL=1500 NNODES=32
+
+Tried to switch to 64 nodes, but the training failed because GBS gets incremented by 16, which limits us to DP_SIZE=16 (with MBS=1) so we can do 32 nodes (128gpus at most).
+
+```
+DP_SIZE=$NNODES*$GPUS_PER_NODE/($PP_SIZE*$TP_SIZE)
+16     = 32*4/(4*2)
+```
+
+will switch to 64 nodes once GBS reaches 1024.
+
+
+The training then crashed with shared memory error after some 10h+ of training:
+```
+ERROR: Unexpected bus error encountered in worker. This might be caused by insufficient shared memory (shm).
+ERROR: Unexpected bus error encountered in worker. This might be caused by insufficient shared memory (shm).
+ERROR: Unexpected bus error encountered in worker. This might be caused by insufficient shared memory (shm).
+ERROR: Unexpected bus error encountered in worker. This might be caused by insufficient shared memory (shm).
+Traceback (most recent call last):
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/site-packages/torch/utils/data/dataloader.py", line 986, in _try_get_data
+Traceback (most recent call last):
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/site-packages/torch/utils/data/dataloader.py", line 986, in _try_get_data
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/queue.py", line 179, in get
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/queue.py", line 179, in get
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/threading.py", line 306, in wait
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/threading.py", line 306, in wait
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/site-packages/torch/utils/data/_utils/signal_handling.py", line 66, in handler
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/site-packages/torch/utils/data/_utils/signal_handling.py", line 66, in handler
+RuntimeError: DataLoader worker (pid 30882) is killed by signal: Bus error. It is possible that dataloader's workers are out of shared memory. Please try to raise your shared memory limit.
+RuntimeError
+The above exception was the direct cause of the following exception:
+: Traceback (most recent call last):
+DataLoader worker (pid 30801) is killed by signal: Bus error. It is possible that dataloader's workers are out of shared memory. Please try to raise your shared memory limit.  File "/gpfswork/rech/six/commun/code/Megatron-DeepSpeed/pretrain_gpt.py", line 215, in <module>
+The above exception was the direct cause of the following exception:
+Traceback (most recent call last):
+  File "/gpfswork/rech/six/commun/code/Megatron-DeepSpeed/pretrain_gpt.py", line 215, in <module>
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 144, in pretrain
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 144, in pretrain
+        iteration = train(forward_step_func,iteration = train(forward_step_func,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 675, in train
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 675, in train
+    train_step(forward_step_func,
+    train_step(forward_step_func,  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 381, in train_step
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 381, in train_step
+    loss = model[0].train_batch(data_iter=data_iterator)
+loss = model[0].train_batch(data_iter=data_iterator)
+```
+
+Each node has 94GB of /dev/shm, so it's very strange that this happened.
+
+```
+df -h | grep shm
+tmpfs            94G  336K   94G   1% /dev/shm
+```
+This is after 2h of training on one node. I wonder if the problem was on some specific node.
+
+Though Remi checked that all nodes used by the training that crashed had this exact setup. And all reported %1 usage.
+
+
+
+To continually diagnose the running nodes's shm memory usage:
+```
+for ((;;)) { (srun --jobid 637799 --gres=gpu:0 $six_ALL_CCFRWORK/bin/report_shm_usage | grep -v "1%"); sleep 10; }
+```
+after adjusting the jobid number.
+
+where:
+```
+cat $six_ALL_CCFRWORK/bin/report_shm_usage
+#!/usr/bin/bash
+
+# print shared memory usage with the host
+
+echo $(hostname) $(df -h | grep /dev/shm)
+```
+
+The shared memory is used by `DataLoader` workers. We just use the default `args.num_workers==2` and 94GB of shm available on each node is a huge amount of shared memory.
+
+And given that we use TP+PP, a single node doesn't have DDP on it, so no multiproc on the local host. Currently one full model replica uses 2 full nodes (`TP*PP = 2*4 = 8`) So it's really a single Dataloader call per each 2 nodes. i.e. tiny tiny needs.
+
+If this happens again, setting `args.num_workers==0` will stop using shared memory, but it'll impact the data loading speed.
+
+Jared hasn't seen this problem in his experience.
+
+So at the moment we don't know what happened.
+
+2 more 20h trainings have been run since then w/o any problems.
+
+## Checking the progress
+
+Someone asked when the current training will complete:
+
+Let's do math:
+
+1. we are currently going at 784 samples in 32 seconds, or 24.5 samples / sec
+2. roughly we have 145M samples to go, so at the current speed 32nodes if we manage to have 20h allocation every 24 hours we get about 82 days. (145_000_000/(20*60*60*24.5))
+3. we should reach GBS=1024 hopefully today and then we can crank up to 64nodes, which should roughly double the speed, so it'll take 41 days to complete if all goes well and we don't sit in the queue for more than 4 hours.
+4. we can dare to try 128 nodes, which would quadruple the speed and we should be done in about 20 days. It's hard to tell how quickly the SLURM scheduler will provide such a large allocation - if more than half-day of wait time, we are probably better off with 64 nodes.
+
+
+## Round3 SAVE_INTERVAL=1500 NNODES=64
+
+Finally GBS is at 1024, so we can do 64 nodes. Clocking about 23-26 secs / iteration - the performance jumps around quite a lot from run to run. But we know that already about JZ - it's very unsteady and depends on network usage by others.
+
+Created a dedicated branch `tr1-13B`, which allows further development w/o the risk of breaking the current training.
+
+## A huge lm loss spike
+
+The training loss just jumped from ~3 to ~9
+```
+ iteration    29020/  311541 | consumed samples:     10698064 | elapsed time per iteration (ms): 22306.6 | learning rate: 9.850E-05 | global batch size:  1024 | lm loss: 2.775923E+00 | loss scale: 32768.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29030/  311541 | consumed samples:     10708304 | elapsed time per iteration (ms): 22336.4 | learning rate: 9.849E-05 | global batch size:  1024 | lm loss: 2.772822E+00 | loss scale: 32768.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29040/  311541 | consumed samples:     10718544 | elapsed time per iteration (ms): 22332.6 | learning rate: 9.849E-05 | global batch size:  1024 | lm loss: 2.768131E+00 | loss scale: 65536.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29050/  311541 | consumed samples:     10728784 | elapsed time per iteration (ms): 22148.5 | learning rate: 9.849E-05 | global batch size:  1024 | lm loss: 7.343709E+00 | loss scale: 8192.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29060/  311541 | consumed samples:     10739024 | elapsed time per iteration (ms): 22181.7 | learning rate: 9.849E-05 | global batch size:  1024 | lm loss: 8.715872E+00 | loss scale: 4096.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29070/  311541 | consumed samples:     10749264 | elapsed time per iteration (ms): 22107.1 | learning rate: 9.848E-05 | global batch size:  1024 | lm loss: 7.654131E+00 | loss scale: 4096.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29080/  311541 | consumed samples:     10759504 | elapsed time per iteration (ms): 22131.2 | learning rate: 9.848E-05 | global batch size:  1024 | lm loss: 7.192470E+00 | loss scale: 4096.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29090/  311541 | consumed samples:     10769744 | elapsed time per iteration (ms): 22119.2 | learning rate: 9.848E-05 | global batch size:  1024 | lm loss: 6.849044E+00 | loss scale: 4096.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+```
+
+You can see the spike at https://huggingface.co/bigscience/tr1-13B-tensorboard/tensorboard
+
+It took some 500 iterations to recover.
+
+There was a second spike a bit later, half the first one this time and recovered very quickly.
+
+We discussed why it may have happened, but we don't have any definitive answer.
+
+
+## Checkpoint bloat issue
+
+We have an issue with per-layer checkpoints that are way bigger than they should be. They are 10x bigger than what they should be. After some research we discovered that `torch.save()` doesn't save the current view, but the whole tensor with its original tensor storage. So that's why were were getting 10x bigger files than the actual data in the per-layer checkpoints.
+
+We need to `.clone()` the tensors before saving them. and then the checkpoint for layers is just modelsize*2 bytes. The reason they were bloated is because ZeRO-1 pre-allocated large tensor buffers for run-time optimization. So this needs to be fixed in Deepspeed's pipe checkpoing saving.
+
+Also will write a script to fix the already-saved checkpoints to `clone` and re-save.
+
+
+## old NCCL
+
+Discovered the NCCL was statically linked into the distributed pytorch and it's really old 2.7.9. Supposedly newer NCCL should help with OPA interlink performance. But that means we either need to switch to a more recent pytorch or build our own. This is not resolved yet.
+
+
+## Watchdog
+
+We created a watchdog, that reports if we are running/scheduled and alerts if neither is happening. E.g. the recent log in the main log file was:
+
+```
+ iteration    33240/  311541 | consumed samples:     15019344 | elapsed time per iteration (ms): 23491.4 | learning rate: 9.702E-05 | global batch size:  1024 | lm loss: 2.722675E+00 | loss scale: 32768.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+saving checkpoint at iteration   33241 to /gpfsscratch/rech/six/commun/checkpoints/tr1-13B/checkpoints
+[2021-08-08 01:00:44,221] [INFO] [logging.py:68:log_dist] [Rank 0] Saving model checkpoint: /gpfsscratch/rech/six/commun/checkpoints/tr1-13B/checkpoints/global_step33241/mp_rank_00_model_states.pt
+  successfully saved checkpoint at iteration   33241 to /gpfsscratch/rech/six/commun/checkpoints/tr1-13B/checkpoints
+time (ms) | save-checkpoint: 57514.53
+[exiting program after 1190.0357275923093 minutes] datetime: 2021-08-08 01:00:51
+[2021-08-08 01:49:40] ***ALERT: tr1-13B-round3.slurm is not RUNNING or SCHEDULED! Alert someone at Eng WG***
+[2021-08-08 02:49:44] ***ALERT: tr1-13B-round3.slurm is not RUNNING or SCHEDULED! Alert someone at Eng WG***
+[2021-08-08 03:56:54] tr1-13B-round3 is scheduled to start in 3 days, 7:24:19 (at 2021-08-11T11:21:14) (682842_[1-5%1] on 'gpu_p13' partition)
+```
+
+## NNODES=96
+
+We thoughts that trying more nodes would be a good idea, but 96 nodes proved to be unacceptable, since
+
+GBS=1024 is not divisible by 384 (96*4), so there is no way to spread data evenly across all replicas.
+
+We can only have either 256, 512 or 1024 gpus (64, 128, 256 nodes)
+
+## Corrupt GPU crashes the training multiple times
+
+One of the array job trainings crashes after many hours of training:
+
+```
+iteration    43680/  311541 | consumed samples:     25709904 | elapsed time per iteration (ms): 25593.4 | learning rate: 9.135E-05 | global batch size:  1024 | lm loss: 2.635663E+00 | loss scale: 131072.0 | grad norm: 17224.723 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+Traceback (most recent call last):
+  File "/gpfswork/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/pretrain_gpt.py", line 222, in <module>
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/training.py", line 144, in pretrain
+    iteration = train(forward_step_func,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/training.py", line 677, in train
+    train_step(forward_step_func,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/training.py", line 381, in train_step
+    loss = model[0].train_batch(data_iter=data_iterator)
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/DeepSpeed-big-science/deepspeed/runtime/pipe/engine.py", line 291, in train_batch
+    self._exec_schedule(sched)
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/DeepSpeed-big-science/deepspeed/runtime/pipe/engine.py", line 1237, in _exec_schedule
+    self._exec_instr(**cmd.kwargs)
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/DeepSpeed-big-science/deepspeed/runtime/pipe/engine.py", line 679, in _exec_backward_pass
+    torch.autograd.backward(tensors=(outputs, ), grad_tensors=(grad_tensors, ))
+  File "/gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/autograd/__init__.py", line 145, in backward
+    Variable._execution_engine.run_backward(
+RuntimeError: transform: failed to synchronize: cudaErrorECCUncorrectable: uncorrectable ECC error encountered
+terminate called after throwing an instance of 'c10::Error'
+  what():  CUDA error: uncorrectable ECC error encountered
+Exception raised from create_event_internal at /opt/conda/conda-bld/pytorch_1616554793803/work/c10/cuda/CUDACachingAllocator.cpp:733 (most recent call first):
+frame #0: c10::Error::Error(c10::SourceLocation, std::string) + 0x42 (0x1500fb4d42f2 in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libc10.so)
+frame #1: c10::detail::torchCheckFail(char const*, char const*, unsigned int, std::string const&) + 0x5b (0x1500fb4d167b in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libc10.so)
+frame #2: c10::cuda::CUDACachingAllocator::raw_delete(void*) + 0x809 (0x1500fb72d219 in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libc10_cuda.so)
+frame #3: c10::TensorImpl::release_resources() + 0x54 (0x1500fb4bc3a4 in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libc10.so)
+frame #4: <unknown function> + 0x6e0e5a (0x150152432e5a in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libtorch_python.so)
+frame #5: <unknown function> + 0x6e0ef1 (0x150152432ef1 in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libtorch_python.so)
+frame #6: <unknown function> + 0x1a6b5a (0x56434fce9b5a in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #7: <unknown function> + 0x110b7c (0x56434fc53b7c in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #8: <unknown function> + 0x1105b9 (0x56434fc535b9 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #9: <unknown function> + 0x1105a3 (0x56434fc535a3 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #10: <unknown function> + 0x1105a3 (0x56434fc535a3 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #11: <unknown function> + 0x177917 (0x56434fcba917 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #12: PyDict_SetItemString + 0x4c (0x56434fcbd86c in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #13: PyImport_Cleanup + 0xac (0x56434fd2f0ec in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #14: Py_FinalizeEx + 0x79 (0x56434fd95589 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #15: Py_RunMain + 0x1bc (0x56434fd988fc in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #16: Py_BytesMain + 0x39 (0x56434fd98ce9 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #17: __libc_start_main + 0xf3 (0x150183467873 in /lib64/libc.so.6)
+frame #18: <unknown function> + 0x1f7847 (0x56434fd3a847 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+```
+
+Nobody was around to notice and slurm scheduler started the next training job in the array, and it crashed too this time right away on:
+
+```
+> initializing tensor model parallel with size 2
+> initializing pipeline model parallel with size 4
+> setting random seeds to 42 ...
+[2021-08-12 08:19:28,225] [INFO] [checkpointing.py:226:model_parallel_cuda_manual_seed] > initializing model parallel cuda seeds on global rank 0, model parallel rank 0, and data parallel rank 0 with model parallel seed: 2760 and data parallel seed: 42
+> compiling dataset index builder ...
+make: Entering directory '/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/data'
+make: Nothing to be done for 'default'.
+make: Leaving directory '/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/data'
+>>> done with dataset index builder. Compilation time: 0.338 seconds
+> compiling and loading fused kernels ...
+Traceback (most recent call last):
+  File "/gpfswork/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/pretrain_gpt.py", line 222, in <module>
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/training.py", line 95, in pretrain
+    initialize_megatron(extra_args_provider=extra_args_provider,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/initialize.py", line 89, in initialize_megatron
+    _compile_dependencies()
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/initialize.py", line 140, in _compile_dependencies
+    torch.distributed.barrier()
+  File "/gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/distributed/distributed_c10d.py", line 2420, in barrier
+    work = default_pg.barrier(opts=opts)
+RuntimeError: CUDA error: out of memory
+```
+
+We figured one of the gpus had a hardware problem. So it crashed the first time. And then the scheduler allocated the same node and of course, we crashed again.
+
+We contacted JZ admins and indeed one of the nodes was faulty. The next training didn't hit this node and the training continued.
+
+Unfortunately we currently don't have a way to correlate the exceptions to the hostname of the node that it happened on. It's really to have this feature available, since if we don't, we can keep on hitting the faulty node and it'll continue crashing the training. If we know the node's hostname we can exclude it from the `sbatch --exclude=node1,node2,... `.
+
+update: At the moment we have to add `%N` to `#SBATCH --output=%x-%j-%N.out` and then each node will have is own log file and then we can tell which node has a corrupt GPU.
+
+## Really long wait time to get allocation
+
+When a job gets queued we often see 3 days expected wait time before yielding, but most of the time the job comes through in several hours. Sometimes we have to wait for a really long time, like 30h, with scheduler bumping our job down multiple times. This is a big problem as it pushes the finish line away continuously. We aren't anywhere close to being able to train 24/7 despite having many hours allocated to us for this project.
+
+Another problem is that within a project we don't have a way to give the main training job a higher priority than other jobs that we run in parallel on various experiments and small trainings. There really should be a way for a user to say, this is a high priority job amongst all other jobs of the same group. But we didn't find a way to do that.
+
+## Test suite added
+
+A `Megatron-Deepspeed` test suite was finally added. It was odd Megatron-LM didn't have one in the first place, so we had to create our own.
+
+Now need to find some hardware with 2 gpus to create a CI.
+
+## Reduced evaluation iterations
+
+Noticed that somehow it was configured to run eval for 100 iterations, after discussion reduced it to 5, thus saving some resources. While validation iterations are much faster than training, this wasn't really needed.
+
+## NNODES=128
+
+Taking advantage of August's holiday in France was able to switch to 128 nodes.
+
+Observed a further drop in TFLOPs, since now we had even less microbatches to go around. This is because Global BS remained the same (GBS=1024) and we currently use 2 nodes for a single replica (TP=2 * TP=4). So with 128 nodes, we have 64 replicas, which leaves only GAS=16 per replica, and that's too little for an efficient pipeline. The idle bubble is too big.
+
+The benchmarking/tune up was done with GAS=128 (GBS=1024/8) and that's where we were getting high TFLops.
+
+Nevertheless, the training is going much faster now and we will catch up lost time quickly.
+
+## NCCL experiments
+
+It was suggested that newer NCCL will lead to faster inter-node communication.
+
+
+hypothesis that newer nccl should be faster on JZ, but the short experiments I run didn't support it. I get the same throughput with:
+
+1. pt=1.8.1, cuda=11.1, nccl=2708
+2. pt=1.9.0, cuda=11.1, nccl=2708
+3. pt=1.10.0.dev20210821, cuda=11.3, nccl=(2, 10, 3)
+
+The experiment was run on the same 4-node allocation with GBS=64, but otherwise everything else was the same as the current training script. The speed was 17-17.5 secs per iteration. Did about 100 iterations.
+So we will stick to pt=1.8.1 for now until a need arises to change that.
+
+## SLURM Job Arrays and Dependency
+
+Switched to using SLURM Job Arrays and Dependency to schedule jobs. Since our account has a huge allocation we were able to start new 20h jobs with no delay.
+
+If this approach is not used even a tiny delay between finishing one job and scheduling the next one often lead to 1-30 hours of wait time in the queue. This is because the scheduler was quick to allocate other jobs in the first few seconds of finishing the currently running job.
+
+The problem remained if something goes wrong - e.g. a mistake in a script or some hardware issue, would lead to a delay in staring new jobs and a long long wait time.
+
+This training was getting its software updated a lot as missing features were added, so it wasn't a super-stable polished production environment.
+
+So as long as we had a stable setup using SLURM Job Arrays and Dependency chaining things went well. When we couldn't use those SLURM was delaying our training sometimes by a lot.
+
+Also since we run secondary trainings we learned to use `--nice=10000` for those trainings. Without this method all slurm jobs of the same account had the same priority.
+
+## Added an alert email notification
+
+Previously implemented watchdog now got hooked up to email notifications, so if it detected that no job was running or scheduled it'd let the group know.
+
+## Checkpoint bloat fixed
+
+The Deepspeed team fixed the bloat in the checkpoints, so new checkpoints were taking 10x less space for layer weights.
+
+I then processed all the old checkpoints to remove the bloat using:
+
+```
+srun -p prepost  -A six@cpu --time=20:00:00 --pty bash
+wget https://raw.githubusercontent.com/stas00/toolbox/master/pytorch/pt-checkpoint-shrink.py
+chmod a+x pt-checkpoint-shrink.py
+cd checkpoints
+find -type d -name "global_step*" -exec pt-checkpoint-shrink.py --checkpoint_dir {} --patterns "layer*pt" \;
+```
+
+## CI was added
+
+A CI was implemented using EC2 instance on demand. With the help of https://github.com/machulav/ec2-github-runner
+
+Eventually it proved to be not usable for PRs made from the forks, as EC2 needs secrets that github actions won't give to PRs not originating from the origin. So this CI is not very useful.
+
+
+## Training completed
+
+On Sep 6th we reached the 300B tokens and on Sep 7th we stopped the training - It took some ~5 weeks to complete.
+
+
+## Checkpoint conversion
+
+We still need to figure out how to make the checkpoint available in the HF `transformers` format. This is a work in progress.
+
+Update: This has been done. All checkpoints converted to HF format and uploaded to HUB.
+
+See [README.md](README.md) for nuances of the conversion.
+
+Made a mistake in the activation function setting when writing the HF model after the conversion. It proved to be a complex situation but it needs to be `gelu_fast` on the HF side since we are using `args.openai_gelu = False; args.bias_gelu_res = True`. So applied fixes to the models on the HUB using the following:
+
+```
+cd /gpfsssd/scratch/rech/six/commun/experiments/fix-config/
+export GIT_LFS_SKIP_SMUDGE=1
+git clone https://huggingface.co/bigscience/tr3e-1B3-c4-checkpoints
+cd tr3e-1B3-c4-checkpoints
+~/prod/code/bigscience/tools/hub-sync.py --repo-path . --patterns '*bogus*'
+set +H
+git branch -a | sort -V | perl -lne 'm|(global_step\d+)| && print qx[git checkout $1; perl -pi -e "s/gelu(?!_)/gelu_fast/" $1/config.json; git commit -m "gelu_fast is the correct activation_function" .; git push --set-upstream origin $1]'
+export GIT_LFS_SKIP_SMUDGE=0
+```
+Note using the trick of not checkout out LFS files since we only need to modify `config.json` which is a normal file - this is thousands times faster than normal checkout.
+
+
+
+and for GCS:
+```
+start-prod
+cd /gpfsssd/scratch/rech/six/commun/checkpoints/to-upload/
+perl -pi -e 's|gelu|gelu_fast|' checkpoints/*/config.json
+gsutil -m rsync -x ".*bin$" -r checkpoints gs://bigscience-backups/tr1-13B/checkpoints
+```

bigscience/train/tr1-13B-base/start-tr1-13B

@@ -0,0 +1,57 @@
+# This is a python production script for JZ / tr1-13B training
+#
+# Activate with:
+#
+# source ./start-tr1-13B
+#
+#
+
+# # if this session isn't run via a login shell, which is the case when running a
+# # command which is not shell via ssh, the bash function `module` will be missing.
+# # so work around it by emulating part of the login shell that loads modules environment
+# if [ -z $(type -t module) ]
+# then
+#    . /etc/profile.d/z_modules.sh
+# fi
+module purge
+module load pytorch-gpu/py3/1.8.1
+module load nvtop git-lfs github-cli mc
+
+# git prompt
+export GIT_PROMPT_ONLY_IN_REPO=0;
+export GIT_PROMPT_THEME="JZPRod"
+source $six_ALL_CCFRWORK/envs/.bash-git-prompt/gitprompt.sh
+
+# We are using common disk spaces for datasets, caches, and experiment dumps:
+#
+#- Code, cache and datasets -> `$six_ALL_CCFRWORK/cache_dir` and ``$six_ALL_CCFRWORK/datasets`
+#- Experiment dumps -> `$six_ALL_CCFRWORK/experiments`
+
+# specific caches
+
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+
+export DATASETS_CUSTOM=$six_ALL_CCFRWORK/datasets-custom
+
+### CONDA ###
+
+# >>> conda initialize >>>
+# !! Contents within this block are managed by 'conda init' !!
+__conda_setup="$('/gpfslocalsup/pub/anaconda-py3/2020.02/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
+if [ $? -eq 0 ]; then
+    eval "$__conda_setup"
+else
+    if [ -f "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh" ]; then
+        . "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh"
+    else
+        export PATH="/gpfslocalsup/pub/anaconda-py3/2020.02/bin:$PATH"
+    fi
+fi
+unset __conda_setup
+# <<< conda initialize <<<
+
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+conda activate tr1-13B

bigscience/train/tr1-13B-base/tr1-13B-hub-sync-logs.slurm

@@ -0,0 +1,23 @@
+#!/bin/bash
+#SBATCH --job-name=tr1-13B-hub-sync-logs  # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1                    # number of nodes
+#SBATCH --cpus-per-task=1            # number of cores per task
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=1:00:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --partition=compil
+#SBATCH --account=six@cpu
+
+echo "START TIME: $(date)"
+
+source $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B
+module load git-lfs
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+LOGS_PATH=$DATA_OUTPUT_PATH/logs
+BIG_SCIENCE_REPO_PATH=$six_ALL_CCFRWORK/code/tr1-13B/bigscience
+
+$BIG_SCIENCE_REPO_PATH/tools/hub-sync.py --repo-path $LOGS_PATH --patterns '*.txt' -d
+
+echo "END TIME: $(date)"

bigscience/train/tr1-13B-base/tr1-13B-hub-sync-tensorboard.slurm

@@ -0,0 +1,23 @@
+#!/bin/bash
+#SBATCH --job-name=tr1-13B-hub-sync-tensorboard  # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1                    # number of nodes
+#SBATCH --cpus-per-task=1            # number of cores per task
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=2:00:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --partition=compil
+#SBATCH --account=six@cpu
+
+echo "START TIME: $(date)"
+
+source $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B
+module load git-lfs
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+TENSORBOARD_PATH=$DATA_OUTPUT_PATH/tensorboard
+BIG_SCIENCE_REPO_PATH=$six_ALL_CCFRWORK/code/tr1-13B/bigscience
+
+$BIG_SCIENCE_REPO_PATH/tools/hub-sync.py --repo-path $TENSORBOARD_PATH --patterns '*tfevents*' -d
+
+echo "END TIME: $(date)"

bigscience/train/tr1-13B-base/tr1-13B-round1.slurm

@@ -0,0 +1,174 @@
+#!/bin/bash
+#SBATCH --job-name=tr1-13B-round3
+#SBATCH --constraint=v100-32g
+#SBATCH --nodes=128
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:4                 # number of gpus
+#SBATCH --time 20:00:00              # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@v100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B
+
+echo "START TIME: $(date)"
+
+#ROUND=3
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints
+TENSORBOARD_PATH=$DATA_OUTPUT_PATH/tensorboard
+CODECARBON_PATH=$DATA_OUTPUT_PATH/codecarbon
+LOGS_PATH=$DATA_OUTPUT_PATH/logs
+
+MEGATRON_DEEPSPEED_REPO=$six_ALL_CCFRWORK/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/
+
+VOCAB_FILE=$MEGATRON_DEEPSPEED_REPO/data/gpt2-vocab.json
+MERGE_FILE=$MEGATRON_DEEPSPEED_REPO/data/gpt2-merges.txt
+DATA_PATH=$six_ALL_CCFRWORK/datasets-custom/oscar-en/meg-gpt2_text_document
+
+cd $MEGATRON_DEEPSPEED_REPO
+
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6000
+
+GPUS_PER_NODE=4
+NNODES=128   # switch to 128
+TP_SIZE=2    # always fixed to the size of a single node
+PP_SIZE=4    # NLAYERS must be a multiple of PP_SIZE here
+#DP_SIZE=$NNODES*$GPUS_PER_NODE/($PP_SIZE*$TP_SIZE) # will get derived automatically by trainer
+
+# GLOBAL_BATCH_SIZE has to be divisible by MICRO_BATCH_SIZE*DP_size
+# GLOBAL_BATCH_SIZE=$(($MICRO_BATCH_SIZE*$GAS*$DP_SIZE)) - GAS is auto-derived by deepspeed
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=1024
+
+NLAYERS=40
+NHIDDEN=5120
+NHEADS=32
+FFN_HIDDEN_SIZE=20480
+SEQ_LEN=2048
+VOCAB_SIZE=50257
+
+SAVE_INTERVAL=1500
+
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.999 \
+    --adam-eps 1e-8 \
+    --lr 1e-4 \
+    --min-lr 1e-5 \
+    --lr-decay-style cosine \
+    --lr-decay-samples 126_953_125 \
+    --lr-warmup-samples 216_320 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-1 \
+    "
+
+EXIT_OPTS=" \
+    --exit-duration-in-mins 1190 \
+    "
+
+GPT_ARGS=" \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --ffn-hidden-size $FFN_HIDDEN_SIZE \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --rampup-batch-size 16 16 5_000_000 \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples 300_000_000 \
+    --vocab-file $VOCAB_FILE \
+    --merge-file $MERGE_FILE \
+    --loss-scale 12 \
+    --clip-grad 1.0 \
+    --fp16 \
+    --checkpoint-activations \
+    --seed 42
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 10 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 1000 \
+    --eval-iters 5 \
+    --codecarbon-dir $CODECARBON_PATH \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.launch \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --master_addr $MASTER_ADDR \
+    --master_port $MASTER_PORT \
+    "
+
+export CMD=" \
+    `pwd`/pretrain_gpt.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --data-path $DATA_PATH \
+    --data-impl mmap \
+    --split 949,50,1 \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# to debug - add echo (it exits and prints what it would have launched)
+clear; srun --jobid $SLURM_JOBID bash -c '$LAUNCHER --node_rank $SLURM_PROCID $CMD' 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"
+
+#