'''simple docstring'''

def      __UpperCamelCase			(  UpperCAmelCase	):
 lowercase__							:       List[Any]										=   len(UpperCamelCase__	)
 lowercase__							:       List[str]										=   sum(UpperCamelCase__	)

 lowercase__							:       Optional[Any]										=   [[False for x in range(s + 1	)] for y in range(n + 1	)]

 for i in range(1						,	n + 1	):
  lowercase__							:       Dict										=   True

 for i in range(1						,	s + 1	):
  lowercase__							:       List[str]										=   False

 for i in range(1						,	n + 1	):
  for j in range(1						,	s + 1	):
   lowercase__							:       List[Any]										=   dp[i][j - 1]

   if arr[i - 1] <= j:
    lowercase__							:       List[str]										=   dp[i][j] or dp[i - 1][j - arr[i - 1]]

 for j in range(int(s / 2	)						,	-1						,	-1	):
  if dp[n][j] is True:
   lowercase__							:       Any										=   s - 2 * j
   break

 return diff








import os
import tempfile
import unittest

from transformers import FlaubertConfig, is_torch_available
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    FlaubertForMultipleChoice,
	    FlaubertForQuestionAnswering,
	    FlaubertForQuestionAnsweringSimple,
	    FlaubertForSequenceClassification,
	    FlaubertForTokenClassification,
	    FlaubertModel,
	    FlaubertWithLMHeadModel,
	)
	from transformers.models.flaubert.modeling_flaubert import FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST




