




'''simple docstring'''



import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TFEfficientFormerForImageClassification,
         TFEfficientFormerForImageClassificationWithTeacher,
         TFEfficientFormerModel,
     )
     from transformers.models.efficientformer.modeling_tf_efficientformer import (
         TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
     )


if is_vision_available():
     from PIL import Image

     from transformers import EfficientFormerImageProcessor





class      lowerCAmelCase :


       def __init__( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE = 13     ,	__SCREAMING_SNAKE_CASE = 64     ,	__SCREAMING_SNAKE_CASE = 2     ,	__SCREAMING_SNAKE_CASE = 3     ,	__SCREAMING_SNAKE_CASE = 3     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = 128     ,	__SCREAMING_SNAKE_CASE=[16, 32, 64, 128]     ,	__SCREAMING_SNAKE_CASE = 7     ,	__SCREAMING_SNAKE_CASE = 4     ,	__SCREAMING_SNAKE_CASE = 37     ,	__SCREAMING_SNAKE_CASE = "gelu"     ,	__SCREAMING_SNAKE_CASE = 0.1     ,	__SCREAMING_SNAKE_CASE = 0.1     ,	__SCREAMING_SNAKE_CASE = 10     ,	__SCREAMING_SNAKE_CASE = 0.02     ,	__SCREAMING_SNAKE_CASE = 2     ,	__SCREAMING_SNAKE_CASE = 1     ,	__SCREAMING_SNAKE_CASE = 128     ,	__SCREAMING_SNAKE_CASE = [2, 2, 2, 2]     ,	__SCREAMING_SNAKE_CASE = 2     ,	__SCREAMING_SNAKE_CASE = 2     ,	)   ->	int:



            '''simple docstring'''




            __snake_case            =	parent
            __snake_case            =	batch_size
            __snake_case            =	image_size
            __snake_case            =	patch_size
            __snake_case            =	num_channels
            __snake_case            =	is_training
            __snake_case            =	use_labels
            __snake_case            =	hidden_size
            __snake_case            =	num_hidden_layers
            __snake_case            =	num_attention_heads
            __snake_case            =	intermediate_size
            __snake_case            =	hidden_act
            __snake_case            =	hidden_dropout_prob
            __snake_case            =	attention_probs_dropout_prob
            __snake_case            =	type_sequence_label_size
            __snake_case            =	initializer_range
            __snake_case            =	encoder_stride
            __snake_case            =	num_attention_outputs
            __snake_case            =	embed_dim
            __snake_case            =	embed_dim + 1
            __snake_case            =	resolution
            __snake_case            =	depths
            __snake_case            =	hidden_sizes
            __snake_case            =	dim
            __snake_case            =	mlp_expansion_ratio


       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

            __snake_case            =	None
            if self.use_labels:
                 __snake_case            =	ids_tensor([self.batch_size]     ,	self.type_sequence_label_size	)

            __snake_case            =	self.get_config()

            return config, pixel_values, labels


       def    lowerCAmelCase   ( self	)   ->	Optional[Any]:



            '''simple docstring'''




            return EfficientFormerConfig(
                image_size=self.image_size     ,	patch_size=self.patch_size     ,	num_channels=self.num_channels     ,	hidden_size=self.hidden_size     ,	num_hidden_layers=self.num_hidden_layers     ,	num_attention_heads=self.num_attention_heads     ,	intermediate_size=self.intermediate_size     ,	hidden_act=self.hidden_act     ,	hidden_dropout_prob=self.hidden_dropout_prob     ,	attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,	is_decoder=__SCREAMING_SNAKE_CASE     ,	initializer_range=self.initializer_range     ,	encoder_stride=self.encoder_stride     ,	resolution=self.resolution     ,	depths=self.depths     ,	hidden_sizes=self.hidden_sizes     ,	dim=self.dim     ,	mlp_expansion_ratio=self.mlp_expansion_ratio     ,	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	str:



            '''simple docstring'''




            __snake_case            =	TFEfficientFormerModel(config=__SCREAMING_SNAKE_CASE	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE     ,	training=__SCREAMING_SNAKE_CASE	)
            self.parent.assertEqual(result.last_hidden_state.shape     ,	(self.batch_size, self.seq_length, self.hidden_size)	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	self.type_sequence_label_size
            __snake_case            =	TFEfficientFormerForImageClassification(__SCREAMING_SNAKE_CASE	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE     ,	labels=__SCREAMING_SNAKE_CASE     ,	training=__SCREAMING_SNAKE_CASE	)
            self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.type_sequence_label_size)	)

            # test greyscale images
            __snake_case            =	1
            __snake_case            =	TFEfficientFormerForImageClassification(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE     ,	labels=__SCREAMING_SNAKE_CASE	)
            self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.type_sequence_label_size)	)




       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	self.prepare_config_and_inputs()
            __snake_case       ,     __snake_case       ,     __snake_case            =	config_and_inputs
            __snake_case            =	{'''pixel_values''': pixel_values}
            return config, inputs_dict





