





import unittest

from transformers import XLMConfig, 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, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           XLMForMultipleChoice,
           XLMForQuestionAnswering,
           XLMForQuestionAnsweringSimple,
           XLMForSequenceClassification,
           XLMForTokenClassification,
           XLMModel,
           XLMWithLMHeadModel,
       )
       from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST





class 			lowerCAmelCase__:






       '''simple docstring'''


       def __init__(      self    ,						__lowerCamelCase    ,						__lowerCamelCase=1_3    ,						__lowerCamelCase=7    ,						__lowerCamelCase=True    ,						__lowerCamelCase=True    ,						__lowerCamelCase=True    ,						__lowerCamelCase=True    ,						__lowerCamelCase=True    ,						__lowerCamelCase=False    ,						__lowerCamelCase=False    ,						__lowerCamelCase=False    ,						__lowerCamelCase=2    ,						__lowerCamelCase=9_9    ,						__lowerCamelCase=0    ,						__lowerCamelCase=3_2    ,						__lowerCamelCase=5    ,						__lowerCamelCase=4    ,						__lowerCamelCase=0.1    ,						__lowerCamelCase=0.1    ,						__lowerCamelCase=5_1_2    ,						__lowerCamelCase=2    ,						__lowerCamelCase=0.02    ,						__lowerCamelCase=2    ,						__lowerCamelCase=4    ,						__lowerCamelCase="last"    ,						__lowerCamelCase=True    ,						__lowerCamelCase=None    ,						__lowerCamelCase=0    ,						)			->     List[str]:
            _SCREAMING_SNAKE_CASE       :	int						    =							parent
            _SCREAMING_SNAKE_CASE       :	Dict						    =							batch_size
            _SCREAMING_SNAKE_CASE       :	Dict						    =							seq_length
            _SCREAMING_SNAKE_CASE       :	Dict						    =							is_training
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							use_input_lengths
            _SCREAMING_SNAKE_CASE       :	str						    =							use_token_type_ids
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							use_labels
            _SCREAMING_SNAKE_CASE       :	Any						    =							gelu_activation
            _SCREAMING_SNAKE_CASE       :	int						    =							sinusoidal_embeddings
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							causal
            _SCREAMING_SNAKE_CASE       :	str						    =							asm
            _SCREAMING_SNAKE_CASE       :	Dict						    =							n_langs
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							vocab_size
            _SCREAMING_SNAKE_CASE       :	Dict						    =							n_special
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							hidden_size
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							num_hidden_layers
            _SCREAMING_SNAKE_CASE       :	Dict						    =							num_attention_heads
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							hidden_dropout_prob
            _SCREAMING_SNAKE_CASE       :	int						    =							attention_probs_dropout_prob
            _SCREAMING_SNAKE_CASE       :	int						    =							max_position_embeddings
            _SCREAMING_SNAKE_CASE       :	Dict						    =							type_sequence_label_size
            _SCREAMING_SNAKE_CASE       :	Any						    =							initializer_range
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							num_labels
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							num_choices
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							summary_type
            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							use_proj
            _SCREAMING_SNAKE_CASE       :	Dict						    =							scope
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							bos_token_id




       def     UpperCamelCase_			(      self							)			->     Tuple:
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							ids_tensor([self.batch_size, self.seq_length]    ,						self.vocab_size							)
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							random_attention_mask([self.batch_size, self.seq_length]							)

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

            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							None
            if self.use_token_type_ids:
                 _SCREAMING_SNAKE_CASE       :	List[Any]						    =							ids_tensor([self.batch_size, self.seq_length]    ,						self.n_langs							)

            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							None
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							None
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							None
            if self.use_labels:
                 _SCREAMING_SNAKE_CASE       :	List[Any]						    =							ids_tensor([self.batch_size]    ,						self.type_sequence_label_size							)
                 _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							ids_tensor([self.batch_size, self.seq_length]    ,						self.num_labels							)
                 _SCREAMING_SNAKE_CASE       :	str						    =							ids_tensor([self.batch_size]    ,						2							).float()
                 _SCREAMING_SNAKE_CASE       :	int						    =							ids_tensor([self.batch_size]    ,						self.num_choices							)

            _SCREAMING_SNAKE_CASE       :	int						    =							self.get_config()

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




       def     UpperCamelCase_			(      self							)			->     int:
            return XLMConfig(
                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    ,						num_labels=self.num_labels    ,						bos_token_id=self.bos_token_id    ,						)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						)			->     str:
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							XLMModel(config=lowerCamelCase_							)
            model.to(lowerCamelCase_							)
            model.eval()
            _SCREAMING_SNAKE_CASE       :	Any						    =							model(lowerCamelCase_    ,						lengths=lowerCamelCase_    ,						langs=lowerCamelCase_							)
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							model(lowerCamelCase_    ,						langs=lowerCamelCase_							)
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							model(lowerCamelCase_							)
            self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, self.seq_length, self.hidden_size)							)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						)			->     Tuple:
            _SCREAMING_SNAKE_CASE       :	Any						    =							XLMWithLMHeadModel(lowerCamelCase_							)
            model.to(lowerCamelCase_							)
            model.eval()

            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							model(lowerCamelCase_    ,						token_type_ids=lowerCamelCase_    ,						labels=lowerCamelCase_							)
            self.parent.assertEqual(result.loss.shape    ,						()							)
            self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.seq_length, self.vocab_size)							)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						)			->     Optional[Any]:
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							XLMForQuestionAnsweringSimple(lowerCamelCase_							)
            model.to(lowerCamelCase_							)
            model.eval()

            _SCREAMING_SNAKE_CASE       :	int						    =							model(lowerCamelCase_							)

            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							model(lowerCamelCase_    ,						start_positions=lowerCamelCase_    ,						end_positions=lowerCamelCase_							)
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							outputs
            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     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						)			->     int:
            _SCREAMING_SNAKE_CASE       :	Dict						    =							XLMForQuestionAnswering(lowerCamelCase_							)
            model.to(lowerCamelCase_							)
            model.eval()

            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							model(lowerCamelCase_							)

            _SCREAMING_SNAKE_CASE       :	str						    =							model(
                lowerCamelCase_    ,						start_positions=lowerCamelCase_    ,						end_positions=lowerCamelCase_    ,						cls_index=lowerCamelCase_    ,						is_impossible=lowerCamelCase_    ,						p_mask=lowerCamelCase_    ,						)

            _SCREAMING_SNAKE_CASE       :	Tuple						    =							model(
                lowerCamelCase_    ,						start_positions=lowerCamelCase_    ,						end_positions=lowerCamelCase_    ,						cls_index=lowerCamelCase_    ,						is_impossible=lowerCamelCase_    ,						)

            (_SCREAMING_SNAKE_CASE					)       :	List[Any]						    =							result_with_labels.to_tuple()

            _SCREAMING_SNAKE_CASE       :	Dict						    =							model(lowerCamelCase_    ,						start_positions=lowerCamelCase_    ,						end_positions=lowerCamelCase_							)

            (_SCREAMING_SNAKE_CASE					)       :	Optional[Any]						    =							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     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						)			->     List[str]:
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							XLMForSequenceClassification(lowerCamelCase_							)
            model.to(lowerCamelCase_							)
            model.eval()

            _SCREAMING_SNAKE_CASE       :	Tuple						    =							model(lowerCamelCase_							)
            _SCREAMING_SNAKE_CASE       :	Any						    =							model(lowerCamelCase_    ,						labels=lowerCamelCase_							)
            self.parent.assertEqual(result.loss.shape    ,						()							)
            self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.type_sequence_label_size)							)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						)			->     Any:
            _SCREAMING_SNAKE_CASE       :	Any						    =							self.num_labels
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							XLMForTokenClassification(lowerCamelCase_							)
            model.to(lowerCamelCase_							)
            model.eval()

            _SCREAMING_SNAKE_CASE       :	List[str]						    =							model(lowerCamelCase_    ,						attention_mask=lowerCamelCase_    ,						labels=lowerCamelCase_							)
            self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.seq_length, self.num_labels)							)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						)			->     Optional[Any]:
            _SCREAMING_SNAKE_CASE       :	Dict						    =							self.num_choices
            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							XLMForMultipleChoice(config=lowerCamelCase_							)
            model.to(lowerCamelCase_							)
            model.eval()
            _SCREAMING_SNAKE_CASE       :	Dict						    =							input_ids.unsqueeze(1							).expand(-1    ,						self.num_choices    ,						-1							).contiguous()
            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							token_type_ids.unsqueeze(1							).expand(-1    ,						self.num_choices    ,						-1							).contiguous()
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							input_mask.unsqueeze(1							).expand(-1    ,						self.num_choices    ,						-1							).contiguous()
            _SCREAMING_SNAKE_CASE       :	int						    =							model(
                lowerCamelCase_    ,						attention_mask=lowerCamelCase_    ,						token_type_ids=lowerCamelCase_    ,						labels=lowerCamelCase_    ,						)
            self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.num_choices)							)







       def     UpperCamelCase_			(      self							)			->     int:
            _SCREAMING_SNAKE_CASE       :	int						    =							self.prepare_config_and_inputs()
            (
                _SCREAMING_SNAKE_CASE					
            )       :	List[str]						    =							config_and_inputs
            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''lengths''': input_lengths}
            return config, inputs_dict





@require_torch
class 			lowerCAmelCase__( _UpperCAmelCase  ,     _UpperCAmelCase  ,     _UpperCAmelCase  ,     unittest.TestCase    ):






       '''simple docstring'''


       __snake_case 			=    (
           (
               XLMModel,
               XLMWithLMHeadModel,
               XLMForQuestionAnswering,
               XLMForSequenceClassification,
               XLMForQuestionAnsweringSimple,
               XLMForTokenClassification,
               XLMForMultipleChoice,
           )
           if is_torch_available()
           else ()
       )
       __snake_case 			=    (
           (XLMWithLMHeadModel,) if is_torch_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       __snake_case 			=    (
           {
               'feature-extraction': XLMModel,
               'fill-mask': XLMWithLMHeadModel,
               'question-answering': XLMForQuestionAnsweringSimple,
               'text-classification': XLMForSequenceClassification,
               'text-generation': XLMWithLMHeadModel,
               'token-classification': XLMForTokenClassification,
               'zero-shot': XLMForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase							)			->     Tuple:




            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     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase=False							)			->     Any:
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							super()._prepare_for_class(lowerCamelCase_    ,						lowerCamelCase_    ,						return_labels=lowerCamelCase_							)

            if return_labels:
                 if model_class.__name__ == "XLMForQuestionAnswering":
                      _SCREAMING_SNAKE_CASE       :	int						    =							torch.zeros(
                          self.model_tester.batch_size    ,						dtype=torch.long    ,						device=lowerCamelCase_							)
                      _SCREAMING_SNAKE_CASE       :	List[str]						    =							torch.zeros(
                          self.model_tester.batch_size    ,						dtype=torch.long    ,						device=lowerCamelCase_							)

            return inputs_dict




       def     UpperCamelCase_			(      self							)			->     int:
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							XLMModelTester(self							)
            _SCREAMING_SNAKE_CASE       :	Dict						    =							ConfigTester(self    ,						config_class=lowerCamelCase_    ,						emb_dim=3_7							)




       def     UpperCamelCase_			(      self							)			->     Dict:
            self.config_tester.run_common_tests()




       def     UpperCamelCase_			(      self							)			->     int:
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_xlm_model(*lowerCamelCase_							)




       def     UpperCamelCase_			(      self							)			->     List[Any]:
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_xlm_lm_head(*lowerCamelCase_							)




       def     UpperCamelCase_			(      self							)			->     Union[str, Any]:
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_xlm_simple_qa(*lowerCamelCase_							)




       def     UpperCamelCase_			(      self							)			->     Optional[Any]:
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_xlm_qa(*lowerCamelCase_							)




       def     UpperCamelCase_			(      self							)			->     Optional[Any]:
            _SCREAMING_SNAKE_CASE       :	int						    =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_xlm_sequence_classif(*lowerCamelCase_							)




       def     UpperCamelCase_			(      self							)			->     Tuple:
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_xlm_token_classif(*lowerCamelCase_							)




       def     UpperCamelCase_			(      self							)			->     Dict:
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCamelCase_							)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase=False    ,						__lowerCamelCase=1							)			->     Union[str, Any]:
            self.assertIsInstance(lowerCamelCase_    ,						lowerCamelCase_							)
            self.assertListEqual(
                [isinstance(lowerCamelCase_    ,						lowerCamelCase_							) for iter_attentions in attentions]    ,						[True] * len(lowerCamelCase_							)							)
            self.assertEqual(len(lowerCamelCase_							)    ,						(max_length - min_length) * num_beam_groups							)

            for idx, iter_attentions in enumerate(lowerCamelCase_							):
                 # adds PAD dummy token
                 _SCREAMING_SNAKE_CASE       :	Any						    =							min_length + idx + 1
                 _SCREAMING_SNAKE_CASE       :	Any						    =							min_length + idx + 1

                 _SCREAMING_SNAKE_CASE       :	int						    =							(
                     batch_size * num_beam_groups,
                     config.num_attention_heads,
                     tgt_len,
                     src_len,
                 )
                 # check attn size
                 self.assertListEqual(
                     [layer_attention.shape for layer_attention in iter_attentions]    ,						[expected_shape] * len(lowerCamelCase_							)							)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase=False    ,						__lowerCamelCase=1							)			->     Tuple:
            self.assertIsInstance(lowerCamelCase_    ,						lowerCamelCase_							)
            self.assertListEqual(
                [isinstance(lowerCamelCase_    ,						lowerCamelCase_							) for iter_hidden_states in hidden_states]    ,						[True] * len(lowerCamelCase_							)    ,						)
            self.assertEqual(len(lowerCamelCase_							)    ,						(max_length - min_length) * num_beam_groups							)

            for idx, iter_hidden_states in enumerate(lowerCamelCase_							):
                 # adds PAD dummy token
                 _SCREAMING_SNAKE_CASE       :	List[str]						    =							min_length + idx + 1
                 _SCREAMING_SNAKE_CASE       :	int						    =							(batch_size * num_beam_groups, seq_len, config.hidden_size)
                 # check hidden size
                 self.assertListEqual(
                     [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]    ,						[expected_shape] * len(lowerCamelCase_							)    ,						)
            pass







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




            for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							XLMModel.from_pretrained(lowerCamelCase_							)
                 self.assertIsNotNone(lowerCamelCase_							)





@require_torch
class 			lowerCAmelCase__( unittest.TestCase    ):






       '''simple docstring'''


       @slow
       def     UpperCamelCase_			(      self							)			->     Dict:
            _SCREAMING_SNAKE_CASE       :	Tuple						    =							XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"							)
            model.to(lowerCamelCase_							)
            _SCREAMING_SNAKE_CASE       :	int						    =							torch.tensor([[1_4, 4_4_7]]    ,						dtype=torch.long    ,						device=lowerCamelCase_							)  # the president
            _SCREAMING_SNAKE_CASE       :	int						    =							[
                1_4,
                4_4_7,
                1_4,
                4_4_7,
                1_4,
                4_4_7,
                1_4,
                4_4_7,
                1_4,
                4_4_7,
                1_4,
                4_4_7,
                1_4,
                4_4_7,
                1_4,
                4_4_7,
                1_4,
                4_4_7,
                1_4,
                4_4_7,
            ]  # the president the president the president the president the president the president the president the president the president the president
            # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							model.generate(lowerCamelCase_    ,						do_sample=lowerCamelCase_							)
            self.assertListEqual(output_ids[0].cpu().numpy().tolist()    ,						lowerCamelCase_							)






from PIL import Image






def     lowerCamelCase__			(__lowerCamelCase	):
     _SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE       :	List[str]						    =							image.size
     _SCREAMING_SNAKE_CASE       :	Tuple						    =							0
     _SCREAMING_SNAKE_CASE       :	Dict						    =							image.load()
     for i in range(__lowerCamelCase	):
          for j in range(__lowerCamelCase	):
               _SCREAMING_SNAKE_CASE       :	List[Any]						    =							pixels[j, i]
               mean += pixel
     mean //= width * height

     for j in range(__lowerCamelCase	):
          for i in range(__lowerCamelCase	):
               _SCREAMING_SNAKE_CASE       :	int						    =							255 if pixels[i, j] > mean else 0
     return image


if __name__ == "__main__":
       UpperCamelCase__      =mean_threshold(Image.open('path_to_image').convert('L'))
       image.save('output_image_path')