pyproject.toml

###############################################################################
#                      MLCommons Algorithmic Efficiency.                      #
###############################################################################

[project]
name = "algoperf"
dynamic = ["version"]
description = "Codebase for the AlgoPerf: Training Algorithms benchmark"
authors = [
  { name = "MLCommons Algorithms Working Group", email = "algorithms@mlcommons.org" },
]
license = { text = "Apache 2.0" }
readme = "README.md"
requires-python = ">=3.11"
keywords = [
  "algoperf",
  "algorithmic-efficiency",
  "machine-learning",
  "deep-learning",
  "optimization",
  "benchmarking",
  "training-methods",
]
classifiers = [
  "Development Status :: 3 - Alpha",
  "Intended Audience :: Developers",
  "Intended Audience :: Science/Research",
  "License :: OSI Approved :: Apache Software License",
  "Operating System :: OS Independent",
  "Programming Language :: Python :: 3.8",
  "Programming Language :: Python :: 3.9",
  "Programming Language :: Python :: 3.10",
  "Topic :: Scientific/Engineering :: Artificial Intelligence",
]
dependencies = [
  "absl-py==2.1.0",
  "networkx==3.2.1",
  "docker==7.1.0",
  "numpy>=2.0.2",
  "pandas>=2.0.1",
  "tensorflow==2.18.0",
  "tensorflow-datasets==4.9.7",
  "tensorflow-probability==0.20.0",
  "tensorflow-addons==0.20.0",
  "gputil==1.4.0",
  "psutil==6.1.0",
  "clu==0.0.12",
  "matplotlib>=3.9.2",
  "tabulate==0.9.0",

]

[build-system]
requires = ["setuptools>=45", "setuptools_scm[toml]>=6.2"]
build-backend = "setuptools.build_meta"

[tool.setuptools]
py-modules = ["submission_runner"]
include-package-data = true
zip-safe = false

[tool.setuptools.packages]
find = {} # Scanning implicit namespaces is active by default

[tool.setuptools_scm]
version_file = "algoperf/_version.py"

###############################################################################
#                          (Optional) Dependencies                            #
###############################################################################
[project.optional-dependencies]
# All workloads
full = [
  "algoperf[criteo1tb,fastmri,ogbg,librispeech_conformer,wmt]",
]
# All workloads plus development dependencies
full_dev = ["algoperf[full,dev]"]
# Dependencies for developing the package
dev = [
  "isort==5.12.0",
  "pylint==2.17.4",
  "pytest==8.3.3",
  "yapf==0.32.0",
  "pre-commit==4.0.1",
]

wandb = ["wandb==0.19.6"]

# Workloads
criteo1tb = ["scikit-learn==1.5.2"]
fastmri = ["h5py==3.12.0", "scikit-image==0.24.0"]
ogbg = ["jraph==0.0.6.dev0", "scikit-learn==1.5.2"]
librispeech_conformer = [
  "sentencepiece==0.2.0",
  "tensorflow-text==2.18.0",
  "pydub==0.25.1",
]
wmt = ["sentencepiece==0.2.0", "tensorflow-text==2.18.0"]

# Frameworks
jax_core_deps = [
  "flax==0.8.4",
  "optax==0.2.2",
  "chex==0.1.86",
  "ml_dtypes==0.4.1",
  "protobuf==4.25.5",
]
jax_cpu = [
  "jax==0.4.28",
  "jaxlib==0.4.28",
  "algoperf[jax_core_deps]",
]
jax_gpu = [
  "jax==0.4.28",
  "jaxlib==0.4.28",
  "jax-cuda12-plugin[with_cuda]==0.4.28",
  "jax-cuda12-pjrt==0.4.28",
  "algoperf[jax_core_deps]",
]
pytorch_cpu = ["torch==2.5.1", "torchvision==0.20.1"]
pytorch_gpu = [
  "torch==2.5.1",
  "torchvision==0.20.1",
] # Note: omit the cuda suffix and installing from the appropriate wheel will result in using locally installed CUDA.

###############################################################################
#                           Linting Configurations                            #
###############################################################################

# yapf configuration
[tool.yapf]
based_on_style = "yapf"
each_dict_entry_on_separate_line = false
split_all_top_level_comma_separated_values = true
[tool.yapfignore]
ignore_patterns = ["algoperf/_version.py"]

