repo_description: 🤗 Transformers: the model-definition framework for state-of-the-art machine learning models in text, vision, audio, and multimodal models, for both inference and training. 
repo_topics: audio deep-learning deepseek gemma glm hacktoberfest llm machine-learning model-hub natural-language-processing nlp pretrained-models python pytorch pytorch-transformers qwen speech-recognition transformer vlm
code: # Copyright 2020 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.
  
  # tests directory-specific settings - this file is run automatically
  # by pytest before any tests are run
  
  import doctest
  import os
  import sys
  import warnings
  from os.path import abspath, dirname, join
  
  import _pytest
  import pytest
  
  from transformers.testing_utils import (
      HfDoctestModule,
      HfDocTestParser,
      is_torch_available,
      patch_testing_methods_to_collect_info,
      patch_torch_compile_force_graph,
  )
  from transformers.utils import enable_tf32
  from transformers.utils.network_logging import register_network_debug_plugin
  
  
  NOT_DEVICE_TESTS = {
      "test_tokenization",
      "test_tokenization_mistral_common",
      "test_processing",
      "test_beam_constraints",
      "test_configuration_utils",
      "test_data_collator",
      "test_trainer_callback",
      "test_trainer_utils",
      "test_feature_extraction",
      "test_image_processing",
      "test_image_processor",
      "test_image_transforms",
      "test_optimization",
      "test_retrieval",
      "test_config",
      "test_from_pretrained_no_checkpoint",
      "test_keep_in_fp32_modules",
      "test_gradient_checkpointing_backward_compatibility",
      "test_gradient_checkpointing_enable_disable",
      "test_torch_save_load",
      "test_forward_signature",
      "test_model_get_set_embeddings",
      "test_model_main_input_name",
      "test_correct_missing_keys",
      "test_can_use_safetensors",
      "test_load_save_without_tied_weights",
      "test_tied_weights_keys",
      "test_model_weights_reload_no_missing_tied_weights",
      "test_can_load_ignoring_mismatched_shapes",
      "test_model_is_small",
      "ModelTest::test_pipeline_",  # None of the pipeline tests from PipelineTesterMixin (of which XxxModelTest inherits from) are running on device
      "ModelTester::test_pipeline_",
      "/repo_utils/",
      "/utils/",
  }
  
  # allow having multiple repository checkouts and not needing to remember to rerun
  # `pip install -e '.[dev]'` when switching between checkouts and running tests.
  git_repo_path = abspath(join(dirname(__file__), "src"))
  sys.path.insert(1, git_repo_path)
  
  # silence FutureWarning warnings in tests since often we can't act on them until
  # they become normal warnings - i.e. the tests still need to test the current functionality
  warnings.simplefilter(action="ignore", category=FutureWarning)
  
  
  def pytest_configure(config):
      config.addinivalue_line("markers", "is_pipeline_test: mark test to run only when pipelines are tested")
      config.addinivalue_line("markers", "is_staging_test: mark test to run only in the staging environment")
      config.addinivalue_line("markers", "accelerate_tests: mark test that require accelerate")
      config.addinivalue_line("markers", "not_device_test: mark the tests always running on cpu")
      config.addinivalue_line("markers", "torch_compile_test: mark test which tests torch compile functionality")
      config.addinivalue_line("markers", "torch_export_test: mark test which tests torch export functionality")
      config.addinivalue_line("markers", "flash_attn_test: mark test which tests flash attention functionality")
      config.addinivalue_line("markers", "flash_attn_3_test: mark test which tests flash attention 3 functionality")
      config.addinivalue_line("markers", "flash_attn_4_test: mark test which tests flash attention 4 functionality")
      config.addinivalue_line(
          "markers", "all_flash_attn_test: mark test which tests all mainline flash attentions' functionality"
      )
      config.addinivalue_line("markers", "training_ci: mark test for training CI validation")
      config.addinivalue_line("markers", "tensor_parallel_ci: mark test for tensor parallel CI validation")
  
      os.environ["DISABLE_SAFETENSORS_CONVERSION"] = "true"
      register_network_debug_plugin(config)
  
  
  def pytest_collection_modifyitems(items):
      for item in items:
          if any(test_name in item.nodeid for test_name in NOT_DEVICE_TESTS):
              item.add_marker(pytest.mark.not_device_test)
  
  
  def pytest_addoption(parser):
      from transformers.testing_utils import pytest_addoption_shared
  
      pytest_addoption_shared(parser)
  
  
  def pytest_runtest_logreport(report):
      if report.when == "call":
          outcome = "PASSED" if report.passed else "FAILED" if report.failed else "SKIPPED"
          print(f"{report.nodeid} [{outcome}] {report.duration:.2f}s")
  
  
  def pytest_terminal_summary(terminalreporter):
      from transformers.testing_utils import pytest_terminal_summary_main
  
      make_reports = terminalreporter.config.getoption("--make-reports")
      if make_reports:
          pytest_terminal_summary_main(terminalreporter, id=make_reports)
  
  
  def pytest_sessionfinish(session, exitstatus):
      # If no tests are collected, pytest exists with code 5, which makes the CI fail.
      if exitstatus == 5:
          session.exitstatus = 0
  
  
  # Doctest custom flag to ignore output.
  IGNORE_RESULT = doctest.register_optionflag("IGNORE_RESULT")
  
  OutputChecker = doctest.OutputChecker
  
  
  class CustomOutputChecker(OutputChecker):
      def check_output(self, want, got, optionflags):
          if IGNORE_RESULT & optionflags:
              return True
          return OutputChecker.check_output(self, want, got, optionflags)
  
  
  doctest.OutputChecker = CustomOutputChecker
  _pytest.doctest.DoctestModule = HfDoctestModule
  doctest.DocTestParser = HfDocTestParser
  
  if is_torch_available():
      # The flag below controls whether to allow TF32 on cuDNN. This flag defaults to True.
      # We set it to `False` for CI. See https://github.com/pytorch/pytorch/issues/157274#issuecomment-3090791615
      enable_tf32(False)
      # # torch.backends.fp32_precision does not cascade to torch.backends.cudnn.conv.fp32_precision and torch.backends.cudnn.rnn.fp32_precision
      # TODO: Considering move this to `enable_tf32`, or report a bug to `torch`.
      import torch
  
      # In order to set `torch.backends.cudnn.conv.fp32_precision = "ieee"` below (new API), we still need to set this
      # (old API) because it defaults to `True` (and not changed automatically when we change `cudnn.conv.fp32_precision`)
      # and such inconsistency cause `torch` to complain `RuntimeError: PyTorch is checking whether allow_tf32 is enabled for cuDNN without a specific operator name,but the current flag(s) indica
      # te that cuDNN conv and cuDNN RNN have different TF32 flags.This combination indicates that you have used a mix of the legacy and new APIs
      #  to set the TF32 flags. We suggest only using the new API to set the TF32 flag(s).`.
      # TODO: report a bug to `torch`
      if hasattr(torch.backends.cudnn, "allow_tf32"):
          torch.backends.cudnn.allow_tf32 = False
  
      # This is necessary to make several `test_batching_equivalence` pass (within the tolerance `1e-5`)
      if hasattr(torch.backends.cudnn, "conv") and hasattr(torch.backends.cudnn.conv, "fp32_precision"):
          torch.backends.cudnn.conv.fp32_precision = "ieee"
  
      # patch `torch.compile`: if `TORCH_COMPILE_FORCE_FULLGRAPH=1` (or values considered as true, e.g. yes, y, etc.),
      # the patched version will always run with `fullgraph=True`.
      patch_torch_compile_force_graph()
  
  
  if os.environ.get("PATCH_TESTING_METHODS_TO_COLLECT_OUTPUTS", "").lower() in ("yes", "true", "on", "y", "1"):
      patch_testing_methods_to_collect_info()
  