




"""simple docstring"""




import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
					from transformers import SpeechaTextFeatureExtractor

lowerCAmelCase							:			Any     							=							random.Random()



def     a__ (				snake_case__       , snake_case__=1.0       , snake_case__=None       , snake_case__=None				)						->					Optional[int]:
			if rng is None:
						lowerCamelCase			      =					global_rng

			lowerCamelCase			      =					[]
			for batch_idx in range(shape[0]				):
						values.append([]				)
						for _ in range(shape[1]				):
									values[-1].append(rng.random() * scale				)

			return values






@require_torch
@require_torchaudio
class     __magic_name__							(       unittest.TestCase				):






				'''simple docstring'''





				def __init__(       self		, _a		, _a=7		, _a=400		, _a=2_000		, _a=24		, _a=24		, _a=0.0		, _a=16_000		, _a=True		, _a=True		, ):





							"""simple docstring"""
							lowerCamelCase			      =					parent
							lowerCamelCase			      =					batch_size
							lowerCamelCase			      =					min_seq_length
							lowerCamelCase			      =					max_seq_length
							lowerCamelCase			      =					(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
							lowerCamelCase			      =					feature_size
							lowerCamelCase			      =					num_mel_bins
							lowerCamelCase			      =					padding_value
							lowerCamelCase			      =					sampling_rate
							lowerCamelCase			      =					return_attention_mask
							lowerCamelCase			      =					do_normalize





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							return {
							    "feature_size": self.feature_size,
							    "num_mel_bins": self.num_mel_bins,
							    "padding_value": self.padding_value,
							    "sampling_rate": self.sampling_rate,
							    "return_attention_mask": self.return_attention_mask,
							    "do_normalize": self.do_normalize,
							}





				def    _lowerCAmelCase				(       self		, _a=False		, _a=False ):





							"""simple docstring"""
							def _flatten(_a ):
										return list(itertools.chain(*_a ) )

							if equal_length:
										lowerCamelCase			      =					[floats_list((self.max_seq_length, self.feature_size) ) for _ in range(self.batch_size )]
							else:
										# make sure that inputs increase in size
										lowerCamelCase			      =					[
										    floats_list((x, self.feature_size) )
										    for x in range(self.min_seq_length		, self.max_seq_length		, self.seq_length_diff )
										]
							if numpify:
										lowerCamelCase			      =					[np.asarray(_a ) for x in speech_inputs]
							return speech_inputs






@require_torch
@require_torchaudio
class     __magic_name__							(       UpperCAmelCase__						,					unittest.TestCase				):






				'''simple docstring'''
				__UpperCamelCase			  =						SpeechaTextFeatureExtractor if is_speech_available() else None





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					SpeechaTextFeatureExtractionTester(self )





				def    _lowerCAmelCase				(       self		, _a ):





							"""simple docstring"""
							self.assertTrue(np.all(np.mean(_a		, axis=0 ) < 1e-3 ) )
							self.assertTrue(np.all(np.abs(np.var(_a		, axis=0 ) - 1 ) < 1e-3 ) )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							# Tests that all call wrap to encode_plus and batch_encode_plus
							lowerCamelCase			      =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
							# create three inputs of length 800, 1000, and 1200
							lowerCamelCase			      =					[floats_list((1, x) )[0] for x in range(800		, 1_400		, 200 )]
							lowerCamelCase			      =					[np.asarray(_a ) for speech_input in speech_inputs]

							# Test feature size
							lowerCamelCase			      =					feature_extractor(_a		, padding=_a		, return_tensors="""np""" ).input_features
							self.assertTrue(input_features.ndim == 3 )
							self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size )

							# Test not batched input
							lowerCamelCase			      =					feature_extractor(speech_inputs[0]		, return_tensors="""np""" ).input_features
							lowerCamelCase			      =					feature_extractor(np_speech_inputs[0]		, return_tensors="""np""" ).input_features
							self.assertTrue(np.allclose(_a		, _a		, atol=1e-3 ) )

							# Test batched
							lowerCamelCase			      =					feature_extractor(_a		, return_tensors="""np""" ).input_features
							lowerCamelCase			      =					feature_extractor(_a		, return_tensors="""np""" ).input_features
							for enc_seq_a, enc_seq_a in zip(_a		, _a ):
										self.assertTrue(np.allclose(_a		, _a		, atol=1e-3 ) )

							# Test 2-D numpy arrays are batched.
							lowerCamelCase			      =					[floats_list((1, x) )[0] for x in (800, 800, 800)]
							lowerCamelCase			      =					np.asarray(_a )
							lowerCamelCase			      =					feature_extractor(_a		, return_tensors="""np""" ).input_features
							lowerCamelCase			      =					feature_extractor(_a		, return_tensors="""np""" ).input_features
							for enc_seq_a, enc_seq_a in zip(_a		, _a ):
										self.assertTrue(np.allclose(_a		, _a		, atol=1e-3 ) )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
							lowerCamelCase			      =					[floats_list((1, x) )[0] for x in range(800		, 1_400		, 200 )]

							lowerCamelCase			      =					["""longest""", """max_length""", """do_not_pad"""]
							lowerCamelCase			      =					[None, 16, None]
							for max_length, padding in zip(_a		, _a ):
										lowerCamelCase			      =					feature_extractor(
										    _a		, padding=_a		, max_length=_a		, return_attention_mask=_a )
										lowerCamelCase			      =					inputs.input_features
										lowerCamelCase			      =					inputs.attention_mask
										lowerCamelCase			      =					[np.sum(_a ) for x in attention_mask]

										self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]] )
										self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]] )
										self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]] )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
							lowerCamelCase			      =					[floats_list((1, x) )[0] for x in range(800		, 1_400		, 200 )]

							lowerCamelCase			      =					["""longest""", """max_length""", """do_not_pad"""]
							lowerCamelCase			      =					[None, 16, None]
							for max_length, padding in zip(_a		, _a ):
										lowerCamelCase			      =					feature_extractor(
										    _a		, max_length=_a		, padding=_a		, return_tensors="""np"""		, return_attention_mask=_a )
										lowerCamelCase			      =					inputs.input_features
										lowerCamelCase			      =					inputs.attention_mask
										lowerCamelCase			      =					[np.sum(_a ) for x in attention_mask]

										self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]] )
										self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6 )
										self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]] )
										self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6 )
										self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]] )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
							lowerCamelCase			      =					[floats_list((1, x) )[0] for x in range(800		, 1_400		, 200 )]
							lowerCamelCase			      =					feature_extractor(
							    _a		, padding="""max_length"""		, max_length=4		, truncation=_a		, return_tensors="""np"""		, return_attention_mask=_a		, )
							lowerCamelCase			      =					inputs.input_features
							lowerCamelCase			      =					inputs.attention_mask
							lowerCamelCase			      =					np.sum(attention_mask == 1		, axis=1 )

							self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] )
							self._check_zero_mean_unit_variance(input_features[1] )
							self._check_zero_mean_unit_variance(input_features[2] )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
							lowerCamelCase			      =					[floats_list((1, x) )[0] for x in range(800		, 1_400		, 200 )]
							lowerCamelCase			      =					feature_extractor(
							    _a		, padding="""longest"""		, max_length=4		, truncation=_a		, return_tensors="""np"""		, return_attention_mask=_a		, )
							lowerCamelCase			      =					inputs.input_features
							lowerCamelCase			      =					inputs.attention_mask
							lowerCamelCase			      =					np.sum(attention_mask == 1		, axis=1 )

							self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] )
							self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]] )
							self._check_zero_mean_unit_variance(input_features[2] )

							# make sure that if max_length < longest -> then pad to max_length
							self.assertEqual(input_features.shape		, (3, 4, 24) )

							lowerCamelCase			      =					[floats_list((1, x) )[0] for x in range(800		, 1_400		, 200 )]
							lowerCamelCase			      =					feature_extractor(
							    _a		, padding="""longest"""		, max_length=16		, truncation=_a		, return_tensors="""np"""		, return_attention_mask=_a		, )
							lowerCamelCase			      =					inputs.input_features
							lowerCamelCase			      =					inputs.attention_mask
							lowerCamelCase			      =					np.sum(attention_mask == 1		, axis=1 )

							self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] )
							self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]] )
							self._check_zero_mean_unit_variance(input_features[2] )

							# make sure that if max_length < longest -> then pad to max_length
							self.assertEqual(input_features.shape		, (3, 6, 24) )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							import torch

							lowerCamelCase			      =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
							lowerCamelCase			      =					np.random.rand(100		, 32 ).astype(np.floataa )
							lowerCamelCase			      =					np_speech_inputs.tolist()

							for inputs in [py_speech_inputs, np_speech_inputs]:
										lowerCamelCase			      =					feature_extractor.pad([{"""input_features""": inputs}]		, return_tensors="""np""" )
										self.assertTrue(np_processed.input_features.dtype == np.floataa )
										lowerCamelCase			      =					feature_extractor.pad([{"""input_features""": inputs}]		, return_tensors="""pt""" )
										self.assertTrue(pt_processed.input_features.dtype == torch.floataa )





				def    _lowerCAmelCase				(       self		, _a ):





							"""simple docstring"""
							from datasets import load_dataset

							lowerCamelCase			      =					load_dataset("""hf-internal-testing/librispeech_asr_dummy"""		, """clean"""		, split="""validation""" )
							# automatic decoding with librispeech
							lowerCamelCase			      =					ds.sort("""id""" ).select(range(_a ) )[:num_samples]["""audio"""]

							return [x["array"] for x in speech_samples]





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							# fmt: off
							lowerCamelCase			      =					np.array([
							    -1.5_745, -1.7_713, -1.7_020, -1.6_069, -1.2_250, -1.1_105, -0.9_072, -0.8_241,
							    -1.2_310, -0.8_098, -0.3_320, -0.4_101, -0.7_985, -0.4_996, -0.8_213, -0.9_128,
							    -1.0_420, -1.1_286, -1.0_440, -0.7_999, -0.8_405, -1.2_275, -1.5_443, -1.4_625,
							] )
							# fmt: on

							lowerCamelCase			      =					self._load_datasamples(1 )
							lowerCamelCase			      =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
							lowerCamelCase			      =					feature_extractor(_a		, return_tensors="""pt""" ).input_features
							self.assertEquals(input_features.shape		, (1, 584, 24) )
							self.assertTrue(np.allclose(input_features[0, 0, :30]		, _a		, atol=1e-4 ) )