class 	UpperCamelCase_							(  UpperCamelCase__     ):


							def __init__(				self     :Union[str, Any]				,					__A     :Optional[int]				,					__A     :Tuple=13				,					__A     :Dict=7				,					__A     :Dict=True				,					__A     :str=True				,					__A     :Optional[Any]=True				,					__A     :Optional[Any]=True				,					__A     :Optional[Any]=True				,					__A     :Any=False				,					__A     :Dict=False				,					__A     :Any=False				,					__A     :Tuple=2				,					__A     :Dict=99				,					__A     :Optional[Any]=0				,					__A     :List[str]=32				,					__A     :Optional[int]=5				,					__A     :Dict=4				,					__A     :List[str]=0.1				,					__A     :Union[str, Any]=0.1				,					__A     :Tuple=512				,					__A     :Any=12				,					__A     :Optional[int]=2				,					__A     :Union[str, Any]=0.0_2				,					__A     :Dict=3				,					__A     :Optional[int]=4				,					__A     :Any="last"				,					__A     :List[Any]=None				,					__A     :Any=None				,					) -> str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   parent
									SCREAMING_SNAKE_CASE__								=   batch_size
									SCREAMING_SNAKE_CASE__								=   seq_length
									SCREAMING_SNAKE_CASE__								=   is_training
									SCREAMING_SNAKE_CASE__								=   use_input_lengths
									SCREAMING_SNAKE_CASE__								=   use_token_type_ids
									SCREAMING_SNAKE_CASE__								=   use_labels
									SCREAMING_SNAKE_CASE__								=   gelu_activation
									SCREAMING_SNAKE_CASE__								=   sinusoidal_embeddings
									SCREAMING_SNAKE_CASE__								=   causal
									SCREAMING_SNAKE_CASE__								=   asm
									SCREAMING_SNAKE_CASE__								=   n_langs
									SCREAMING_SNAKE_CASE__								=   vocab_size
									SCREAMING_SNAKE_CASE__								=   n_special
									SCREAMING_SNAKE_CASE__								=   hidden_size
									SCREAMING_SNAKE_CASE__								=   num_hidden_layers
									SCREAMING_SNAKE_CASE__								=   num_attention_heads
									SCREAMING_SNAKE_CASE__								=   hidden_dropout_prob
									SCREAMING_SNAKE_CASE__								=   attention_probs_dropout_prob
									SCREAMING_SNAKE_CASE__								=   max_position_embeddings
									SCREAMING_SNAKE_CASE__								=   type_vocab_size
									SCREAMING_SNAKE_CASE__								=   type_sequence_label_size
									SCREAMING_SNAKE_CASE__								=   initializer_range
									SCREAMING_SNAKE_CASE__								=   num_labels
									SCREAMING_SNAKE_CASE__								=   num_choices
									SCREAMING_SNAKE_CASE__								=   summary_type
									SCREAMING_SNAKE_CASE__								=   use_proj
									SCREAMING_SNAKE_CASE__								=   scope


							def   _snake_case	(				self     :Optional[Any]		) -> List[str]:



									"""simple docstring"""



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

									SCREAMING_SNAKE_CASE__								=   None
									if self.use_input_lengths:
											SCREAMING_SNAKE_CASE__								=   (
											    ids_tensor([self.batch_size]				,					vocab_size=2		) + self.seq_length - 2
											)  # small variation of seq_length

									SCREAMING_SNAKE_CASE__								=   None
									if self.use_token_type_ids:
											SCREAMING_SNAKE_CASE__								=   ids_tensor([self.batch_size, self.seq_length]				,					self.n_langs		)

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

									SCREAMING_SNAKE_CASE__								=   self.get_config()

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


							def   _snake_case	(				self     :List[str]		) -> Optional[int]:



									"""simple docstring"""



									return FlaubertConfig(
									    vocab_size=self.vocab_size				,					n_special=self.n_special				,					emb_dim=self.hidden_size				,					n_layers=self.num_hidden_layers				,					n_heads=self.num_attention_heads				,					dropout=self.hidden_dropout_prob				,					attention_dropout=self.attention_probs_dropout_prob				,					gelu_activation=self.gelu_activation				,					sinusoidal_embeddings=self.sinusoidal_embeddings				,					asm=self.asm				,					causal=self.causal				,					n_langs=self.n_langs				,					max_position_embeddings=self.max_position_embeddings				,					initializer_range=self.initializer_range				,					summary_type=self.summary_type				,					use_proj=self.use_proj				,					)


							def   _snake_case	(				self     :Tuple				,					__A     :str				,					__A     :int				,					__A     :Optional[int]				,					__A     :Any				,					__A     :Union[str, Any]				,					__A     :Optional[int]				,					__A     :Union[str, Any]				,					__A     :Union[str, Any]				,					__A     :str				,					) -> List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   FlaubertModel(config=__A		)
									model.to(__A		)
									model.eval()
									SCREAMING_SNAKE_CASE__								=   model(__A				,					lengths=__A				,					langs=__A		)
									SCREAMING_SNAKE_CASE__								=   model(__A				,					langs=__A		)
									SCREAMING_SNAKE_CASE__								=   model(__A		)
									self.parent.assertEqual(result.last_hidden_state.shape				,					(self.batch_size, self.seq_length, self.hidden_size)		)


							def   _snake_case	(				self     :str				,					__A     :Any				,					__A     :str				,					__A     :Union[str, Any]				,					__A     :Optional[Any]				,					__A     :Optional[int]				,					__A     :Any				,					__A     :Union[str, Any]				,					__A     :Optional[Any]				,					__A     :Union[str, Any]				,					) -> Dict:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   FlaubertWithLMHeadModel(__A		)
									model.to(__A		)
									model.eval()

									SCREAMING_SNAKE_CASE__								=   model(__A				,					token_type_ids=__A				,					labels=__A		)
									self.parent.assertEqual(result.loss.shape				,					()		)
									self.parent.assertEqual(result.logits.shape				,					(self.batch_size, self.seq_length, self.vocab_size)		)


							def   _snake_case	(				self     :Tuple				,					__A     :Union[str, Any]				,					__A     :Optional[Any]				,					__A     :Dict				,					__A     :Dict				,					__A     :Union[str, Any]				,					__A     :List[str]				,					__A     :Optional[int]				,					__A     :int				,					__A     :str				,					) -> int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   FlaubertForQuestionAnsweringSimple(__A		)
									model.to(__A		)
									model.eval()

									SCREAMING_SNAKE_CASE__								=   model(__A		)

									SCREAMING_SNAKE_CASE__								=   model(__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   _snake_case	(				self     :List[str]				,					__A     :Any				,					__A     :int				,					__A     :Tuple				,					__A     :Optional[Any]				,					__A     :Tuple				,					__A     :Optional[int]				,					__A     :str				,					__A     :int				,					__A     :str				,					) -> Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   FlaubertForQuestionAnswering(__A		)
									model.to(__A		)
									model.eval()

									SCREAMING_SNAKE_CASE__								=   model(__A		)

									SCREAMING_SNAKE_CASE__								=   model(
									    __A				,					start_positions=__A				,					end_positions=__A				,					cls_index=__A				,					is_impossible=__A				,					p_mask=__A				,					)

									SCREAMING_SNAKE_CASE__								=   model(
									    __A				,					start_positions=__A				,					end_positions=__A				,					cls_index=__A				,					is_impossible=__A				,					)

									((SCREAMING_SNAKE_CASE__)						,    )								=   result_with_labels.to_tuple()

									SCREAMING_SNAKE_CASE__								=   model(__A				,					start_positions=__A				,					end_positions=__A		)

									((SCREAMING_SNAKE_CASE__)						,    )								=   result_with_labels.to_tuple()

									self.parent.assertEqual(result_with_labels.loss.shape				,					()		)
									self.parent.assertEqual(result.start_top_log_probs.shape				,					(self.batch_size, model.config.start_n_top)		)
									self.parent.assertEqual(result.start_top_index.shape				,					(self.batch_size, model.config.start_n_top)		)
									self.parent.assertEqual(
									    result.end_top_log_probs.shape				,					(self.batch_size, model.config.start_n_top * model.config.end_n_top)		)
									self.parent.assertEqual(
									    result.end_top_index.shape				,					(self.batch_size, model.config.start_n_top * model.config.end_n_top)		)
									self.parent.assertEqual(result.cls_logits.shape				,					(self.batch_size,)		)


							def   _snake_case	(				self     :Optional[int]				,					__A     :str				,					__A     :Optional[int]				,					__A     :Tuple				,					__A     :Dict				,					__A     :List[str]				,					__A     :Tuple				,					__A     :List[str]				,					__A     :Dict				,					__A     :List[str]				,					) -> Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   FlaubertForSequenceClassification(__A		)
									model.to(__A		)
									model.eval()

									SCREAMING_SNAKE_CASE__								=   model(__A		)
									SCREAMING_SNAKE_CASE__								=   model(__A				,					labels=__A		)

									self.parent.assertEqual(result.loss.shape				,					()		)
									self.parent.assertEqual(result.logits.shape				,					(self.batch_size, self.type_sequence_label_size)		)


							def   _snake_case	(				self     :Optional[Any]				,					__A     :Optional[Any]				,					__A     :Optional[Any]				,					__A     :List[str]				,					__A     :Optional[Any]				,					__A     :int				,					__A     :Tuple				,					__A     :Optional[int]				,					__A     :Union[str, Any]				,					__A     :Dict				,					) -> Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.num_labels
									SCREAMING_SNAKE_CASE__								=   FlaubertForTokenClassification(__A		)
									model.to(__A		)
									model.eval()

									SCREAMING_SNAKE_CASE__								=   model(__A				,					attention_mask=__A				,					labels=__A		)
									self.parent.assertEqual(result.logits.shape				,					(self.batch_size, self.seq_length, self.num_labels)		)


							def   _snake_case	(				self     :str				,					__A     :Any				,					__A     :Tuple				,					__A     :List[str]				,					__A     :Tuple				,					__A     :Any				,					__A     :int				,					__A     :Dict				,					__A     :List[str]				,					__A     :Tuple				,					) -> Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.num_choices
									SCREAMING_SNAKE_CASE__								=   FlaubertForMultipleChoice(config=__A		)
									model.to(__A		)
									model.eval()
									SCREAMING_SNAKE_CASE__								=   input_ids.unsqueeze(1		).expand(-1				,					self.num_choices				,					-1		).contiguous()
									SCREAMING_SNAKE_CASE__								=   token_type_ids.unsqueeze(1		).expand(-1				,					self.num_choices				,					-1		).contiguous()
									SCREAMING_SNAKE_CASE__								=   input_mask.unsqueeze(1		).expand(-1				,					self.num_choices				,					-1		).contiguous()
									SCREAMING_SNAKE_CASE__								=   model(
									    __A				,					attention_mask=__A				,					token_type_ids=__A				,					labels=__A				,					)
									self.parent.assertEqual(result.logits.shape				,					(self.batch_size, self.num_choices)		)


							def   _snake_case	(				self     :Union[str, Any]		) -> Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.prepare_config_and_inputs()
									(
									    (
									    SCREAMING_SNAKE_CASE__
									)						,    (
									    SCREAMING_SNAKE_CASE__
									)						,    (
									    SCREAMING_SNAKE_CASE__
									)						,    (
									    SCREAMING_SNAKE_CASE__
									)						,    (
									    SCREAMING_SNAKE_CASE__
									)						,    (
									    SCREAMING_SNAKE_CASE__
									)						,    (
									    SCREAMING_SNAKE_CASE__
									)						,    (
									    SCREAMING_SNAKE_CASE__
									)						,    (
									    SCREAMING_SNAKE_CASE__
									)						,    
									)								=   config_and_inputs
									SCREAMING_SNAKE_CASE__								=   {
									    """input_ids""": input_ids,
									    """token_type_ids""": token_type_ids,
									    """lengths""": input_lengths,
									    """attention_mask""": input_mask,
									}
									return config, inputs_dict




@require_torch
class 	UpperCamelCase_							(  UpperCamelCase__					,	UpperCamelCase__					,	unittest.TestCase     ):
							lowerCamelCase_							     =       (
							    (
							        FlaubertModel,
							        FlaubertWithLMHeadModel,
							        FlaubertForQuestionAnswering,
							        FlaubertForQuestionAnsweringSimple,
							        FlaubertForSequenceClassification,
							        FlaubertForTokenClassification,
							        FlaubertForMultipleChoice,
							    )
							    if is_torch_available()
							    else ()
							)
							lowerCamelCase_							     =       (
							    {
							        "feature-extraction": FlaubertModel,
							        "fill-mask": FlaubertWithLMHeadModel,
							        "question-answering": FlaubertForQuestionAnsweringSimple,
							        "text-classification": FlaubertForSequenceClassification,
							        "token-classification": FlaubertForTokenClassification,
							        "zero-shot": FlaubertForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)


							def   _snake_case	(				self     :Any				,					__A     :Optional[int]				,					__A     :Optional[int]				,					__A     :Dict				,					__A     :List[Any]				,					__A     :Tuple		) -> str:



									"""simple docstring"""



									if (
									    pipeline_test_casse_name == "QAPipelineTests"
									    and tokenizer_name is not None
									    and not tokenizer_name.endswith("""Fast"""		)
									):
											# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
											# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
											# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
											return True

									return False


							def   _snake_case	(				self     :Tuple				,					__A     :List[str]				,					__A     :Optional[int]				,					__A     :Dict=False		) -> List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   super()._prepare_for_class(__A				,					__A				,					return_labels=__A		)

									if return_labels:
											if model_class.__name__ == "FlaubertForQuestionAnswering":
													SCREAMING_SNAKE_CASE__								=   torch.zeros(
													    self.model_tester.batch_size				,					dtype=torch.long				,					device=__A		)
													SCREAMING_SNAKE_CASE__								=   torch.zeros(
													    self.model_tester.batch_size				,					dtype=torch.long				,					device=__A		)

									return inputs_dict


							def   _snake_case	(				self     :str		) -> Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   FlaubertModelTester(self		)
									SCREAMING_SNAKE_CASE__								=   ConfigTester(self				,					config_class=__A				,					emb_dim=37		)


							def   _snake_case	(				self     :int		) -> int:



									"""simple docstring"""



									self.config_tester.run_common_tests()


							def   _snake_case	(				self     :Optional[Any]		) -> List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_model(*__A		)


							def   _snake_case	(				self     :Tuple		) -> List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_lm_head(*__A		)


							def   _snake_case	(				self     :str		) -> Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_simple_qa(*__A		)


							def   _snake_case	(				self     :Union[str, Any]		) -> Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_qa(*__A		)


							def   _snake_case	(				self     :str		) -> Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_sequence_classif(*__A		)


							def   _snake_case	(				self     :Any		) -> Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_token_classif(*__A		)


							def   _snake_case	(				self     :Any		) -> Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_flaubert_multiple_choice(*__A		)


							@slow
							def   _snake_case	(				self     :Union[str, Any]		) -> List[str]:



									"""simple docstring"""



									for model_name in FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE__								=   FlaubertModel.from_pretrained(__A		)
											self.assertIsNotNone(__A		)


							@slow
							@require_torch_gpu
							def   _snake_case	(				self     :Tuple		) -> List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__						,    SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs_for_common()
									for model_class in self.all_model_classes:
											# FlauBertForMultipleChoice behaves incorrectly in JIT environments.
											if model_class == FlaubertForMultipleChoice:
													return

											SCREAMING_SNAKE_CASE__								=   True
											SCREAMING_SNAKE_CASE__								=   model_class(config=__A		)

											SCREAMING_SNAKE_CASE__								=   self._prepare_for_class(__A				,					__A		)
											SCREAMING_SNAKE_CASE__								=   torch.jit.trace(
											    __A				,					(inputs_dict["""input_ids"""].to("""cpu"""		), inputs_dict["""attention_mask"""].to("""cpu"""		))		)

											with tempfile.TemporaryDirectory() as tmp:
													torch.jit.save(__A				,					os.path.join(__A				,					"""traced_model.pt"""		)		)
													SCREAMING_SNAKE_CASE__								=   torch.jit.load(os.path.join(__A				,					"""traced_model.pt"""		)				,					map_location=__A		)
													loaded(inputs_dict["""input_ids"""].to(__A		)				,					inputs_dict["""attention_mask"""].to(__A		)		)




@require_torch
class 	UpperCamelCase_							(  unittest.TestCase     ):


							@slow
							def   _snake_case	(				self     :Dict		) -> Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   FlaubertModel.from_pretrained("""flaubert/flaubert_base_cased"""		)
									SCREAMING_SNAKE_CASE__								=   torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]		)
									with torch.no_grad():
											SCREAMING_SNAKE_CASE__								=   model(__A		)[0]
									SCREAMING_SNAKE_CASE__								=   torch.Size((1, 11, 768)		)
									self.assertEqual(output.shape				,					__A		)
									SCREAMING_SNAKE_CASE__								=   torch.tensor(
									    [[[-2.6_2_5_1, -1.4_2_9_8, -0.0_2_2_7], [-2.8_5_1_0, -1.6_3_8_7, 0.2_2_5_8], [-2.8_1_1_4, -1.1_8_3_2, -0.3_0_6_6]]]		)

									self.assertTrue(torch.allclose(output[:, :3, :3]				,					__A				,					atol=1E-4		)		)