
# This test is meant to be run in on an instance with TPUs like this:
#
#   python examples/pytorch/xla_spawn.py --num_cores=8 tests/test_trainer_tpu.py
#
# Replace 8 with the number of TPU cores you have.
#

import sys
from typing import Dict

from transformers import EvalPrediction, HfArgumentParser, TrainingArguments, is_torch_available
from transformers.utils import logging


__lowerCAmelCase      :					Optional[Any]   	=       logging.get_logger(__name__)


if is_torch_available():
    import torch
    from torch import nn
    from torch.utils.data import Dataset

    from transformers import Trainer




    class 	UpperCAmelCase_      (			_A					):


      '''simple docstring'''







      def __init__(			self      :			Union[str, Any]      ,							UpperCamelCase__      :			int = 101   )      ->     Tuple:







        """simple docstring"""






        __magic_name__    					=	length
      def __len__(			self      :			Tuple   )      ->     Any:







        """simple docstring"""






        return self.length





      def __getitem__(			self      :			int      ,							UpperCamelCase__      :			Tuple   )      ->     int:







        """simple docstring"""






        return i







    class 	UpperCAmelCase_      :


      '''simple docstring'''







      def __call__(			self      :			str      ,							UpperCamelCase__      :			List[Any]   )      ->     List[str]:







        """simple docstring"""






        return {"input_ids": torch.tensor(UpperCamelCase__   ), "labels": torch.tensor(UpperCamelCase__   )}







    class 	UpperCAmelCase_      (			nn.Module					):


      '''simple docstring'''







      def __init__(			self      :			List[str]   )      ->     Union[str, Any]:







        """simple docstring"""






        super().__init__()
        # Add some (unused) params otherwise DDP will complain.
        __magic_name__    					=	nn.Linear(120      ,							80   )





      def 							_lowercase							(			self      :			Union[str, Any]      ,							UpperCamelCase__      :			Any      ,							UpperCamelCase__      :			List[Any]=None   )      ->     List[str]:







        """simple docstring"""






        if labels is not None:
          return torch.tensor(0.0      ,							device=input_ids.device   ), input_ids
        else:
          return input_ids

def a__   (	):






  '''simple docstring'''





  __magic_name__    					=	HfArgumentParser((TrainingArguments,) )
  sys.argv += ["--output_dir", "./examples"]
  __magic_name__    					=	parser.parse_args_into_dataclasses()[0]

  logger.warning(
      f'''Process rank: {training_args.local_rank}, device: {training_args.device}, '''
      f'''tpu_num_cores: {training_args.tpu_num_cores}''',					)

  # Essentially, what we want to verify in the distributed case is
  # that we get all samples back, in the right order.
  # (this is crucial for prediction for instance)
  for dataset_length in [1001, 256, 15]:
    __magic_name__    					=	DummyDataset(A_ )

    def compute_metrics(A_ ) -> Dict:
      __magic_name__    					=	list(range(len(A_ ) ) )
      __magic_name__    					=	p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential
      return {"success": success}

    __magic_name__    					=	Trainer(
        model=DummyModel(),					args=A_,					data_collator=DummyDataCollator(),					eval_dataset=A_,					compute_metrics=A_,					)
    __magic_name__    					=	trainer.evaluate()
    logger.info(A_ )
    if metrics["eval_success"] is not True:
      logger.error(A_ )
      exit(1 )

    __magic_name__    					=	trainer.predict(A_ )
    logger.info(p.metrics )
    if p.metrics["test_success"] is not True:
      logger.error(p.metrics )
      exit(1 )

    __magic_name__    					=	2

    __magic_name__    					=	trainer.evaluate()
    logger.info(A_ )
    if metrics["eval_success"] is not True:
      logger.error(A_ )
      exit(1 )

    __magic_name__    					=	trainer.predict(A_ )
    logger.info(p.metrics )
    if p.metrics["test_success"] is not True:
      logger.error(p.metrics )
      exit(1 )

    __magic_name__    					=	None

  logger.info("""🔥 All distributed tests successful""" )

def a__   (	A_ ):






  '''simple docstring'''





  main()


if __name__ == "__main__":
    main()



from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


__lowerCAmelCase      :					str   	=       logging.get_logger(__name__)




