

'''simple docstring'''






import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch
      from torch import nn

      from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
      from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor
class      SCREAMING_SNAKE_CASE__      :




    def __init__( self    ,					lowercase__    ,					lowercase__=13    ,					lowercase__=32    ,					lowercase__=2    ,					lowercase__=3    ,					lowercase__=16    ,					lowercase__=[1, 2, 1]    ,					lowercase__=[2, 2, 4]    ,					lowercase__=2    ,					lowercase__=2.0    ,					lowercase__=True    ,					lowercase__=0.0    ,					lowercase__=0.0    ,					lowercase__=0.1    ,					lowercase__="gelu"    ,					lowercase__=False    ,					lowercase__=True    ,					lowercase__=0.02    ,					lowercase__=1e-5    ,					lowercase__=True    ,					lowercase__=None    ,					lowercase__=True    ,					lowercase__=10    ,					lowercase__=8    ,					lowercase__=["stage1", "stage2"]    ,					lowercase__=[1, 2]    ,					):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Dict					=	parent
          SCREAMING_SNAKE_CASE_				:      Tuple					=	batch_size
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	image_size
          SCREAMING_SNAKE_CASE_				:      Tuple					=	patch_size
          SCREAMING_SNAKE_CASE_				:      Tuple					=	num_channels
          SCREAMING_SNAKE_CASE_				:      int					=	embed_dim
          SCREAMING_SNAKE_CASE_				:      Tuple					=	depths
          SCREAMING_SNAKE_CASE_				:      Any					=	num_heads
          SCREAMING_SNAKE_CASE_				:      str					=	window_size
          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	mlp_ratio
          SCREAMING_SNAKE_CASE_				:      Dict					=	qkv_bias
          SCREAMING_SNAKE_CASE_				:      Tuple					=	hidden_dropout_prob
          SCREAMING_SNAKE_CASE_				:      List[Any]					=	attention_probs_dropout_prob
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	drop_path_rate
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	hidden_act
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	use_absolute_embeddings
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	patch_norm
          SCREAMING_SNAKE_CASE_				:      Tuple					=	layer_norm_eps
          SCREAMING_SNAKE_CASE_				:      Any					=	initializer_range
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	is_training
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	scope
          SCREAMING_SNAKE_CASE_				:      str					=	use_labels
          SCREAMING_SNAKE_CASE_				:      Tuple					=	type_sequence_label_size
          SCREAMING_SNAKE_CASE_				:      str					=	encoder_stride
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	out_features
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	out_indices




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      List[str]					=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

          SCREAMING_SNAKE_CASE_				:      Dict					=	None
          if self.use_labels:
                SCREAMING_SNAKE_CASE_				:      Any					=	ids_tensor([self.batch_size]    ,					self.type_sequence_label_size      )

          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	self.get_config()

          return config, pixel_values, labels




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          return SwinConfig(
              image_size=self.image_size    ,					patch_size=self.patch_size    ,					num_channels=self.num_channels    ,					embed_dim=self.embed_dim    ,					depths=self.depths    ,					num_heads=self.num_heads    ,					window_size=self.window_size    ,					mlp_ratio=self.mlp_ratio    ,					qkv_bias=self.qkv_bias    ,					hidden_dropout_prob=self.hidden_dropout_prob    ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,					drop_path_rate=self.drop_path_rate    ,					hidden_act=self.hidden_act    ,					use_absolute_embeddings=self.use_absolute_embeddings    ,					path_norm=self.patch_norm    ,					layer_norm_eps=self.layer_norm_eps    ,					initializer_range=self.initializer_range    ,					encoder_stride=self.encoder_stride    ,					out_features=self.out_features    ,					out_indices=self.out_indices    ,					)




    def   __lowerCamelCase				( self    ,					lowercase__    ,					lowercase__    ,					lowercase__      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Dict					=	SwinModel(config=lowercase__      )
          model.to(lowercase__      )
          model.eval()
          SCREAMING_SNAKE_CASE_				:      int					=	model(lowercase__      )

          SCREAMING_SNAKE_CASE_				:      str					=	((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths      ) - 1))
          SCREAMING_SNAKE_CASE_				:      Any					=	int(config.embed_dim * 2 ** (len(config.depths      ) - 1)      )

          self.parent.assertEqual(result.last_hidden_state.shape    ,					(self.batch_size, expected_seq_len, expected_dim)      )




    def   __lowerCamelCase				( self    ,					lowercase__    ,					lowercase__    ,					lowercase__      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Tuple					=	SwinBackbone(config=lowercase__      )
          model.to(lowercase__      )
          model.eval()
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	model(lowercase__      )

          # verify hidden states
          self.parent.assertEqual(len(result.feature_maps      )    ,					len(config.out_features      )      )
          self.parent.assertListEqual(list(result.feature_maps[0].shape      )    ,					[self.batch_size, model.channels[0], 16, 16]      )

          # verify channels
          self.parent.assertEqual(len(model.channels      )    ,					len(config.out_features      )      )

          # verify backbone works with out_features=None
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	None
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	SwinBackbone(config=lowercase__      )
          model.to(lowercase__      )
          model.eval()
          SCREAMING_SNAKE_CASE_				:      int					=	model(lowercase__      )

          # verify feature maps
          self.parent.assertEqual(len(result.feature_maps      )    ,					1      )
          self.parent.assertListEqual(list(result.feature_maps[0].shape      )    ,					[self.batch_size, model.channels[-1], 4, 4]      )

          # verify channels
          self.parent.assertEqual(len(model.channels      )    ,					1      )




    def   __lowerCamelCase				( self    ,					lowercase__    ,					lowercase__    ,					lowercase__      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      str					=	SwinForMaskedImageModeling(config=lowercase__      )
          model.to(lowercase__      )
          model.eval()
          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	model(lowercase__      )
          self.parent.assertEqual(
              result.logits.shape    ,					(self.batch_size, self.num_channels, self.image_size, self.image_size)      )

          # test greyscale images
          SCREAMING_SNAKE_CASE_				:      str					=	1
          SCREAMING_SNAKE_CASE_				:      Any					=	SwinForMaskedImageModeling(lowercase__      )
          model.to(lowercase__      )
          model.eval()

          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
          SCREAMING_SNAKE_CASE_				:      List[Any]					=	model(lowercase__      )
          self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, 1, self.image_size, self.image_size)      )




    def   __lowerCamelCase				( self    ,					lowercase__    ,					lowercase__    ,					lowercase__      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	self.type_sequence_label_size
          SCREAMING_SNAKE_CASE_				:      int					=	SwinForImageClassification(lowercase__      )
          model.to(lowercase__      )
          model.eval()
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	model(lowercase__    ,					labels=lowercase__      )
          self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.type_sequence_label_size)      )

          # test greyscale images
          SCREAMING_SNAKE_CASE_				:      int					=	1
          SCREAMING_SNAKE_CASE_				:      List[Any]					=	SwinForImageClassification(lowercase__      )
          model.to(lowercase__      )
          model.eval()

          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
          SCREAMING_SNAKE_CASE_				:      int					=	model(lowercase__      )
          self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.type_sequence_label_size)      )







    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      List[str]					=	self.prepare_config_and_inputs()
          (
              SCREAMING_SNAKE_CASE_						
          )				:      List[str]					=	config_and_inputs
          SCREAMING_SNAKE_CASE_				:      Tuple					=	{"pixel_values": pixel_values}
          return config, inputs_dict






