Add files using upload-large-folder tool

ckpts/llama-3b/global_step100/bf16_zero_pp_rank_185_mp_rank_03_optim_states.pt

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

ckpts/llama-3b/global_step100/bf16_zero_pp_rank_46_mp_rank_03_optim_states.pt

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

venv/lib/python3.10/site-packages/huggingface_hub/serialization/__init__.py

@@ -0,0 +1,20 @@
+# Copyright 2024 The HuggingFace 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.
+# ruff: noqa: F401
+"""Contains helpers to serialize tensors."""
+
+from ._base import StateDictSplit, split_state_dict_into_shards_factory
+from ._numpy import split_numpy_state_dict_into_shards
+from ._tensorflow import split_tf_state_dict_into_shards
+from ._torch import split_torch_state_dict_into_shards

venv/lib/python3.10/site-packages/huggingface_hub/serialization/_base.py

@@ -0,0 +1,169 @@
+# Copyright 2024 The HuggingFace 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.
+"""Contains helpers to split tensors into shards."""
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, TypeVar
+
+from .. import logging
+
+
+TensorT = TypeVar("TensorT")
+TensorSizeFn_T = Callable[[TensorT], int]
+StorageIDFn_T = Callable[[TensorT], Optional[Any]]
+
+MAX_SHARD_SIZE = 5_000_000_000  # 5GB
+FILENAME_PATTERN = "model{suffix}.safetensors"
+
+logger = logging.get_logger(__file__)
+
+
+@dataclass
+class StateDictSplit:
+    is_sharded: bool = field(init=False)
+    metadata: Dict[str, Any]
+    filename_to_tensors: Dict[str, List[str]]
+    tensor_to_filename: Dict[str, str]
+
+    def __post_init__(self):
+        self.is_sharded = len(self.filename_to_tensors) > 1
+
+
+def split_state_dict_into_shards_factory(
+    state_dict: Dict[str, TensorT],
+    *,
+    get_tensor_size: TensorSizeFn_T,
+    get_storage_id: StorageIDFn_T = lambda tensor: None,
+    filename_pattern: str = FILENAME_PATTERN,
+    max_shard_size: int = MAX_SHARD_SIZE,
+) -> StateDictSplit:
+    """
+    Split a model state dictionary in shards so that each shard is smaller than a given size.
+
+    The shards are determined by iterating through the `state_dict` in the order of its keys. There is no optimization
+    made to make each shard as close as possible to the maximum size passed. For example, if the limit is 10GB and we
+    have tensors of sizes [6GB, 6GB, 2GB, 6GB, 2GB, 2GB] they will get sharded as [6GB], [6+2GB], [6+2+2GB] and not
+    [6+2+2GB], [6+2GB], [6GB].
+
+    <Tip warning={true}>
+
+    If one of the model's tensor is bigger than `max_shard_size`, it will end up in its own shard which will have a
+    size greater than `max_shard_size`.
+
+    </Tip>
+
+    Args:
+        state_dict (`Dict[str, Tensor]`):
+            The state dictionary to save.
+        get_tensor_size (`Callable[[Tensor], int]`):
+            A function that returns the size of a tensor in bytes.
+        get_storage_id (`Callable[[Tensor], Optional[Any]]`, *optional*):
+            A function that returns a unique identifier to a tensor storage. Multiple different tensors can share the
+            same underlying storage. This identifier is guaranteed to be unique and constant for this tensor's storage
+            during its lifetime. Two tensor storages with non-overlapping lifetimes may have the same id.
+        filename_pattern (`str`, *optional*):
+            The pattern to generate the files names in which the model will be saved. Pattern must be a string that
+            can be formatted with `filename_pattern.format(suffix=...)` and must contain the keyword `suffix`
+            Defaults to `"model{suffix}.safetensors"`.
+        max_shard_size (`int` or `str`, *optional*):
+            The maximum size of each shard, in bytes. Defaults to 5GB.
+
+    Returns:
+        [`StateDictSplit`]: A `StateDictSplit` object containing the shards and the index to retrieve them.
+    """
+    storage_id_to_tensors: Dict[Any, List[str]] = {}
+
+    shard_list: List[Dict[str, TensorT]] = []
+    current_shard: Dict[str, TensorT] = {}
+    current_shard_size = 0
+    total_size = 0
+
+    for key, tensor in state_dict.items():
+        # when bnb serialization is used the weights in the state dict can be strings
+        # check: https://github.com/huggingface/transformers/pull/24416 for more details
+        if isinstance(tensor, str):
+            logger.info("Skipping tensor %s as it is a string (bnb serialization)", key)
+            continue
+
+        # If a `tensor` shares the same underlying storage as another tensor, we put `tensor` in the same `block`
+        storage_id = get_storage_id(tensor)
+        if storage_id is not None:
+            if storage_id in storage_id_to_tensors:
+                # We skip this tensor for now and will reassign to correct shard later
+                storage_id_to_tensors[storage_id].append(key)
+                continue
+            else:
+                # This is the first tensor with this storage_id, we create a new entry
+                # in the storage_id_to_tensors dict => we will assign the shard id later
+                storage_id_to_tensors[storage_id] = [key]
+
+        # Compute tensor size
+        tensor_size = get_tensor_size(tensor)
+
+        # If this tensor is bigger than the maximal size, we put it in its own shard
+        if tensor_size > max_shard_size:
+            total_size += tensor_size
+            shard_list.append({key: tensor})
+            continue
+
+        # If this tensor is going to tip up over the maximal size, we split.
+        # Current shard already has some tensors, we add it to the list of shards and create a new one.
+        if current_shard_size + tensor_size > max_shard_size:
+            shard_list.append(current_shard)
+            current_shard = {}
+            current_shard_size = 0
+
+        # Add the tensor to the current shard
+        current_shard[key] = tensor
+        current_shard_size += tensor_size
+        total_size += tensor_size
+
+    # Add the last shard
+    if len(current_shard) > 0:
+        shard_list.append(current_shard)
+    nb_shards = len(shard_list)
+
+    # Loop over the tensors that share the same storage and assign them together
+    for storage_id, keys in storage_id_to_tensors.items():
+        # Let's try to find the shard where the first tensor of this storage is and put all tensors in the same shard
+        for shard in shard_list:
+            if keys[0] in shard:
+                for key in keys:
+                    shard[key] = state_dict[key]
+                break
+
+    # If we only have one shard, we return it => no need to build the index
+    if nb_shards == 1:
+        filename = filename_pattern.format(suffix="")
+        return StateDictSplit(
+            metadata={"total_size": total_size},
+            filename_to_tensors={filename: list(state_dict.keys())},
+            tensor_to_filename={key: filename for key in state_dict.keys()},
+        )
+
+    # Now that each tensor is assigned to a shard, let's assign a filename to each shard
+    tensor_name_to_filename = {}
+    filename_to_tensors = {}
+    for idx, shard in enumerate(shard_list):
+        filename = filename_pattern.format(suffix=f"-{idx+1:05d}-of-{nb_shards:05d}")
+        for key in shard:
+            tensor_name_to_filename[key] = filename
+        filename_to_tensors[filename] = list(shard.keys())
+
+    # Build the index and return
+    return StateDictSplit(
+        metadata={"total_size": total_size},
+        filename_to_tensors=filename_to_tensors,
+        tensor_to_filename=tensor_name_to_filename,
+    )

