"""simple docstring"""


import inspect
import os
from argparse import ArgumentParser, Namespace
from importlib import import_module

import huggingface_hub
import numpy as np
from packaging import version

from .. import (
    FEATURE_EXTRACTOR_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoImageProcessor,
    AutoProcessor,
    AutoTokenizer,
    is_datasets_available,
    is_tf_available,
    is_torch_available,
)
from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
from . import BaseTransformersCLICommand


if is_tf_available():
	import tensorflow as tf

	tf.config.experimental.enable_tensor_float_aa_execution(False)

if is_torch_available():
	import torch

if is_datasets_available():
	from datasets import load_dataset


a							=5E-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors





def 			lowerCamelCase_ (					__lowerCAmelCase				)							->					Any:




						'''simple docstring'''



						return PTtoTFCommand(
						    args.model_name   ,    args.local_dir   ,    args.max_error   ,    args.new_weights   ,    args.no_pr   ,    args.push   ,    args.extra_commit_description   ,    args.override_model_class   ,    )






class    __UpperCAmelCase						(	__lowerCAmelCase	):

				@staticmethod
				def 		_a	(      _lowerCamelCase      ):
										lowerCamelCase__					=parser.add_parser(
										    "pt-to-tf"	, help=(
										        "CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint."
										        " Can also be used to validate existing weights without opening PRs, with --no-pr."
										    )	, )
										train_parser.add_argument(
										    "--model-name"	, type=_lowerCamelCase	, required=_lowerCamelCase	, help="The model name, including owner/organization, as seen on the hub."	, )
										train_parser.add_argument(
										    "--local-dir"	, type=_lowerCamelCase	, default=""	, help="Optional local directory of the model repository. Defaults to /tmp/{model_name}"	, )
										train_parser.add_argument(
										    "--max-error"	, type=_lowerCamelCase	, default=_lowerCamelCase	, help=(
										        F'''Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk.'''
										    )	, )
										train_parser.add_argument(
										    "--new-weights"	, action="store_true"	, help="Optional flag to create new TensorFlow weights, even if they already exist."	, )
										train_parser.add_argument(
										    "--no-pr"	, action="store_true"	, help="Optional flag to NOT open a PR with converted weights."      )
										train_parser.add_argument(
										    "--push"	, action="store_true"	, help="Optional flag to push the weights directly to `main` (requires permissions)"	, )
										train_parser.add_argument(
										    "--extra-commit-description"	, type=_lowerCamelCase	, default=""	, help="Optional additional commit description to use when opening a PR (e.g. to tag the owner)."	, )
										train_parser.add_argument(
										    "--override-model-class"	, type=_lowerCamelCase	, default=_lowerCamelCase	, help="If you think you know better than the auto-detector, you can specify the model class here. "
										    "Can be either an AutoModel class or a specific model class like BertForSequenceClassification."	, )
										train_parser.set_defaults(func=_lowerCamelCase      )

				@staticmethod
				def 		_a	(      _lowerCamelCase	, _lowerCamelCase      ):
										lowerCamelCase__					=set(pt_outputs.keys()      )
										lowerCamelCase__					=set(tf_outputs.keys()      )
										if pt_out_attrs != tf_out_attrs:
																raise ValueError(
																    F'''The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:'''
																    F''' {tf_out_attrs})'''      )

										# 2. For each output attribute, computes the difference
										def _find_pt_tf_differences(_lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase=""      ):
																# If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
																# recursivelly, keeping the name of the attribute.
																if isinstance(_lowerCamelCase	, torch.Tensor      ):
																						lowerCamelCase__					=np.max(np.abs(pt_out.numpy() - tf_out.numpy()      )      )
																						lowerCamelCase__					=tensor_difference
																else:
																						lowerCamelCase__					=attr_name
																						for i, pt_item in enumerate(_lowerCamelCase      ):
																												# If it is a named attribute, we keep the name. Otherwise, just its index.
																												if isinstance(_lowerCamelCase	, _lowerCamelCase      ):
																																		lowerCamelCase__					=root_name + pt_item
																																		lowerCamelCase__					=tf_out[pt_item]
																																		lowerCamelCase__					=pt_out[pt_item]
																												else:
																																		lowerCamelCase__					=root_name + F'''[{i}]'''
																																		lowerCamelCase__					=tf_out[i]
																												lowerCamelCase__					=_find_pt_tf_differences(_lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase      )

																return differences

										return _find_pt_tf_differences(_lowerCamelCase	, _lowerCamelCase	, {}      )

				def __init__(      self	, _lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase	, *_lowerCamelCase	, ):
										lowerCamelCase__					=logging.get_logger("transformers-cli/pt_to_tf"      )
										lowerCamelCase__					=model_name
										lowerCamelCase__					=local_dir if local_dir else os.path.join("/tmp"	, _lowerCamelCase      )
										lowerCamelCase__					=max_error
										lowerCamelCase__					=new_weights
										lowerCamelCase__					=no_pr
										lowerCamelCase__					=push
										lowerCamelCase__					=extra_commit_description
										lowerCamelCase__					=override_model_class

				def 		_a	(      self	, _lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase      ):

										def _get_audio_input():
																lowerCamelCase__					=load_dataset("hf-internal-testing/librispeech_asr_dummy"	, "clean"	, split="validation"      )
																lowerCamelCase__					=ds.sort("id"      ).select(range(2      )      )[:2]["audio"]
																lowerCamelCase__					=[x["array"] for x in speech_samples]
																return raw_samples

										lowerCamelCase__					=type(pt_model.config      )
										if model_config_class in PROCESSOR_MAPPING:
																lowerCamelCase__					=AutoProcessor.from_pretrained(self._local_dir      )
																if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
																						lowerCamelCase__					=processor.tokenizer.eos_token
										elif model_config_class in IMAGE_PROCESSOR_MAPPING:
																lowerCamelCase__					=AutoImageProcessor.from_pretrained(self._local_dir      )
										elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
																lowerCamelCase__					=AutoFeatureExtractor.from_pretrained(self._local_dir      )
										elif model_config_class in TOKENIZER_MAPPING:
																lowerCamelCase__					=AutoTokenizer.from_pretrained(self._local_dir      )
																if processor.pad_token is None:
																						lowerCamelCase__					=processor.eos_token
										else:
																raise ValueError(F'''Unknown data processing type (model config type: {model_config_class})'''      )

										lowerCamelCase__					=set(inspect.signature(pt_model.forward      ).parameters.keys()      )
										lowerCamelCase__					={}
										if "input_ids" in model_forward_signature:
																processor_inputs.update(
																    {
																        "text": ["Hi there!", "I am a batch with more than one row and different input lengths."],
																        "padding": True,
																        "truncation": True,
																    }      )
										if "pixel_values" in model_forward_signature:
																lowerCamelCase__					=load_dataset("cifar10"	, "plain_text"	, split="test"      )[:2]["img"]
																processor_inputs.update({"images": sample_images}      )
										if "input_features" in model_forward_signature:
																lowerCamelCase__					=inspect.signature(processor.feature_extractor      ).parameters
																# Pad to the largest input length by default but take feature extractor default
																# padding value if it exists e.g. "max_length" and is not False or None
																if "padding" in feature_extractor_signature:
																						lowerCamelCase__					=feature_extractor_signature["padding"].default
																						if default_strategy is not False and default_strategy is not None:
																												lowerCamelCase__					=default_strategy
																						else:
																												lowerCamelCase__					=True
																else:
																						lowerCamelCase__					=True
																processor_inputs.update({"audio": _get_audio_input(), "padding": padding_strategy}      )
										if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
																processor_inputs.update({"audio": _get_audio_input(), "padding": True}      )
										lowerCamelCase__					=processor(**_lowerCamelCase	, return_tensors="pt"      )
										lowerCamelCase__					=processor(**_lowerCamelCase	, return_tensors="tf"      )

										# Extra input requirements, in addition to the input modality
										if (
										    config.is_encoder_decoder
										    or (hasattr(_lowerCamelCase	, "encoder"      ) and hasattr(_lowerCamelCase	, "decoder"      ))
										    or "decoder_input_ids" in tf_dummy_inputs
										):
																lowerCamelCase__					=np.asarray([[1], [1]]	, dtype=_lowerCamelCase      ) * (pt_model.config.decoder_start_token_id or 0)
																pt_input.update({"decoder_input_ids": torch.tensor(_lowerCamelCase      )}      )
																tf_input.update({"decoder_input_ids": tf.convert_to_tensor(_lowerCamelCase      )}      )

										return pt_input, tf_input






				def 		_a	(      self      ):
										# hub version 0.9.0 introduced the possibility of programmatically opening PRs with normal write tokens.
										if version.parse(huggingface_hub.__version__      ) < version.parse("0.9.0"      ):
																raise ImportError(
																    "The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub"
																    " installation."      )
										else:
																from huggingface_hub import Repository, create_commit
																from huggingface_hub._commit_api import CommitOperationAdd

										# Fetch remote data
										lowerCamelCase__					=Repository(local_dir=self._local_dir	, clone_from=self._model_name      )

										# Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
										lowerCamelCase__					=AutoConfig.from_pretrained(self._local_dir      )
										lowerCamelCase__					=config.architectures
										if self._override_model_class is not None:
																if self._override_model_class.startswith("TF"      ):
																						lowerCamelCase__					=[self._override_model_class[2:]]
																else:
																						lowerCamelCase__					=[self._override_model_class]
																try:
																						lowerCamelCase__					=getattr(import_module("transformers"      )	, architectures[0]      )
																except AttributeError:
																						raise ValueError(F'''Model class {self._override_model_class} not found in transformers.'''      )
																try:
																						lowerCamelCase__					=getattr(import_module("transformers"      )	, "TF" + architectures[0]      )
																except AttributeError:
																						raise ValueError(F'''TF model class TF{self._override_model_class} not found in transformers.'''      )
										elif architectures is None:  # No architecture defined -- use auto classes
																lowerCamelCase__					=getattr(import_module("transformers"      )	, "AutoModel"      )
																lowerCamelCase__					=getattr(import_module("transformers"      )	, "TFAutoModel"      )
																self._logger.warning("No detected architecture, using AutoModel/TFAutoModel"      )
										else:  # Architecture defined -- use it
																if len(_lowerCamelCase      ) > 1:
																						raise ValueError(F'''More than one architecture was found, aborting. (architectures = {architectures})'''      )
																self._logger.warning(F'''Detected architecture: {architectures[0]}'''      )
																lowerCamelCase__					=getattr(import_module("transformers"      )	, architectures[0]      )
																try:
																						lowerCamelCase__					=getattr(import_module("transformers"      )	, "TF" + architectures[0]      )
																except AttributeError:
																						raise AttributeError(F'''The TensorFlow equivalent of {architectures[0]} doesn\'t exist in transformers.'''      )

        # Check the TF dummy inputs to see what keys we need in the forward pass
										lowerCamelCase__					=tf_class.from_config(_lowerCamelCase      )
										lowerCamelCase__					=tf_from_pt_model.dummy_inputs

										del tf_from_pt_model  # Try to keep only one model in memory at a time

										# Load the model and get some basic inputs
										lowerCamelCase__					=pt_class.from_pretrained(self._local_dir      )
										pt_model.eval()

										lowerCamelCase__					,      lowerCamelCase__					=self.get_inputs(_lowerCamelCase	, _lowerCamelCase	, _lowerCamelCase      )

										with torch.no_grad():
																lowerCamelCase__					=pt_model(**_lowerCamelCase	, output_hidden_states=_lowerCamelCase      )
										del pt_model  # will no longer be used, and may have a large memory footprint

										lowerCamelCase__					=tf_class.from_pretrained(self._local_dir	, from_pt=_lowerCamelCase      )
										lowerCamelCase__					=tf_from_pt_model(**_lowerCamelCase	, output_hidden_states=_lowerCamelCase	, training=_lowerCamelCase      )

										# Confirms that cross loading PT weights into TF worked.
										lowerCamelCase__					=self.find_pt_tf_differences(_lowerCamelCase	, _lowerCamelCase      )
										lowerCamelCase__					={k: v for k, v in crossload_differences.items() if "hidden" not in k}
										lowerCamelCase__					={k: v for k, v in crossload_differences.items() if "hidden" in k}
										if len(_lowerCamelCase      ) == 0 and architectures is not None:
																raise ValueError(
																    F'''Something went wrong -- the config file has architectures ({architectures}), but no model head'''
																    " output was found. All outputs start with 'hidden'"      )
										lowerCamelCase__					=max(output_differences.values()      ) if output_differences else 0.0
										lowerCamelCase__					=max(hidden_differences.values()      )
										if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
																raise ValueError(
																    "The cross-loaded TensorFlow model has different outputs, something went wrong!\n"
																    + F'''\nList of maximum output differences above the threshold ({self._max_error}):\n'''
																    + "\n".join([F'''{k}: {v:.3e}''' for k, v in output_differences.items() if v > self._max_error]      )
																    + F'''\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'''
																    + "\n".join([F'''{k}: {v:.3e}''' for k, v in hidden_differences.items() if v > self._max_error]      )      )

										# Save the weights in a TF format (if needed) and confirms that the results are still good
										lowerCamelCase__					=os.path.join(self._local_dir	, _lowerCamelCase      )
										lowerCamelCase__					=os.path.join(self._local_dir	, _lowerCamelCase      )
										if (not os.path.exists(_lowerCamelCase      ) and not os.path.exists(_lowerCamelCase      )) or self._new_weights:
																tf_from_pt_model.save_pretrained(self._local_dir      )
										del tf_from_pt_model  # will no longer be used, and may have a large memory footprint

										lowerCamelCase__					=tf_class.from_pretrained(self._local_dir      )
										lowerCamelCase__					=tf_model(**_lowerCamelCase	, output_hidden_states=_lowerCamelCase      )

										lowerCamelCase__					=self.find_pt_tf_differences(_lowerCamelCase	, _lowerCamelCase      )
										lowerCamelCase__					={k: v for k, v in conversion_differences.items() if "hidden" not in k}
										lowerCamelCase__					={k: v for k, v in conversion_differences.items() if "hidden" in k}
										if len(_lowerCamelCase      ) == 0 and architectures is not None:
																raise ValueError(
																    F'''Something went wrong -- the config file has architectures ({architectures}), but no model head'''
																    " output was found. All outputs start with 'hidden'"      )
										lowerCamelCase__					=max(output_differences.values()      ) if output_differences else 0.0
										lowerCamelCase__					=max(hidden_differences.values()      )
										if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
																raise ValueError(
																    "The converted TensorFlow model has different outputs, something went wrong!\n"
																    + F'''\nList of maximum output differences above the threshold ({self._max_error}):\n'''
																    + "\n".join([F'''{k}: {v:.3e}''' for k, v in output_differences.items() if v > self._max_error]      )
																    + F'''\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'''
																    + "\n".join([F'''{k}: {v:.3e}''' for k, v in hidden_differences.items() if v > self._max_error]      )      )

										lowerCamelCase__					="Update TF weights" if self._new_weights else "Add TF weights"
										if self._push:
																repo.git_add(auto_lfs_track=_lowerCamelCase      )
																repo.git_commit(_lowerCamelCase      )
																repo.git_push(blocking=_lowerCamelCase      )  # this prints a progress bar with the upload
																self._logger.warning(F'''TF weights pushed into {self._model_name}'''      )
										elif not self._no_pr:
																self._logger.warning("Uploading the weights into a new PR..."      )
																lowerCamelCase__					=(
																    "Model converted by the [`transformers`' `pt_to_tf`"
																    " CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). "
																    "All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n"
																    F'''Maximum crossload output difference={max_crossload_output_diff:.3e}; '''
																    F'''Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n'''
																    F'''Maximum conversion output difference={max_conversion_output_diff:.3e}; '''
																    F'''Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n'''
																)
																if self._max_error > MAX_ERROR:
																						commit_descrition += (
																						    F'''\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!'''
																						)
																if self._extra_commit_description:
																						commit_descrition += "\n\n" + self._extra_commit_description

																# sharded model -> adds all related files (index and .h5 shards)
																if os.path.exists(_lowerCamelCase      ):
																						lowerCamelCase__					=[
																						    CommitOperationAdd(path_in_repo=_lowerCamelCase	, path_or_fileobj=_lowerCamelCase      )
																						]
																						for shard_path in tf.io.gfile.glob(self._local_dir + "/tf_model-*.h5"      ):
																												operations += [
																												    CommitOperationAdd(path_in_repo=os.path.basename(_lowerCamelCase      )	, path_or_fileobj=_lowerCamelCase      )
																												]
																else:
																						lowerCamelCase__					=[CommitOperationAdd(path_in_repo=_lowerCamelCase	, path_or_fileobj=_lowerCamelCase      )]

																lowerCamelCase__					=create_commit(
																    repo_id=self._model_name	, operations=_lowerCamelCase	, commit_message=_lowerCamelCase	, commit_description=_lowerCamelCase	, repo_type="model"	, create_pr=_lowerCamelCase	, ).pr_url
																self._logger.warning(F'''PR open in {hub_pr_url}'''      )





