





'''simple docstring'''


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
_SCREAMING_SNAKE_CASE		       =							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")

_SCREAMING_SNAKE_CASE		       =							list(MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING.keys())
_SCREAMING_SNAKE_CASE		       =							tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)


def 		__a(SCREAMING_SNAKE_CASE_     :    List[str]			):



    '''simple docstring'''





    with open(__snake_case						,				"rb"			) as f:
        _lowerCAmelCase			=					Image.open(__snake_case			)
        return im.convert("RGB"			)

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




 def 							_snake_case      (		self						)			->							Tuple:







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







def 		__a(SCREAMING_SNAKE_CASE_     :    List[str]			):



    '''simple docstring'''





    _lowerCAmelCase			=					torch.stack([example["pixel_values"] for example in examples]			)
    _lowerCAmelCase			=					torch.tensor([example["labels"] for example in examples]			)
    return {"pixel_values": pixel_values, "labels": labels}


def 		__a():



    '''simple docstring'''





    _lowerCAmelCase			=					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.
        _lowerCAmelCase	,	_lowerCAmelCase	,	_lowerCAmelCase			=					parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]			)			)
    else:
        _lowerCAmelCase	,	_lowerCAmelCase	,	_lowerCAmelCase			=					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"						,				__snake_case						,				__snake_case			)

    # 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()

    _lowerCAmelCase			=					training_args.get_process_log_level()
    logger.setLevel(__snake_case			)
    transformers.utils.logging.set_verbosity(__snake_case			)
    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.
    _lowerCAmelCase			=					None
    if os.path.isdir(training_args.output_dir			) and training_args.do_train and not training_args.overwrite_output_dir:
        _lowerCAmelCase			=					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:
        _lowerCAmelCase			=					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:
        _lowerCAmelCase			=					{}
        if data_args.train_dir is not None:
            _lowerCAmelCase			=					os.path.join(data_args.train_dir						,				"**"			)
        if data_args.validation_dir is not None:
            _lowerCAmelCase			=					os.path.join(data_args.validation_dir						,				"**"			)
        _lowerCAmelCase			=					load_dataset(
            "imagefolder"						,				data_files=__snake_case						,				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.
    _lowerCAmelCase			=					None if "validation" in dataset.keys() else data_args.train_val_split
    if isinstance(data_args.train_val_split						,				__snake_case			) and data_args.train_val_split > 0.0:
        _lowerCAmelCase			=					dataset["train"].train_test_split(data_args.train_val_split			)
        _lowerCAmelCase			=					split["train"]
        _lowerCAmelCase			=					split["test"]

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

    # Load the accuracy metric from the datasets package
    _lowerCAmelCase			=					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(SCREAMING_SNAKE_CASE_     :    Optional[Any]			):
        return metric.compute(predictions=np.argmax(p.predictions						,				axis=1			)						,				references=p.label_ids			)

    _lowerCAmelCase			=					AutoConfig.from_pretrained(
        model_args.config_name or model_args.model_name_or_path						,				num_labels=len(__snake_case			)						,				labelaid=__snake_case						,				idalabel=__snake_case						,				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						,				)
    _lowerCAmelCase			=					AutoModelForImageClassification.from_pretrained(
        model_args.model_name_or_path						,				from_tf=bool(".ckpt" in model_args.model_name_or_path			)						,				config=__snake_case						,				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						,				)
    _lowerCAmelCase			=					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:
        _lowerCAmelCase			=					image_processor.size["shortest_edge"]
    else:
        _lowerCAmelCase			=					(image_processor.size["height"], image_processor.size["width"])
    _lowerCAmelCase			=					Normalize(mean=image_processor.image_mean						,				std=image_processor.image_std			)
    _lowerCAmelCase			=					Compose(
        [
            RandomResizedCrop(__snake_case			),
            RandomHorizontalFlip(),
            ToTensor(),
            normalize,
        ]			)
    _lowerCAmelCase			=					Compose(
        [
            Resize(__snake_case			),
            CenterCrop(__snake_case			),
            ToTensor(),
            normalize,
        ]			)

    def train_transforms(SCREAMING_SNAKE_CASE_     :    List[Any]			):
        _lowerCAmelCase			=					[
            _train_transforms(pil_img.convert("RGB"			)			) for pil_img in example_batch["image"]
        ]
        return example_batch

    def val_transforms(SCREAMING_SNAKE_CASE_     :    List[str]			):
        _lowerCAmelCase			=					[_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:
            _lowerCAmelCase			=					(
                dataset["train"].shuffle(seed=training_args.seed			).select(range(data_args.max_train_samples			)			)
            )
        # Set the training transforms
        dataset["train"].set_transform(__snake_case			)

    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:
            _lowerCAmelCase			=					(
                dataset["validation"].shuffle(seed=training_args.seed			).select(range(data_args.max_eval_samples			)			)
            )
        # Set the validation transforms
        dataset["validation"].set_transform(__snake_case			)

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

    # Training
    if training_args.do_train:
        _lowerCAmelCase			=					None
        if training_args.resume_from_checkpoint is not None:
            _lowerCAmelCase			=					training_args.resume_from_checkpoint
        elif last_checkpoint is not None:
            _lowerCAmelCase			=					last_checkpoint
        _lowerCAmelCase			=					trainer.train(resume_from_checkpoint=__snake_case			)
        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:
        _lowerCAmelCase			=					trainer.evaluate()
        trainer.log_metrics("eval"						,				__snake_case			)
        trainer.save_metrics("eval"						,				__snake_case			)

    # Write model card and (optionally) push to hub
    _lowerCAmelCase			=					{
        "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(**__snake_case			)
    else:
        trainer.create_model_card(**__snake_case			)


if __name__ == "__main__":
       main()









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

_a 						=      random.Random()





def lowerCAmelCase__(__snake_case       ,__snake_case=1.0       ,__snake_case=None       ,__snake_case=None							)				->      List[Any]:







	'''simple docstring'''







	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 					__A    (    unittest.TestCase ):

			'''simple docstring'''







			def __init__(    self       ,  __lowerCAmelCase       ,  __lowerCAmelCase=7       ,  __lowerCAmelCase=4_0_0       ,  __lowerCAmelCase=2_0_0_0       ,  __lowerCAmelCase=2_4       ,  __lowerCAmelCase=2_4       ,  __lowerCAmelCase=0.0       ,  __lowerCAmelCase=1_6_0_0_0       ,  __lowerCAmelCase=True       ,  __lowerCAmelCase=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       ,  __lowerCAmelCase=False       ,  __lowerCAmelCase=False							):



				'''simple docstring'''







				def _flatten(__lowerCAmelCase							):
					return list(itertools.chain(*__lowerCAmelCase							)							)

				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(__lowerCAmelCase							) for x in speech_inputs]
				return speech_inputs






@require_torch
@require_torchaudio
class 					__A    (    lowerCAmelCase			,				unittest.TestCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						SpeechaTextFeatureExtractor if is_speech_available() else None





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		SpeechaTextFeatureExtractionTester(self							)





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase							):



				'''simple docstring'''







				self.assertTrue(np.all(np.mean(__lowerCAmelCase       ,  axis=0							) < 1E-3							)							)
				self.assertTrue(np.all(np.abs(np.var(__lowerCAmelCase       ,  axis=0							) - 1							) < 1E-3							)							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				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(8_0_0       ,  1_4_0_0       ,  2_0_0							)]
				lowerCamelCase__								=		[np.asarray(__lowerCAmelCase							) for speech_input in speech_inputs]

				# Test feature size
				lowerCamelCase__								=		feature_extractor(__lowerCAmelCase       ,  padding=__lowerCAmelCase       ,  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(__lowerCAmelCase       ,  __lowerCAmelCase       ,  atol=1E-3							)							)

				# Test batched
				lowerCamelCase__								=		feature_extractor(__lowerCAmelCase       ,  return_tensors='''np'''							).input_features
				lowerCamelCase__								=		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.
				lowerCamelCase__								=		[floats_list((1, x)							)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
				lowerCamelCase__								=		np.asarray(__lowerCAmelCase							)
				lowerCamelCase__								=		feature_extractor(__lowerCAmelCase       ,  return_tensors='''np'''							).input_features
				lowerCamelCase__								=		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							):



				'''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(8_0_0       ,  1_4_0_0       ,  2_0_0							)]

				lowerCamelCase__								=		['''longest''', '''max_length''', '''do_not_pad''']
				lowerCamelCase__								=		[None, 1_6, None]
				for max_length, padding in zip(__lowerCAmelCase       ,  __lowerCAmelCase							):
					lowerCamelCase__								=		feature_extractor(
					    __lowerCAmelCase       ,  padding=__lowerCAmelCase       ,  max_length=__lowerCAmelCase       ,  return_attention_mask=__lowerCAmelCase							)
					lowerCamelCase__								=		inputs.input_features
					lowerCamelCase__								=		inputs.attention_mask
					lowerCamelCase__								=		[np.sum(__lowerCAmelCase							) 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(8_0_0       ,  1_4_0_0       ,  2_0_0							)]

				lowerCamelCase__								=		['''longest''', '''max_length''', '''do_not_pad''']
				lowerCamelCase__								=		[None, 1_6, None]
				for max_length, padding in zip(__lowerCAmelCase       ,  __lowerCAmelCase							):
					lowerCamelCase__								=		feature_extractor(
					    __lowerCAmelCase       ,  max_length=__lowerCAmelCase       ,  padding=__lowerCAmelCase       ,  return_tensors='''np'''       ,  return_attention_mask=__lowerCAmelCase							)
					lowerCamelCase__								=		inputs.input_features
					lowerCamelCase__								=		inputs.attention_mask
					lowerCamelCase__								=		[np.sum(__lowerCAmelCase							) 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(8_0_0       ,  1_4_0_0       ,  2_0_0							)]
				lowerCamelCase__								=		feature_extractor(
				    __lowerCAmelCase       ,  padding='''max_length'''       ,  max_length=4       ,  truncation=__lowerCAmelCase       ,  return_tensors='''np'''       ,  return_attention_mask=__lowerCAmelCase       ,  )
				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(8_0_0       ,  1_4_0_0       ,  2_0_0							)]
				lowerCamelCase__								=		feature_extractor(
				    __lowerCAmelCase       ,  padding='''longest'''       ,  max_length=4       ,  truncation=__lowerCAmelCase       ,  return_tensors='''np'''       ,  return_attention_mask=__lowerCAmelCase       ,  )
				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, 2_4)							)

				lowerCamelCase__								=		[floats_list((1, x)							)[0] for x in range(8_0_0       ,  1_4_0_0       ,  2_0_0							)]
				lowerCamelCase__								=		feature_extractor(
				    __lowerCAmelCase       ,  padding='''longest'''       ,  max_length=1_6       ,  truncation=__lowerCAmelCase       ,  return_tensors='''np'''       ,  return_attention_mask=__lowerCAmelCase       ,  )
				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, 2_4)							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				import torch

				lowerCamelCase__								=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
				lowerCamelCase__								=		np.random.rand(1_0_0       ,  3_2							).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       ,  __lowerCAmelCase							):



				'''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(__lowerCAmelCase							)							)[:num_samples]['''audio''']

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





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		np.array([
				    -1.5745, -1.7713, -1.7020, -1.6069, -1.2250, -1.1105, -0.9072, -0.8241,
				    -1.2310, -0.8098, -0.3320, -0.4101, -0.7985, -0.4996, -0.8213, -0.9128,
				    -1.0420, -1.1286, -1.0440, -0.7999, -0.8405, -1.2275, -1.5443, -1.4625,
				]							)
				# fmt: on

				lowerCamelCase__								=		self._load_datasamples(1							)
				lowerCamelCase__								=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
				lowerCamelCase__								=		feature_extractor(__lowerCAmelCase       ,  return_tensors='''pt'''							).input_features
				self.assertEquals(input_features.shape       ,  (1, 5_8_4, 2_4)							)
				self.assertTrue(np.allclose(input_features[0, 0, :3_0]       ,  __lowerCAmelCase       ,  atol=1E-4							)							)