venv/lib/python3.10/site-packages/huggingface_hub/serialization/_numpy.py

@@ -0,0 +1,68 @@
+# Copyright 2024 The HuggingFace 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.
+"""Contains numpy-specific helpers."""
+
+from typing import TYPE_CHECKING, Dict
+
+from ._base import FILENAME_PATTERN, MAX_SHARD_SIZE, StateDictSplit, split_state_dict_into_shards_factory
+
+
+if TYPE_CHECKING:
+    import numpy as np
+
+
+def split_numpy_state_dict_into_shards(
+    state_dict: Dict[str, "np.ndarray"],
+    *,
+    filename_pattern: str = FILENAME_PATTERN,
+    max_shard_size: int = MAX_SHARD_SIZE,
+) -> StateDictSplit:
+    """
+    Split a model state dictionary in shards so that each shard is smaller than a given size.
+
+    The shards are determined by iterating through the `state_dict` in the order of its keys. There is no optimization
+    made to make each shard as close as possible to the maximum size passed. For example, if the limit is 10GB and we
+    have tensors of sizes [6GB, 6GB, 2GB, 6GB, 2GB, 2GB] they will get sharded as [6GB], [6+2GB], [6+2+2GB] and not
+    [6+2+2GB], [6+2GB], [6GB].
+
+    <Tip warning={true}>
+
+    If one of the model's tensor is bigger than `max_shard_size`, it will end up in its own shard which will have a
+    size greater than `max_shard_size`.
+
+    </Tip>
+
+    Args:
+        state_dict (`Dict[str, np.ndarray]`):
+            The state dictionary to save.
+        filename_pattern (`str`, *optional*):
+            The pattern to generate the files names in which the model will be saved. Pattern must be a string that
+            can be formatted with `filename_pattern.format(suffix=...)` and must contain the keyword `suffix`
+            Defaults to `"model{suffix}.safetensors"`.
+        max_shard_size (`int` or `str`, *optional*):
+            The maximum size of each shard, in bytes. Defaults to 5GB.
+
+    Returns:
+        [`StateDictSplit`]: A `StateDictSplit` object containing the shards and the index to retrieve them.
+    """
+    return split_state_dict_into_shards_factory(
+        state_dict,
+        max_shard_size=max_shard_size,
+        filename_pattern=filename_pattern,
+        get_tensor_size=get_tensor_size,
+    )
+
+
+def get_tensor_size(tensor: "np.ndarray") -> int:
+    return tensor.nbytes