import unittest

from transformers import (
    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    PreTrainedTokenizer,
    is_vision_available,
)
from transformers.pipelines import ImageClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
 from PIL import Image
else:






 class 		__magic_name__ :






      @staticmethod
      def      UpperCAmelCase_							(							*_lowercase						,		**_lowercase     )->			Tuple:
          pass






@is_pipeline_test
@require_torch_or_tf
@require_vision
class 		__magic_name__ (				unittest.TestCase							):
     UpperCamelCase_     :Union[str, Any]									=	MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
     UpperCamelCase_     :Any									=	TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING






     def      UpperCAmelCase_							(							self						,		_lowercase						,		_lowercase						,		_lowercase     )->			List[Any]:
         UpperCamelCase_          =		ImageClassificationPipeline(model=_lowercase						,		image_processor=_lowercase						,		top_k=2     )
         UpperCamelCase_          =		[
             Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"     ),
             "http://images.cocodataset.org/val2017/000000039769.jpg",
         ]
         return image_classifier, examples






     def      UpperCAmelCase_							(							self						,		_lowercase						,		_lowercase     )->			List[str]:
         UpperCamelCase_          =		image_classifier("./tests/fixtures/tests_samples/COCO/000000039769.png"     )

         self.assertEqual(
             _lowercase						,		[
                 {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
             ]						,		)

         import datasets

         UpperCamelCase_          =		datasets.load_dataset("hf-internal-testing/fixtures_image_utils"						,		"image"						,		split="test"     )

         # Accepts URL + PIL.Image + lists
         UpperCamelCase_          =		image_classifier(
             [
                 Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"     ),
                 "http://images.cocodataset.org/val2017/000000039769.jpg",
                 # RGBA
                 dataset[0]["file"],
                 # LA
                 dataset[1]["file"],
                 # L
                 dataset[2]["file"],
             ]     )
         self.assertEqual(
             _lowercase						,		[
                 [
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 ],
                 [
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 ],
                 [
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 ],
                 [
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 ],
                 [
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                     {"score": ANY(_lowercase     ), "label": ANY(_lowercase     )},
                 ],
             ]						,		)






     @require_torch
     def      UpperCAmelCase_							(							self     )->			str:
         UpperCamelCase_          =		"hf-internal-testing/tiny-random-vit"
         UpperCamelCase_          =		pipeline("image-classification"						,		model=_lowercase     )

         UpperCamelCase_          =		image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"     )
         self.assertEqual(
             nested_simplify(_lowercase						,		decimals=4     )						,		[{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}]						,		)

         UpperCamelCase_          =		image_classifier(
             [
                 "http://images.cocodataset.org/val2017/000000039769.jpg",
                 "http://images.cocodataset.org/val2017/000000039769.jpg",
             ]						,		top_k=2						,		)
         self.assertEqual(
             nested_simplify(_lowercase						,		decimals=4     )						,		[
                 [{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}],
                 [{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}],
             ]						,		)






     @require_tf
     def      UpperCAmelCase_							(							self     )->			Tuple:
         UpperCamelCase_          =		"hf-internal-testing/tiny-random-vit"
         UpperCamelCase_          =		pipeline("image-classification"						,		model=_lowercase						,		framework="tf"     )

         UpperCamelCase_          =		image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"     )
         self.assertEqual(
             nested_simplify(_lowercase						,		decimals=4     )						,		[{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}]						,		)

         UpperCamelCase_          =		image_classifier(
             [
                 "http://images.cocodataset.org/val2017/000000039769.jpg",
                 "http://images.cocodataset.org/val2017/000000039769.jpg",
             ]						,		top_k=2						,		)
         self.assertEqual(
             nested_simplify(_lowercase						,		decimals=4     )						,		[
                 [{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}],
                 [{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}],
             ]						,		)






     def      UpperCAmelCase_							(							self     )->			Optional[Any]:
         UpperCamelCase_          =		PreTrainedTokenizer()

         # Assert that the pipeline can be initialized with a feature extractor that is not in any mapping
         UpperCamelCase_          =		pipeline(
             "image-classification"						,		model="hf-internal-testing/tiny-random-vit"						,		tokenizer=_lowercase     )

         self.assertIs(image_classifier.tokenizer						,		_lowercase     )






     @slow
     @require_torch
     def      UpperCAmelCase_							(							self     )->			int:
         # Perceiver is not tested by `run_pipeline_test` properly.
         # That is because the type of feature_extractor and model preprocessor need to be kept
         # in sync, which is not the case in the current design
         UpperCamelCase_          =		pipeline("image-classification"						,		model="deepmind/vision-perceiver-conv"     )
         UpperCamelCase_          =		image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"     )
         self.assertEqual(
             nested_simplify(_lowercase						,		decimals=4     )						,		[
                 {"score": 0.4_385, "label": "tabby, tabby cat"},
                 {"score": 0.321, "label": "tiger cat"},
                 {"score": 0.0_502, "label": "Egyptian cat"},
                 {"score": 0.0_137, "label": "crib, cot"},
                 {"score": 0.007, "label": "radiator"},
             ]						,		)

         UpperCamelCase_          =		pipeline("image-classification"						,		model="deepmind/vision-perceiver-fourier"     )
         UpperCamelCase_          =		image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"     )
         self.assertEqual(
             nested_simplify(_lowercase						,		decimals=4     )						,		[
                 {"score": 0.5_658, "label": "tabby, tabby cat"},
                 {"score": 0.1_309, "label": "tiger cat"},
                 {"score": 0.0_722, "label": "Egyptian cat"},
                 {"score": 0.0_707, "label": "remote control, remote"},
                 {"score": 0.0_082, "label": "computer keyboard, keypad"},
             ]						,		)

         UpperCamelCase_          =		pipeline("image-classification"						,		model="deepmind/vision-perceiver-learned"     )
         UpperCamelCase_          =		image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"     )
         self.assertEqual(
             nested_simplify(_lowercase						,		decimals=4     )						,		[
                 {"score": 0.3_022, "label": "tabby, tabby cat"},
                 {"score": 0.2_362, "label": "Egyptian cat"},
                 {"score": 0.1_856, "label": "tiger cat"},
                 {"score": 0.0_324, "label": "remote control, remote"},
                 {"score": 0.0_096, "label": "quilt, comforter, comfort, puff"},
             ]						,		)
