




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       a__   :






						def __init__(       self		,      _A		,      _A=1_3		,      _A=7		,      _A=True		,      _A=True		,      _A=True		,      _A=True		,      _A=9_9		,      _A=2_4		,      _A=2		,      _A=6		,      _A=3_7		,      _A="gelu"		,      _A=0.1		,      _A=0.1		,      _A=5_1_2		,      _A=1_6		,      _A=2		,      _A=0.02		,      _A=3		,      _A=None		,      _A=1_0_0_0		,      ):




											"""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           =	hidden_size
											__lowerCAmelCase           =	num_hidden_layers
											__lowerCAmelCase           =	num_attention_heads
											__lowerCAmelCase           =	intermediate_size
											__lowerCAmelCase           =	hidden_act
											__lowerCAmelCase           =	hidden_dropout_prob
											__lowerCAmelCase           =	attention_probs_dropout_prob
											__lowerCAmelCase           =	max_position_embeddings
											__lowerCAmelCase           =	type_vocab_size
											__lowerCAmelCase           =	type_sequence_label_size
											__lowerCAmelCase           =	initializer_range
											__lowerCAmelCase           =	num_labels
											__lowerCAmelCase           =	scope
											__lowerCAmelCase           =	range_bbox






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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

											__lowerCAmelCase           =	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]:
																										__lowerCAmelCase           =	bbox[i, j, 3]
																										__lowerCAmelCase           =	bbox[i, j, 1]
																										__lowerCAmelCase           =	t
																					if bbox[i, j, 2] < bbox[i, j, 0]:
																										__lowerCAmelCase           =	bbox[i, j, 2]
																										__lowerCAmelCase           =	bbox[i, j, 0]
																										__lowerCAmelCase           =	t

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

											__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
											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           =	self.get_config()

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






						def     __SCREAMING_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     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      ):




											"""simple docstring"""



											__lowerCAmelCase           =	LiltModel(config=_A      )
											model.to(_A      )
											model.eval()
											__lowerCAmelCase           =	model(_A		,      bbox=_A		,      attention_mask=_A		,      token_type_ids=_A      )
											__lowerCAmelCase           =	model(_A		,      bbox=_A		,      token_type_ids=_A      )
											__lowerCAmelCase           =	model(_A		,      bbox=_A      )

											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     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      ):




											"""simple docstring"""



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






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      ):




											"""simple docstring"""



											__lowerCAmelCase           =	LiltForQuestionAnswering(config=_A      )
											model.to(_A      )
											model.eval()
											__lowerCAmelCase           =	model(
											    _A		,      bbox=_A		,      attention_mask=_A		,      token_type_ids=_A		,      start_positions=_A		,      end_positions=_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     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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






@require_torch
class       a__   ( snake_case__			,    snake_case__			,    snake_case__			,    unittest.TestCase				):
						_a							:   List[str] =   (
						    (
						        LiltModel,
						        LiltForSequenceClassification,
						        LiltForTokenClassification,
						        LiltForQuestionAnswering,
						    )
						    if is_torch_available()
						    else ()
						)
						_a							:   Optional[int] =   (
						    {
						        """feature-extraction""": LiltModel,
						        """question-answering""": LiltForQuestionAnswering,
						        """text-classification""": LiltForSequenceClassification,
						        """token-classification""": LiltForTokenClassification,
						        """zero-shot""": LiltForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)
						_a							:   Optional[Any] =   False
						_a							:   str =   False






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A		,      _A      ):




											"""simple docstring"""



											return True






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	LiltModelTester(self      )
											__lowerCAmelCase           =	ConfigTester(self		,      config_class=_A		,      hidden_size=3_7      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											self.config_tester.run_common_tests()






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*_A      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*_A      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*_A      )






						@slow
						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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






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






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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

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

											# forward pass
											with torch.no_grad():
																__lowerCAmelCase           =	model(input_ids=_A		,      bbox=_A      )

											__lowerCAmelCase           =	torch.Size([1, 2, 7_6_8]      )
											__lowerCAmelCase           =	torch.tensor(
											    [[-0.06_53, 0.09_50, -0.00_61], [-0.05_45, 0.09_26, -0.03_24]]		,      device=_A		,      )

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










from __future__ import annotations







def      _a				(						SCREAMING_SNAKE_CASE_							:    float				,				SCREAMING_SNAKE_CASE_							:    float				,				SCREAMING_SNAKE_CASE_							:    float				,				):
					if (electron_conc, hole_conc, intrinsic_conc).count(0					) != 1:
										raise ValueError("You cannot supply more or less than 2 values"					)
					elif electron_conc < 0:
										raise ValueError("Electron concentration cannot be negative in a semiconductor"					)
					elif hole_conc < 0:
										raise ValueError("Hole concentration cannot be negative in a semiconductor"					)
					elif intrinsic_conc < 0:
										raise ValueError(
										    "Intrinsic concentration cannot be negative in a semiconductor"					)
					elif electron_conc == 0:
										return (
										    "electron_conc",
										    intrinsic_conc**2 / hole_conc,
										)
					elif hole_conc == 0:
										return (
										    "hole_conc",
										    intrinsic_conc**2 / electron_conc,
										)
					elif intrinsic_conc == 0:
										return (
										    "intrinsic_conc",
										    (electron_conc * hole_conc) ** 0.5,
										)
					else:
										return (-1, -1)


if __name__ == "__main__":
					import doctest

					doctest.testmod()