venv/lib/python3.10/site-packages/huggingface_hub/serialization/_tensorflow.py

@@ -0,0 +1,94 @@
+# Copyright 2024 The HuggingFace 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.
+"""Contains tensorflow-specific helpers."""
+
+import math
+import re
+from typing import TYPE_CHECKING, Dict
+
+from ._base import MAX_SHARD_SIZE, StateDictSplit, split_state_dict_into_shards_factory
+
+
+if TYPE_CHECKING:
+    import tensorflow as tf
+
+
+def split_tf_state_dict_into_shards(
+    state_dict: Dict[str, "tf.Tensor"],
+    *,
+    filename_pattern: str = "tf_model{suffix}.h5",
+    max_shard_size: int = MAX_SHARD_SIZE,
+) -> StateDictSplit:
+    """
+    Split a model state dictionary in shards so that each shard is smaller than a given size.
+
+    The shards are determined by iterating through the `state_dict` in the order of its keys. There is no optimization
+    made to make each shard as close as possible to the maximum size passed. For example, if the limit is 10GB and we
+    have tensors of sizes [6GB, 6GB, 2GB, 6GB, 2GB, 2GB] they will get sharded as [6GB], [6+2GB], [6+2+2GB] and not
+    [6+2+2GB], [6+2GB], [6GB].
+
+    <Tip warning={true}>
+
+    If one of the model's tensor is bigger than `max_shard_size`, it will end up in its own shard which will have a
+    size greater than `max_shard_size`.
+
+    </Tip>
+
+    Args:
+        state_dict (`Dict[str, Tensor]`):
+            The state dictionary to save.
+        filename_pattern (`str`, *optional*):
+            The pattern to generate the files names in which the model will be saved. Pattern must be a string that
+            can be formatted with `filename_pattern.format(suffix=...)` and must contain the keyword `suffix`
+            Defaults to `"tf_model{suffix}.h5"`.
+        max_shard_size (`int` or `str`, *optional*):
+            The maximum size of each shard, in bytes. Defaults to 5GB.
+
+    Returns:
+        [`StateDictSplit`]: A `StateDictSplit` object containing the shards and the index to retrieve them.
+    """
+    return split_state_dict_into_shards_factory(
+        state_dict,
+        max_shard_size=max_shard_size,
+        filename_pattern=filename_pattern,
+        get_tensor_size=get_tensor_size,
+    )
+
+
+def get_tensor_size(tensor: "tf.Tensor") -> int:
+    # Return `math.ceil` since dtype byte size can be a float (e.g., 0.125 for tf.bool).
+    # Better to overestimate than underestimate.
+    return math.ceil(tensor.numpy().size * _dtype_byte_size_tf(tensor.dtype))
+
+
+def _dtype_byte_size_tf(dtype) -> float:
+    """
+    Returns the size (in bytes) occupied by one parameter of type `dtype`.
+    Taken from https://github.com/huggingface/transformers/blob/74d9d0cebb0263a3f8ab9c280569170cc74651d0/src/transformers/modeling_tf_utils.py#L608.
+    NOTE: why not `tensor.numpy().nbytes`?
+    Example:
+    ```py
+    >>> _dtype_byte_size(tf.float32)
+    4
+    ```
+    """
+    import tensorflow as tf
+
+    if dtype == tf.bool:
+        return 1 / 8
+    bit_search = re.search(r"[^\d](\d+)$", dtype.name)
+    if bit_search is None:
+        raise ValueError(f"`dtype` is not a valid dtype: {dtype}.")
+    bit_size = int(bit_search.groups()[0])
+    return bit_size // 8

venv/lib/python3.10/site-packages/huggingface_hub/serialization/_torch.py