# isort configuration
[tool.isort]
profile = "google"

# pylint configuration
[tool.pylint.MASTER]
persistent = false
ignore = "get_references_web.py,get_references_web_single_group.py,_version.py"

[tool.pylint.REPORTS]
reports = false
msg-template = "{msg_id}:{line:3} {obj}: {msg} [{symbol}]"

[tool.pylint.MESSAGES_CONTROL]
enable = "indexing-exception,old-raise-syntax"

[tool.pylint.BASIC]
# Required attributes for module, separated by a comma
#required-attributes=
# Regular expression which should only match the name
# of functions or classes which do not require a docstring.
no-docstring-rgx = "(__.*__|main)"
# Min length in lines of a function that requires a docstring.
docstring-min-length = 10
# Regular expression which should only match correct module names. The
# leading underscore is sanctioned for private modules by Google's style
# guide.
#
# There are exceptions to the basic rule (_?[a-z][a-z0-9_]*) to cover
# requirements of Python's module system.
module-rgx = "^(_?[a-z][a-z0-9_]*)|__init__$"
# Regular expression which should only match correct module level names
const-rgx = "^(_?[A-Z][A-Z0-9_]*|__[a-z0-9_]+__|_?[a-z][a-z0-9_]*)$"
# Regular expression which should only match correct class attribute
class-attribute-rgx = "^(_?[A-Z][A-Z0-9_]*|__[a-z0-9_]+__|_?[a-z][a-z0-9_]*)$"
# Regular expression which should only match correct class names
class-rgx = "^_?[A-Z][a-zA-Z0-9]*$"
# Regular expression which should only match correct function names.
# 'camel_case' and 'snake_case' group names are used for consistency of naming
# styles across functions and methods.
function-rgx = "^(?:(?P<exempt>setUp|tearDown|setUpModule|tearDownModule)|(?P<camel_case>_?[A-Z][a-zA-Z0-9]*)|(?P<snake_case>_?[a-z][a-z0-9_]*))$"
# Regular expression which should only match correct method names.
# 'camel_case' and 'snake_case' group names are used for consistency of naming
# styles across functions and methods. 'exempt' indicates a name which is
# consistent with all naming styles.
method-rgx = "(?x)^(?:(?P<exempt>_[a-z0-9_]+__|runTest|setUp|tearDown|setUpTestCase|tearDownTestCase|setupSelf|tearDownClass|_testDatasetSize|setUpClass|test|assert)_*[A-Z0-9][a-zA-Z0-9_]*|(?:test|assert)_*[A-Z0-9][a-zA-Z0-9_]*|next|(?P<camel_case>_{0,2}[A-Z][a-zA-Z0-9_]*)|(?P<snake_case>_{0,2}[a-z][a-z0-9_]*))$"
# Regular expression which should only match correct instance attribute names
attr-rgx = "^_{0,2}[a-z][a-z0-9_]*$"
# Regular expression which should only match correct argument names
argument-rgx = "^[a-z][a-z0-9_]*$"
# Regular expression which should only match correct variable names
variable-rgx = "^[a-z][a-z0-9_]*$"
# Regular expression which should only match correct list comprehension /
# generator expression variable names
inlinevar-rgx = "^[a-z][a-z0-9_]*$"
# Good variable names which should always be accepted, separated by a comma
good-names = "main,_"
# Bad variable names which should always be refused, separated by a comma
bad-names = ""
# List of builtins function names that should not be used, separated by a comma
#bad-functions=input,apply,reduce
# List of decorators that define properties, such as abc.abstractproperty.
property-classes = "abc.abstractproperty"

[tool.pylint.typecheck]
# Tells whether missing members accessed in mixin class should be ignored. A
# mixin class is detected if its name ends with "mixin" (case insensitive).
ignore-mixin-members = true

# List of decorators that create context managers from functions, such as
# contextlib.contextmanager.
contextmanager-decorators = [
  "contextlib.contextmanager",
  "contextlib2.contextmanager",
]

[tool.pylint.VARIABLES]
# Tells whether we should check for unused import in __init__ files.
init-import = false

# A regular expression matching names used for dummy variables (i.e. not used).
dummy-variables-rgx = "^\\*{0,2}(_$|unused_|dummy_)"

