




'''simple docstring'''







import inspect
import unittest

from transformers import SegformerConfig, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
   import torch

   from transformers import (
       MODEL_MAPPING,
       SegformerForImageClassification,
       SegformerForSemanticSegmentation,
       SegformerModel,
   )
   from transformers.models.segformer.modeling_segformer import SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import SegformerImageProcessor


class 			_a  (	__a ):
       def     A      (	self						:	str				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.config_class(**self.inputs_dict				)
           self.parent.assertTrue(hasattr(lowercase   ,				'''hidden_sizes'''				)				)
           self.parent.assertTrue(hasattr(lowercase   ,				'''num_attention_heads'''				)				)
           self.parent.assertTrue(hasattr(lowercase   ,				'''num_encoder_blocks'''				)				)






class 			_a  :
       def __init__(	self						:	Optional[Any]   ,				lowercase						:	Any   ,				lowercase						:	Optional[Any]=13   ,				lowercase						:	Any=64   ,				lowercase						:	Any=3   ,				lowercase						:	int=4   ,				lowercase						:	Any=[2, 2, 2, 2]   ,				lowercase						:	Optional[int]=[8, 4, 2, 1]   ,				lowercase						:	int=[16, 32, 64, 128]   ,				lowercase						:	Dict=[1, 4, 8, 16]   ,				lowercase						:	List[Any]=[1, 2, 4, 8]   ,				lowercase						:	Optional[Any]=True   ,				lowercase						:	Tuple=True   ,				lowercase						:	Tuple="gelu"   ,				lowercase						:	Any=0.1   ,				lowercase						:	Optional[int]=0.1   ,				lowercase						:	Optional[Any]=0.02   ,				lowercase						:	Optional[int]=3   ,				lowercase						:	Optional[int]=None   ,				):



           '''simple docstring'''

           UpperCAmelCase			       =		parent
           UpperCAmelCase			       =		batch_size
           UpperCAmelCase			       =		image_size
           UpperCAmelCase			       =		num_channels
           UpperCAmelCase			       =		num_encoder_blocks
           UpperCAmelCase			       =		sr_ratios
           UpperCAmelCase			       =		depths
           UpperCAmelCase			       =		hidden_sizes
           UpperCAmelCase			       =		downsampling_rates
           UpperCAmelCase			       =		num_attention_heads
           UpperCAmelCase			       =		is_training
           UpperCAmelCase			       =		use_labels
           UpperCAmelCase			       =		hidden_act
           UpperCAmelCase			       =		hidden_dropout_prob
           UpperCAmelCase			       =		attention_probs_dropout_prob
           UpperCAmelCase			       =		initializer_range
           UpperCAmelCase			       =		num_labels
           UpperCAmelCase			       =		scope
       def     A      (	self						:	List[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

           UpperCAmelCase			       =		None
           if self.use_labels:
               UpperCAmelCase			       =		ids_tensor([self.batch_size, self.image_size, self.image_size]   ,				self.num_labels				)

           UpperCAmelCase			       =		self.get_config()
           return config, pixel_values, labels
       def     A      (	self						:	List[str]				):



           '''simple docstring'''

           return SegformerConfig(
               image_size=self.image_size   ,				num_channels=self.num_channels   ,				num_encoder_blocks=self.num_encoder_blocks   ,				depths=self.depths   ,				hidden_sizes=self.hidden_sizes   ,				num_attention_heads=self.num_attention_heads   ,				hidden_act=self.hidden_act   ,				hidden_dropout_prob=self.hidden_dropout_prob   ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,				initializer_range=self.initializer_range   ,				)
       def     A      (	self						:	Any   ,				lowercase						:	Optional[int]   ,				lowercase						:	Optional[Any]   ,				lowercase						:	Any				):



           '''simple docstring'''

           UpperCAmelCase			       =		SegformerModel(config=lowercase				)
           model.to(lowercase				)
           model.eval()
           UpperCAmelCase			       =		model(lowercase				)
           UpperCAmelCase			       =		UpperCAmelCase			       =		self.image_size // (self.downsampling_rates[-1] * 2)
           self.parent.assertEqual(
               result.last_hidden_state.shape   ,				(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)				)
       def     A      (	self						:	Optional[int]   ,				lowercase						:	Dict   ,				lowercase						:	Dict   ,				lowercase						:	List[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.num_labels
           UpperCAmelCase			       =		SegformerForSemanticSegmentation(lowercase				)
           model.to(lowercase				)
           model.eval()
           UpperCAmelCase			       =		model(lowercase				)
           self.parent.assertEqual(
               result.logits.shape   ,				(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)				)
           UpperCAmelCase			       =		model(lowercase   ,				labels=lowercase				)
           self.parent.assertEqual(
               result.logits.shape   ,				(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)				)
           self.parent.assertGreater(result.loss   ,				0.0				)
       def     A      (	self						:	Dict   ,				lowercase						:	Union[str, Any]   ,				lowercase						:	Tuple   ,				lowercase						:	Union[str, Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		1
           UpperCAmelCase			       =		SegformerForSemanticSegmentation(config=lowercase				)
           model.to(lowercase				)
           model.eval()
           UpperCAmelCase			       =		torch.randint(0   ,				1   ,				(self.batch_size, self.image_size, self.image_size)				).to(lowercase				)
           UpperCAmelCase			       =		model(lowercase   ,				labels=lowercase				)
           self.parent.assertGreater(result.loss   ,				0.0				)







       def     A      (	self						:	List[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.prepare_config_and_inputs()
           UpperCAmelCase       ,     UpperCAmelCase       ,     UpperCAmelCase			       =		config_and_inputs
           UpperCAmelCase			       =		{'''pixel_values''': pixel_values}
           return config, inputs_dict






@require_torch
class 			_a  (	__a							,							__a							,							unittest.TestCase ):
       __a				:     Optional[Any]   				=					(
           (
               SegformerModel,
               SegformerForSemanticSegmentation,
               SegformerForImageClassification,
           )
           if is_torch_available()
           else ()
       )
       __a				:     Dict   				=					(
           {
               """feature-extraction""": SegformerModel,
               """image-classification""": SegformerForImageClassification,
               """image-segmentation""": SegformerForSemanticSegmentation,
           }
           if is_torch_available()
           else {}
       )

       __a				:     Union[str, Any]   				=					True
       __a				:     str   				=					False
       __a				:     Dict   				=					False
       __a				:     int   				=					False
       def     A      (	self						:	int				):



           '''simple docstring'''

           UpperCAmelCase			       =		SegformerModelTester(self				)
           UpperCAmelCase			       =		SegformerConfigTester(self   ,				config_class=lowercase				)
       def     A      (	self						:	Dict				):



           '''simple docstring'''

           self.config_tester.run_common_tests()
       def     A      (	self						:	Union[str, Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowercase				)
       def     A      (	self						:	str				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_binary_image_segmentation(*lowercase				)
       def     A      (	self						:	Union[str, Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_segmentation(*lowercase				)
       @unittest.skip('''SegFormer does not use inputs_embeds'''				)
       def     A      (	self						:	str				):



           '''simple docstring'''

           pass
       @unittest.skip('''SegFormer does not have get_input_embeddings method and get_output_embeddings methods'''				)
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           pass
       def     A      (	self						:	Tuple				):



           '''simple docstring'''

           UpperCAmelCase       ,     UpperCAmelCase			       =		self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               UpperCAmelCase			       =		model_class(lowercase				)
               UpperCAmelCase			       =		inspect.signature(model.forward				)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               UpperCAmelCase			       =		[*signature.parameters.keys()]

               UpperCAmelCase			       =		['''pixel_values''']
               self.assertListEqual(arg_names[:1]   ,				lowercase				)
       def     A      (	self						:	List[str]				):



           '''simple docstring'''

           UpperCAmelCase       ,     UpperCAmelCase			       =		self.model_tester.prepare_config_and_inputs_for_common()
           UpperCAmelCase			       =		True

           for model_class in self.all_model_classes:
               UpperCAmelCase			       =		True
               UpperCAmelCase			       =		False
               UpperCAmelCase			       =		True
               UpperCAmelCase			       =		model_class(lowercase				)
               model.to(lowercase				)
               model.eval()
               with torch.no_grad():
                   UpperCAmelCase			       =		model(**self._prepare_for_class(lowercase   ,				lowercase				)				)
               UpperCAmelCase			       =		outputs.attentions

               UpperCAmelCase			       =		sum(self.model_tester.depths				)
               self.assertEqual(len(lowercase				)   ,				lowercase				)

               # check that output_attentions also work using config
               del inputs_dict["output_attentions"]
               UpperCAmelCase			       =		True
               UpperCAmelCase			       =		model_class(lowercase				)
               model.to(lowercase				)
               model.eval()
               with torch.no_grad():
                   UpperCAmelCase			       =		model(**self._prepare_for_class(lowercase   ,				lowercase				)				)
               UpperCAmelCase			       =		outputs.attentions

               self.assertEqual(len(lowercase				)   ,				lowercase				)

               # verify the first attentions (first block, first layer)
               UpperCAmelCase			       =		(self.model_tester.image_size // 4) ** 2
               UpperCAmelCase			       =		(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
               self.assertListEqual(
                   list(attentions[0].shape[-3:]				)   ,				[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]   ,				)

               # verify the last attentions (last block, last layer)
               UpperCAmelCase			       =		(self.model_tester.image_size // 32) ** 2
               UpperCAmelCase			       =		(self.model_tester.image_size // (32 * self.model_tester.sr_ratios[-1])) ** 2
               self.assertListEqual(
                   list(attentions[-1].shape[-3:]				)   ,				[self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len]   ,				)
               UpperCAmelCase			       =		len(lowercase				)

               # Check attention is always last and order is fine
               UpperCAmelCase			       =		True
               UpperCAmelCase			       =		True
               UpperCAmelCase			       =		model_class(lowercase				)
               model.to(lowercase				)
               model.eval()
               with torch.no_grad():
                   UpperCAmelCase			       =		model(**self._prepare_for_class(lowercase   ,				lowercase				)				)

               self.assertEqual(out_len + 1   ,				len(lowercase				)				)

               UpperCAmelCase			       =		outputs.attentions

               self.assertEqual(len(lowercase				)   ,				lowercase				)
               # verify the first attentions (first block, first layer)
               UpperCAmelCase			       =		(self.model_tester.image_size // 4) ** 2
               UpperCAmelCase			       =		(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
               self.assertListEqual(
                   list(self_attentions[0].shape[-3:]				)   ,				[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]   ,				)
       def     A      (	self						:	Union[str, Any]				):



           '''simple docstring'''

           def check_hidden_states_output(lowercase						:	Dict   ,				lowercase						:	List[str]   ,				lowercase						:	Optional[Any]				):
               UpperCAmelCase			       =		model_class(lowercase				)
               model.to(lowercase				)
               model.eval()

               with torch.no_grad():
                   UpperCAmelCase			       =		model(**self._prepare_for_class(lowercase   ,				lowercase				)				)

               UpperCAmelCase			       =		outputs.hidden_states

               UpperCAmelCase			       =		self.model_tester.num_encoder_blocks
               self.assertEqual(len(lowercase				)   ,				lowercase				)

               # verify the first hidden states (first block)
               self.assertListEqual(
                   list(hidden_states[0].shape[-3:]				)   ,				[
                       self.model_tester.hidden_sizes[0],
                       self.model_tester.image_size // 4,
                       self.model_tester.image_size // 4,
                   ]   ,				)

           UpperCAmelCase       ,     UpperCAmelCase			       =		self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               UpperCAmelCase			       =		True
               check_hidden_states_output(lowercase   ,				lowercase   ,				lowercase				)

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               UpperCAmelCase			       =		True

               check_hidden_states_output(lowercase   ,				lowercase   ,				lowercase				)
       def     A      (	self						:	Any				):



           '''simple docstring'''

           if not self.model_tester.is_training:
               return

           UpperCAmelCase       ,     UpperCAmelCase			       =		self.model_tester.prepare_config_and_inputs_for_common()
           UpperCAmelCase			       =		True

           for model_class in self.all_model_classes:
               if model_class in get_values(lowercase				):
                   continue

               UpperCAmelCase			       =		model_class(lowercase				)
               model.to(lowercase				)
               model.train()
               UpperCAmelCase			       =		self._prepare_for_class(lowercase   ,				lowercase   ,				return_labels=lowercase				)
               UpperCAmelCase			       =		model(**lowercase				).loss
               loss.backward()
       @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''				)
       def     A      (	self						:	Optional[Any]				):



           '''simple docstring'''

           pass







       @slow
       def     A      (	self						:	List[str]				):



           '''simple docstring'''

           for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               UpperCAmelCase			       =		SegformerModel.from_pretrained(lowercase				)
               self.assertIsNotNone(lowercase				)






def 						snake_case_							():
    UpperCAmelCase			       =		Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
    return image







@require_torch
class 			_a  (	unittest.TestCase ):
       @slow
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           UpperCAmelCase			       =		SegformerImageProcessor(
               image_scale=(512, 512)   ,				keep_ratio=lowercase   ,				align=lowercase   ,				do_random_crop=lowercase				)
           UpperCAmelCase			       =		SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''				).to(
               lowercase				)

           UpperCAmelCase			       =		prepare_img()
           UpperCAmelCase			       =		image_processor(images=lowercase   ,				return_tensors='''pt'''				)
           UpperCAmelCase			       =		encoded_inputs.pixel_values.to(lowercase				)

           with torch.no_grad():
               UpperCAmelCase			       =		model(lowercase				)

           UpperCAmelCase			       =		torch.Size((1, model.config.num_labels, 128, 128)				)
           self.assertEqual(outputs.logits.shape   ,				lowercase				)

           UpperCAmelCase			       =		torch.tensor(
               [
                   [[-4.6310, -5.5232, -6.2356], [-5.1921, -6.1444, -6.5996], [-5.4424, -6.2790, -6.7574]],
                   [[-12.1391, -13.3122, -13.9554], [-12.8732, -13.9352, -14.3563], [-12.9438, -13.8226, -14.2513]],
                   [[-12.5134, -13.4686, -14.4915], [-12.8669, -14.4343, -14.7758], [-13.2523, -14.5819, -15.0694]],
               ]				).to(lowercase				)
           self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]   ,				lowercase   ,				atol=1E-4				)				)
       @slow
       def     A      (	self						:	Optional[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		SegformerImageProcessor(
               image_scale=(512, 512)   ,				keep_ratio=lowercase   ,				align=lowercase   ,				do_random_crop=lowercase				)
           UpperCAmelCase			       =		SegformerForSemanticSegmentation.from_pretrained(
               '''nvidia/segformer-b1-finetuned-cityscapes-1024-1024'''				).to(lowercase				)

           UpperCAmelCase			       =		prepare_img()
           UpperCAmelCase			       =		image_processor(images=lowercase   ,				return_tensors='''pt'''				)
           UpperCAmelCase			       =		encoded_inputs.pixel_values.to(lowercase				)

           with torch.no_grad():
               UpperCAmelCase			       =		model(lowercase				)

           UpperCAmelCase			       =		torch.Size((1, model.config.num_labels, 128, 128)				)
           self.assertEqual(outputs.logits.shape   ,				lowercase				)

           UpperCAmelCase			       =		torch.tensor(
               [
                   [[-13.5748, -13.9111, -12.6500], [-14.3500, -15.3683, -14.2328], [-14.7532, -16.0424, -15.6087]],
                   [[-17.1651, -15.8725, -12.9653], [-17.2580, -17.3718, -14.8223], [-16.6058, -16.8783, -16.7452]],
                   [[-3.6456, -3.0209, -1.4203], [-3.0797, -3.1959, -2.0000], [-1.8757, -1.9217, -1.6997]],
               ]				).to(lowercase				)
           self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]   ,				lowercase   ,				atol=1E-1				)				)







       @slow
       def     A      (	self						:	int				):



           '''simple docstring'''

           UpperCAmelCase			       =		SegformerImageProcessor(
               image_scale=(512, 512)   ,				keep_ratio=lowercase   ,				align=lowercase   ,				do_random_crop=lowercase				)
           UpperCAmelCase			       =		SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''				).to(
               lowercase				)

           UpperCAmelCase			       =		prepare_img()
           UpperCAmelCase			       =		image_processor(images=lowercase   ,				return_tensors='''pt'''				)
           UpperCAmelCase			       =		encoded_inputs.pixel_values.to(lowercase				)

           with torch.no_grad():
               UpperCAmelCase			       =		model(lowercase				)

           UpperCAmelCase			       =		outputs.logits.detach().cpu()

           UpperCAmelCase			       =		image_processor.post_process_semantic_segmentation(outputs=lowercase   ,				target_sizes=[(500, 300)]				)
           UpperCAmelCase			       =		torch.Size((500, 300)				)
           self.assertEqual(segmentation[0].shape   ,				lowercase				)

           UpperCAmelCase			       =		image_processor.post_process_semantic_segmentation(outputs=lowercase				)
           UpperCAmelCase			       =		torch.Size((128, 128)				)
           self.assertEqual(segmentation[0].shape   ,				lowercase				)










'''simple docstring'''







import argparse
import json
import logging
import os
import sys
from unittest.mock import patch

from transformers.testing_utils import TestCasePlus, get_gpu_count, slow


A     =[
    os.path.join(os.path.dirname(__file__), dirname)
    for dirname in [
        'text-classification',
        'language-modeling',
        'summarization',
        'token-classification',
        'question-answering',
    ]
]
sys.path.extend(SRC_DIRS)


if SRC_DIRS is not None:
   import run_clm_flax
   import run_flax_glue
   import run_flax_ner
   import run_mlm_flax
   import run_qa
   import run_summarization_flax
   import run_ta_mlm_flax


logging.basicConfig(level=logging.DEBUG)

A     =logging.getLogger()





def 						snake_case_							():
    UpperCAmelCase			       =		argparse.ArgumentParser()
    parser.add_argument('''-f'''     )
    UpperCAmelCase			       =		parser.parse_args()
    return args.f





def 						snake_case_							(_a	:							List[str]    ,   _a	:							Union[str, Any]="eval"     ):
    UpperCAmelCase			       =		os.path.join(_a    ,   F"{split}_results.json"     )
    if os.path.exists(_a     ):
        with open(_a    ,   '''r'''     ) as f:
            return json.load(_a     )
    raise ValueError(F"can't find {path}"     )


A     =logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)







class 			_a  (	__a ):
       def     A      (	self						:	Any				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_auto_remove_tmp_dir()
           UpperCAmelCase			       =		f"\n            run_glue.py\n            --model_name_or_path distilbert-base-uncased\n            --output_dir {tmp_dir}\n            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --learning_rate=1e-4\n            --eval_steps=2\n            --warmup_steps=2\n            --seed=42\n            --max_seq_length=128\n            ".split()

           with patch.object(lowercase   ,				'''argv'''   ,				lowercase				):
               run_flax_glue.main()
               UpperCAmelCase			       =		get_results(lowercase				)
               self.assertGreaterEqual(result['''eval_accuracy''']   ,				0.75				)
       @slow
       def     A      (	self						:	Any				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_auto_remove_tmp_dir()
           UpperCAmelCase			       =		f"\n            run_clm_flax.py\n            --model_name_or_path distilgpt2\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --do_train\n            --do_eval\n            --block_size 128\n            --per_device_train_batch_size 4\n            --per_device_eval_batch_size 4\n            --num_train_epochs 2\n            --logging_steps 2 --eval_steps 2\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            ".split()

           with patch.object(lowercase   ,				'''argv'''   ,				lowercase				):
               run_clm_flax.main()
               UpperCAmelCase			       =		get_results(lowercase				)
               self.assertLess(result['''eval_perplexity''']   ,				100				)
       @slow
       def     A      (	self						:	str				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_auto_remove_tmp_dir()
           UpperCAmelCase			       =		f"\n            run_summarization.py\n            --model_name_or_path t5-small\n            --train_file tests/fixtures/tests_samples/xsum/sample.json\n            --validation_file tests/fixtures/tests_samples/xsum/sample.json\n            --test_file tests/fixtures/tests_samples/xsum/sample.json\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            --num_train_epochs=3\n            --warmup_steps=8\n            --do_train\n            --do_eval\n            --do_predict\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --predict_with_generate\n        ".split()

           with patch.object(lowercase   ,				'''argv'''   ,				lowercase				):
               run_summarization_flax.main()
               UpperCAmelCase			       =		get_results(lowercase   ,				split='''test'''				)
               self.assertGreaterEqual(result['''test_rouge1''']   ,				10				)
               self.assertGreaterEqual(result['''test_rouge2''']   ,				2				)
               self.assertGreaterEqual(result['''test_rougeL''']   ,				7				)
               self.assertGreaterEqual(result['''test_rougeLsum''']   ,				7				)
       @slow
       def     A      (	self						:	int				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_auto_remove_tmp_dir()
           UpperCAmelCase			       =		f"\n            run_mlm.py\n            --model_name_or_path distilroberta-base\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            --max_seq_length 128\n            --per_device_train_batch_size 4\n            --per_device_eval_batch_size 4\n            --logging_steps 2 --eval_steps 2\n            --do_train\n            --do_eval\n            --num_train_epochs=1\n        ".split()

           with patch.object(lowercase   ,				'''argv'''   ,				lowercase				):
               run_mlm_flax.main()
               UpperCAmelCase			       =		get_results(lowercase				)
               self.assertLess(result['''eval_perplexity''']   ,				42				)
       @slow
       def     A      (	self						:	Tuple				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_auto_remove_tmp_dir()
           UpperCAmelCase			       =		f"\n            run_t5_mlm_flax.py\n            --model_name_or_path t5-small\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --do_train\n            --do_eval\n            --max_seq_length 128\n            --per_device_train_batch_size 4\n            --per_device_eval_batch_size 4\n            --num_train_epochs 2\n            --logging_steps 2 --eval_steps 2\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            ".split()

           with patch.object(lowercase   ,				'''argv'''   ,				lowercase				):
               run_ta_mlm_flax.main()
               UpperCAmelCase			       =		get_results(lowercase				)
               self.assertGreaterEqual(result['''eval_accuracy''']   ,				0.42				)
       @slow
       def     A      (	self						:	Tuple				):



           '''simple docstring'''

           UpperCAmelCase			       =		7 if get_gpu_count() > 1 else 2

           UpperCAmelCase			       =		self.get_auto_remove_tmp_dir()
           UpperCAmelCase			       =		f"\n            run_flax_ner.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/conll/sample.json\n            --validation_file tests/fixtures/tests_samples/conll/sample.json\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            --do_train\n            --do_eval\n            --warmup_steps=2\n            --learning_rate=2e-4\n            --logging_steps 2 --eval_steps 2\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=2\n            --num_train_epochs={epochs}\n            --seed 7\n        ".split()

           with patch.object(lowercase   ,				'''argv'''   ,				lowercase				):
               run_flax_ner.main()
               UpperCAmelCase			       =		get_results(lowercase				)
               self.assertGreaterEqual(result['''eval_accuracy''']   ,				0.75				)
               self.assertGreaterEqual(result['''eval_f1''']   ,				0.3				)







       @slow
       def     A      (	self						:	Union[str, Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.get_auto_remove_tmp_dir()
           UpperCAmelCase			       =		f"\n            run_qa.py\n            --model_name_or_path bert-base-uncased\n            --version_2_with_negative\n            --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --output_dir {tmp_dir}\n            --overwrite_output_dir\n            --num_train_epochs=3\n            --warmup_steps=2\n            --do_train\n            --do_eval\n            --logging_steps 2 --eval_steps 2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n        ".split()

           with patch.object(lowercase   ,				'''argv'''   ,				lowercase				):
               run_qa.main()
               UpperCAmelCase			       =		get_results(lowercase				)
               self.assertGreaterEqual(result['''eval_f1''']   ,				30				)
               self.assertGreaterEqual(result['''eval_exact''']   ,				30				)