@@ -0,0 +1,200 @@
+# Copyright 2024 The HuggingFace 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.
+"""Contains pytorch-specific helpers."""
+
+import importlib
+from functools import lru_cache
+from typing import TYPE_CHECKING, Dict, Tuple
+
+from ._base import FILENAME_PATTERN, MAX_SHARD_SIZE, StateDictSplit, split_state_dict_into_shards_factory
+
+
+if TYPE_CHECKING:
+    import torch
+
+
+def split_torch_state_dict_into_shards(
+    state_dict: Dict[str, "torch.Tensor"],
+    *,
+    filename_pattern: str = FILENAME_PATTERN,
+    max_shard_size: int = MAX_SHARD_SIZE,
+) -> StateDictSplit:
+    """
+    Split a model state dictionary in shards so that each shard is smaller than a given size.
+
+    The shards are determined by iterating through the `state_dict` in the order of its keys. There is no optimization
+    made to make each shard as close as possible to the maximum size passed. For example, if the limit is 10GB and we
+    have tensors of sizes [6GB, 6GB, 2GB, 6GB, 2GB, 2GB] they will get sharded as [6GB], [6+2GB], [6+2+2GB] and not
+    [6+2+2GB], [6+2GB], [6GB].
+
+    <Tip warning={true}>
+
+    If one of the model's tensor is bigger than `max_shard_size`, it will end up in its own shard which will have a
+    size greater than `max_shard_size`.
+
+    </Tip>
+
+    Args:
+        state_dict (`Dict[str, torch.Tensor]`):
+            The state dictionary to save.
+        filename_pattern (`str`, *optional*):
+            The pattern to generate the files names in which the model will be saved. Pattern must be a string that
+            can be formatted with `filename_pattern.format(suffix=...)` and must contain the keyword `suffix`
+            Defaults to `"model{suffix}.safetensors"`.
+        max_shard_size (`int` or `str`, *optional*):
+            The maximum size of each shard, in bytes. Defaults to 5GB.
+
+    Returns:
+        [`StateDictSplit`]: A `StateDictSplit` object containing the shards and the index to retrieve them.
+
+    Example:
+    ```py
+    >>> import json
+    >>> import os
+    >>> from safetensors.torch import save_file as safe_save_file
+    >>> from huggingface_hub import split_torch_state_dict_into_shards
+
+    >>> def save_state_dict(state_dict: Dict[str, torch.Tensor], save_directory: str):
+    ...     state_dict_split = split_torch_state_dict_into_shards(state_dict)
+    ...     for filename, tensors in state_dict_split.filename_to_tensors.values():
+    ...         shard = {tensor: state_dict[tensor] for tensor in tensors}
+    ...         safe_save_file(
+    ...             shard,
+    ...             os.path.join(save_directory, filename),
+    ...             metadata={"format": "pt"},
+    ...         )
+    ...     if state_dict_split.is_sharded:
+    ...         index = {
+    ...             "metadata": state_dict_split.metadata,
+    ...             "weight_map": state_dict_split.tensor_to_filename,
+    ...         }
+    ...         with open(os.path.join(save_directory, "model.safetensors.index.json"), "w") as f:
+    ...             f.write(json.dumps(index, indent=2))
+    ```
+    """
+    return split_state_dict_into_shards_factory(
+        state_dict,
+        max_shard_size=max_shard_size,
+        filename_pattern=filename_pattern,
+        get_tensor_size=get_tensor_size,
+        get_storage_id=get_storage_id,
+    )
+
+
+def get_storage_id(tensor: "torch.Tensor") -> Tuple["torch.device", int, int]:
+    """
+    Return unique identifier to a tensor storage.
+
+    Multiple different tensors can share the same underlying storage. For
+    example, "meta" tensors all share the same storage, and thus their identifier will all be equal. This identifier is
+    guaranteed to be unique and constant for this tensor's storage during its lifetime. Two tensor storages with
+    non-overlapping lifetimes may have the same id.
+
+    Taken from https://github.com/huggingface/transformers/blob/1ecf5f7c982d761b4daaa96719d162c324187c64/src/transformers/pytorch_utils.py#L278.
+    """
+    if tensor.device.type == "xla" and is_torch_tpu_available():
+        # NOTE: xla tensors dont have storage
+        # use some other unique id to distinguish.
+        # this is a XLA tensor, it must be created using torch_xla's
+        # device. So the following import is safe:
+        import torch_xla
+
+        unique_id = torch_xla._XLAC._xla_get_tensor_id(tensor)
+    else:
+        unique_id = storage_ptr(tensor)
+
+    return tensor.device, unique_id, get_storage_size(tensor)
+
+
+def get_tensor_size(tensor: "torch.Tensor") -> int:
+    return tensor.numel() * tensor.element_size()
+
+
+@lru_cache()
+def is_torch_tpu_available(check_device=True):
+    """
+    Checks if `torch_xla` is installed and potentially if a TPU is in the environment
+
+    Taken from https://github.com/huggingface/transformers/blob/1ecf5f7c982d761b4daaa96719d162c324187c64/src/transformers/utils/import_utils.py#L463.
+    """
+    if importlib.util.find_spec("torch_xla") is not None:
+        if check_device:
+            # We need to check if `xla_device` can be found, will raise a RuntimeError if not
+            try:
+                import torch_xla.core.xla_model as xm
+
+                _ = xm.xla_device()
+                return True
+            except RuntimeError:
+                return False
+        return True
+    return False
+
+
+def storage_ptr(tensor: "torch.Tensor") -> int:
+    """
+    Taken from https://github.com/huggingface/safetensors/blob/08db34094e9e59e2f9218f2df133b7b4aaff5a99/bindings/python/py_src/safetensors/torch.py#L11C1-L20C21.
+    """
+    try:
+        return tensor.untyped_storage().data_ptr()
+    except Exception:
+        # Fallback for torch==1.10
+        try:
+            return tensor.storage().data_ptr()
+        except NotImplementedError:
+            # Fallback for meta storage
+            return 0
+
+
+def get_storage_size(tensor: "torch.Tensor") -> int:
+    """
+    Taken from https://github.com/huggingface/safetensors/blob/08db34094e9e59e2f9218f2df133b7b4aaff5a99/bindings/python/py_src/safetensors/torch.py#L31C1-L41C59
+    """
+    try:
+        return tensor.untyped_storage().nbytes()
+    except AttributeError:
+        # Fallback for torch==1.10
+        try:
+            return tensor.storage().size() * _get_dtype_size(tensor.dtype)
+        except NotImplementedError:
+            # Fallback for meta storage
+            # On torch >=2.0 this is the tensor size
+            return tensor.nelement() * _get_dtype_size(tensor.dtype)
+
+
+@lru_cache()
+def _get_dtype_size(dtype: "torch.dtype") -> int:
+    """
+    Taken from https://github.com/huggingface/safetensors/blob/08db34094e9e59e2f9218f2df133b7b4aaff5a99/bindings/python/py_src/safetensors/torch.py#L344
+    """
+    import torch
+
+    # torch.float8 formats require 2.1; we do not support these dtypes on earlier versions
+    _float8_e4m3fn = getattr(torch, "float8_e4m3fn", None)
+    _float8_e5m2 = getattr(torch, "float8_e5m2", None)
+    _SIZE = {
+        torch.int64: 8,
+        torch.float32: 4,
+        torch.int32: 4,
+        torch.bfloat16: 2,
+        torch.float16: 2,
+        torch.int16: 2,
+        torch.uint8: 1,
+        torch.int8: 1,
+        torch.bool: 1,
+        torch.float64: 8,
+        _float8_e4m3fn: 1,
+        _float8_e5m2: 1,
+    }
+    return _SIZE[dtype]

