



"""simple docstring"""







import numpy as np
from PIL import Image

def       _lowerCamelCase				(							UpperCAmelCase_ :       np.ndarray,	UpperCAmelCase_ :       int,	UpperCAmelCase_ :       int     )	-> np.ndarray:






	"""simple docstring"""





	A__											=					np.array(UpperCAmelCase_     )
	if arr.shape[0] != arr.shape[1]:
		raise ValueError("The input array is not a square matrix"     )
	A__											=					0
	A__											=					0
	A__											=					0
	A__											=					0

	# compute the shape of the output matrix
	A__											=					(arr.shape[0] - size) // stride + 1
	# initialize the output matrix with zeros of shape maxpool_shape
	A__											=					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
			A__											=					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
		A__											=					0
		A__											=					0

	return updated_arr

def       _lowerCamelCase				(							UpperCAmelCase_ :       np.ndarray,	UpperCAmelCase_ :       int,	UpperCAmelCase_ :       int     )	-> np.ndarray:






	"""simple docstring"""





	A__											=					np.array(UpperCAmelCase_     )
	if arr.shape[0] != arr.shape[1]:
		raise ValueError("The input array is not a square matrix"     )
	A__											=					0
	A__											=					0
	A__											=					0
	A__											=					0

	# compute the shape of the output matrix
	A__											=					(arr.shape[0] - size) // stride + 1
	# initialize the output matrix with zeros of shape avgpool_shape
	A__											=					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
			A__											=					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
		A__											=					0
		A__											=					0

	return updated_arr


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

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

			# Loading the image
			UpperCamelCase     =							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()








# 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.
import torch

from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor
from ..utils import is_datasets_available
from .base import PipelineTool


if is_datasets_available():
				from datasets import load_dataset







class 	__lowercase    (__SCREAMING_SNAKE_CASE  ):





							"""simple docstring"""







							_UpperCAmelCase      =						"""microsoft/speecht5_tts"""
							_UpperCAmelCase      =						(
							    """This is a tool that reads an English text out loud. It takes an input named `text` which should contain the """
							    """text to read (in English) and returns a waveform object containing the sound."""
							)
							_UpperCAmelCase      =						"""text_reader"""
							_UpperCAmelCase      =						SpeechTaProcessor
							_UpperCAmelCase      =						SpeechTaForTextToSpeech
							_UpperCAmelCase      =						SpeechTaHifiGan

							_UpperCAmelCase      =						["""text"""]
							_UpperCAmelCase      =						["""audio"""]






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										if self.post_processor is None:
													SCREAMING_SNAKE_CASE_		:     List[Any]					=					'microsoft/speecht5_hifigan'
										super().setup()






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__			,						lowerCAmelCase__=None       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     int					=					self.pre_processor(text=lowerCAmelCase__			,						return_tensors='pt'			,						truncation=lowerCAmelCase__       )

										if speaker_embeddings is None:
													if not is_datasets_available():
																raise ImportError('Datasets needs to be installed if not passing speaker embeddings.'       )

													SCREAMING_SNAKE_CASE_		:     List[Any]					=					load_dataset('Matthijs/cmu-arctic-xvectors'			,						split='validation'       )
													SCREAMING_SNAKE_CASE_		:     Optional[int]					=					torch.tensor(embeddings_dataset[7_3_0_5]['xvector']       ).unsqueeze(0       )

										return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings}






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




										with torch.no_grad():
													return self.model.generate_speech(**lowerCAmelCase__       )






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




										with torch.no_grad():
													return self.post_processor(lowerCAmelCase__       ).cpu().detach()