"""simple docstring"""




from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, logging


if is_torch_available():
					import torch


lowerCAmelCase							:			int     							=							logging.get_logger(__name__)






class     __magic_name__							(       UpperCAmelCase__				):






				'''simple docstring'''
				__UpperCamelCase			  =						["pixel_values"]





				def __init__(       self		, _a = True		, _a = None		, _a = PILImageResampling.BILINEAR		, _a = True		, _a = None		, _a = True		, _a = 1 / 255		, _a = True		, _a = None		, _a = None		, **_a		, ):





							"""simple docstring"""
							super().__init__(**_a )
							lowerCamelCase			      =					size if size is not None else {"""shortest_edge""": 256}
							lowerCamelCase			      =					get_size_dict(_a		, default_to_square=_a )
							lowerCamelCase			      =					crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
							lowerCamelCase			      =					get_size_dict(_a		, param_name="""crop_size""" )
							lowerCamelCase			      =					do_resize
							lowerCamelCase			      =					size
							lowerCamelCase			      =					resample
							lowerCamelCase			      =					do_center_crop
							lowerCamelCase			      =					crop_size
							lowerCamelCase			      =					do_rescale
							lowerCamelCase			      =					rescale_factor
							lowerCamelCase			      =					do_normalize
							lowerCamelCase			      =					image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
							lowerCamelCase			      =					image_std if image_std is not None else IMAGENET_STANDARD_STD





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a = PILImageResampling.BICUBIC		, _a = None		, **_a		, ):





							"""simple docstring"""
							lowerCamelCase			      =					get_size_dict(_a		, default_to_square=_a )
							if "shortest_edge" not in size:
										raise ValueError(f'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}' )
							lowerCamelCase			      =					get_resize_output_image_size(_a		, size=size["""shortest_edge"""]		, default_to_square=_a )
							return resize(_a		, size=_a		, resample=_a		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a = None		, **_a		, ):





							"""simple docstring"""
							lowerCamelCase			      =					get_size_dict(_a )
							if "height" not in size or "width" not in size:
										raise ValueError(f'The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}' )
							return center_crop(_a		, size=(size["""height"""], size["""width"""])		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a = None		, **_a ):





							"""simple docstring"""
							return rescale(_a		, scale=_a		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a		, _a = None		, **_a		, ):





							"""simple docstring"""
							return normalize(_a		, mean=_a		, std=_a		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = None		, _a = ChannelDimension.FIRST		, **_a		, ):





							"""simple docstring"""
							lowerCamelCase			      =					do_resize if do_resize is not None else self.do_resize
							lowerCamelCase			      =					size if size is not None else self.size
							lowerCamelCase			      =					get_size_dict(_a		, default_to_square=_a )
							lowerCamelCase			      =					resample if resample is not None else self.resample
							lowerCamelCase			      =					do_center_crop if do_center_crop is not None else self.do_center_crop
							lowerCamelCase			      =					crop_size if crop_size is not None else self.crop_size
							lowerCamelCase			      =					get_size_dict(_a		, param_name="""crop_size""" )
							lowerCamelCase			      =					do_rescale if do_rescale is not None else self.do_rescale
							lowerCamelCase			      =					rescale_factor if rescale_factor is not None else self.rescale_factor
							lowerCamelCase			      =					do_normalize if do_normalize is not None else self.do_normalize
							lowerCamelCase			      =					image_mean if image_mean is not None else self.image_mean
							lowerCamelCase			      =					image_std if image_std is not None else self.image_std

							lowerCamelCase			      =					make_list_of_images(_a )

							if not valid_images(_a ):
										raise ValueError(
										    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
										    """torch.Tensor, tf.Tensor or jax.ndarray.""" )

							if do_resize and size is None:
										raise ValueError("""Size must be specified if do_resize is True.""" )

							if do_center_crop and crop_size is None:
										raise ValueError("""Crop size must be specified if do_center_crop is True.""" )

							if do_rescale and rescale_factor is None:
										raise ValueError("""Rescale factor must be specified if do_rescale is True.""" )

							if do_normalize and (image_mean is None or image_std is None):
										raise ValueError("""Image mean and std must be specified if do_normalize is True.""" )

							# All transformations expect numpy arrays.
							lowerCamelCase			      =					[to_numpy_array(_a ) for image in images]

							if do_resize:
										lowerCamelCase			      =					[self.resize(image=_a		, size=_a		, resample=_a ) for image in images]

							if do_center_crop:
										lowerCamelCase			      =					[self.center_crop(image=_a		, size=_a ) for image in images]

							if do_rescale:
										lowerCamelCase			      =					[self.rescale(image=_a		, scale=_a ) for image in images]

							if do_normalize:
										lowerCamelCase			      =					[self.normalize(image=_a		, mean=_a		, std=_a ) for image in images]

							lowerCamelCase			      =					[to_channel_dimension_format(_a		, _a ) for image in images]

							lowerCamelCase			      =					{"""pixel_values""": images}
							return BatchFeature(data=_a		, tensor_type=_a )





				def    _lowerCAmelCase				(       self		, _a		, _a = None ):





							"""simple docstring"""
							lowerCamelCase			      =					outputs.logits

							# Resize logits and compute semantic segmentation maps
							if target_sizes is not None:
										if len(_a ) != len(_a ):
													raise ValueError(
													    """Make sure that you pass in as many target sizes as the batch dimension of the logits""" )

										if is_torch_tensor(_a ):
													lowerCamelCase			      =					target_sizes.numpy()

										lowerCamelCase			      =					[]

										for idx in range(len(_a ) ):
													lowerCamelCase			      =					torch.nn.functional.interpolate(
													    logits[idx].unsqueeze(dim=0 )		, size=target_sizes[idx]		, mode="""bilinear"""		, align_corners=_a )
													lowerCamelCase			      =					resized_logits[0].argmax(dim=0 )
													semantic_segmentation.append(_a )
							else:
										lowerCamelCase			      =					logits.argmax(dim=1 )
										lowerCamelCase			      =					[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0] )]

							return semantic_segmentation



