





from .constants import (
    MODEL_NAME,
    OPTIMIZER_NAME,
    RNG_STATE_NAME,
    SAFE_WEIGHTS_INDEX_NAME,
    SAFE_WEIGHTS_NAME,
    SCALER_NAME,
    SCHEDULER_NAME,
    TORCH_LAUNCH_PARAMS,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
)
from .dataclasses import (
    BnbQuantizationConfig,
    ComputeEnvironment,
    CustomDtype,
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    DynamoBackend,
    FPaRecipeKwargs,
    FullyShardedDataParallelPlugin,
    GradientAccumulationPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    KwargsHandler,
    LoggerType,
    MegatronLMPlugin,
    PrecisionType,
    ProjectConfiguration,
    RNGType,
    SageMakerDistributedType,
    TensorInformation,
    TorchDynamoPlugin,
)
from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env
from .imports import (
    get_ccl_version,
    is_abit_bnb_available,
    is_abit_bnb_available,
    is_aim_available,
    is_bfaa_available,
    is_bnb_available,
    is_botoa_available,
    is_ccl_available,
    is_comet_ml_available,
    is_datasets_available,
    is_deepspeed_available,
    is_fpa_available,
    is_ipex_available,
    is_megatron_lm_available,
    is_mlflow_available,
    is_mps_available,
    is_npu_available,
    is_rich_available,
    is_safetensors_available,
    is_sagemaker_available,
    is_tensorboard_available,
    is_tpu_available,
    is_transformers_available,
    is_wandb_available,
    is_xpu_available,
)
from .modeling import (
    check_device_map,
    check_tied_parameters_in_config,
    check_tied_parameters_on_same_device,
    compute_module_sizes,
    convert_file_size_to_int,
    dtype_byte_size,
    find_tied_parameters,
    get_balanced_memory,
    get_max_layer_size,
    get_max_memory,
    get_mixed_precision_context_manager,
    id_tensor_storage,
    infer_auto_device_map,
    load_checkpoint_in_model,
    load_offloaded_weights,
    load_state_dict,
    named_module_tensors,
    retie_parameters,
    set_module_tensor_to_device,
    shard_checkpoint,
)
from .offload import (
    OffloadedWeightsLoader,
    PrefixedDataset,
    extract_submodules_state_dict,
    load_offloaded_weight,
    offload_state_dict,
    offload_weight,
    save_offload_index,
)
from .operations import (
    broadcast,
    broadcast_object_list,
    concatenate,
    convert_outputs_to_fpaa,
    convert_to_fpaa,
    find_batch_size,
    find_device,
    gather,
    gather_object,
    get_data_structure,
    honor_type,
    initialize_tensors,
    is_namedtuple,
    is_tensor_information,
    is_torch_tensor,
    listify,
    pad_across_processes,
    recursively_apply,
    reduce,
    send_to_device,
    slice_tensors,
)
from .versions import compare_versions, is_torch_version


if is_deepspeed_available():
				from .deepspeed import (
				    DeepSpeedEngineWrapper,
				    DeepSpeedOptimizerWrapper,
				    DeepSpeedSchedulerWrapper,
				    DummyOptim,
				    DummyScheduler,
				    HfDeepSpeedConfig,
				)

from .bnb import has_abit_bnb_layers, load_and_quantize_model
from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer
from .launch import (
    PrepareForLaunch,
    _filter_args,
    prepare_deepspeed_cmd_env,
    prepare_multi_gpu_env,
    prepare_sagemager_args_inputs,
    prepare_simple_launcher_cmd_env,
    prepare_tpu,
)
from .megatron_lm import (
    AbstractTrainStep,
    BertTrainStep,
    GPTTrainStep,
    MegatronEngine,
    MegatronLMDummyDataLoader,
    MegatronLMDummyScheduler,
    MegatronLMOptimizerWrapper,
    MegatronLMSchedulerWrapper,
    TaTrainStep,
    avg_losses_across_data_parallel_group,
    gather_across_data_parallel_groups,
)
from .megatron_lm import initialize as megatron_lm_initialize
from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader
from .megatron_lm import prepare_model as megatron_lm_prepare_model
from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer
from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler
from .memory import find_executable_batch_size, release_memory
from .other import (
    extract_model_from_parallel,
    get_pretty_name,
    is_port_in_use,
    merge_dicts,
    patch_environment,
    save,
    wait_for_everyone,
    write_basic_config,
)
from .random import set_seed, synchronize_rng_state, synchronize_rng_states
from .torch_xla import install_xla
from .tqdm import tqdm
from .transformer_engine import convert_model, has_transformer_engine_layers





import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
  import torch

if is_vision_available():
  from PIL import Image

  from transformers import MobileNetVaImageProcessor

