

import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Optional

import evaluate
import numpy as np
import torch
from datasets import load_dataset
from PIL import Image
from torchvision.transforms import (
    CenterCrop,
    Compose,
    Normalize,
    RandomHorizontalFlip,
    RandomResizedCrop,
    Resize,
    ToTensor,
)

import transformers
from transformers import (
    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    AutoModelForImageClassification,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import get_last_checkpoint
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version
UpperCAmelCase_							:					List[str]		 =   logging.getLogger(__name__)

# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version('''4.31.0''')

require_version('''datasets>=1.8.0''', '''To fix: pip install -r examples/pytorch/image-classification/requirements.txt''')

UpperCAmelCase_							:					Optional[Any]		 =   list(MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING.keys())
UpperCAmelCase_							:					Dict		 =   tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)
def 							__SCREAMING_SNAKE_CASE     (   a__    :   str       )					->				List[Any]:
	with open(a__			,"""rb"""       ) as f:
		__A :			Tuple		    =			Image.open(a__       )
		return im.convert("""RGB"""       )






@dataclass
class      lowerCamelCase_      :
	_lowercase		:   Optional[str]     					=				field(
	    default=_lowercase						,      metadata={
	        '''help''': '''Name of a dataset from the hub (could be your own, possibly private dataset hosted on the hub).'''
	    }						,      )
	_lowercase		:   Optional[str]     					=				field(
	    default=_lowercase						,      metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''}	)
	_lowercase		:   Optional[str]     					=				field(default=_lowercase						,      metadata={'''help''': '''A folder containing the training data.'''}	)
	_lowercase		:   Optional[str]     					=				field(default=_lowercase						,      metadata={'''help''': '''A folder containing the validation data.'''}	)
	_lowercase		:   Optional[float]     					=				field(
	    default=0.15						,      metadata={'''help''': '''Percent to split off of train for validation.'''}	)
	_lowercase		:   Optional[int]     					=				field(
	    default=_lowercase						,      metadata={
	        '''help''': (
	            '''For debugging purposes or quicker training, truncate the number of training examples to this '''
	            '''value if set.'''
	        )
	    }						,      )
	_lowercase		:   Optional[int]     					=				field(
	    default=_lowercase						,      metadata={
	        '''help''': (
	            '''For debugging purposes or quicker training, truncate the number of evaluation examples to this '''
	            '''value if set.'''
	        )
	    }						,      )




	def        lowerCAmelCase_       (     self						:     Optional[Any]							):
		if self.dataset_name is None and (self.train_dir is None and self.validation_dir is None):
			raise ValueError(
			    """You must specify either a dataset name from the hub or a train and/or validation directory."""							)






@dataclass
class      lowerCamelCase_      :
	_lowercase		:   str     					=				field(
	    default='''google/vit-base-patch16-224-in21k'''						,      metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}						,      )
	_lowercase		:   Optional[str]     					=				field(
	    default=_lowercase						,      metadata={'''help''': '''If training from scratch, pass a model type from the list: ''' + ''', '''.join(_lowercase	)}						,      )
	_lowercase		:   Optional[str]     					=				field(
	    default=_lowercase						,      metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''}	)
	_lowercase		:   Optional[str]     					=				field(
	    default=_lowercase						,      metadata={'''help''': '''Where do you want to store the pretrained models downloaded from s3'''}	)
	_lowercase		:   str     					=				field(
	    default='''main'''						,      metadata={'''help''': '''The specific model version to use (can be a branch name, tag name or commit id).'''}						,      )
	_lowercase		:   str     					=				field(default=_lowercase						,      metadata={'''help''': '''Name or path of preprocessor config.'''}	)
	_lowercase		:   bool     					=				field(
	    default=_lowercase						,      metadata={
	        '''help''': (
	            '''Will use the token generated when running `huggingface-cli login` (necessary to use this script '''
	            '''with private models).'''
	        )
	    }						,      )
	_lowercase		:   bool     					=				field(
	    default=_lowercase						,      metadata={'''help''': '''Will enable to load a pretrained model whose head dimensions are different.'''}						,      )