# List of additional names supposed to be defined in builtins.
additional-builtins = []

[tool.pylint.CLASSES]
# List of method names used to declare (i.e. assign) instance attributes.
defining-attr-methods = ["__init__", "__new__", "setUp"]

# Valid names for the first argument to a class method.
valid-classmethod-first-arg = ["cls", "class_"]

[tool.pylint.EXCEPTIONS]
overgeneral-exceptions = [
  "builtins.StandardError",
  "builtins.Exception",
  "builtins.BaseException",
]

[tool.pylint.IMPORTS]
# Deprecated modules which should not be used, separated by a comma
deprecated-modules = ["regsub", "TERMIOS", "Bastion", "rexec", "sets"]

[tool.pylint.FORMAT]
# List of checkers and warnings to disable.
disable = [
  "abstract-method",
  "access-member-before-definition",
  "arguments-differ",
  "assignment-from-no-return",
  "attribute-defined-outside-init",
  "bad-mcs-classmethod-argument",
  "bad-option-value",
  "c-extension-no-member",
  "consider-merging-isinstance",
  "consider-using-dict-comprehension",
  "consider-using-enumerate",
  "consider-using-in",
  "consider-using-set-comprehension",
  "consider-using-ternary",
  "deprecated-method",
  "design",
  "file-ignored",
  "fixme",
  "global-statement",
  "import-error",
  "inconsistent-return-statements",
  "invalid-unary-operand-type",
  "len-as-condition",
  "locally-disabled",
  "locally-enabled",
  "misplaced-comparison-constant",
  "missing-docstring",
  "multiple-imports",
  "no-else-return",
  "no-member",
  "no-name-in-module",
  "no-self-use",
  "no-value-for-parameter",
  "not-an-iterable",
  "not-context-manager",
  "pointless-except",
  "protected-access",
  "redefined-argument-from-local",
  "signature-differs",
  "similarities",
  "simplifiable-if-expression",
  "star-args",
  "super-init-not-called",
  "suppressed-message",
  "too-many-function-args",
  "trailing-comma-tuple",
  "trailing-newlines",
  "ungrouped-imports",
  "unnecessary-pass",
  "unsubscriptable-object",
  "unused-argument",
  "useless-object-inheritance",
  "useless-return",
  "useless-suppression",
  "wrong-import-order",
  "wrong-import-position",
  "unneeded-not",
  "unexpected-keyword-arg",
  "redundant-keyword-arg",
  "unspecified-encoding",
  "logging-fstring-interpolation",
  "consider-using-f-string",
  "use-dict-literal",
]
# Maximum number of characters on a single line.
max-line-length = 80
ignore-long-lines = "(?x)(^\\s*(import|from)\\s|^\\s*(\\#\\ )?<?(https?|ftp):\\/\\/[^\\s\\/$.?#].[^\\s]*>?$|^[a-zA-Z_][a-zA-Z0-9_]*\\s*=\\s*('[^']\\S+'|\"[^\"]\\S+\"))"
# Maximum number of lines in a module
max-module-lines = 99999
# String used as indentation unit. We differ from PEP8's normal 4 spaces.
indent-string = '  '
single-line-if-stmt = true
# Do not warn about multiple statements on a single line for constructs like
#   if test: stmt
[tool.pylint.LOGGING]
logging-modules = "logging,absl.logging"
# Add logging modules.
[tool.pylint.MISCELLANEOUS]
# Maximum line length for lambdas
#short-func-length=1
# List of module members that should be marked as deprecated.
# All of the string functions are listed in 4.1.4 Deprecated string functions
# in the Python 2.4 docs.
#deprecated-members=string.atof,string.atoi,string.atol,string.capitalize,string.expandtabs,string.find,string.rfind,string.index,string.rindex,string.count,string.lower,string.split,string.rsplit,string.splitfields,string.join,string.joinfields,string.lstrip,string.rstrip,string.strip,string.swapcase,string.translate,string.upper,string.ljust,string.rjust,string.center,string.zfill,string.replace,sys.exitfunc,sys.maxint
# List of exceptions that do not need to be mentioned in the Raises section of
# a docstring.
#ignore-exceptions=AssertionError,NotImplementedError,StopIteration,TypeError
# Number of spaces of indent required when the last token on the preceding line
# is an open (, [, or {.
indent-after-paren = 4