@require_tf
class      lowerCAmelCase (			__UpperCamelCase					, __UpperCamelCase					, unittest.TestCase):
       __lowercase	:   str										=      (
           (
               TFEfficientFormerModel,
               TFEfficientFormerForImageClassificationWithTeacher,
               TFEfficientFormerForImageClassification,
           )
           if is_tf_available()
           else ()
       )
       __lowercase	:   List[str]										=      (
           {
               'feature-extraction': TFEfficientFormerModel,
               'image-classification': (
                   TFEfficientFormerForImageClassification,
                   TFEfficientFormerForImageClassificationWithTeacher,
               ),
           }
           if is_tf_available()
           else {}
       )

       __lowercase	:   Optional[Any]										=      False

       __lowercase	:   List[Any]										=      False
       __lowercase	:   Tuple										=      False
       __lowercase	:   List[Any]										=      False
       __lowercase	:   Any										=      False


       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	TFEfficientFormerModelTester(self	)
            __snake_case            =	ConfigTester(
                self     ,	config_class=__SCREAMING_SNAKE_CASE     ,	has_text_modality=__SCREAMING_SNAKE_CASE     ,	hidden_size=37	)


       def    lowerCAmelCase   ( self	)   ->	List[str]:



            '''simple docstring'''




            self.config_tester.run_common_tests()


       @unittest.skip(reason='''EfficientFormer does not use inputs_embeds'''	)
       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            pass


       @unittest.skip(reason='''EfficientFormer does not support input and output embeddings'''	)
       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            pass


       def    lowerCAmelCase   ( self	)   ->	List[Any]:



            '''simple docstring'''




            __snake_case       ,     __snake_case            =	self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	inspect.signature(model.call	)
                 # signature.parameters is an OrderedDict => so arg_names order is deterministic
                 __snake_case            =	[*signature.parameters.keys()]

                 __snake_case            =	['''pixel_values''']
                 self.assertListEqual(arg_names[:1]     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Optional[Any]:



            '''simple docstring'''




            def check_hidden_states_output(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	):
                 __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)

                 __snake_case            =	model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)     ,	training=__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                 __snake_case            =	getattr(
                     self.model_tester     ,	'''expected_num_hidden_layers'''     ,	self.model_tester.num_hidden_layers + 1	)
                 self.assertEqual(len(__SCREAMING_SNAKE_CASE	)     ,	__SCREAMING_SNAKE_CASE	)

                 if hasattr(self.model_tester     ,	'''encoder_seq_length'''	):
                      __snake_case            =	self.model_tester.encoder_seq_length
                      if hasattr(self.model_tester     ,	'''chunk_length'''	) and self.model_tester.chunk_length > 1:
                           __snake_case            =	seq_length * self.model_tester.chunk_length
                 else:
                      __snake_case            =	self.model_tester.seq_length

                 self.assertListEqual(
                     list(hidden_states[-1].shape[-2:]	)     ,	[seq_length, self.model_tester.hidden_size]     ,	)

                 if config.is_encoder_decoder:
                      __snake_case            =	outputs.decoder_hidden_states

                      self.asseretIsInstance(__SCREAMING_SNAKE_CASE     ,	(list, tuple)	)
                      self.assertEqual(len(__SCREAMING_SNAKE_CASE	)     ,	__SCREAMING_SNAKE_CASE	)
                      __snake_case            =	getattr(self.model_tester     ,	'''seq_length'''     ,	__SCREAMING_SNAKE_CASE	)
                      __snake_case            =	getattr(self.model_tester     ,	'''decoder_seq_length'''     ,	__SCREAMING_SNAKE_CASE	)

                      self.assertListEqual(
                          list(hidden_states[-1].shape[-2:]	)     ,	[decoder_seq_length, self.model_tester.hidden_size]     ,	)

            __snake_case       ,     __snake_case            =	self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 __snake_case            =	True
                 check_hidden_states_output(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 __snake_case            =	True

                 check_hidden_states_output(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=False	)   ->	Dict:



            '''simple docstring'''




            __snake_case            =	super()._prepare_for_class(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	return_labels=__SCREAMING_SNAKE_CASE	)

            if return_labels:
                 if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
                      del inputs_dict["labels"]

            return inputs_dict


       def    lowerCAmelCase   ( self	)   ->	List[Any]:



            '''simple docstring'''




            __snake_case            =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE	)


       @unittest.skip(reason='''EfficientFormer does not implement masked image modeling yet'''	)
       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Optional[Any]:



            '''simple docstring'''




            __snake_case            =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE	)


       @slow
       def    lowerCAmelCase   ( self	)   ->	List[str]:



            '''simple docstring'''




            for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __snake_case            =	TFEfficientFormerModel.from_pretrained(__SCREAMING_SNAKE_CASE	)
                 self.assertIsNotNone(__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	str:



            '''simple docstring'''




            __snake_case       ,     __snake_case            =	self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case            =	True

            __snake_case            =	getattr(self.model_tester     ,	'''seq_length'''     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	getattr(self.model_tester     ,	'''encoder_seq_length'''     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	getattr(self.model_tester     ,	'''key_length'''     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	getattr(self.model_tester     ,	'''chunk_length'''     ,	__SCREAMING_SNAKE_CASE	)

            if chunk_length is not None and hasattr(self.model_tester     ,	'''num_hashes'''	):
                 __snake_case            =	encoder_seq_length * self.model_tester.num_hashes

            for model_class in self.all_model_classes:
                 __snake_case            =	True
                 __snake_case            =	False
                 __snake_case            =	True
                 __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)

                 __snake_case            =	model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)     ,	training=__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
                 self.assertEqual(len(__SCREAMING_SNAKE_CASE	)     ,	self.model_tester.num_attention_outputs	)

                 # check that output_attentions also work using config
                 del inputs_dict["output_attentions"]
                 __snake_case            =	True
                 __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)     ,	training=__SCREAMING_SNAKE_CASE	)

                 __snake_case            =	outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
                 self.assertEqual(len(__SCREAMING_SNAKE_CASE	)     ,	self.model_tester.num_attention_outputs	)

                 if chunk_length is not None:
                      self.assertListEqual(
                          list(attentions[0].shape[-4:]	)     ,	[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]     ,	)
                 else:
                      self.assertListEqual(
                          list(attentions[0].shape[-3:]	)     ,	[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]     ,	)




       def    lowerCAmelCase   ( self	)   ->	List[str]:



            '''simple docstring'''




            __snake_case       ,     __snake_case            =	self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 # Prepare our model
                 __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)
                 # These are maximally general inputs for the model, with multiple None dimensions
                 # Hopefully this will catch any conditionals that fail for flexible shapes
                 __snake_case            =	{
                     key: tf.keras.Input(shape=val.shape[1:]     ,	dtype=val.dtype     ,	name=__SCREAMING_SNAKE_CASE	)
                     for key, val in model.input_signature.items()
                     if key in model.dummy_inputs
                 }
                 __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
                 self.assertTrue(outputs_dict is not None	)