venv/lib/python3.10/site-packages/sacrebleu/__init__.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2017--2018 Amazon.com, Inc. or its affiliates. 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. A copy of the License
+# is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+
+__version__ = '2.4.2'
+__description__ = 'Hassle-free computation of shareable, comparable, and reproducible BLEU, chrF, and TER scores'
+
+
+from .utils import smart_open, SACREBLEU_DIR, download_test_set
+from .utils import get_source_file, get_reference_files
+from .utils import get_available_testsets, get_langpairs_for_testset
+from .metrics.helpers import extract_word_ngrams, extract_char_ngrams
+from .dataset import DATASETS
+from .metrics import BLEU, CHRF, TER
+
+# Backward compatibility functions for old style API access (<= 1.4.10)
+from .compat import corpus_bleu, raw_corpus_bleu, sentence_bleu
+from .compat import corpus_chrf, sentence_chrf
+from .compat import corpus_ter, sentence_ter
+
+__all__ = [
+    'smart_open', 'SACREBLEU_DIR', 'download_test_set',
+    'get_source_file', 'get_reference_files',
+    'get_available_testsets', 'get_langpairs_for_testset',
+    'extract_word_ngrams', 'extract_char_ngrams',
+    'DATASETS',
+    'BLEU', 'CHRF', 'TER',
+    'corpus_bleu', 'raw_corpus_bleu', 'sentence_bleu',
+    'corpus_chrf', 'sentence_chrf',
+    'corpus_ter', 'sentence_ter'
+]

venv/lib/python3.10/site-packages/sacrebleu/__main__.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2017--2018 Amazon.com, Inc. or its affiliates. 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. A copy of the License
+# is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+
+"""
+SacreBLEU provides hassle-free computation of shareable, comparable, and reproducible BLEU scores.
+Inspired by Rico Sennrich's `multi-bleu-detok.perl`, it produces the official WMT scores but works with plain text.
+It also knows all the standard test sets and handles downloading, processing, and tokenization for you.
+
+See the [README.md] file for more information.
+"""
+from .sacrebleu import main
+
+if __name__ == '__main__':
+    main()

venv/lib/python3.10/site-packages/sacrebleu/compat.py

