





import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
    import jax.numpy as jnp

if is_tf_available():
    import tensorflow as tf

if is_torch_available():
    import torch



class  A__       (	unittest.TestCase      ):





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




       UpperCamelCase     : Any	     =       {
           '''task_specific_params''': {
               '''summarization''': {'''length_penalty''': 1.0, '''max_length''': 128, '''min_length''': 12, '''num_beams''': 4},
               '''summarization_cnn''': {'''length_penalty''': 2.0, '''max_length''': 142, '''min_length''': 56, '''num_beams''': 4},
               '''summarization_xsum''': {'''length_penalty''': 1.0, '''max_length''': 62, '''min_length''': 11, '''num_beams''': 6},
           }
       }
       UpperCamelCase     : Tuple	     =       {
           '''task_specific_params.summarization.length_penalty''': 1.0,
           '''task_specific_params.summarization.max_length''': 128,
           '''task_specific_params.summarization.min_length''': 12,
           '''task_specific_params.summarization.num_beams''': 4,
           '''task_specific_params.summarization_cnn.length_penalty''': 2.0,
           '''task_specific_params.summarization_cnn.max_length''': 142,
           '''task_specific_params.summarization_cnn.min_length''': 56,
           '''task_specific_params.summarization_cnn.num_beams''': 4,
           '''task_specific_params.summarization_xsum.length_penalty''': 1.0,
           '''task_specific_params.summarization_xsum.max_length''': 62,
           '''task_specific_params.summarization_xsum.min_length''': 11,
           '''task_specific_params.summarization_xsum.num_beams''': 6,
       }

       self.assertEqual(flatten_dict(snake_case_       )	,							snake_case_       )





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




       UpperCamelCase     : List[Any]	     =       np.random.randn(3	,							4       )
       self.assertTrue(np.allclose(transpose(snake_case_       )	,							x.transpose()       )       )

       UpperCamelCase     : Union[str, Any]	     =       np.random.randn(3	,							4	,							5       )
       self.assertTrue(np.allclose(transpose(snake_case_	,							axes=(1, 2, 0)       )	,							x.transpose((1, 2, 0)       )       )       )





      @require_torch
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[Any]	     =       np.random.randn(3	,							4       )
       UpperCamelCase     : str	     =       torch.tensor(snake_case_       )
       self.assertTrue(np.allclose(transpose(snake_case_       )	,							transpose(snake_case_       ).numpy()       )       )

       UpperCamelCase     : Optional[Any]	     =       np.random.randn(3	,							4	,							5       )
       UpperCamelCase     : Any	     =       torch.tensor(snake_case_       )
       self.assertTrue(np.allclose(transpose(snake_case_	,							axes=(1, 2, 0)       )	,							transpose(snake_case_	,							axes=(1, 2, 0)       ).numpy()       )       )





      @require_tf
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Any	     =       np.random.randn(3	,							4       )
       UpperCamelCase     : int	     =       tf.constant(snake_case_       )
       self.assertTrue(np.allclose(transpose(snake_case_       )	,							transpose(snake_case_       ).numpy()       )       )

       UpperCamelCase     : Optional[Any]	     =       np.random.randn(3	,							4	,							5       )
       UpperCamelCase     : Dict	     =       tf.constant(snake_case_       )
       self.assertTrue(np.allclose(transpose(snake_case_	,							axes=(1, 2, 0)       )	,							transpose(snake_case_	,							axes=(1, 2, 0)       ).numpy()       )       )





      @require_flax
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Optional[Any]	     =       np.random.randn(3	,							4       )
       UpperCamelCase     : List[str]	     =       jnp.array(snake_case_       )
       self.assertTrue(np.allclose(transpose(snake_case_       )	,							np.asarray(transpose(snake_case_       )       )       )       )

       UpperCamelCase     : int	     =       np.random.randn(3	,							4	,							5       )
       UpperCamelCase     : Optional[int]	     =       jnp.array(snake_case_       )
       self.assertTrue(np.allclose(transpose(snake_case_	,							axes=(1, 2, 0)       )	,							np.asarray(transpose(snake_case_	,							axes=(1, 2, 0)       )       )       )       )





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




       UpperCamelCase     : Optional[Any]	     =       np.random.randn(3	,							4       )
       self.assertTrue(np.allclose(reshape(snake_case_	,							(4, 3)       )	,							np.reshape(snake_case_	,							(4, 3)       )       )       )

       UpperCamelCase     : Any	     =       np.random.randn(3	,							4	,							5       )
       self.assertTrue(np.allclose(reshape(snake_case_	,							(12, 5)       )	,							np.reshape(snake_case_	,							(12, 5)       )       )       )





      @require_torch
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Union[str, Any]	     =       np.random.randn(3	,							4       )
       UpperCamelCase     : str	     =       torch.tensor(snake_case_       )
       self.assertTrue(np.allclose(reshape(snake_case_	,							(4, 3)       )	,							reshape(snake_case_	,							(4, 3)       ).numpy()       )       )

       UpperCamelCase     : List[Any]	     =       np.random.randn(3	,							4	,							5       )
       UpperCamelCase     : int	     =       torch.tensor(snake_case_       )
       self.assertTrue(np.allclose(reshape(snake_case_	,							(12, 5)       )	,							reshape(snake_case_	,							(12, 5)       ).numpy()       )       )





      @require_tf
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Union[str, Any]	     =       np.random.randn(3	,							4       )
       UpperCamelCase     : Dict	     =       tf.constant(snake_case_       )
       self.assertTrue(np.allclose(reshape(snake_case_	,							(4, 3)       )	,							reshape(snake_case_	,							(4, 3)       ).numpy()       )       )

       UpperCamelCase     : Tuple	     =       np.random.randn(3	,							4	,							5       )
       UpperCamelCase     : Optional[Any]	     =       tf.constant(snake_case_       )
       self.assertTrue(np.allclose(reshape(snake_case_	,							(12, 5)       )	,							reshape(snake_case_	,							(12, 5)       ).numpy()       )       )





      @require_flax
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Optional[Any]	     =       np.random.randn(3	,							4       )
       UpperCamelCase     : List[Any]	     =       jnp.array(snake_case_       )
       self.assertTrue(np.allclose(reshape(snake_case_	,							(4, 3)       )	,							np.asarray(reshape(snake_case_	,							(4, 3)       )       )       )       )

       UpperCamelCase     : Any	     =       np.random.randn(3	,							4	,							5       )
       UpperCamelCase     : Optional[Any]	     =       jnp.array(snake_case_       )
       self.assertTrue(np.allclose(reshape(snake_case_	,							(12, 5)       )	,							np.asarray(reshape(snake_case_	,							(12, 5)       )       )       )       )





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




       UpperCamelCase     : str	     =       np.random.randn(1	,							3	,							4       )
       self.assertTrue(np.allclose(squeeze(snake_case_       )	,							np.squeeze(snake_case_       )       )       )

       UpperCamelCase     : Dict	     =       np.random.randn(1	,							4	,							1	,							5       )
       self.assertTrue(np.allclose(squeeze(snake_case_	,							axis=2       )	,							np.squeeze(snake_case_	,							axis=2       )       )       )





      @require_torch
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Optional[int]	     =       np.random.randn(1	,							3	,							4       )
       UpperCamelCase     : List[Any]	     =       torch.tensor(snake_case_       )
       self.assertTrue(np.allclose(squeeze(snake_case_       )	,							squeeze(snake_case_       ).numpy()       )       )

       UpperCamelCase     : Tuple	     =       np.random.randn(1	,							4	,							1	,							5       )
       UpperCamelCase     : Optional[int]	     =       torch.tensor(snake_case_       )
       self.assertTrue(np.allclose(squeeze(snake_case_	,							axis=2       )	,							squeeze(snake_case_	,							axis=2       ).numpy()       )       )





      @require_tf
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : str	     =       np.random.randn(1	,							3	,							4       )
       UpperCamelCase     : int	     =       tf.constant(snake_case_       )
       self.assertTrue(np.allclose(squeeze(snake_case_       )	,							squeeze(snake_case_       ).numpy()       )       )

       UpperCamelCase     : Optional[Any]	     =       np.random.randn(1	,							4	,							1	,							5       )
       UpperCamelCase     : Any	     =       tf.constant(snake_case_       )
       self.assertTrue(np.allclose(squeeze(snake_case_	,							axis=2       )	,							squeeze(snake_case_	,							axis=2       ).numpy()       )       )





      @require_flax
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Tuple	     =       np.random.randn(1	,							3	,							4       )
       UpperCamelCase     : str	     =       jnp.array(snake_case_       )
       self.assertTrue(np.allclose(squeeze(snake_case_       )	,							np.asarray(squeeze(snake_case_       )       )       )       )

       UpperCamelCase     : Union[str, Any]	     =       np.random.randn(1	,							4	,							1	,							5       )
       UpperCamelCase     : Dict	     =       jnp.array(snake_case_       )
       self.assertTrue(np.allclose(squeeze(snake_case_	,							axis=2       )	,							np.asarray(squeeze(snake_case_	,							axis=2       )       )       )       )





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




       UpperCamelCase     : Any	     =       np.random.randn(3	,							4       )
       self.assertTrue(np.allclose(expand_dims(snake_case_	,							axis=1       )	,							np.expand_dims(snake_case_	,							axis=1       )       )       )





      @require_torch
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Dict	     =       np.random.randn(3	,							4       )
       UpperCamelCase     : Any	     =       torch.tensor(snake_case_       )
       self.assertTrue(np.allclose(expand_dims(snake_case_	,							axis=1       )	,							expand_dims(snake_case_	,							axis=1       ).numpy()       )       )





      @require_tf
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Union[str, Any]	     =       np.random.randn(3	,							4       )
       UpperCamelCase     : Optional[Any]	     =       tf.constant(snake_case_       )
       self.assertTrue(np.allclose(expand_dims(snake_case_	,							axis=1       )	,							expand_dims(snake_case_	,							axis=1       ).numpy()       )       )





      @require_flax
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Dict	     =       np.random.randn(3	,							4       )
       UpperCamelCase     : str	     =       jnp.array(snake_case_       )
       self.assertTrue(np.allclose(expand_dims(snake_case_	,							axis=1       )	,							np.asarray(expand_dims(snake_case_	,							axis=1       )       )       )       )







from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCamelCase	:					Tuple			  =					logging.get_logger(__name__)



class  A__       (	__snake_case      ):
      _UpperCAmelCase     :List[Any]						   =       'timm_backbone'





      def __init__(			self	,							A_=None	,							A_=3	,							A_=True	,							A_=True	,							A_=None	,							**A_	,							):
       '''simple docstring'''




       super().__init__(**A_       )
       UpperCamelCase     : Tuple	     =       backbone
       UpperCamelCase     : Dict	     =       num_channels
       UpperCamelCase     : Tuple	     =       features_only
       UpperCamelCase     : Optional[int]	     =       use_pretrained_backbone
       UpperCamelCase     : Dict	     =       True
       UpperCamelCase     : List[str]	     =       out_indices if out_indices is not None else (-1,)
