




"""simple docstring"""




from __future__ import annotations

import unittest

from transformers import FunnelConfig, is_tf_available
from transformers.testing_utils import require_tf

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TFFunnelBaseModel,
					    TFFunnelForMaskedLM,
					    TFFunnelForMultipleChoice,
					    TFFunnelForPreTraining,
					    TFFunnelForQuestionAnswering,
					    TFFunnelForSequenceClassification,
					    TFFunnelForTokenClassification,
					    TFFunnelModel,
					)






class     __magic_name__							:






				'''simple docstring'''





				def __init__(       self		, _a		, _a=13		, _a=7		, _a=True		, _a=True		, _a=True		, _a=True		, _a=99		, _a=[1, 1, 2]		, _a=1		, _a=32		, _a=4		, _a=8		, _a=37		, _a="gelu_new"		, _a=0.1		, _a=0.1		, _a=0.0		, _a=512		, _a=3		, _a=0.02		, _a=3		, _a=4		, _a=None		, _a=False		, ):





							"""simple docstring"""
							lowerCamelCase			      =					parent
							lowerCamelCase			      =					batch_size
							lowerCamelCase			      =					seq_length
							lowerCamelCase			      =					is_training
							lowerCamelCase			      =					use_input_mask
							lowerCamelCase			      =					use_token_type_ids
							lowerCamelCase			      =					use_labels
							lowerCamelCase			      =					vocab_size
							lowerCamelCase			      =					block_sizes
							lowerCamelCase			      =					num_decoder_layers
							lowerCamelCase			      =					d_model
							lowerCamelCase			      =					n_head
							lowerCamelCase			      =					d_head
							lowerCamelCase			      =					d_inner
							lowerCamelCase			      =					hidden_act
							lowerCamelCase			      =					hidden_dropout
							lowerCamelCase			      =					attention_dropout
							lowerCamelCase			      =					activation_dropout
							lowerCamelCase			      =					max_position_embeddings
							lowerCamelCase			      =					type_vocab_size
							lowerCamelCase			      =					2
							lowerCamelCase			      =					num_labels
							lowerCamelCase			      =					num_choices
							lowerCamelCase			      =					scope
							lowerCamelCase			      =					initializer_std

							# Used in the tests to check the size of the first attention layer
							lowerCamelCase			      =					n_head
							# Used in the tests to check the size of the first hidden state
							lowerCamelCase			      =					self.d_model
							# Used in the tests to check the number of output hidden states/attentions
							lowerCamelCase			      =					sum(self.block_sizes ) + (0 if base else self.num_decoder_layers)
							# FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
							# the last hidden state of the first block (which is the first hidden state of the decoder).
							if not base:
										lowerCamelCase			      =					self.num_hidden_layers + 2





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					ids_tensor([self.batch_size, self.seq_length]		, self.vocab_size )

							lowerCamelCase			      =					None
							if self.use_input_mask:
										lowerCamelCase			      =					random_attention_mask([self.batch_size, self.seq_length] )

							lowerCamelCase			      =					None
							if self.use_token_type_ids:
										lowerCamelCase			      =					ids_tensor([self.batch_size, self.seq_length]		, self.type_vocab_size )

							lowerCamelCase			      =					None
							lowerCamelCase			      =					None
							lowerCamelCase			      =					None
							if self.use_labels:
										lowerCamelCase			      =					ids_tensor([self.batch_size]		, self.type_sequence_label_size )
										lowerCamelCase			      =					ids_tensor([self.batch_size, self.seq_length]		, self.num_labels )
										lowerCamelCase			      =					ids_tensor([self.batch_size]		, self.num_choices )

							lowerCamelCase			      =					FunnelConfig(
							    vocab_size=self.vocab_size		, block_sizes=self.block_sizes		, num_decoder_layers=self.num_decoder_layers		, d_model=self.d_model		, n_head=self.n_head		, d_head=self.d_head		, d_inner=self.d_inner		, hidden_act=self.hidden_act		, hidden_dropout=self.hidden_dropout		, attention_dropout=self.attention_dropout		, activation_dropout=self.activation_dropout		, max_position_embeddings=self.max_position_embeddings		, type_vocab_size=self.type_vocab_size		, initializer_std=self.initializer_std		, )

							return (
							    config,
							    input_ids,
							    token_type_ids,
							    input_mask,
							    sequence_labels,
							    token_labels,
							    choice_labels,
							)





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





							"""simple docstring"""
							lowerCamelCase			      =					TFFunnelModel(config=_a )
							lowerCamelCase			      =					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase			      =					model(_a )

							lowerCamelCase			      =					[input_ids, input_mask]
							lowerCamelCase			      =					model(_a )

							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.last_hidden_state.shape		, (self.batch_size, self.seq_length, self.d_model) )

							lowerCamelCase			      =					False
							lowerCamelCase			      =					TFFunnelModel(config=_a )
							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.last_hidden_state.shape		, (self.batch_size, self.seq_length, self.d_model) )

							lowerCamelCase			      =					False
							lowerCamelCase			      =					TFFunnelModel(config=_a )
							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.last_hidden_state.shape		, (self.batch_size, self.seq_length, self.d_model) )





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





							"""simple docstring"""
							lowerCamelCase			      =					TFFunnelBaseModel(config=_a )
							lowerCamelCase			      =					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase			      =					model(_a )

							lowerCamelCase			      =					[input_ids, input_mask]
							lowerCamelCase			      =					model(_a )

							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.last_hidden_state.shape		, (self.batch_size, 2, self.d_model) )

							lowerCamelCase			      =					False
							lowerCamelCase			      =					TFFunnelBaseModel(config=_a )
							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.last_hidden_state.shape		, (self.batch_size, 3, self.d_model) )

							lowerCamelCase			      =					False
							lowerCamelCase			      =					TFFunnelBaseModel(config=_a )
							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.last_hidden_state.shape		, (self.batch_size, 2, self.d_model) )





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





							"""simple docstring"""
							lowerCamelCase			      =					TFFunnelForPreTraining(config=_a )
							lowerCamelCase			      =					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length) )





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





							"""simple docstring"""
							lowerCamelCase			      =					TFFunnelForMaskedLM(config=_a )
							lowerCamelCase			      =					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length, self.vocab_size) )





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





							"""simple docstring"""
							lowerCamelCase			      =					self.num_labels
							lowerCamelCase			      =					TFFunnelForSequenceClassification(config=_a )
							lowerCamelCase			      =					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.num_labels) )





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





							"""simple docstring"""
							lowerCamelCase			      =					self.num_choices
							lowerCamelCase			      =					TFFunnelForMultipleChoice(config=_a )
							lowerCamelCase			      =					tf.tile(tf.expand_dims(_a		, 1 )		, (1, self.num_choices, 1) )
							lowerCamelCase			      =					tf.tile(tf.expand_dims(_a		, 1 )		, (1, self.num_choices, 1) )
							lowerCamelCase			      =					tf.tile(tf.expand_dims(_a		, 1 )		, (1, self.num_choices, 1) )
							lowerCamelCase			      =					{
							    """input_ids""": multiple_choice_inputs_ids,
							    """attention_mask""": multiple_choice_input_mask,
							    """token_type_ids""": multiple_choice_token_type_ids,
							}
							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.num_choices) )





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





							"""simple docstring"""
							lowerCamelCase			      =					self.num_labels
							lowerCamelCase			      =					TFFunnelForTokenClassification(config=_a )
							lowerCamelCase			      =					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length, self.num_labels) )





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





							"""simple docstring"""
							lowerCamelCase			      =					TFFunnelForQuestionAnswering(config=_a )
							lowerCamelCase			      =					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase			      =					model(_a )
							self.parent.assertEqual(result.start_logits.shape		, (self.batch_size, self.seq_length) )
							self.parent.assertEqual(result.end_logits.shape		, (self.batch_size, self.seq_length) )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.prepare_config_and_inputs()
							(
							    (
							    lowerCamelCase
							)      ,   (
							    lowerCamelCase
							)      ,   (
							    lowerCamelCase
							)      ,   (
							    lowerCamelCase
							)      ,   (
							    lowerCamelCase
							)      ,   (
							    lowerCamelCase
							)      ,   (
							    lowerCamelCase
							)      ,   
							)			      =					config_and_inputs
							lowerCamelCase			      =					{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
							return config, inputs_dict






@require_tf
class     __magic_name__							(       UpperCAmelCase__						,					UpperCAmelCase__						,					unittest.TestCase				):






				'''simple docstring'''
				__UpperCamelCase			  =						(
				    (
				        TFFunnelModel,
				        TFFunnelForMaskedLM,
				        TFFunnelForPreTraining,
				        TFFunnelForQuestionAnswering,
				        TFFunnelForTokenClassification,
				    )
				    if is_tf_available()
				    else ()
				)
				__UpperCamelCase			  =						(
				    {
				        "feature-extraction": (TFFunnelBaseModel, TFFunnelModel),
				        "fill-mask": TFFunnelForMaskedLM,
				        "question-answering": TFFunnelForQuestionAnswering,
				        "text-classification": TFFunnelForSequenceClassification,
				        "token-classification": TFFunnelForTokenClassification,
				        "zero-shot": TFFunnelForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				__UpperCamelCase			  =						False
				__UpperCamelCase			  =						False





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					TFFunnelModelTester(self )
							lowerCamelCase			      =					ConfigTester(self		, config_class=_a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							self.config_tester.run_common_tests()





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_pretraining(*_a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*_a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*_a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*_a )






@require_tf
class     __magic_name__							(       UpperCAmelCase__						,					unittest.TestCase				):






				'''simple docstring'''
				__UpperCamelCase			  =						(
				    (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
				)
				__UpperCamelCase			  =						False
				__UpperCamelCase			  =						False





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					TFFunnelModelTester(self		, base=_a )
							lowerCamelCase			      =					ConfigTester(self		, config_class=_a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							self.config_tester.run_common_tests()





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_base_model(*_a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*_a )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*_a )









"""simple docstring"""




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

import numpy as np

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


if is_torch_available():
					import torch


lowerCAmelCase							:			int     							=							logging.get_logger(__name__)






class     __magic_name__							(       UpperCAmelCase__				):






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





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





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





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





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





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





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





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





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





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





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





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





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

							lowerCamelCase			      =					make_list_of_images(_a )

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

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

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

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

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

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

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

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

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

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

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

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





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





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

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

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

										lowerCamelCase			      =					[]

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

							return semantic_segmentation