def 							__SCREAMING_SNAKE_CASE     (   a__    :   List[str]       )					->				Tuple:
	__A :			int		    =			torch.stack([example["""pixel_values"""] for example in examples]       )
	__A :			Dict		    =			torch.tensor([example["""labels"""] for example in examples]       )
	return {"pixel_values": pixel_values, "labels": labels}
def 							__SCREAMING_SNAKE_CASE     (   )					->				List[Any]:
	# See all possible arguments in src/transformers/training_args.py
	# or by passing the --help flag to this script.
	# We now keep distinct sets of args, for a cleaner separation of concerns.

	__A :			Any		    =			HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)       )
	if len(sys.argv       ) == 2 and sys.argv[1].endswith(""".json"""       ):
		# If we pass only one argument to the script and it's the path to a json file,
		# let's parse it to get our arguments.
		__A    ,				__A    ,				__A :			Any		    =			parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]       )       )
	else:
		__A    ,				__A    ,				__A :			int		    =			parser.parse_args_into_dataclasses()

	# Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
	# information sent is the one passed as arguments along with your Python/PyTorch versions.
	send_example_telemetry("""run_image_classification"""			,a__			,a__       )

	# Setup logging
	logging.basicConfig(
	    format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s"""			,datefmt="""%m/%d/%Y %H:%M:%S"""			,handlers=[logging.StreamHandler(sys.stdout       )]			,)

	if training_args.should_log:
		# The default of training_args.log_level is passive, so we set log level at info here to have that default.
		transformers.utils.logging.set_verbosity_info()

	__A :			str		    =			training_args.get_process_log_level()
	logger.setLevel(a__       )
	transformers.utils.logging.set_verbosity(a__       )
	transformers.utils.logging.enable_default_handler()
	transformers.utils.logging.enable_explicit_format()

	# Log on each process the small summary:
	logger.warning(
	    f"""Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"""
	    + f"""distributed training: {bool(training_args.local_rank != -1       )}, 16-bits training: {training_args.fpaa}"""       )
	logger.info(f"""Training/evaluation parameters {training_args}"""       )

	# Detecting last checkpoint.
	__A :			str		    =			None
	if os.path.isdir(training_args.output_dir       ) and training_args.do_train and not training_args.overwrite_output_dir:
		__A :			Any		    =			get_last_checkpoint(training_args.output_dir       )
		if last_checkpoint is None and len(os.listdir(training_args.output_dir       )       ) > 0:
			raise ValueError(
			    f"""Output directory ({training_args.output_dir}) already exists and is not empty. """
			    """Use --overwrite_output_dir to overcome."""       )
		elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
			logger.info(
			    f"""Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change """
			    """the `--output_dir` or add `--overwrite_output_dir` to train from scratch."""       )

    # Set seed before initializing model.
	set_seed(training_args.seed       )

	# Initialize our dataset and prepare it for the 'image-classification' task.
	if data_args.dataset_name is not None:
		__A :			List[Any]		    =			load_dataset(
		    data_args.dataset_name			,data_args.dataset_config_name			,cache_dir=model_args.cache_dir			,task="""image-classification"""			,use_auth_token=True if model_args.use_auth_token else None			,)
	else:
		__A :			Optional[Any]		    =			{}
		if data_args.train_dir is not None:
			__A :			Any		    =			os.path.join(data_args.train_dir			,"""**"""       )
		if data_args.validation_dir is not None:
			__A :			List[str]		    =			os.path.join(data_args.validation_dir			,"""**"""       )
		__A :			List[str]		    =			load_dataset(
		    """imagefolder"""			,data_files=a__			,cache_dir=model_args.cache_dir			,task="""image-classification"""			,)

	# If we don't have a validation split, split off a percentage of train as validation.
	__A :			Tuple		    =			None if """validation""" in dataset.keys() else data_args.train_val_split
	if isinstance(data_args.train_val_split			,a__       ) and data_args.train_val_split > 0.0:
		__A :			int		    =			dataset["""train"""].train_test_split(data_args.train_val_split       )
		__A :			str		    =			split["""train"""]
		__A :			int		    =			split["""test"""]

	# Prepare label mappings.
	# We'll include these in the model's config to get human readable labels in the Inference API.
	__A :			Dict		    =			dataset["""train"""].features["""labels"""].names
	__A    ,				__A :			Union[str, Any]		    =			{}, {}
	for i, label in enumerate(a__       ):
		__A :			Optional[int]		    =			str(a__       )
		__A :			Optional[Any]		    =			label

	# Load the accuracy metric from the datasets package
	__A :			Tuple		    =			evaluate.load("""accuracy"""       )

	# Define our compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a
	# predictions and label_ids field) and has to return a dictionary string to float.
	def compute_metrics(a__    :   int       ):
		return metric.compute(predictions=np.argmax(p.predictions			,axis=1       )			,references=p.label_ids       )

	__A :			Optional[int]		    =			AutoConfig.from_pretrained(
	    model_args.config_name or model_args.model_name_or_path			,num_labels=len(a__       )			,labelaid=a__			,idalabel=a__			,finetuning_task="""image-classification"""			,cache_dir=model_args.cache_dir			,revision=model_args.model_revision			,use_auth_token=True if model_args.use_auth_token else None			,)
	__A :			Tuple		    =			AutoModelForImageClassification.from_pretrained(
	    model_args.model_name_or_path			,from_tf=bool(""".ckpt""" in model_args.model_name_or_path       )			,config=a__			,cache_dir=model_args.cache_dir			,revision=model_args.model_revision			,use_auth_token=True if model_args.use_auth_token else None			,ignore_mismatched_sizes=model_args.ignore_mismatched_sizes			,)
	__A :			Union[str, Any]		    =			AutoImageProcessor.from_pretrained(
	    model_args.image_processor_name or model_args.model_name_or_path			,cache_dir=model_args.cache_dir			,revision=model_args.model_revision			,use_auth_token=True if model_args.use_auth_token else None			,)

	# Define torchvision transforms to be applied to each image.
	if "shortest_edge" in image_processor.size:
		__A :			int		    =			image_processor.size["""shortest_edge"""]
	else:
		__A :			List[Any]		    =			(image_processor.size["""height"""], image_processor.size["""width"""])
	__A :			Optional[int]		    =			Normalize(mean=image_processor.image_mean			,std=image_processor.image_std       )
	__A :			Dict		    =			Compose(
	    [
	        RandomResizedCrop(a__       ),
	        RandomHorizontalFlip(),
	        ToTensor(),
	        normalize,
	    ]       )
	__A :			Tuple		    =			Compose(
	    [
	        Resize(a__       ),
	        CenterCrop(a__       ),
	        ToTensor(),
	        normalize,
	    ]       )

	def train_transforms(a__    :   int       ):
		__A :			int		    =			[
		    _train_transforms(pil_img.convert("""RGB"""       )       ) for pil_img in example_batch["""image"""]
		]
		return example_batch

	def val_transforms(a__    :   Union[str, Any]       ):
		__A :			List[Any]		    =			[_val_transforms(pil_img.convert("""RGB"""       )       ) for pil_img in example_batch["""image"""]]
		return example_batch

	if training_args.do_train:
		if "train" not in dataset:
			raise ValueError("""--do_train requires a train dataset"""       )
		if data_args.max_train_samples is not None:
			__A :			Any		    =			(
			    dataset["""train"""].shuffle(seed=training_args.seed       ).select(range(data_args.max_train_samples       )       )
			)
		# Set the training transforms
		dataset["train"].set_transform(a__       )

	if training_args.do_eval:
		if "validation" not in dataset:
			raise ValueError("""--do_eval requires a validation dataset"""       )
		if data_args.max_eval_samples is not None:
			__A :			str		    =			(
			    dataset["""validation"""].shuffle(seed=training_args.seed       ).select(range(data_args.max_eval_samples       )       )
			)
		# Set the validation transforms
		dataset["validation"].set_transform(a__       )

	# Initalize our trainer
	__A :			List[Any]		    =			Trainer(
	    model=a__			,args=a__			,train_dataset=dataset["""train"""] if training_args.do_train else None			,eval_dataset=dataset["""validation"""] if training_args.do_eval else None			,compute_metrics=a__			,tokenizer=a__			,data_collator=a__			,)

	# Training
	if training_args.do_train:
		__A :			Tuple		    =			None
		if training_args.resume_from_checkpoint is not None:
			__A :			Any		    =			training_args.resume_from_checkpoint
		elif last_checkpoint is not None:
			__A :			List[str]		    =			last_checkpoint
		__A :			str		    =			trainer.train(resume_from_checkpoint=a__       )
		trainer.save_model()
		trainer.log_metrics("""train"""			,train_result.metrics       )
		trainer.save_metrics("""train"""			,train_result.metrics       )
		trainer.save_state()

	# Evaluation
	if training_args.do_eval:
		__A :			Optional[int]		    =			trainer.evaluate()
		trainer.log_metrics("""eval"""			,a__       )
		trainer.save_metrics("""eval"""			,a__       )

	# Write model card and (optionally) push to hub
	__A :			List[str]		    =			{
	    """finetuned_from""": model_args.model_name_or_path,
	    """tasks""": """image-classification""",
	    """dataset""": data_args.dataset_name,
	    """tags""": ["""image-classification""", """vision"""],
	}
	if training_args.push_to_hub:
		trainer.push_to_hub(**a__       )
	else:
		trainer.create_model_card(**a__       )


if __name__ == "__main__":
			main()









import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
   from transformers import WhisperFeatureExtractor

if is_torch_available():
   import torch

SCREAMING_SNAKE_CASE						:Optional[int]			=  random.Random()



def       _lowerCAmelCase    (				lowerCAmelCase_				:List[str]		,    lowerCAmelCase_				:Tuple=1.0		,    lowerCAmelCase_				:Optional[int]=None		,    lowerCAmelCase_				:List[Any]=None				)->Dict:
   '''simple docstring'''






   if rng is None:
      snake_case_            =       global_rng

   snake_case_            =       []
   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      __lowerCAmelCase  (			unittest.TestCase       ):






  """simple docstring"""





  def __init__(  self							:							Optional[int]     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							List[str]=7     ,					_lowerCAmelCase							:							List[Any]=4_0_0     ,					_lowerCAmelCase							:							Optional[Any]=2_0_0_0     ,					_lowerCAmelCase							:							Tuple=1_0     ,					_lowerCAmelCase							:							Optional[int]=1_6_0     ,					_lowerCAmelCase							:							List[Any]=8     ,					_lowerCAmelCase							:							List[Any]=0.0     ,					_lowerCAmelCase							:							Dict=4_0_0_0     ,					_lowerCAmelCase							:							str=False     ,					_lowerCAmelCase							:							List[str]=True     ,					) ->			str:




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



  def        lowerCAmelCase__	(  self							:							int	) ->			str:




     """simple docstring"""
     return {
         "feature_size": self.feature_size,
         "hop_length": self.hop_length,
         "chunk_length": self.chunk_length,
         "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							:							int     ,					_lowerCAmelCase							:							Optional[Any]=False     ,					_lowerCAmelCase							:							List[Any]=False	) ->			int:




     """simple docstring"""
     def _flatten(_lowerCAmelCase							:							Union[str, Any]	):
        return list(itertools.chain(*_lowerCAmelCase	)	)

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






@require_torch
@require_torchaudio
class      __lowerCAmelCase  (			a			,	unittest.TestCase       ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		     =							WhisperFeatureExtractor if is_speech_available() else None



  def        lowerCAmelCase__	(  self							:							str	) ->			Union[str, Any]:




     """simple docstring"""
     snake_case_            =       WhisperFeatureExtractionTester(self	)



  def        lowerCAmelCase__	(  self							:							Tuple	) ->			Union[str, Any]:




     """simple docstring"""
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_dict	)

     with tempfile.TemporaryDirectory() as tmpdirname:
        snake_case_            =       feat_extract_first.save_pretrained(_lowerCAmelCase	)[0]
        check_json_file_has_correct_format(_lowerCAmelCase	)
        snake_case_            =       self.feature_extraction_class.from_pretrained(_lowerCAmelCase	)

     snake_case_            =       feat_extract_first.to_dict()
     snake_case_            =       feat_extract_second.to_dict()
     snake_case_            =       feat_extract_first.mel_filters
     snake_case_            =       feat_extract_second.mel_filters
     self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase	)	)
     self.assertEqual(_lowerCAmelCase     ,					_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							List[Any]	) ->			str:




     """simple docstring"""
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_dict	)

     with tempfile.TemporaryDirectory() as tmpdirname:
        snake_case_            =       os.path.join(_lowerCAmelCase     ,					"feat_extract.json"	)
        feat_extract_first.to_json_file(_lowerCAmelCase	)
        snake_case_            =       self.feature_extraction_class.from_json_file(_lowerCAmelCase	)

     snake_case_            =       feat_extract_first.to_dict()
     snake_case_            =       feat_extract_second.to_dict()
     snake_case_            =       feat_extract_first.mel_filters
     snake_case_            =       feat_extract_second.mel_filters
     self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase	)	)
     self.assertEqual(_lowerCAmelCase     ,					_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							Any	) ->			Optional[int]:




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

     # Test feature size
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					padding="max_length"     ,					return_tensors="np"	).input_features
     self.assertTrue(input_features.ndim == 3	)
     self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames	)
     self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size	)

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

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

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

     # Test truncation required
     snake_case_            =       [floats_list((1, x)	)[0] for x in range(2_0_0     ,					(feature_extractor.n_samples + 5_0_0)     ,					2_0_0	)]
     snake_case_            =       [np.asarray(_lowerCAmelCase	) for speech_input in speech_inputs]

     snake_case_            =       [x[: feature_extractor.n_samples] for x in speech_inputs]
     snake_case_            =       [np.asarray(_lowerCAmelCase	) for speech_input in speech_inputs_truncated]

     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     for enc_seq_a, enc_seq_a in zip(_lowerCAmelCase     ,					_lowerCAmelCase	):
        self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase     ,					atol=1e-3	)	)



  def        lowerCAmelCase__	(  self							:							Optional[int]	) ->			Tuple:




     """simple docstring"""
     import torch

     snake_case_            =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
     snake_case_            =       np.random.rand(1_0_0     ,					3_2	).astype(np.floataa	)
     snake_case_            =       np_speech_inputs.tolist()

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



  def        lowerCAmelCase__	(  self							:							List[Any]     ,					_lowerCAmelCase							:							Dict	) ->			int:




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

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



  def        lowerCAmelCase__	(  self							:							Optional[Any]	) ->			Optional[Any]:




     """simple docstring"""
     # fmt: off
     snake_case_            =       torch.tensor(
         [
             0.1_193, -0.0_946, -0.1_098, -0.0_196, 0.0_225, -0.0_690, -0.1_736, 0.0_951,
             0.0_971, -0.0_817, -0.0_702, 0.0_162, 0.0_260, 0.0_017, -0.0_192, -0.1_678,
             0.0_709, -0.1_867, -0.0_655, -0.0_274, -0.0_234, -0.1_884, -0.0_516, -0.0_554,
             -0.0_274, -0.1_425, -0.1_423, 0.0_837, 0.0_377, -0.0_854
         ]	)
     # fmt: on

     snake_case_            =       self._load_datasamples(1	)
     snake_case_            =       WhisperFeatureExtractor()
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="pt"	).input_features
     self.assertEqual(input_features.shape     ,					(1, 8_0, 3_0_0_0)	)
     self.assertTrue(torch.allclose(input_features[0, 0, :3_0]     ,					_lowerCAmelCase     ,					atol=1e-4	)	)



  def        lowerCAmelCase__	(  self							:							Union[str, Any]	) ->			List[str]:




     """simple docstring"""
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
     snake_case_            =       self._load_datasamples(1	)[0]
     snake_case_            =       ((audio - audio.min()) / (audio.max() - audio.min())) * 6_5_5_3_5  # Rescale to [0, 65535] to show issue
     snake_case_            =       feat_extract.zero_mean_unit_var_norm([audio]     ,					attention_mask=_lowerCAmelCase	)[0]

     self.assertTrue(np.all(np.mean(_lowerCAmelCase	) < 1e-3	)	)
     self.assertTrue(np.all(np.abs(np.var(_lowerCAmelCase	) - 1	) < 1e-3	)	)




