'''simple docstring'''

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       UpperCAmelCase  (						unittest.TestCase ):





       '''simple docstring'''



       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   Tuple						=				{
            '''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},
            }
        }
        lowercase__    :   List[str]						=				{
            '''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(__lowerCAmelCase			)     ,       __lowerCAmelCase			)

       def _lowerCAmelCase(						self			)  ->  List[str]:
        lowercase__    :   Dict						=				np.random.randn(3     ,       4			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase			)     ,       x.transpose()			)			)

        lowercase__    :   Any						=				np.random.randn(3     ,       4     ,       5			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			)     ,       x.transpose((1, 2, 0)			)			)			)

       @require_torch
       def _lowerCAmelCase(						self			)  ->  Any:
        lowercase__    :   Dict						=				np.random.randn(3     ,       4			)
        lowercase__    :   Dict						=				torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase			)     ,       transpose(__lowerCAmelCase			).numpy()			)			)

        lowercase__    :   Optional[int]						=				np.random.randn(3     ,       4     ,       5			)
        lowercase__    :   Union[str, Any]						=				torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			)     ,       transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			).numpy()			)			)

       @require_tf
       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   Optional[int]						=				np.random.randn(3     ,       4			)
        lowercase__    :   Union[str, Any]						=				tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase			)     ,       transpose(__lowerCAmelCase			).numpy()			)			)

        lowercase__    :   int						=				np.random.randn(3     ,       4     ,       5			)
        lowercase__    :   str						=				tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			)     ,       transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			).numpy()			)			)

       @require_flax
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   int						=				np.random.randn(3     ,       4			)
        lowercase__    :   Union[str, Any]						=				jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase			)     ,       np.asarray(transpose(__lowerCAmelCase			)			)			)			)

        lowercase__    :   Optional[Any]						=				np.random.randn(3     ,       4     ,       5			)
        lowercase__    :   Union[str, Any]						=				jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			)     ,       np.asarray(transpose(__lowerCAmelCase     ,       axes=(1, 2, 0)			)			)			)			)

       def _lowerCAmelCase(						self			)  ->  Tuple:
        lowercase__    :   List[Any]						=				np.random.randn(3     ,       4			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (4, 3)			)     ,       np.reshape(__lowerCAmelCase     ,       (4, 3)			)			)			)

        lowercase__    :   str						=				np.random.randn(3     ,       4     ,       5			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (12, 5)			)     ,       np.reshape(__lowerCAmelCase     ,       (12, 5)			)			)			)

       @require_torch
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   str						=				np.random.randn(3     ,       4			)
        lowercase__    :   Tuple						=				torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (4, 3)			)     ,       reshape(__lowerCAmelCase     ,       (4, 3)			).numpy()			)			)

        lowercase__    :   List[str]						=				np.random.randn(3     ,       4     ,       5			)
        lowercase__    :   Union[str, Any]						=				torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (12, 5)			)     ,       reshape(__lowerCAmelCase     ,       (12, 5)			).numpy()			)			)

       @require_tf
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   int						=				np.random.randn(3     ,       4			)
        lowercase__    :   Optional[int]						=				tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (4, 3)			)     ,       reshape(__lowerCAmelCase     ,       (4, 3)			).numpy()			)			)

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

       @require_flax
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   Optional[Any]						=				np.random.randn(3     ,       4			)
        lowercase__    :   Any						=				jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(reshape(__lowerCAmelCase     ,       (4, 3)			)     ,       np.asarray(reshape(__lowerCAmelCase     ,       (4, 3)			)			)			)			)

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

       def _lowerCAmelCase(						self			)  ->  int:
        lowercase__    :   str						=				np.random.randn(1     ,       3     ,       4			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase			)     ,       np.squeeze(__lowerCAmelCase			)			)			)

        lowercase__    :   int						=				np.random.randn(1     ,       4     ,       1     ,       5			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase     ,       axis=2			)     ,       np.squeeze(__lowerCAmelCase     ,       axis=2			)			)			)

       @require_torch
       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   Optional[int]						=				np.random.randn(1     ,       3     ,       4			)
        lowercase__    :   Union[str, Any]						=				torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase			)     ,       squeeze(__lowerCAmelCase			).numpy()			)			)

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

       @require_tf
       def _lowerCAmelCase(						self			)  ->  Optional[Any]:
        lowercase__    :   Dict						=				np.random.randn(1     ,       3     ,       4			)
        lowercase__    :   int						=				tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase			)     ,       squeeze(__lowerCAmelCase			).numpy()			)			)

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

       @require_flax
       def _lowerCAmelCase(						self			)  ->  Any:
        lowercase__    :   int						=				np.random.randn(1     ,       3     ,       4			)
        lowercase__    :   List[str]						=				jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(squeeze(__lowerCAmelCase			)     ,       np.asarray(squeeze(__lowerCAmelCase			)			)			)			)

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

       def _lowerCAmelCase(						self			)  ->  Dict:
        lowercase__    :   Dict						=				np.random.randn(3     ,       4			)
        self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase     ,       axis=1			)     ,       np.expand_dims(__lowerCAmelCase     ,       axis=1			)			)			)

       @require_torch
       def _lowerCAmelCase(						self			)  ->  Any:
        lowercase__    :   Any						=				np.random.randn(3     ,       4			)
        lowercase__    :   Optional[Any]						=				torch.tensor(__lowerCAmelCase			)
        self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase     ,       axis=1			)     ,       expand_dims(__lowerCAmelCase     ,       axis=1			).numpy()			)			)

       @require_tf
       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   str						=				np.random.randn(3     ,       4			)
        lowercase__    :   List[str]						=				tf.constant(__lowerCAmelCase			)
        self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase     ,       axis=1			)     ,       expand_dims(__lowerCAmelCase     ,       axis=1			).numpy()			)			)


       @require_flax
       def _lowerCAmelCase(						self			)  ->  Tuple:
        lowercase__    :   Dict						=				np.random.randn(3     ,       4			)
        lowercase__    :   List[str]						=				jnp.array(__lowerCAmelCase			)
        self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase     ,       axis=1			)     ,       np.asarray(expand_dims(__lowerCAmelCase     ,       axis=1			)			)			)			)


'''simple docstring'''

import numpy as np
def       __UpperCamelCase	(       UpperCAmelCase					):
 return 1 / (1 + np.exp(-vector					))
def       __UpperCamelCase	(       UpperCAmelCase					):
 return vector * sigmoid(UpperCAmelCase					)


if __name__ == "__main__":
  import doctest

  doctest.testmod()