@require_torch
class      SCREAMING_SNAKE_CASE__      (    _UpperCAmelCase,_UpperCAmelCase,unittest.TestCase				):
    _A         =							(
        (
            SwinModel,
            SwinBackbone,
            SwinForImageClassification,
            SwinForMaskedImageModeling,
        )
        if is_torch_available()
        else ()
    )
    _A         =							(
        {"feature-extraction": SwinModel, "image-classification": SwinForImageClassification}
        if is_torch_available()
        else {}
    )
    _A         =							True

    _A         =							False
    _A         =							False
    _A         =							False




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Dict					=	SwinModelTester(self      )
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	ConfigTester(self    ,					config_class=lowercase__    ,					embed_dim=37      )




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          self.create_and_test_config_common_properties()
          self.config_tester.create_and_test_config_to_json_string()
          self.config_tester.create_and_test_config_to_json_file()
          self.config_tester.create_and_test_config_from_and_save_pretrained()
          self.config_tester.create_and_test_config_with_num_labels()
          self.config_tester.check_config_can_be_init_without_params()
          self.config_tester.check_config_arguments_init()




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          return




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Dict					=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase__      )




    @unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0."      )
    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          pass




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          super().test_training_gradient_checkpointing()




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      List[Any]					=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_backbone(*lowercase__      )




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*lowercase__      )




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      int					=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowercase__      )




    @unittest.skip(reason="Swin does not use inputs_embeds"      )
    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          pass




    @unittest.skip(reason="Swin Transformer does not use feedforward chunking"      )
    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          pass




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Dict					=	self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	model_class(lowercase__      )
                self.assertIsInstance(model.get_input_embeddings()    ,					(nn.Module)      )
                SCREAMING_SNAKE_CASE_				:      List[str]					=	model.get_output_embeddings()
                self.assertTrue(x is None or isinstance(lowercase__    ,					nn.Linear      )      )




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                SCREAMING_SNAKE_CASE_				:      List[str]					=	model_class(lowercase__      )
                SCREAMING_SNAKE_CASE_				:      Tuple					=	inspect.signature(model.forward      )
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                SCREAMING_SNAKE_CASE_				:      str					=	[*signature.parameters.keys()]

                SCREAMING_SNAKE_CASE_				:      Tuple					=	["pixel_values"]
                self.assertListEqual(arg_names[:1]    ,					lowercase__      )




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      List[str]					=	self.model_tester.prepare_config_and_inputs_for_common()
          SCREAMING_SNAKE_CASE_				:      Any					=	True

          for model_class in self.all_model_classes:
                SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	True
                SCREAMING_SNAKE_CASE_				:      Dict					=	False
                SCREAMING_SNAKE_CASE_				:      str					=	True
                SCREAMING_SNAKE_CASE_				:      int					=	model_class(lowercase__      )
                model.to(lowercase__      )
                model.eval()
                with torch.no_grad():
                      SCREAMING_SNAKE_CASE_				:      str					=	model(**self._prepare_for_class(lowercase__    ,					lowercase__      )      )
                SCREAMING_SNAKE_CASE_				:      Tuple					=	outputs.attentions
                SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	len(self.model_tester.depths      )
                self.assertEqual(len(lowercase__      )    ,					lowercase__      )

                # check that output_attentions also work using config
                del inputs_dict["output_attentions"]
                SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	True
                SCREAMING_SNAKE_CASE_				:      Dict					=	config.window_size**2
                SCREAMING_SNAKE_CASE_				:      List[str]					=	model_class(lowercase__      )
                model.to(lowercase__      )
                model.eval()
                with torch.no_grad():
                      SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	model(**self._prepare_for_class(lowercase__    ,					lowercase__      )      )
                SCREAMING_SNAKE_CASE_				:      Tuple					=	outputs.attentions
                self.assertEqual(len(lowercase__      )    ,					lowercase__      )

                self.assertListEqual(
                    list(attentions[0].shape[-3:]      )    ,					[self.model_tester.num_heads[0], window_size_squared, window_size_squared]    ,					)
                SCREAMING_SNAKE_CASE_				:      str					=	len(lowercase__      )

                # Check attention is always last and order is fine
                SCREAMING_SNAKE_CASE_				:      Tuple					=	True
                SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	True
                SCREAMING_SNAKE_CASE_				:      Optional[int]					=	model_class(lowercase__      )
                model.to(lowercase__      )
                model.eval()
                with torch.no_grad():
                      SCREAMING_SNAKE_CASE_				:      List[str]					=	model(**self._prepare_for_class(lowercase__    ,					lowercase__      )      )

                # also another +1 for reshaped_hidden_states
                SCREAMING_SNAKE_CASE_				:      List[str]					=	1 if model_class.__name__ == "SwinBackbone" else 2
                self.assertEqual(out_len + added_hidden_states    ,					len(lowercase__      )      )

                SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	outputs.attentions

                self.assertEqual(len(lowercase__      )    ,					lowercase__      )

                self.assertListEqual(
                    list(self_attentions[0].shape[-3:]      )    ,					[self.model_tester.num_heads[0], window_size_squared, window_size_squared]    ,					)




    def   __lowerCamelCase				( self    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      List[str]					=	model_class(lowercase__      )
          model.to(lowercase__      )
          model.eval()

          with torch.no_grad():
                SCREAMING_SNAKE_CASE_				:      int					=	model(**self._prepare_for_class(lowercase__    ,					lowercase__      )      )

          SCREAMING_SNAKE_CASE_				:      List[Any]					=	outputs.hidden_states

          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	getattr(
              self.model_tester    ,					"expected_num_hidden_layers"    ,					len(self.model_tester.depths      ) + 1      )
          self.assertEqual(len(lowercase__      )    ,					lowercase__      )

          # Swin has a different seq_length
          SCREAMING_SNAKE_CASE_				:      List[str]					=	(
              config.patch_size
              if isinstance(config.patch_size    ,					collections.abc.Iterable      )
              else (config.patch_size, config.patch_size)
          )

          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

          self.assertListEqual(
              list(hidden_states[0].shape[-2:]      )    ,					[num_patches, self.model_tester.embed_dim]    ,					)

          if not model_class.__name__ == "SwinBackbone":
                SCREAMING_SNAKE_CASE_				:      Any					=	outputs.reshaped_hidden_states
                self.assertEqual(len(lowercase__      )    ,					lowercase__      )

                SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	reshaped_hidden_states[0].shape
                SCREAMING_SNAKE_CASE_				:      List[Any]					=	(
                    reshaped_hidden_states[0].view(lowercase__    ,					lowercase__    ,					height * width      ).permute(0    ,					2    ,					1      )
                )
                self.assertListEqual(
                    list(reshaped_hidden_states.shape[-2:]      )    ,					[num_patches, self.model_tester.embed_dim]    ,					)




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	self.model_tester.prepare_config_and_inputs_for_common()

          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	(
              self.model_tester.image_size
              if isinstance(self.model_tester.image_size    ,					collections.abc.Iterable      )
              else (self.model_tester.image_size, self.model_tester.image_size)
          )

          for model_class in self.all_model_classes:
                SCREAMING_SNAKE_CASE_				:      List[Any]					=	True
                self.check_hidden_states_output(lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__      )

                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	True

                self.check_hidden_states_output(lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__      )




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	self.model_tester.prepare_config_and_inputs_for_common()
          SCREAMING_SNAKE_CASE_				:      List[str]					=	3

          SCREAMING_SNAKE_CASE_				:      int					=	(
              self.model_tester.image_size
              if isinstance(self.model_tester.image_size    ,					collections.abc.Iterable      )
              else (self.model_tester.image_size, self.model_tester.image_size)
          )
          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	(
              config.patch_size
              if isinstance(config.patch_size    ,					collections.abc.Iterable      )
              else (config.patch_size, config.patch_size)
          )

          SCREAMING_SNAKE_CASE_				:      int					=	image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
          SCREAMING_SNAKE_CASE_				:      Any					=	image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

          for model_class in self.all_model_classes:
                SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	True
                self.check_hidden_states_output(lowercase__    ,					lowercase__    ,					lowercase__    ,					(padded_height, padded_width)      )

                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                SCREAMING_SNAKE_CASE_				:      Optional[int]					=	True
                self.check_hidden_states_output(lowercase__    ,					lowercase__    ,					lowercase__    ,					(padded_height, padded_width)      )




    @slow
    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                SCREAMING_SNAKE_CASE_				:      Any					=	SwinModel.from_pretrained(lowercase__      )
                self.assertIsNotNone(lowercase__      )







    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      str					=	self.model_tester.prepare_config_and_inputs_for_common()

          SCREAMING_SNAKE_CASE_				:      Dict					=	_config_zero_init(lowercase__      )
          for model_class in self.all_model_classes:
                SCREAMING_SNAKE_CASE_				:      Optional[int]					=	model_class(config=lowercase__      )
                for name, param in model.named_parameters():
                      if "embeddings" not in name and param.requires_grad:
                            self.assertIn(
                                ((param.data.mean() * 1e9).round() / 1e9).item()    ,					[0.0, 1.0]    ,					msg=F"Parameter {name} of model {model_class} seems not properly initialized"    ,					)






@require_vision
@require_torch
class      SCREAMING_SNAKE_CASE__      (    unittest.TestCase				):




    @cached_property
    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          return (
              AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224"      )
              if is_vision_available()
              else None
          )







    @slow
    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-224"      ).to(lowercase__      )
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	self.default_image_processor

          SCREAMING_SNAKE_CASE_				:      List[Any]					=	Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
          SCREAMING_SNAKE_CASE_				:      str					=	image_processor(images=lowercase__    ,					return_tensors="pt"      ).to(lowercase__      )

          # forward pass
          with torch.no_grad():
                SCREAMING_SNAKE_CASE_				:      str					=	model(**lowercase__      )

          # verify the logits
          SCREAMING_SNAKE_CASE_				:      Any					=	torch.Size((1, 1000)      )
          self.assertEqual(outputs.logits.shape    ,					lowercase__      )
          SCREAMING_SNAKE_CASE_				:      Tuple					=	torch.tensor([-0.0948, -0.6454, -0.0921]      ).to(lowercase__      )
          self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,					lowercase__    ,					atol=1e-4      )      )






