
'''simple docstring'''

import numpy as np
from PIL import Image


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_      ,			lowerCamelCase_			):







 """simple docstring"""


 lowerCAmelCase__     :   Tuple     		=	np.array(lowerCamelCase_			)
 if arr.shape[0] != arr.shape[1]:
  raise ValueError("The input array is not a square matrix"			)
 lowerCAmelCase__     :   Tuple     		=	0
 lowerCAmelCase__     :   List[str]     		=	0
 lowerCAmelCase__     :   Tuple     		=	0
 lowerCAmelCase__     :   Dict     		=	0

 # compute the shape of the output matrix
 lowerCAmelCase__     :   Union[str, Any]     		=	(arr.shape[0] - size) // stride + 1
 # initialize the output matrix with zeros of shape maxpool_shape
 lowerCAmelCase__     :   str     		=	np.zeros((maxpool_shape, maxpool_shape)			)

 while i < arr.shape[0]:
  if i + size > arr.shape[0]:
   # if the end of the matrix is reached, break
   break
  while j < arr.shape[1]:
   # if the end of the matrix is reached, break
   if j + size > arr.shape[1]:
    break
   # compute the maximum of the pooling matrix
   lowerCAmelCase__     :   int     		=	np.max(arr[i : i + size, j : j + size]			)
   # shift the pooling matrix by stride of column pixels
   j += stride
   mat_j += 1

  # shift the pooling matrix by stride of row pixels
  i += stride
  mat_i += 1

  # reset the column index to 0
  lowerCAmelCase__     :   str     		=	0
  lowerCAmelCase__     :   int     		=	0

 return updated_arr


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_      ,			lowerCamelCase_			):







 """simple docstring"""


 lowerCAmelCase__     :   Union[str, Any]     		=	np.array(lowerCamelCase_			)
 if arr.shape[0] != arr.shape[1]:
  raise ValueError("The input array is not a square matrix"			)
 lowerCAmelCase__     :   Union[str, Any]     		=	0
 lowerCAmelCase__     :   List[str]     		=	0
 lowerCAmelCase__     :   Optional[Any]     		=	0
 lowerCAmelCase__     :   int     		=	0

 # compute the shape of the output matrix
 lowerCAmelCase__     :   Optional[int]     		=	(arr.shape[0] - size) // stride + 1
 # initialize the output matrix with zeros of shape avgpool_shape
 lowerCAmelCase__     :   List[str]     		=	np.zeros((avgpool_shape, avgpool_shape)			)

 while i < arr.shape[0]:
  # if the end of the matrix is reached, break
  if i + size > arr.shape[0]:
   break
  while j < arr.shape[1]:
   # if the end of the matrix is reached, break
   if j + size > arr.shape[1]:
    break
   # compute the average of the pooling matrix
   lowerCAmelCase__     :   Any     		=	int(np.average(arr[i : i + size, j : j + size]			)			)
   # shift the pooling matrix by stride of column pixels
   j += stride
   mat_j += 1

  # shift the pooling matrix by stride of row pixels
  i += stride
  mat_i += 1
  # reset the column index to 0
  lowerCAmelCase__     :   Union[str, Any]     		=	0
  lowerCAmelCase__     :   List[Any]     		=	0

 return updated_arr


# Main Function
if __name__ == "__main__":
     from doctest import testmod

     testmod(name="""avgpooling""", verbose=True)

     # Loading the image
     snake_case									=    Image.open("""path_to_image""")

     # Converting the image to numpy array and maxpooling, displaying the result
     # Ensure that the image is a square matrix

     Image.fromarray(maxpooling(np.array(image), size=3, stride=2)).show()

     # Converting the image to numpy array and averagepooling, displaying the result
     # Ensure that the image is a square matrix

     Image.fromarray(avgpooling(np.array(image), size=3, stride=2)).show()







'''simple docstring'''

# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# 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.
from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool




class    lowerCAmelCase       (     UpperCamelCase_  ):
 A_				:				int	=			"""openai/whisper-base"""
 A_				:				str	=			(
     """This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the """
     """transcribed text."""
 )
 A_				:				Union[str, Any]	=			"""transcriber"""
 A_				:				Tuple	=			WhisperProcessor
 A_				:				Dict	=			WhisperForConditionalGeneration

 A_				:				Tuple	=			["""audio"""]
 A_				:				Optional[int]	=			["""text"""]


 def    _A	(    self  : Optional[int]			,							a__  : Optional[int]    ):
  '''simple docstring'''

  return self.pre_processor(a__			,							return_tensors="pt"    ).input_features


 def    _A	(    self  : List[str]			,							a__  : Union[str, Any]    ):
  '''simple docstring'''

  return self.model.generate(inputs=a__    )


 def    _A	(    self  : Optional[Any]			,							a__  : Dict    ):
  '''simple docstring'''

  return self.pre_processor.batch_decode(a__			,							skip_special_tokens=a__    )[0]





