


import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import (
						    LiltForQuestionAnswering,
						    LiltForSequenceClassification,
						    LiltForTokenClassification,
						    LiltModel,
						)
						from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST







class        lowerCamelCase__	:






			"""simple docstring"""






			def __init__(							self      ,						snake_case      ,						snake_case=13      ,						snake_case=7      ,						snake_case=True      ,						snake_case=True      ,						snake_case=True      ,						snake_case=True      ,						snake_case=99      ,						snake_case=24      ,						snake_case=2      ,						snake_case=6      ,						snake_case=37      ,						snake_case="gelu"      ,						snake_case=0.1      ,						snake_case=0.1      ,						snake_case=512      ,						snake_case=16      ,						snake_case=2      ,						snake_case=0.02      ,						snake_case=3      ,						snake_case=None      ,						snake_case=1000      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       parent
						UpperCamelCase__					=       batch_size
						UpperCamelCase__					=       seq_length
						UpperCamelCase__					=       is_training
						UpperCamelCase__					=       use_input_mask
						UpperCamelCase__					=       use_token_type_ids
						UpperCamelCase__					=       use_labels
						UpperCamelCase__					=       vocab_size
						UpperCamelCase__					=       hidden_size
						UpperCamelCase__					=       num_hidden_layers
						UpperCamelCase__					=       num_attention_heads
						UpperCamelCase__					=       intermediate_size
						UpperCamelCase__					=       hidden_act
						UpperCamelCase__					=       hidden_dropout_prob
						UpperCamelCase__					=       attention_probs_dropout_prob
						UpperCamelCase__					=       max_position_embeddings
						UpperCamelCase__					=       type_vocab_size
						UpperCamelCase__					=       type_sequence_label_size
						UpperCamelCase__					=       initializer_range
						UpperCamelCase__					=       num_labels
						UpperCamelCase__					=       scope
						UpperCamelCase__					=       range_bbox




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       ids_tensor([self.batch_size, self.seq_length]      ,						self.vocab_size     )

						UpperCamelCase__					=       ids_tensor([self.batch_size, self.seq_length, 4]      ,						self.range_bbox     )
						# Ensure that bbox is legal
						for i in range(bbox.shape[0]     ):
									for j in range(bbox.shape[1]     ):
												if bbox[i, j, 3] < bbox[i, j, 1]:
															UpperCamelCase__					=       bbox[i, j, 3]
															UpperCamelCase__					=       bbox[i, j, 1]
															UpperCamelCase__					=       t
												if bbox[i, j, 2] < bbox[i, j, 0]:
															UpperCamelCase__					=       bbox[i, j, 2]
															UpperCamelCase__					=       bbox[i, j, 0]
															UpperCamelCase__					=       t

						UpperCamelCase__					=       None
						if self.use_input_mask:
									UpperCamelCase__					=       ids_tensor([self.batch_size, self.seq_length]      ,						vocab_size=2     )

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

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

						UpperCamelCase__					=       self.get_config()

						return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return LiltConfig(
						    vocab_size=self.vocab_size      ,						hidden_size=self.hidden_size      ,						num_hidden_layers=self.num_hidden_layers      ,						num_attention_heads=self.num_attention_heads      ,						intermediate_size=self.intermediate_size      ,						hidden_act=self.hidden_act      ,						hidden_dropout_prob=self.hidden_dropout_prob      ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,						max_position_embeddings=self.max_position_embeddings      ,						type_vocab_size=self.type_vocab_size      ,						initializer_range=self.initializer_range      ,						)




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       LiltModel(config=snake_case     )
						model.to(snake_case     )
						model.eval()
						UpperCamelCase__					=       model(snake_case      ,						bbox=snake_case      ,						attention_mask=snake_case      ,						token_type_ids=snake_case     )
						UpperCamelCase__					=       model(snake_case      ,						bbox=snake_case      ,						token_type_ids=snake_case     )
						UpperCamelCase__					=       model(snake_case      ,						bbox=snake_case     )

						self.parent.assertEqual(result.last_hidden_state.shape      ,						(self.batch_size, self.seq_length, self.hidden_size)     )
						self.parent.assertEqual(result.pooler_output.shape      ,						(self.batch_size, self.hidden_size)     )




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       self.num_labels
						UpperCamelCase__					=       LiltForTokenClassification(config=snake_case     )
						model.to(snake_case     )
						model.eval()
						UpperCamelCase__					=       model(
						    snake_case      ,						bbox=snake_case      ,						attention_mask=snake_case      ,						token_type_ids=snake_case      ,						labels=snake_case     )
						self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.seq_length, self.num_labels)     )




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       LiltForQuestionAnswering(config=snake_case     )
						model.to(snake_case     )
						model.eval()
						UpperCamelCase__					=       model(
						    snake_case      ,						bbox=snake_case      ,						attention_mask=snake_case      ,						token_type_ids=snake_case      ,						start_positions=snake_case      ,						end_positions=snake_case      ,						)
						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 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.prepare_config_and_inputs()
						(
						    (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      (
						    UpperCamelCase__
						),      
						)					=       config_and_inputs
						UpperCamelCase__					=       {
						    "input_ids": input_ids,
						    "bbox": bbox,
						    "token_type_ids": token_type_ids,
						    "attention_mask": input_mask,
						}
						return config, inputs_dict







@require_torch
class        lowerCamelCase__	(							UpperCAmelCase					,	UpperCAmelCase					,	UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Dict    =		(
			    (
			        LiltModel,
			        LiltForSequenceClassification,
			        LiltForTokenClassification,
			        LiltForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			_UpperCamelCase		:					str    =		(
			    {
			        'feature-extraction': LiltModel,
			        'question-answering': LiltForQuestionAnswering,
			        'text-classification': LiltForSequenceClassification,
			        'token-classification': LiltForTokenClassification,
			        'zero-shot': LiltForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			_UpperCamelCase		:					List[Any]    =		False
			_UpperCamelCase		:					List[str]    =		False




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						return True




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       LiltModelTester(self     )
						UpperCamelCase__					=       ConfigTester(self      ,						config_class=snake_case      ,						hidden_size=37     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						self.config_tester.run_common_tests()




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						for type in ["absolute", "relative_key", "relative_key_query"]:
									UpperCamelCase__					=       type
									self.model_tester.create_and_check_model(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*snake_case     )







			@slow
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									UpperCamelCase__					=       LiltModel.from_pretrained(snake_case     )
									self.assertIsNotNone(snake_case     )







@require_torch
@slow
class        lowerCamelCase__	(							unittest.TestCase      ):






			"""simple docstring"""






			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       LiltModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base"     ).to(snake_case     )

						UpperCamelCase__					=       torch.tensor([[1, 2]]      ,						device=snake_case     )
						UpperCamelCase__					=       torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]      ,						device=snake_case     )

						# forward pass
						with torch.no_grad():
									UpperCamelCase__					=       model(input_ids=snake_case      ,						bbox=snake_case     )

						UpperCamelCase__					=       torch.Size([1, 2, 768]     )
						UpperCamelCase__					=       torch.tensor(
						    [[-0.0653, 0.0950, -0.0061], [-0.0545, 0.0926, -0.0324]]      ,						device=snake_case      ,						)

						self.assertTrue(outputs.last_hidden_state.shape      ,						snake_case     )
						self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3]      ,						snake_case      ,						atol=1E-3     )     )






import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

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

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
						from transformers import WhisperFeatureExtractor

if is_torch_available():
						import torch

__UpperCamelCase    		=       random.Random()
def        UpperCamelCase_(				_A   :Tuple				,     _A   :str=1.0				,     _A   :int=None				,     _A   :Dict=None  )->		str:
			if rng is None:
						UpperCamelCase__					=       global_rng

			UpperCamelCase__					=       []
			for batch_idx in range(shape[0]  ):
						values.append([]  )
						for _ in range(shape[1]  ):
									values[-1].append(rng.random() * scale  )

			return values







@require_torch
@require_torchaudio
class        lowerCamelCase__	(							unittest.TestCase      ):






			"""simple docstring"""






			def __init__(							self      ,						snake_case      ,						snake_case=7      ,						snake_case=400      ,						snake_case=2000      ,						snake_case=10      ,						snake_case=160      ,						snake_case=8      ,						snake_case=0.0      ,						snake_case=4000      ,						snake_case=False      ,						snake_case=True      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       parent
						UpperCamelCase__					=       batch_size
						UpperCamelCase__					=       min_seq_length
						UpperCamelCase__					=       max_seq_length
						UpperCamelCase__					=       (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
						UpperCamelCase__					=       padding_value
						UpperCamelCase__					=       sampling_rate
						UpperCamelCase__					=       return_attention_mask
						UpperCamelCase__					=       do_normalize
						UpperCamelCase__					=       feature_size
						UpperCamelCase__					=       chunk_length
						UpperCamelCase__					=       hop_length




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						return {
						    "feature_size": self.feature_size,
						    "hop_length": self.hop_length,
						    "chunk_length": self.chunk_length,
						    "padding_value": self.padding_value,
						    "sampling_rate": self.sampling_rate,
						    "return_attention_mask": self.return_attention_mask,
						    "do_normalize": self.do_normalize,
						}







			def 				snake_case__				(							self      ,						snake_case=False      ,						snake_case=False     ):

						'''simple docstring'''


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

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







@require_torch
@require_torchaudio
class        lowerCamelCase__	(							UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Any    =		WhisperFeatureExtractor if is_speech_available() else None




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       WhisperFeatureExtractionTester(self     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.feature_extraction_class(**self.feat_extract_dict     )

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

						UpperCamelCase__					=       feat_extract_first.to_dict()
						UpperCamelCase__					=       feat_extract_second.to_dict()
						UpperCamelCase__					=       feat_extract_first.mel_filters
						UpperCamelCase__					=       feat_extract_second.mel_filters
						self.assertTrue(np.allclose(snake_case      ,						snake_case     )     )
						self.assertEqual(snake_case      ,						snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.feature_extraction_class(**self.feat_extract_dict     )

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

						UpperCamelCase__					=       feat_extract_first.to_dict()
						UpperCamelCase__					=       feat_extract_second.to_dict()
						UpperCamelCase__					=       feat_extract_first.mel_filters
						UpperCamelCase__					=       feat_extract_second.mel_filters
						self.assertTrue(np.allclose(snake_case      ,						snake_case     )     )
						self.assertEqual(snake_case      ,						snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
						# create three inputs of length 800, 1000, and 1200
						UpperCamelCase__					=       [floats_list((1, x)     )[0] for x in range(800      ,						1400      ,						200     )]
						UpperCamelCase__					=       [np.asarray(snake_case     ) for speech_input in speech_inputs]

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

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

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

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

						# Test truncation required
						UpperCamelCase__					=       [floats_list((1, x)     )[0] for x in range(200      ,						(feature_extractor.n_samples + 500)      ,						200     )]
						UpperCamelCase__					=       [np.asarray(snake_case     ) for speech_input in speech_inputs]

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

						UpperCamelCase__					=       feature_extractor(snake_case      ,						return_tensors="np"     ).input_features
						UpperCamelCase__					=       feature_extractor(snake_case      ,						return_tensors="np"     ).input_features
						for enc_seq_a, enc_seq_a in zip(snake_case      ,						snake_case     ):
									self.assertTrue(np.allclose(snake_case      ,						snake_case      ,						atol=1E-3     )     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						import torch

						UpperCamelCase__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
						UpperCamelCase__					=       np.random.rand(100      ,						32     ).astype(np.floataa     )
						UpperCamelCase__					=       np_speech_inputs.tolist()

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




			def 				snake_case__				(							self      ,						snake_case     ):

						'''simple docstring'''


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

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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       torch.tensor(
						    [
						        0.1193, -0.0946, -0.1098, -0.0196, 0.0225, -0.0690, -0.1736, 0.0951,
						        0.0971, -0.0817, -0.0702, 0.0162, 0.0260, 0.0017, -0.0192, -0.1678,
						        0.0709, -0.1867, -0.0655, -0.0274, -0.0234, -0.1884, -0.0516, -0.0554,
						        -0.0274, -0.1425, -0.1423, 0.0837, 0.0377, -0.0854
						    ]     )
						# fmt: on

						UpperCamelCase__					=       self._load_datasamples(1     )
						UpperCamelCase__					=       WhisperFeatureExtractor()
						UpperCamelCase__					=       feature_extractor(snake_case      ,						return_tensors="pt"     ).input_features
						self.assertEqual(input_features.shape      ,						(1, 80, 3000)     )
						self.assertTrue(torch.allclose(input_features[0, 0, :30]      ,						snake_case      ,						atol=1E-4     )     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
						UpperCamelCase__					=       self._load_datasamples(1     )[0]
						UpperCamelCase__					=       ((audio - audio.min()) / (audio.max() - audio.min())) * 65535  # Rescale to [0, 65535] to show issue
						UpperCamelCase__					=       feat_extract.zero_mean_unit_var_norm([audio]      ,						attention_mask=snake_case     )[0]

						self.assertTrue(np.all(np.mean(snake_case     ) < 1E-3     )     )
						self.assertTrue(np.all(np.abs(np.var(snake_case     ) - 1     ) < 1E-3     )     )


