





"""simple docstring"""






import inspect
import unittest

from transformers import BitConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import BitBackbone, BitForImageClassification, BitImageProcessor, BitModel
		from transformers.models.bit.modeling_bit import BIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image




class 			__lowercase     :







					'''simple docstring'''




					def __init__(  self		,     _UpperCAmelCase		,     _UpperCAmelCase=3		,     _UpperCAmelCase=32		,     _UpperCAmelCase=3		,     _UpperCAmelCase=10		,     _UpperCAmelCase=[8, 16, 32, 64]		,     _UpperCAmelCase=[1, 1, 2, 1]		,     _UpperCAmelCase=True		,     _UpperCAmelCase=True		,     _UpperCAmelCase="relu"		,     _UpperCAmelCase=3		,     _UpperCAmelCase=None		,     _UpperCAmelCase=["stage2", "stage3", "stage4"]		,     _UpperCAmelCase=[2, 3, 4]		,     _UpperCAmelCase=1		,     ):
									__a	:  Union[str, Any]         =					parent
									__a	:  List[str]         =					batch_size
									__a	:  List[str]         =					image_size
									__a	:  Union[str, Any]         =					num_channels
									__a	:  List[str]         =					embeddings_size
									__a	:  Optional[Any]         =					hidden_sizes
									__a	:  List[str]         =					depths
									__a	:  Union[str, Any]         =					is_training
									__a	:  Optional[Any]         =					use_labels
									__a	:  Any         =					hidden_act
									__a	:  Union[str, Any]         =					num_labels
									__a	:  int         =					scope
									__a	:  Dict         =					len(_UpperCAmelCase       )
									__a	:  Dict         =					out_features
									__a	:  str         =					out_indices
									__a	:  Optional[int]         =					num_groups







					def 	_lowerCamelCase						(  self       ):
									__a	:  Any         =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

									__a	:  Union[str, Any]         =					None
									if self.use_labels:
													__a	:  Any         =					ids_tensor([self.batch_size]		,     self.num_labels       )

									__a	:  Optional[int]         =					self.get_config()

									return config, pixel_values, labels







					def 	_lowerCamelCase						(  self       ):
									return BitConfig(
									    num_channels=self.num_channels		,     embeddings_size=self.embeddings_size		,     hidden_sizes=self.hidden_sizes		,     depths=self.depths		,     hidden_act=self.hidden_act		,     num_labels=self.num_labels		,     out_features=self.out_features		,     out_indices=self.out_indices		,     num_groups=self.num_groups		,     )







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
									__a	:  Optional[Any]         =					BitModel(config=_UpperCAmelCase       )
									model.to(_UpperCAmelCase       )
									model.eval()
									__a	:  Tuple         =					model(_UpperCAmelCase       )
									self.parent.assertEqual(
									    result.last_hidden_state.shape		,     (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)		,     )







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
									__a	:  List[Any]         =					self.num_labels
									__a	:  Dict         =					BitForImageClassification(_UpperCAmelCase       )
									model.to(_UpperCAmelCase       )
									model.eval()
									__a	:  Any         =					model(_UpperCAmelCase		,     labels=_UpperCAmelCase       )
									self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_labels)       )







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
									__a	:  Union[str, Any]         =					BitBackbone(config=_UpperCAmelCase       )
									model.to(_UpperCAmelCase       )
									model.eval()
									__a	:  Optional[Any]         =					model(_UpperCAmelCase       )

									# verify feature maps
									self.parent.assertEqual(len(result.feature_maps       )		,     len(config.out_features       )       )
									self.parent.assertListEqual(list(result.feature_maps[0].shape       )		,     [self.batch_size, self.hidden_sizes[1], 4, 4]       )

									# verify channels
									self.parent.assertEqual(len(model.channels       )		,     len(config.out_features       )       )
									self.parent.assertListEqual(model.channels		,     config.hidden_sizes[1:]       )

									# verify backbone works with out_features=None
									__a	:  Tuple         =					None
									__a	:  Union[str, Any]         =					BitBackbone(config=_UpperCAmelCase       )
									model.to(_UpperCAmelCase       )
									model.eval()
									__a	:  Tuple         =					model(_UpperCAmelCase       )

									# verify feature maps
									self.parent.assertEqual(len(result.feature_maps       )		,     1       )
									self.parent.assertListEqual(list(result.feature_maps[0].shape       )		,     [self.batch_size, self.hidden_sizes[-1], 1, 1]       )

									# verify channels
									self.parent.assertEqual(len(model.channels       )		,     1       )
									self.parent.assertListEqual(model.channels		,     [config.hidden_sizes[-1]]       )







					def 	_lowerCamelCase						(  self       ):
									__a	:  List[Any]         =					self.prepare_config_and_inputs()
									__a    ,  __a    ,  __a	:  Optional[Any]         =					config_and_inputs
									__a	:  Optional[int]         =					{'''pixel_values''': pixel_values}
									return config, inputs_dict