@require_torch
class      SCREAMING_SNAKE_CASE__      (    unittest.TestCase,_UpperCAmelCase				):
    _A         =							(SwinBackbone,) if is_torch_available() else ()
    _A         =							SwinConfig




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Tuple					=	SwinModelTester(self      )




'''simple docstring'''






import os
from argparse import ArgumentParser
from pathlib import Path
from shutil import copyfile
from typing import List

from datasets import config
from datasets.builder import DatasetBuilder
from datasets.commands import BaseDatasetsCLICommand
from datasets.download.download_config import DownloadConfig
from datasets.download.download_manager import DownloadMode
from datasets.load import dataset_module_factory, import_main_class
from datasets.utils.info_utils import VerificationMode


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     int  ,  **SCREAMING_SNAKE_CASE_					:     int   )							->       str:
      """simple docstring"""

      return RunBeamCommand(
          args.dataset  ,  args.name  ,  args.cache_dir  ,  args.beam_pipeline_options  ,  args.data_dir  ,  args.all_configs  ,  args.save_info or args.save_infos  ,  args.ignore_verifications  ,  args.force_redownload  ,  **SCREAMING_SNAKE_CASE_  ,  )





class      SCREAMING_SNAKE_CASE__      (    _UpperCAmelCase				):




    @staticmethod
    def   __lowerCamelCase				( lowercase__      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      str					=	parser.add_parser("run_beam"    ,					help="Run a Beam dataset processing pipeline"      )
          run_beam_parser.add_argument("dataset"    ,					type=lowercase__    ,					help="Name of the dataset to download"      )
          run_beam_parser.add_argument("--name"    ,					type=lowercase__    ,					default=lowercase__    ,					help="Dataset config name"      )
          run_beam_parser.add_argument(
              "--cache_dir"    ,					type=lowercase__    ,					default=lowercase__    ,					help="Cache directory where the datasets are stored"    ,					)
          run_beam_parser.add_argument(
              "--beam_pipeline_options"    ,					type=lowercase__    ,					default=""    ,					help="Beam pipeline options, separated by commas. Example:: `--beam_pipeline_options=job_name=my-job,project=my-project`"    ,					)
          run_beam_parser.add_argument(
              "--data_dir"    ,					type=lowercase__    ,					default=lowercase__    ,					help="Can be used to specify a manual directory to get the files from"    ,					)
          run_beam_parser.add_argument("--all_configs"    ,					action="store_true"    ,					help="Test all dataset configurations"      )
          run_beam_parser.add_argument("--save_info"    ,					action="store_true"    ,					help="Save the dataset infos file"      )
          run_beam_parser.add_argument(
              "--ignore_verifications"    ,					action="store_true"    ,					help="Run the test without checksums and splits checks"      )
          run_beam_parser.add_argument("--force_redownload"    ,					action="store_true"    ,					help="Force dataset redownload"      )
          # aliases
          run_beam_parser.add_argument("--save_infos"    ,					action="store_true"    ,					help="alias for save_info"      )
          run_beam_parser.set_defaults(func=lowercase__      )




    def __init__( self    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					lowercase__    ,					**lowercase__    ,					):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Tuple					=	dataset
          SCREAMING_SNAKE_CASE_				:      Dict					=	name
          SCREAMING_SNAKE_CASE_				:      str					=	cache_dir
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	beam_pipeline_options
          SCREAMING_SNAKE_CASE_				:      List[Any]					=	data_dir
          SCREAMING_SNAKE_CASE_				:      Dict					=	all_configs
          SCREAMING_SNAKE_CASE_				:      List[str]					=	save_infos
          SCREAMING_SNAKE_CASE_				:      List[Any]					=	ignore_verifications
          SCREAMING_SNAKE_CASE_				:      int					=	force_redownload
          SCREAMING_SNAKE_CASE_				:      Tuple					=	config_kwargs







    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          import apache_beam as beam

          if self._name is not None and self._all_configs:
                print("Both parameters `name` and `all_configs` can't be used at once."      )
                exit(1      )
          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				:      Any					=	self._dataset, self._name
          SCREAMING_SNAKE_CASE_				:      List[str]					=	dataset_module_factory(lowercase__      )
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	import_main_class(dataset_module.module_path      )
          SCREAMING_SNAKE_CASE_				:      List[DatasetBuilder]					=	[]
          if self._beam_pipeline_options:
                SCREAMING_SNAKE_CASE_				:      List[str]					=	beam.options.pipeline_options.PipelineOptions(
                    flags=[F"--{opt.strip()}" for opt in self._beam_pipeline_options.split(","      ) if opt]      )
          else:
                SCREAMING_SNAKE_CASE_				:      Dict					=	None
          if self._all_configs and len(builder_cls.BUILDER_CONFIGS      ) > 0:
                for builder_config in builder_cls.BUILDER_CONFIGS:
                      builders.append(
                          builder_cls(
                              config_name=builder_config.name    ,					data_dir=self._data_dir    ,					hash=dataset_module.hash    ,					beam_options=lowercase__    ,					cache_dir=self._cache_dir    ,					base_path=dataset_module.builder_kwargs.get("base_path"      )    ,					)      )
          else:
                builders.append(
                    builder_cls(
                        config_name=lowercase__    ,					data_dir=self._data_dir    ,					beam_options=lowercase__    ,					cache_dir=self._cache_dir    ,					base_path=dataset_module.builder_kwargs.get("base_path"      )    ,					**self._config_kwargs    ,					)      )

          for builder in builders:
                builder.download_and_prepare(
                    download_mode=DownloadMode.REUSE_CACHE_IF_EXISTS
                    if not self._force_redownload
                    else DownloadMode.FORCE_REDOWNLOAD    ,					download_config=DownloadConfig(cache_dir=config.DOWNLOADED_DATASETS_PATH      )    ,					verification_mode=VerificationMode.NO_CHECKS
                    if self._ignore_verifications
                    else VerificationMode.ALL_CHECKS    ,					try_from_hf_gcs=lowercase__    ,					)
                if self._save_infos:
                      builder._save_infos()

          print("Apache beam run successful."      )

          # If save_infos=True, the dataset infos file is created next to the loaded module file.
          # Let's move it to the original directory of the dataset script, to allow the user to
          # upload them on S3 at the same time afterwards.
          if self._save_infos:
                SCREAMING_SNAKE_CASE_				:      Dict					=	os.path.join(builder_cls.get_imported_module_dir()    ,					config.DATASETDICT_INFOS_FILENAME      )

                SCREAMING_SNAKE_CASE_				:      List[Any]					=	Path(lowercase__      ).name + ".py"

                SCREAMING_SNAKE_CASE_				:      Optional[int]					=	os.path.join(lowercase__    ,					lowercase__      )
                if os.path.isfile(lowercase__      ):
                      SCREAMING_SNAKE_CASE_				:      Any					=	os.path.dirname(lowercase__      )
                elif os.path.isfile(lowercase__      ):
                      SCREAMING_SNAKE_CASE_				:      List[str]					=	path
                else:  # in case of a remote dataset
                      print(F"Dataset Infos file saved at {dataset_infos_path}"      )
                      exit(1      )

                # Move datasetinfo back to the user
                SCREAMING_SNAKE_CASE_				:      Optional[int]					=	os.path.join(lowercase__    ,					config.DATASETDICT_INFOS_FILENAME      )
                copyfile(lowercase__    ,					lowercase__      )
                print(F"Dataset Infos file saved at {user_dataset_infos_path}"      )