class 	UpperCAmelCase_      (			_A					):


  '''simple docstring'''







  a__   	=		["""pixel_values"""]
  def __init__(			self      :			Tuple      ,							UpperCamelCase__      :			bool = True      ,							UpperCamelCase__      :			Optional[Dict[str, int]] = None      ,							UpperCamelCase__      :			PILImageResampling = PILImageResampling.BILINEAR      ,							UpperCamelCase__      :			bool = True      ,							UpperCamelCase__      :			Union[int, float] = 1 / 255      ,							UpperCamelCase__      :			bool = True      ,							UpperCamelCase__      :			Optional[Union[float, List[float]]] = None      ,							UpperCamelCase__      :			Optional[Union[float, List[float]]] = None      ,							**UpperCamelCase__      :			Optional[Any]      ,							)      ->     None:







    """simple docstring"""






    super().__init__(**UpperCamelCase__   )
    __magic_name__    					=	size if size is not None else {"""height""": 224, """width""": 224}
    __magic_name__    					=	get_size_dict(UpperCamelCase__   )
    __magic_name__    					=	do_resize
    __magic_name__    					=	do_rescale
    __magic_name__    					=	do_normalize
    __magic_name__    					=	size
    __magic_name__    					=	resample
    __magic_name__    					=	rescale_factor
    __magic_name__    					=	image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
    __magic_name__    					=	image_std if image_std is not None else IMAGENET_STANDARD_STD
  def 							_lowercase							(			self      :			Optional[Any]      ,							UpperCamelCase__      :			np.ndarray      ,							UpperCamelCase__      :			Dict[str, int]      ,							UpperCamelCase__      :			PILImageResampling = PILImageResampling.BILINEAR      ,							UpperCamelCase__      :			Optional[Union[str, ChannelDimension]] = None      ,							**UpperCamelCase__      :			Optional[int]      ,							)      ->     np.ndarray:







    """simple docstring"""






    __magic_name__    					=	get_size_dict(UpperCamelCase__   )
    if "height" not in size or "width" not in size:
      raise ValueError(F'''The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}'''   )
    return resize(
        UpperCamelCase__      ,							size=(size["""height"""], size["""width"""])      ,							resample=UpperCamelCase__      ,							data_format=UpperCamelCase__      ,							**UpperCamelCase__   )
  def 							_lowercase							(			self      :			Tuple      ,							UpperCamelCase__      :			np.ndarray      ,							UpperCamelCase__      :			float      ,							UpperCamelCase__      :			Optional[Union[str, ChannelDimension]] = None      ,							**UpperCamelCase__      :			Union[str, Any]   )      ->     np.ndarray:







    """simple docstring"""






    return rescale(UpperCamelCase__      ,							scale=UpperCamelCase__      ,							data_format=UpperCamelCase__      ,							**UpperCamelCase__   )
  def 							_lowercase							(			self      :			List[str]      ,							UpperCamelCase__      :			np.ndarray      ,							UpperCamelCase__      :			Union[float, List[float]]      ,							UpperCamelCase__      :			Union[float, List[float]]      ,							UpperCamelCase__      :			Optional[Union[str, ChannelDimension]] = None      ,							**UpperCamelCase__      :			Union[str, Any]      ,							)      ->     np.ndarray:







    """simple docstring"""






    return normalize(UpperCamelCase__      ,							mean=UpperCamelCase__      ,							std=UpperCamelCase__      ,							data_format=UpperCamelCase__      ,							**UpperCamelCase__   )





  def 							_lowercase							(			self      :			Tuple      ,							UpperCamelCase__      :			ImageInput      ,							UpperCamelCase__      :			Optional[bool] = None      ,							UpperCamelCase__      :			Dict[str, int] = None      ,							UpperCamelCase__      :			PILImageResampling = None      ,							UpperCamelCase__      :			Optional[bool] = None      ,							UpperCamelCase__      :			Optional[float] = None      ,							UpperCamelCase__      :			Optional[bool] = None      ,							UpperCamelCase__      :			Optional[Union[float, List[float]]] = None      ,							UpperCamelCase__      :			Optional[Union[float, List[float]]] = None      ,							UpperCamelCase__      :			Optional[Union[str, TensorType]] = None      ,							UpperCamelCase__      :			Union[str, ChannelDimension] = ChannelDimension.FIRST      ,							**UpperCamelCase__      :			List[str]      ,							)      ->     Optional[int]:







    """simple docstring"""






    __magic_name__    					=	do_resize if do_resize is not None else self.do_resize
    __magic_name__    					=	do_rescale if do_rescale is not None else self.do_rescale
    __magic_name__    					=	do_normalize if do_normalize is not None else self.do_normalize
    __magic_name__    					=	resample if resample is not None else self.resample
    __magic_name__    					=	rescale_factor if rescale_factor is not None else self.rescale_factor
    __magic_name__    					=	image_mean if image_mean is not None else self.image_mean
    __magic_name__    					=	image_std if image_std is not None else self.image_std

    __magic_name__    					=	size if size is not None else self.size
    __magic_name__    					=	get_size_dict(UpperCamelCase__   )

    __magic_name__    					=	make_list_of_images(UpperCamelCase__   )

    if not valid_images(UpperCamelCase__   ):
      raise ValueError(
          """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
          """torch.Tensor, tf.Tensor or jax.ndarray."""   )

    if do_resize and size is None:
      raise ValueError("""Size must be specified if do_resize is True."""   )

    if do_rescale and rescale_factor is None:
      raise ValueError("""Rescale factor must be specified if do_rescale is True."""   )

    # All transformations expect numpy arrays.
    __magic_name__    					=	[to_numpy_array(UpperCamelCase__   ) for image in images]

    if do_resize:
      __magic_name__    					=	[self.resize(image=UpperCamelCase__      ,							size=UpperCamelCase__      ,							resample=UpperCamelCase__   ) for image in images]

    if do_rescale:
      __magic_name__    					=	[self.rescale(image=UpperCamelCase__      ,							scale=UpperCamelCase__   ) for image in images]

    if do_normalize:
      __magic_name__    					=	[self.normalize(image=UpperCamelCase__      ,							mean=UpperCamelCase__      ,							std=UpperCamelCase__   ) for image in images]

    __magic_name__    					=	[to_channel_dimension_format(UpperCamelCase__      ,							UpperCamelCase__   ) for image in images]

    __magic_name__    					=	{"""pixel_values""": images}
    return BatchFeature(data=UpperCamelCase__      ,							tensor_type=UpperCamelCase__   )