@@ -0,0 +1,205 @@
+from typing import Sequence, Optional
+
+from .metrics import BLEU, CHRF, TER, BLEUScore, CHRFScore, TERScore
+
+
+######################################################################
+# Backward compatibility functions for old style API access (< 1.4.11)
+######################################################################
+def corpus_bleu(hypotheses: Sequence[str],
+                references: Sequence[Sequence[str]],
+                smooth_method='exp',
+                smooth_value=None,
+                force=False,
+                lowercase=False,
+                tokenize=BLEU.TOKENIZER_DEFAULT,
+                use_effective_order=False) -> BLEUScore:
+    """Computes BLEU for a corpus against a single (or multiple) reference(s).
+    This is the main CLI entry point for computing BLEU between a system output
+    and a reference sentence.
+
+    :param hypotheses: A sequence of hypothesis strings.
+    :param references: A sequence of reference documents with document being
+        defined as a sequence of reference strings.
+    :param smooth_method: The smoothing method to use ('floor', 'add-k', 'exp' or 'none')
+    :param smooth_value: The smoothing value for `floor` and `add-k` methods. `None` falls back to default value.
+    :param force: Ignore data that looks already tokenized
+    :param lowercase: Lowercase the data
+    :param tokenize: The tokenizer to use
+    :param use_effective_order: Don't take into account n-gram orders without any match.
+    :return: a `BLEUScore` object
+    """
+    metric = BLEU(
+        lowercase=lowercase, force=force, tokenize=tokenize,
+        smooth_method=smooth_method, smooth_value=smooth_value,
+        effective_order=use_effective_order)
+
+    return metric.corpus_score(hypotheses, references)
+
+
+def raw_corpus_bleu(hypotheses: Sequence[str],
+                    references: Sequence[Sequence[str]],
+                    smooth_value: Optional[float] = BLEU.SMOOTH_DEFAULTS['floor']) -> BLEUScore:
+    """Computes BLEU for a corpus against a single (or multiple) reference(s).
+    This convenience function assumes a particular set of arguments i.e.
+    it disables tokenization and applies a `floor` smoothing with value `0.1`.
+
+    This convenience call does not apply any tokenization at all,
+    neither to the system output nor the reference. It just computes
+    BLEU on the "raw corpus" (hence the name).
+
+    :param hypotheses: A sequence of hypothesis strings.
+    :param references: A sequence of reference documents with document being
+        defined as a sequence of reference strings.
+    :param smooth_value: The smoothing value for `floor`. If not given, the default of 0.1 is used.
+    :return: Returns a `BLEUScore` object.
+
+    """
+    return corpus_bleu(
+        hypotheses, references, smooth_method='floor',
+        smooth_value=smooth_value, force=True, tokenize='none',
+        use_effective_order=True)
+
+
+def sentence_bleu(hypothesis: str,
+                  references: Sequence[str],
+                  smooth_method: str = 'exp',
+                  smooth_value: Optional[float] = None,
+                  lowercase: bool = False,
+                  tokenize=BLEU.TOKENIZER_DEFAULT,
+                  use_effective_order: bool = True) -> BLEUScore:
+    """
+    Computes BLEU for a single sentence against a single (or multiple) reference(s).
+
+    Disclaimer: Computing BLEU at the sentence level is not its intended use as
+    BLEU is a corpus-level metric.
+
+    :param hypothesis: A single hypothesis string.
+    :param references: A sequence of reference strings.
+    :param smooth_method: The smoothing method to use ('floor', 'add-k', 'exp' or 'none')
+    :param smooth_value: The smoothing value for `floor` and `add-k` methods. `None` falls back to default value.
+    :param lowercase: Lowercase the data
+    :param tokenize: The tokenizer to use
+    :param use_effective_order: Don't take into account n-gram orders without any match.
+    :return: Returns a `BLEUScore` object.
+    """
+    metric = BLEU(
+        lowercase=lowercase, tokenize=tokenize, force=False,
+        smooth_method=smooth_method, smooth_value=smooth_value,
+        effective_order=use_effective_order)
+
+    return metric.sentence_score(hypothesis, references)
+
+
+def corpus_chrf(hypotheses: Sequence[str],
+                references: Sequence[Sequence[str]],
+                char_order: int = CHRF.CHAR_ORDER,
+                word_order: int = CHRF.WORD_ORDER,
+                beta: int = CHRF.BETA,
+                remove_whitespace: bool = True,
+                eps_smoothing: bool = False) -> CHRFScore:
+    """
+    Computes chrF for a corpus against a single (or multiple) reference(s).
+    If `word_order` equals to 2, the metric is referred to as chrF++.
+
+    :param hypotheses: A sequence of hypothesis strings.
+    :param references: A sequence of reference documents with document being
+        defined as a sequence of reference strings.
+    :param char_order: Character n-gram order.
+    :param word_order: Word n-gram order. If equals to 2, the metric is referred to as chrF++.
+    :param beta: Determine the importance of recall w.r.t precision.
+    :param eps_smoothing: If `True`, applies epsilon smoothing similar
+    to reference chrF++.py, NLTK and Moses implementations. Otherwise,
+    it takes into account effective match order similar to sacreBLEU < 2.0.0.
+    :param remove_whitespace: If `True`, removes whitespaces prior to character n-gram extraction.
+    :return: A `CHRFScore` object.
+    """
+    metric = CHRF(
+        char_order=char_order,
+        word_order=word_order,
+        beta=beta,
+        whitespace=not remove_whitespace,
+        eps_smoothing=eps_smoothing)
+    return metric.corpus_score(hypotheses, references)
+
+
+def sentence_chrf(hypothesis: str,
+                  references: Sequence[str],
+                  char_order: int = CHRF.CHAR_ORDER,
+                  word_order: int = CHRF.WORD_ORDER,
+                  beta: int = CHRF.BETA,
+                  remove_whitespace: bool = True,
+                  eps_smoothing: bool = False) -> CHRFScore:
+    """
+    Computes chrF for a single sentence against a single (or multiple) reference(s).
+    If `word_order` equals to 2, the metric is referred to as chrF++.
+
+    :param hypothesis: A single hypothesis string.
+    :param references: A sequence of reference strings.
+    :param char_order: Character n-gram order.
+    :param word_order: Word n-gram order. If equals to 2, the metric is referred to as chrF++.
+    :param beta: Determine the importance of recall w.r.t precision.
+    :param eps_smoothing: If `True`, applies epsilon smoothing similar
+    to reference chrF++.py, NLTK and Moses implementations. Otherwise,
+    it takes into account effective match order similar to sacreBLEU < 2.0.0.
+    :param remove_whitespace: If `True`, removes whitespaces prior to character n-gram extraction.
+    :return: A `CHRFScore` object.
+    """
+    metric = CHRF(
+        char_order=char_order,
+        word_order=word_order,
+        beta=beta,
+        whitespace=not remove_whitespace,
+        eps_smoothing=eps_smoothing)
+    return metric.sentence_score(hypothesis, references)
+
+
+def corpus_ter(hypotheses: Sequence[str],
+               references: Sequence[Sequence[str]],
+               normalized: bool = False,
+               no_punct: bool = False,
+               asian_support: bool = False,
+               case_sensitive: bool = False) -> TERScore:
+    """
+    Computes TER for a corpus against a single (or multiple) reference(s).
+
+    :param hypotheses: A sequence of hypothesis strings.
+    :param references: A sequence of reference documents with document being
+        defined as a sequence of reference strings.
+    :param normalized: Enable character normalization.
+    :param no_punct: Remove punctuation.
+    :param asian_support: Enable special treatment of Asian characters.
+    :param case_sensitive: Enables case-sensitivity.
+    :return: A `TERScore` object.
+    """
+    metric = TER(
+        normalized=normalized,
+        no_punct=no_punct,
+        asian_support=asian_support,
+        case_sensitive=case_sensitive)
+    return metric.corpus_score(hypotheses, references)
+
+
+def sentence_ter(hypothesis: str,
+                 references: Sequence[str],
+                 normalized: bool = False,
+                 no_punct: bool = False,
+                 asian_support: bool = False,
+                 case_sensitive: bool = False) -> TERScore:
+    """
+    Computes TER for a single hypothesis against a single (or multiple) reference(s).
+
+    :param hypothesis: A single hypothesis string.
+    :param references: A sequence of reference strings.
+    :param normalized: Enable character normalization.
+    :param no_punct: Remove punctuation.
+    :param asian_support: Enable special treatment of Asian characters.
+    :param case_sensitive: Enable case-sensitivity.
+    :return: A `TERScore` object.
+    """
+    metric = TER(
+        normalized=normalized,
+        no_punct=no_punct,
+        asian_support=asian_support,
+        case_sensitive=case_sensitive)
+    return metric.sentence_score(hypothesis, references)