class __snake_case		(      unittest.TestCase     ):
    def __init__(  self		,snake_case		,snake_case=7		,snake_case=3		,snake_case=18		,snake_case=30		,snake_case=400		,snake_case=True		,snake_case=None		,snake_case=True		,snake_case=None		,):



           '''simple docstring'''







           lowercase							:     Dict       	=      size if size is not None else {"""shortest_edge""": 20}
           lowercase							:     Union[str, Any]       	=      crop_size if crop_size is not None else {"""height""": 18, """width""": 18}
           lowercase							:     str       	=      parent
           lowercase							:     int       	=      batch_size
           lowercase							:     str       	=      num_channels
           lowercase							:     int       	=      image_size
           lowercase							:     List[str]       	=      min_resolution
           lowercase							:     str       	=      max_resolution
           lowercase							:     Dict       	=      do_resize
           lowercase							:     Dict       	=      size
           lowercase							:     Dict       	=      do_center_crop
           lowercase							:     str       	=      crop_size
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           return {
               "do_resize": self.do_resize,
               "size": self.size,
               "do_center_crop": self.do_center_crop,
               "crop_size": self.crop_size,
           }






@require_torch
@require_vision
class __snake_case		(      lowerCAmelCase					,	unittest.TestCase     ):
    _a		:						Any=				MobileNetVaImageProcessor if is_vision_available() else None
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[Any]       	=      MobileNetVaImageProcessingTester(self      )
    @property
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           return self.image_processor_tester.prepare_image_processor_dict()
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Optional[int]       	=      self.image_processing_class(**self.image_processor_dict      )
           self.assertTrue(hasattr(snake_case		,"""do_resize"""      )      )
           self.assertTrue(hasattr(snake_case		,"""size"""      )      )
           self.assertTrue(hasattr(snake_case		,"""do_center_crop"""      )      )
           self.assertTrue(hasattr(snake_case		,"""crop_size"""      )      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     int       	=      self.image_processing_class.from_dict(self.image_processor_dict      )
           self.assertEqual(image_processor.size		,{"""shortest_edge""": 20}      )
           self.assertEqual(image_processor.crop_size		,{"""height""": 18, """width""": 18}      )

           lowercase							:     int       	=      self.image_processing_class.from_dict(self.image_processor_dict		,size=42		,crop_size=84      )
           self.assertEqual(image_processor.size		,{"""shortest_edge""": 42}      )
           self.assertEqual(image_processor.crop_size		,{"""height""": 84, """width""": 84}      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           pass
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Optional[Any]       	=      self.image_processing_class(**self.image_processor_dict      )
           # create random PIL images
           lowercase							:     str       	=      prepare_image_inputs(self.image_processor_tester		,equal_resolution=snake_case      )
           for image in image_inputs:
                  self.assertIsInstance(snake_case		,Image.Image      )

           # Test not batched input
           lowercase							:     Dict       	=      image_processing(image_inputs[0]		,return_tensors="""pt"""      ).pixel_values
           self.assertEqual(
               encoded_images.shape		,(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )		,)

           # Test batched
           lowercase							:     Tuple       	=      image_processing(snake_case		,return_tensors="""pt"""      ).pixel_values
           self.assertEqual(
               encoded_images.shape		,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )		,)
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[Any]       	=      self.image_processing_class(**self.image_processor_dict      )
           # create random numpy tensors
           lowercase							:     Union[str, Any]       	=      prepare_image_inputs(self.image_processor_tester		,equal_resolution=snake_case		,numpify=snake_case      )
           for image in image_inputs:
                  self.assertIsInstance(snake_case		,np.ndarray      )

           # Test not batched input
           lowercase							:     Optional[Any]       	=      image_processing(image_inputs[0]		,return_tensors="""pt"""      ).pixel_values
           self.assertEqual(
               encoded_images.shape		,(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )		,)

           # Test batched
           lowercase							:     List[str]       	=      image_processing(snake_case		,return_tensors="""pt"""      ).pixel_values
           self.assertEqual(
               encoded_images.shape		,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )		,)
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Optional[Any]       	=      self.image_processing_class(**self.image_processor_dict      )
           # create random PyTorch tensors
           lowercase							:     Tuple       	=      prepare_image_inputs(self.image_processor_tester		,equal_resolution=snake_case		,torchify=snake_case      )
           for image in image_inputs:
                  self.assertIsInstance(snake_case		,torch.Tensor      )

           # Test not batched input
           lowercase							:     Optional[int]       	=      image_processing(image_inputs[0]		,return_tensors="""pt"""      ).pixel_values
           self.assertEqual(
               encoded_images.shape		,(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )		,)

           # Test batched
           lowercase							:     List[str]       	=      image_processing(snake_case		,return_tensors="""pt"""      ).pixel_values
           self.assertEqual(
               encoded_images.shape		,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.crop_size["""height"""],
                   self.image_processor_tester.crop_size["""width"""],
               )		,)
