

'''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 							_snake_case (       unittest.TestCase						):
   def     __UpperCamelCase						( self			:      Optional[Any]							):
     SCREAMING_SNAKE_CASE:List[str]						      =					{
         "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},
         }
     }
     SCREAMING_SNAKE_CASE: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(SCREAMING_SNAKE_CASE__							)     ,SCREAMING_SNAKE_CASE__							)
   def     __UpperCamelCase						( self			:      Tuple							):
     SCREAMING_SNAKE_CASE:Tuple						      =					np.random.randn(3     ,4							)
     self.assertTrue(np.allclose(transpose(SCREAMING_SNAKE_CASE__							)     ,x.transpose()							)							)

     SCREAMING_SNAKE_CASE:Dict						      =					np.random.randn(3     ,4     ,5							)
     self.assertTrue(np.allclose(transpose(SCREAMING_SNAKE_CASE__     ,axes=(1, 2, 0)							)     ,x.transpose((1, 2, 0)							)							)							)
   @require_torch
   def     __UpperCamelCase						( self			:      Any							):
     SCREAMING_SNAKE_CASE:Tuple						      =					np.random.randn(3     ,4							)
     SCREAMING_SNAKE_CASE:List[str]						      =					torch.tensor(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(transpose(SCREAMING_SNAKE_CASE__							)     ,transpose(SCREAMING_SNAKE_CASE__							).numpy()							)							)

     SCREAMING_SNAKE_CASE:str						      =					np.random.randn(3     ,4     ,5							)
     SCREAMING_SNAKE_CASE:List[str]						      =					torch.tensor(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(transpose(SCREAMING_SNAKE_CASE__     ,axes=(1, 2, 0)							)     ,transpose(SCREAMING_SNAKE_CASE__     ,axes=(1, 2, 0)							).numpy()							)							)
   @require_tf
   def     __UpperCamelCase						( self			:      Tuple							):
     SCREAMING_SNAKE_CASE:List[str]						      =					np.random.randn(3     ,4							)
     SCREAMING_SNAKE_CASE:Tuple						      =					tf.constant(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(transpose(SCREAMING_SNAKE_CASE__							)     ,transpose(SCREAMING_SNAKE_CASE__							).numpy()							)							)

     SCREAMING_SNAKE_CASE:Optional[Any]						      =					np.random.randn(3     ,4     ,5							)
     SCREAMING_SNAKE_CASE:int						      =					tf.constant(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(transpose(SCREAMING_SNAKE_CASE__     ,axes=(1, 2, 0)							)     ,transpose(SCREAMING_SNAKE_CASE__     ,axes=(1, 2, 0)							).numpy()							)							)
   @require_flax
   def     __UpperCamelCase						( self			:      List[str]							):
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					np.random.randn(3     ,4							)
     SCREAMING_SNAKE_CASE:str						      =					jnp.array(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(transpose(SCREAMING_SNAKE_CASE__							)     ,np.asarray(transpose(SCREAMING_SNAKE_CASE__							)							)							)							)

     SCREAMING_SNAKE_CASE:List[Any]						      =					np.random.randn(3     ,4     ,5							)
     SCREAMING_SNAKE_CASE:Any						      =					jnp.array(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(transpose(SCREAMING_SNAKE_CASE__     ,axes=(1, 2, 0)							)     ,np.asarray(transpose(SCREAMING_SNAKE_CASE__     ,axes=(1, 2, 0)							)							)							)							)
   def     __UpperCamelCase						( self			:      Dict							):
     SCREAMING_SNAKE_CASE:Tuple						      =					np.random.randn(3     ,4							)
     self.assertTrue(np.allclose(reshape(SCREAMING_SNAKE_CASE__     ,(4, 3)							)     ,np.reshape(SCREAMING_SNAKE_CASE__     ,(4, 3)							)							)							)

     SCREAMING_SNAKE_CASE:List[Any]						      =					np.random.randn(3     ,4     ,5							)
     self.assertTrue(np.allclose(reshape(SCREAMING_SNAKE_CASE__     ,(12, 5)							)     ,np.reshape(SCREAMING_SNAKE_CASE__     ,(12, 5)							)							)							)
   @require_torch
   def     __UpperCamelCase						( self			:      Dict							):
     SCREAMING_SNAKE_CASE:List[Any]						      =					np.random.randn(3     ,4							)
     SCREAMING_SNAKE_CASE:Tuple						      =					torch.tensor(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(reshape(SCREAMING_SNAKE_CASE__     ,(4, 3)							)     ,reshape(SCREAMING_SNAKE_CASE__     ,(4, 3)							).numpy()							)							)

     SCREAMING_SNAKE_CASE:str						      =					np.random.randn(3     ,4     ,5							)
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					torch.tensor(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(reshape(SCREAMING_SNAKE_CASE__     ,(12, 5)							)     ,reshape(SCREAMING_SNAKE_CASE__     ,(12, 5)							).numpy()							)							)
   @require_tf
   def     __UpperCamelCase						( self			:      str							):
     SCREAMING_SNAKE_CASE:Any						      =					np.random.randn(3     ,4							)
     SCREAMING_SNAKE_CASE:Tuple						      =					tf.constant(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(reshape(SCREAMING_SNAKE_CASE__     ,(4, 3)							)     ,reshape(SCREAMING_SNAKE_CASE__     ,(4, 3)							).numpy()							)							)

     SCREAMING_SNAKE_CASE:List[str]						      =					np.random.randn(3     ,4     ,5							)
     SCREAMING_SNAKE_CASE:str						      =					tf.constant(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(reshape(SCREAMING_SNAKE_CASE__     ,(12, 5)							)     ,reshape(SCREAMING_SNAKE_CASE__     ,(12, 5)							).numpy()							)							)
   @require_flax
   def     __UpperCamelCase						( self			:      List[str]							):
     SCREAMING_SNAKE_CASE:List[Any]						      =					np.random.randn(3     ,4							)
     SCREAMING_SNAKE_CASE:Any						      =					jnp.array(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(reshape(SCREAMING_SNAKE_CASE__     ,(4, 3)							)     ,np.asarray(reshape(SCREAMING_SNAKE_CASE__     ,(4, 3)							)							)							)							)

     SCREAMING_SNAKE_CASE:Tuple						      =					np.random.randn(3     ,4     ,5							)
     SCREAMING_SNAKE_CASE:int						      =					jnp.array(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(reshape(SCREAMING_SNAKE_CASE__     ,(12, 5)							)     ,np.asarray(reshape(SCREAMING_SNAKE_CASE__     ,(12, 5)							)							)							)							)
   def     __UpperCamelCase						( self			:      Dict							):
     SCREAMING_SNAKE_CASE:List[str]						      =					np.random.randn(1     ,3     ,4							)
     self.assertTrue(np.allclose(squeeze(SCREAMING_SNAKE_CASE__							)     ,np.squeeze(SCREAMING_SNAKE_CASE__							)							)							)

     SCREAMING_SNAKE_CASE:int						      =					np.random.randn(1     ,4     ,1     ,5							)
     self.assertTrue(np.allclose(squeeze(SCREAMING_SNAKE_CASE__     ,axis=2							)     ,np.squeeze(SCREAMING_SNAKE_CASE__     ,axis=2							)							)							)
   @require_torch
   def     __UpperCamelCase						( self			:      List[str]							):
     SCREAMING_SNAKE_CASE:List[Any]						      =					np.random.randn(1     ,3     ,4							)
     SCREAMING_SNAKE_CASE:Any						      =					torch.tensor(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(squeeze(SCREAMING_SNAKE_CASE__							)     ,squeeze(SCREAMING_SNAKE_CASE__							).numpy()							)							)

     SCREAMING_SNAKE_CASE:Dict						      =					np.random.randn(1     ,4     ,1     ,5							)
     SCREAMING_SNAKE_CASE:List[Any]						      =					torch.tensor(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(squeeze(SCREAMING_SNAKE_CASE__     ,axis=2							)     ,squeeze(SCREAMING_SNAKE_CASE__     ,axis=2							).numpy()							)							)
   @require_tf
   def     __UpperCamelCase						( self			:      Optional[Any]							):
     SCREAMING_SNAKE_CASE:Tuple						      =					np.random.randn(1     ,3     ,4							)
     SCREAMING_SNAKE_CASE:Dict						      =					tf.constant(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(squeeze(SCREAMING_SNAKE_CASE__							)     ,squeeze(SCREAMING_SNAKE_CASE__							).numpy()							)							)

     SCREAMING_SNAKE_CASE:Tuple						      =					np.random.randn(1     ,4     ,1     ,5							)
     SCREAMING_SNAKE_CASE:Any						      =					tf.constant(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(squeeze(SCREAMING_SNAKE_CASE__     ,axis=2							)     ,squeeze(SCREAMING_SNAKE_CASE__     ,axis=2							).numpy()							)							)
   @require_flax
   def     __UpperCamelCase						( self			:      Dict							):
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					np.random.randn(1     ,3     ,4							)
     SCREAMING_SNAKE_CASE:List[str]						      =					jnp.array(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(squeeze(SCREAMING_SNAKE_CASE__							)     ,np.asarray(squeeze(SCREAMING_SNAKE_CASE__							)							)							)							)

     SCREAMING_SNAKE_CASE:int						      =					np.random.randn(1     ,4     ,1     ,5							)
     SCREAMING_SNAKE_CASE:Optional[int]						      =					jnp.array(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(squeeze(SCREAMING_SNAKE_CASE__     ,axis=2							)     ,np.asarray(squeeze(SCREAMING_SNAKE_CASE__     ,axis=2							)							)							)							)
   def     __UpperCamelCase						( self			:      List[Any]							):
     SCREAMING_SNAKE_CASE:Optional[int]						      =					np.random.randn(3     ,4							)
     self.assertTrue(np.allclose(expand_dims(SCREAMING_SNAKE_CASE__     ,axis=1							)     ,np.expand_dims(SCREAMING_SNAKE_CASE__     ,axis=1							)							)							)
   @require_torch
   def     __UpperCamelCase						( self			:      Optional[int]							):
     SCREAMING_SNAKE_CASE:Optional[int]						      =					np.random.randn(3     ,4							)
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					torch.tensor(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(expand_dims(SCREAMING_SNAKE_CASE__     ,axis=1							)     ,expand_dims(SCREAMING_SNAKE_CASE__     ,axis=1							).numpy()							)							)
   @require_tf
   def     __UpperCamelCase						( self			:      Tuple							):
     SCREAMING_SNAKE_CASE:Tuple						      =					np.random.randn(3     ,4							)
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					tf.constant(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(expand_dims(SCREAMING_SNAKE_CASE__     ,axis=1							)     ,expand_dims(SCREAMING_SNAKE_CASE__     ,axis=1							).numpy()							)							)







   @require_flax
   def     __UpperCamelCase						( self			:      Any							):
     SCREAMING_SNAKE_CASE:str						      =					np.random.randn(3     ,4							)
     SCREAMING_SNAKE_CASE:List[str]						      =					jnp.array(SCREAMING_SNAKE_CASE__							)
     self.assertTrue(np.allclose(expand_dims(SCREAMING_SNAKE_CASE__     ,axis=1							)     ,np.asarray(expand_dims(SCREAMING_SNAKE_CASE__     ,axis=1							)							)							)							)





'''simple docstring'''

import PIL.Image
import PIL.ImageOps
from packaging import version
from PIL import Image


if version.parse(version.parse(PIL.__version__).base_version) >= version.parse("9.1.0"):
    A_       						=							{
        "linear": PIL.Image.Resampling.BILINEAR,
        "bilinear": PIL.Image.Resampling.BILINEAR,
        "bicubic": PIL.Image.Resampling.BICUBIC,
        "lanczos": PIL.Image.Resampling.LANCZOS,
        "nearest": PIL.Image.Resampling.NEAREST,
    }
else:
    A_       						=							{
        "linear": PIL.Image.LINEAR,
        "bilinear": PIL.Image.BILINEAR,
        "bicubic": PIL.Image.BICUBIC,
        "lanczos": PIL.Image.LANCZOS,
        "nearest": PIL.Image.NEAREST,
    }





def    A_  ( snake_case ):
  SCREAMING_SNAKE_CASE:Any						      =					(images / 2 + 0.5).clamp(0      ,       1 )
  SCREAMING_SNAKE_CASE:Optional[Any]						      =					images.cpu().permute(0      ,       2      ,       3      ,       1 ).float().numpy()
  SCREAMING_SNAKE_CASE:str						      =					numpy_to_pil(snake_case )
  return images





def    A_  ( snake_case ):
  if images.ndim == 3:
    SCREAMING_SNAKE_CASE:List[str]						      =					images[None, ...]
  SCREAMING_SNAKE_CASE:List[Any]						      =					(images * 255).round().astype("uint8" )
  if images.shape[-1] == 1:
    # special case for grayscale (single channel) images
    SCREAMING_SNAKE_CASE:Any						      =					[Image.fromarray(image.squeeze()      ,       mode="L" ) for image in images]
  else:
    SCREAMING_SNAKE_CASE:int						      =					[Image.fromarray(snake_case ) for image in images]

  return pil_images