def       _UpperCamelCase			()-> List[Any]:




     '''simple docstring'''





     __snake_case            =	Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
     return image







@require_tf
@require_vision
class      lowerCAmelCase (			unittest.TestCase):


       @cached_property
       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            return (
                EfficientFormerImageProcessor.from_pretrained('''snap-research/efficientformer-l1-300'''	)
                if is_vision_available()
                else None
            )


       @slow
       def    lowerCAmelCase   ( self	)   ->	Union[str, Any]:



            '''simple docstring'''




            __snake_case            =	TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300'''	)
            __snake_case            =	self.default_image_processor
            __snake_case            =	prepare_img()
            __snake_case            =	image_processor(images=__SCREAMING_SNAKE_CASE     ,	return_tensors='''tf'''	)
            # forward pass
            __snake_case            =	model(**__SCREAMING_SNAKE_CASE     ,	training=__SCREAMING_SNAKE_CASE	)
            # verify the logits
            __snake_case            =	tf.TensorShape((1, 1000)	)
            self.assertEqual(outputs.logits.shape     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	tf.constant([-0.0_555, 0.4_825, -0.0_852]	)
            self.assertTrue(np.allclose(outputs.logits[0, :3]     ,	__SCREAMING_SNAKE_CASE     ,	atol=1E-4	)	)




       @slow
       def    lowerCAmelCase   ( self	)   ->	str:



            '''simple docstring'''




            __snake_case            =	TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
                '''snap-research/efficientformer-l1-300'''	)
            __snake_case            =	self.default_image_processor
            __snake_case            =	prepare_img()
            __snake_case            =	image_processor(images=__SCREAMING_SNAKE_CASE     ,	return_tensors='''tf'''	)
            # forward pass
            __snake_case            =	model(**__SCREAMING_SNAKE_CASE     ,	training=__SCREAMING_SNAKE_CASE	)
            # verify the logits
            __snake_case            =	tf.TensorShape((1, 1000)	)
            self.assertEqual(outputs.logits.shape     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	tf.constant([-0.1_312, 0.4_353, -1.0_499]	)
            self.assertTrue(np.allclose(outputs.logits[0, :3]     ,	__SCREAMING_SNAKE_CASE     ,	atol=1E-4	)	)








# coding=utf-8
# Copyright 2020 The HuggingFace Inc. team.
#
# 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.

# this script dumps information about the environment

import os
import sys

import transformers


__magic_name__  							=	'''3'''

print('''Python version:''', sys.version)
print('''transformers version:''', transformers.__version__)

try:
     import torch

     print('''Torch version:''', torch.__version__)
     print('''Cuda available:''', torch.cuda.is_available())
     print('''Cuda version:''', torch.version.cuda)
     print('''CuDNN version:''', torch.backends.cudnn.version())
     print('''Number of GPUs available:''', torch.cuda.device_count())
     print('''NCCL version:''', torch.cuda.nccl.version())
except ImportError:
     print('''Torch version:''', None)

try:
     import deepspeed

     print('''DeepSpeed version:''', deepspeed.__version__)
except ImportError:
     print('''DeepSpeed version:''', None)

try:
     import tensorflow as tf

     print('''TensorFlow version:''', tf.__version__)
     print('''TF GPUs available:''', bool(tf.config.list_physical_devices('''GPU''')))
     print('''Number of TF GPUs available:''', len(tf.config.list_physical_devices('''GPU''')))
except ImportError:
     print('''TensorFlow version:''', None)