venv/lib/python3.10/site-packages/sacrebleu/dataset/__main__.py

@@ -0,0 +1,45 @@
+import sys
+
+from . import DATASETS
+
+try:
+    cmd = sys.argv[1]
+except IndexError:
+    print(f"Usage: {sys.argv[0]} --check | --dump")
+    sys.exit(1)
+
+if cmd == "--check":
+    import hashlib
+    import urllib.request
+
+    url_md5 = {}
+
+    for item in DATASETS.values():
+        if item.md5 is not None:
+            assert item.data
+            assert item.md5
+            assert len(item.data) == len(item.md5)
+            pairs = zip(item.data, item.md5)
+            for url, md5_hash in pairs:
+                url_md5[url] = md5_hash
+
+    for url, md5_hash in url_md5.items():
+        try:
+            print("Downloading ", url)
+            with urllib.request.urlopen(url) as f:
+                data = f.read()
+        except Exception as exc:
+            raise (exc)
+
+        if hashlib.md5(data).hexdigest() != md5_hash:
+            print("MD5 check failed for", url)
+elif cmd == "--dump":
+    import re
+
+    # Dumps a table in markdown format
+    print(f'| {"Dataset":<30} | {"Description":<115} |')
+    header = "| " + "-" * 30 + " | " + "-" * 115 + " |"
+    print(header)
+    for name, item in DATASETS.items():
+        desc = re.sub(r"(http[s]?:\/\/\S+)", r"[URL](\1)", str(item.description))
+        print(f"| {name:<30} | {desc:<115} |")

