

"""simple docstring"""






import time
import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, torch_device

from ..test_modeling_common import ids_tensor


if is_torch_available():
 import torch

 from transformers.generation import (
     MaxLengthCriteria,
     MaxNewTokensCriteria,
     MaxTimeCriteria,
     StoppingCriteriaList,
     validate_stopping_criteria,
 )







@require_torch
class 	__UpperCamelCase    (    unittest.TestCase						):

  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[str]  =    3
      _lowerCAmelCase       :   str  =    250

      _lowerCAmelCase       :   str  =    ids_tensor((batch_size, length)    ,_A      )
      _lowerCAmelCase       :   Optional[int]  =    torch.ones((batch_size, length)    ,device=_A    ,dtype=torch.float      ) / length
      return input_ids, scores

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Any  =    self._get_tensors(5      )

      _lowerCAmelCase       :   Any  =    StoppingCriteriaList(
          [
              MaxLengthCriteria(max_length=10      ),
              MaxTimeCriteria(max_time=0.1      ),
          ]      )

      self.assertFalse(criteria(_A    ,_A      )      )

      _lowerCAmelCase       :   Dict  =    self._get_tensors(9      )
      self.assertFalse(criteria(_A    ,_A      )      )

      _lowerCAmelCase       :   int  =    self._get_tensors(10      )
      self.assertTrue(criteria(_A    ,_A      )      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[str]  =    MaxLengthCriteria(max_length=10      )

      _lowerCAmelCase       :   List[Any]  =    self._get_tensors(5      )
      self.assertFalse(criteria(_A    ,_A      )      )

      _lowerCAmelCase       :   Any  =    self._get_tensors(9      )
      self.assertFalse(criteria(_A    ,_A      )      )

      _lowerCAmelCase       :   int  =    self._get_tensors(10      )
      self.assertTrue(criteria(_A    ,_A      )      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[Any]  =    MaxNewTokensCriteria(start_length=5    ,max_new_tokens=5      )

      _lowerCAmelCase       :   str  =    self._get_tensors(5      )
      self.assertFalse(criteria(_A    ,_A      )      )

      _lowerCAmelCase       :   Union[str, Any]  =    self._get_tensors(9      )
      self.assertFalse(criteria(_A    ,_A      )      )

      _lowerCAmelCase       :   Dict  =    self._get_tensors(10      )
      self.assertTrue(criteria(_A    ,_A      )      )

      _lowerCAmelCase       :   List[Any]  =    StoppingCriteriaList([criteria]      )
      self.assertEqual(criteria_list.max_length    ,10      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    self._get_tensors(5      )

      _lowerCAmelCase       :   int  =    MaxTimeCriteria(max_time=0.1      )
      self.assertFalse(criteria(_A    ,_A      )      )

      _lowerCAmelCase       :   Union[str, Any]  =    MaxTimeCriteria(max_time=0.1    ,initial_timestamp=time.time() - 0.2      )
      self.assertTrue(criteria(_A    ,_A      )      )







  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      validate_stopping_criteria(StoppingCriteriaList([MaxLengthCriteria(10      )]      )    ,10      )

      with self.assertWarns(_A      ):
          validate_stopping_criteria(StoppingCriteriaList([MaxLengthCriteria(10      )]      )    ,11      )

      _lowerCAmelCase       :   List[Any]  =    validate_stopping_criteria(StoppingCriteriaList()    ,11      )

      self.assertEqual(len(_A      )    ,1      )


"""simple docstring"""






import inspect
import os
import unittest

import torch

import accelerate
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_multi_gpu
from accelerate.utils import patch_environment







class 	__UpperCamelCase    (    unittest.TestCase						):

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Dict  =    inspect.getfile(accelerate.test_utils      )
      _lowerCAmelCase       :   Union[str, Any]  =    os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ['scripts', 'test_script.py']      )
      _lowerCAmelCase       :   int  =    os.path.sep.join(
          mod_file.split(os.path.sep      )[:-1] + ['scripts', 'test_distributed_data_loop.py']      )
      _lowerCAmelCase       :   Optional[Any]  =    os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ['scripts', 'test_ops.py']      )

  @require_multi_gpu
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      print(F"""Found {torch.cuda.device_count()} devices."""      )
      _lowerCAmelCase       :   int  =    ['torchrun', F"""--nproc_per_node={torch.cuda.device_count()}""", self.test_file_path]
      with patch_environment(omp_num_threads=1      ):
          execute_subprocess_async(_A    ,env=os.environ.copy()      )

  @require_multi_gpu
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      print(F"""Found {torch.cuda.device_count()} devices."""      )
      _lowerCAmelCase       :   str  =    ['torchrun', F"""--nproc_per_node={torch.cuda.device_count()}""", self.operation_file_path]
      print(F"""Command: {cmd}"""      )
      with patch_environment(omp_num_threads=1      ):
          execute_subprocess_async(_A    ,env=os.environ.copy()      )

  @require_multi_gpu
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[Any]  =    ['torchrun', F"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__      )]
      with patch_environment(omp_num_threads=1      ):
          execute_subprocess_async(_A    ,env=os.environ.copy()      )







  @require_multi_gpu
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      print(F"""Found {torch.cuda.device_count()} devices, using 2 devices only"""      )
      _lowerCAmelCase       :   Tuple  =    ['torchrun', F"""--nproc_per_node={torch.cuda.device_count()}""", self.data_loop_file_path]
      with patch_environment(omp_num_threads=1    ,cuda_visible_devices='0,1'      ):
          execute_subprocess_async(_A    ,env=os.environ.copy()      )


if __name__ == "__main__":
 _lowerCAmelCase						=		Accelerator()
 _lowerCAmelCase						=		(accelerator.state.process_index + 2, 1_0)
 _lowerCAmelCase						=		torch.randint(0, 1_0, shape).to(accelerator.device)

 _lowerCAmelCase						=		""""""

 _lowerCAmelCase						=		accelerator.pad_across_processes(tensor)
 if tensora.shape[0] != accelerator.state.num_processes + 1:
  error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
 if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor):
  error_msg += "Tensors have different values."
 if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0):
  error_msg += "Padding was not done with the right value (0)."

 _lowerCAmelCase						=		accelerator.pad_across_processes(tensor, pad_first=True)
 if tensora.shape[0] != accelerator.state.num_processes + 1:
  error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
 _lowerCAmelCase						=		accelerator.state.num_processes - accelerator.state.process_index - 1
 if not torch.equal(tensora[index:], tensor):
  error_msg += "Tensors have different values."
 if not torch.all(tensora[:index] == 0):
  error_msg += "Padding was not done with the right value (0)."

 # Raise error at the end to make sure we don't stop at the first failure.
 if len(error_msg) > 0:
  raise ValueError(error_msg)