@require_torch
class 			__lowercase     (     _UpperCamelCase				, _UpperCamelCase				, unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase					=					(BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else ()
					__lowerCAmelCase					=					(
					    {'''feature-extraction''': BitModel, '''image-classification''': BitForImageClassification}
					    if is_torch_available()
					    else {}
					)

					__lowerCAmelCase					=					False
					__lowerCAmelCase					=					False
					__lowerCAmelCase					=					False
					__lowerCAmelCase					=					False
					__lowerCAmelCase					=					False







					def 	_lowerCamelCase						(  self       ):
									__a	:  List[Any]         =					BitModelTester(self       )
									__a	:  Any         =					ConfigTester(self		,     config_class=_UpperCAmelCase		,     has_text_modality=_UpperCAmelCase       )







					def 	_lowerCamelCase						(  self       ):
									self.create_and_test_config_common_properties()
									self.config_tester.create_and_test_config_to_json_string()
									self.config_tester.create_and_test_config_to_json_file()
									self.config_tester.create_and_test_config_from_and_save_pretrained()
									self.config_tester.create_and_test_config_with_num_labels()
									self.config_tester.check_config_can_be_init_without_params()
									self.config_tester.check_config_arguments_init()







					def 	_lowerCamelCase						(  self       ):
									return







					@unittest.skip(reason='''Bit does not output attentions'''       )
					def 	_lowerCamelCase						(  self       ):
									pass







					@unittest.skip(reason='''Bit does not use inputs_embeds'''       )
					def 	_lowerCamelCase						(  self       ):
									pass







					@unittest.skip(reason='''Bit does not support input and output embeddings'''       )
					def 	_lowerCamelCase						(  self       ):
									pass







					def 	_lowerCamelCase						(  self       ):
									__a    ,  __a	:  Optional[Any]         =					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													__a	:  Optional[Any]         =					model_class(_UpperCAmelCase       )
													__a	:  Optional[int]         =					inspect.signature(model.forward       )
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													__a	:  Union[str, Any]         =					[*signature.parameters.keys()]

													__a	:  Dict         =					['''pixel_values''']
													self.assertListEqual(arg_names[:1]		,     _UpperCAmelCase       )







					def 	_lowerCamelCase						(  self       ):
									__a	:  Tuple         =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_UpperCAmelCase       )







					def 	_lowerCamelCase						(  self       ):
									__a	:  Tuple         =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_backbone(*_UpperCAmelCase       )







					def 	_lowerCamelCase						(  self       ):
									__a    ,  __a	:  Any         =					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													__a	:  Union[str, Any]         =					model_class(config=_UpperCAmelCase       )
													for name, module in model.named_modules():
																	if isinstance(_UpperCAmelCase		,     (nn.BatchNormad, nn.GroupNorm)       ):
																					self.assertTrue(
																					    torch.all(module.weight == 1       )		,     msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""		,     )
																					self.assertTrue(
																					    torch.all(module.bias == 0       )		,     msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""		,     )







					def 	_lowerCamelCase						(  self       ):
									def check_hidden_states_output(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
													__a	:  Dict         =					model_class(_UpperCAmelCase       )
													model.to(_UpperCAmelCase       )
													model.eval()

													with torch.no_grad():
																	__a	:  Optional[Any]         =					model(**self._prepare_for_class(_UpperCAmelCase		,     _UpperCAmelCase       )       )

													__a	:  str         =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													__a	:  List[Any]         =					self.model_tester.num_stages
													self.assertEqual(len(_UpperCAmelCase       )		,     expected_num_stages + 1       )

													# Bit's feature maps are of shape (batch_size, num_channels, height, width)
													self.assertListEqual(
													    list(hidden_states[0].shape[-2:]       )		,     [self.model_tester.image_size // 4, self.model_tester.image_size // 4]		,     )

									__a    ,  __a	:  List[Any]         =					self.model_tester.prepare_config_and_inputs_for_common()
									__a	:  Optional[int]         =					['''preactivation''', '''bottleneck''']
									for model_class in self.all_model_classes:
													for layer_type in layers_type:
																	__a	:  List[str]         =					layer_type
																	__a	:  Optional[Any]         =					True
																	check_hidden_states_output(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       )

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	__a	:  Optional[int]         =					True

																	check_hidden_states_output(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       )







					@unittest.skip(reason='''Bit does not use feedforward chunking'''       )
					def 	_lowerCamelCase						(  self       ):
									pass







					def 	_lowerCamelCase						(  self       ):
									__a	:  Any         =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase       )







					@slow
					def 	_lowerCamelCase						(  self       ):
									for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__a	:  List[Any]         =					BitModel.from_pretrained(_UpperCAmelCase       )
													self.assertIsNotNone(_UpperCAmelCase       )






def       __A (     )						->						Optional[Any]:
				__a	:  Optional[int]         =					Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
				return image




@require_torch
@require_vision
class 			__lowercase     (     unittest.TestCase							):







					'''simple docstring'''




					@cached_property
					def 	_lowerCamelCase						(  self       ):
									return (
									    BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       ) if is_vision_available() else None
									)







					@slow
					def 	_lowerCamelCase						(  self       ):
									__a	:  int         =					BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       ).to(_UpperCAmelCase       )

									__a	:  List[Any]         =					self.default_image_processor
									__a	:  Optional[Any]         =					prepare_img()
									__a	:  str         =					image_processor(images=_UpperCAmelCase		,     return_tensors='''pt'''       ).to(_UpperCAmelCase       )

									# forward pass
									with torch.no_grad():
													__a	:  List[Any]         =					model(**_UpperCAmelCase       )

									# verify the logits
									__a	:  Dict         =					torch.Size((1, 1000)       )
									self.assertEqual(outputs.logits.shape		,     _UpperCAmelCase       )

									__a	:  Tuple         =					torch.tensor([[-0.6_5_2_6, -0.5_2_6_3, -1.4_3_9_8]]       ).to(_UpperCAmelCase       )

									self.assertTrue(torch.allclose(outputs.logits[0, :3]		,     _UpperCAmelCase		,     atol=1e-4       )       )






@require_torch
class 			__lowercase     (     _UpperCamelCase				, unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase					=					(BitBackbone,) if is_torch_available() else ()
					__lowerCAmelCase					=					BitConfig

					__lowerCAmelCase					=					False







					def 	_lowerCamelCase						(  self       ):
									__a	:  List[str]         =					BitModelTester(self       )






"""simple docstring"""






# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool




class 			__lowercase     (     _UpperCamelCase							):







					'''simple docstring'''




					__lowerCAmelCase					=					'''openai/whisper-base'''
					__lowerCAmelCase					=					(
					    '''This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the '''
					    '''transcribed text.'''
					)
					__lowerCAmelCase					=					'''transcriber'''
					__lowerCAmelCase					=					WhisperProcessor
					__lowerCAmelCase					=					WhisperForConditionalGeneration

					__lowerCAmelCase					=					['''audio''']
					__lowerCAmelCase					=					['''text''']







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase       ):
									return self.pre_processor(_UpperCAmelCase		,     return_tensors='''pt'''       ).input_features







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase       ):
									return self.model.generate(inputs=_UpperCAmelCase       )







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase       ):
									return self.pre_processor.batch_decode(_UpperCAmelCase		,     skip_special_tokens=_UpperCAmelCase       )[0]