venv/lib/python3.10/site-packages/sacrebleu/dataset/iwslt_xml.py

@@ -0,0 +1,8 @@
+from .fake_sgml import FakeSGMLDataset
+
+
+class IWSLTXMLDataset(FakeSGMLDataset):
+    """IWSLT dataset format. Can be parsed with the lxml parser."""
+
+    # Same as FakeSGMLDataset. Nothing to do here.
+    pass

venv/lib/python3.10/site-packages/sacrebleu/dataset/plain_text.py

@@ -0,0 +1,36 @@
+import os
+
+from ..utils import smart_open
+from .base import Dataset
+
+
+class PlainTextDataset(Dataset):
+    """
+    The plain text format. Data is separated into source and reference files.
+    Each line of the two files is aligned.
+    """
+
+    def process_to_text(self, langpair=None):
+        """Processes raw files to plain text files.
+
+        :param langpair: The language pair to process. e.g. "en-de". If None, all files will be processed.
+        """
+        # ensure that the dataset is downloaded
+        self.maybe_download()
+        langpairs = self._get_langpair_metadata(langpair)
+
+        for langpair in langpairs:
+            fieldnames = self.fieldnames(langpair)
+            origin_files = [
+                os.path.join(self._rawdir, path) for path in langpairs[langpair]
+            ]
+
+            for field, origin_file in zip(fieldnames, origin_files):
+
+                origin_file = os.path.join(self._rawdir, origin_file)
+                output_file = self._get_txt_file_path(langpair, field)
+
+                with smart_open(origin_file) as fin:
+                    with smart_open(output_file, "wt") as fout:
+                        for line in fin:
+                            print(line.rstrip(), file=fout)

venv/lib/python3.10/site-packages/sacrebleu/dataset/tsv.py

@@ -0,0 +1,61 @@
+import os
+
+from ..utils import smart_open
+from .base import Dataset
+
+
+class TSVDataset(Dataset):
+    """
+    The format used by the MTNT datasets. Data is in a single TSV file.
+    """
+
+    @staticmethod
+    def _split_index_and_filename(meta, field):
+        """
+        Splits the index and filename from a metadata string.
+
+        e.g. meta="3:en-de.tsv", filed=[Any value] -> (3, "en-de.tsv")
+             "en-de.tsv", filed="src" -> (1, "en-de.tsv")
+             "en-de.tsv", filed="tgt" -> (2, "en-de.tsv")
+        """
+        arr = meta.split(":")
+        if len(arr) == 2:
+            try:
+                index = int(arr[0])
+            except ValueError:
+                raise Exception(f"Invalid meta for TSVDataset: {meta}")
+            return index, arr[1]
+
+        else:
+            index = 0 if field == "src" else 1
+            return index, meta
+
+    def process_to_text(self, langpair=None):
+        """Processes raw files to plain text files.
+
+        :param langpair: The language pair to process. e.g. "en-de". If None, all files will be processed.
+        """
+        # ensure that the dataset is downloaded
+        self.maybe_download()
+        langpairs = self._get_langpair_metadata(langpair)
+
+        for langpair in langpairs:
+            fieldnames = self.fieldnames(langpair)
+            origin_files = [
+                os.path.join(self._rawdir, path) for path in langpairs[langpair]
+            ]
+
+            for field, origin_file, meta in zip(
+                fieldnames, origin_files, langpairs[langpair]
+            ):
+                index, origin_file = self._split_index_and_filename(meta, field)
+
+                origin_file = os.path.join(self._rawdir, origin_file)
+                output_file = self._get_txt_file_path(langpair, field)
+
+                with smart_open(origin_file) as fin:
+                    with smart_open(output_file, "wt") as fout:
+                        for line in fin:
+                            # be careful with empty source or reference lines
+                            # MTNT2019/ja-en.final.tsv:632 `'1033\t718\t\t\n'`
+                            print(line.rstrip("\n").split("\t")[index], file=fout)