






import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
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 torch import nn

	from transformers import MaskFormerSwinBackbone
	from transformers.models.maskformer import MaskFormerSwinModel


class    _lowerCAmelCase			:



			"""simple docstring"""



			def __init__(      self    :    Dict			,		UpperCamelCase__    :    str			,		UpperCamelCase__    :    Optional[Any]=1_3			,		UpperCamelCase__    :    Optional[int]=3_2			,		UpperCamelCase__    :    Union[str, Any]=2			,		UpperCamelCase__    :    Union[str, Any]=3			,		UpperCamelCase__    :    List[str]=1_6			,		UpperCamelCase__    :    Union[str, Any]=[1, 2, 1]			,		UpperCamelCase__    :    List[str]=[2, 2, 4]			,		UpperCamelCase__    :    Optional[int]=2			,		UpperCamelCase__    :    str=2.0			,		UpperCamelCase__    :    Dict=True			,		UpperCamelCase__    :    Tuple=0.0			,		UpperCamelCase__    :    Any=0.0			,		UpperCamelCase__    :    List[Any]=0.1			,		UpperCamelCase__    :    Any="gelu"			,		UpperCamelCase__    :    List[str]=False			,		UpperCamelCase__    :    str=True			,		UpperCamelCase__    :    Optional[int]=0.02			,		UpperCamelCase__    :    Union[str, Any]=1E-5			,		UpperCamelCase__    :    Optional[int]=True			,		UpperCamelCase__    :    int=None			,		UpperCamelCase__    :    Dict=True			,		UpperCamelCase__    :    Optional[Any]=1_0			,		UpperCamelCase__    :    Tuple=8			,		UpperCamelCase__    :    str=["stage1", "stage2", "stage3"]			,		UpperCamelCase__    :    str=[1, 2, 3]			,		):






										'''simple docstring'''







										snake_case__	  =       parent
										snake_case__	  =       batch_size
										snake_case__	  =       image_size
										snake_case__	  =       patch_size
										snake_case__	  =       num_channels
										snake_case__	  =       embed_dim
										snake_case__	  =       depths
										snake_case__	  =       num_heads
										snake_case__	  =       window_size
										snake_case__	  =       mlp_ratio
										snake_case__	  =       qkv_bias
										snake_case__	  =       hidden_dropout_prob
										snake_case__	  =       attention_probs_dropout_prob
										snake_case__	  =       drop_path_rate
										snake_case__	  =       hidden_act
										snake_case__	  =       use_absolute_embeddings
										snake_case__	  =       patch_norm
										snake_case__	  =       layer_norm_eps
										snake_case__	  =       initializer_range
										snake_case__	  =       is_training
										snake_case__	  =       scope
										snake_case__	  =       use_labels
										snake_case__	  =       type_sequence_label_size
										snake_case__	  =       encoder_stride
										snake_case__	  =       out_features
										snake_case__	  =       out_indices



			def 					__magic_name__							(      self    :    List[str]):






										'''simple docstring'''







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

										snake_case__	  =       None
										if self.use_labels:
																	snake_case__	  =       ids_tensor([self.batch_size]			,		self.type_sequence_label_size)

										snake_case__	  =       self.get_config()

										return config, pixel_values, labels



			def 					__magic_name__							(      self    :    str):






										'''simple docstring'''







										return MaskFormerSwinConfig(
										    image_size=self.image_size			,		patch_size=self.patch_size			,		num_channels=self.num_channels			,		embed_dim=self.embed_dim			,		depths=self.depths			,		num_heads=self.num_heads			,		window_size=self.window_size			,		mlp_ratio=self.mlp_ratio			,		qkv_bias=self.qkv_bias			,		hidden_dropout_prob=self.hidden_dropout_prob			,		attention_probs_dropout_prob=self.attention_probs_dropout_prob			,		drop_path_rate=self.drop_path_rate			,		hidden_act=self.hidden_act			,		use_absolute_embeddings=self.use_absolute_embeddings			,		path_norm=self.patch_norm			,		layer_norm_eps=self.layer_norm_eps			,		initializer_range=self.initializer_range			,		encoder_stride=self.encoder_stride			,		out_features=self.out_features			,		out_indices=self.out_indices			,		)



			def 					__magic_name__							(      self    :    List[str]			,		UpperCamelCase__    :    Any			,		UpperCamelCase__    :    Dict			,		UpperCamelCase__    :    Any):






										'''simple docstring'''







										snake_case__	  =       MaskFormerSwinModel(config=UpperCamelCase__)
										model.to(UpperCamelCase__)
										model.eval()
										snake_case__	  =       model(UpperCamelCase__)

										snake_case__	  =       ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1))
										snake_case__	  =       int(config.embed_dim * 2 ** (len(config.depths) - 1))

										self.parent.assertEqual(result.last_hidden_state.shape			,		(self.batch_size, expected_seq_len, expected_dim))



			def 					__magic_name__							(      self    :    Tuple			,		UpperCamelCase__    :    Optional[Any]			,		UpperCamelCase__    :    Any			,		UpperCamelCase__    :    int):






										'''simple docstring'''







										snake_case__	  =       MaskFormerSwinBackbone(config=UpperCamelCase__)
										model.to(UpperCamelCase__)
										model.eval()
										snake_case__	  =       model(UpperCamelCase__)

										# verify feature maps
										self.parent.assertEqual(len(result.feature_maps)			,		len(config.out_features))
										self.parent.assertListEqual(list(result.feature_maps[0].shape)			,		[1_3, 1_6, 1_6, 1_6])

										# verify channels
										self.parent.assertEqual(len(model.channels)			,		len(config.out_features))
										self.parent.assertListEqual(model.channels			,		[1_6, 3_2, 6_4])

										# verify ValueError
										with self.parent.assertRaises(UpperCamelCase__):
																	snake_case__	  =       ["""stem"""]
																	snake_case__	  =       MaskFormerSwinBackbone(config=UpperCamelCase__)



			def 					__magic_name__							(      self    :    int):






										'''simple docstring'''







										snake_case__	  =       self.prepare_config_and_inputs()
										snake_case__  , snake_case__  , snake_case__	  =       config_and_inputs
										snake_case__	  =       {"""pixel_values""": pixel_values}
										return config, inputs_dict


@require_torch
class    _lowerCAmelCase			(		lowercase_     ,      lowercase_     ,      unittest.TestCase      ):



			"""simple docstring"""



			_lowercase				:   str      =  (
			    (
			        MaskFormerSwinModel,
			        MaskFormerSwinBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			_lowercase				:   Optional[int]      =  {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
			_lowercase				:   Any      =  False
			_lowercase				:   Optional[int]      =  False
			_lowercase				:   Dict      =  False
			_lowercase				:   str      =  False
			_lowercase				:   Tuple      =  False



			def 					__magic_name__							(      self    :    Optional[Any]):






										'''simple docstring'''







										snake_case__	  =       MaskFormerSwinModelTester(self)
										snake_case__	  =       ConfigTester(self			,		config_class=UpperCamelCase__			,		embed_dim=3_7)



			@require_torch_multi_gpu
			@unittest.skip(
			    reason=(
			        """`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with"""
			        """ `nn.DataParallel`"""
			    ))
			def 					__magic_name__							(      self    :    Union[str, Any]):






										'''simple docstring'''







										pass



			def 					__magic_name__							(      self    :    Dict):






										'''simple docstring'''







										self.create_and_test_config_common_properties()
										self.config_tester.create_and_test_config_to_json_string()
										self.config_tester.create_and_test_config_to_json_file()
										self.config_tester.create_and_test_config_from_and_save_pretrained()
										self.config_tester.create_and_test_config_with_num_labels()
										self.config_tester.check_config_can_be_init_without_params()
										self.config_tester.check_config_arguments_init()



			def 					__magic_name__							(      self    :    Optional[Any]):






										'''simple docstring'''







										return



			def 					__magic_name__							(      self    :    Optional[Any]):






										'''simple docstring'''







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



			def 					__magic_name__							(      self    :    Dict):






										'''simple docstring'''







										snake_case__	  =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*UpperCamelCase__)



			@unittest.skip("""Swin does not use inputs_embeds""")
			def 					__magic_name__							(      self    :    Dict):






										'''simple docstring'''







										pass



			@unittest.skip("""Swin does not support feedforward chunking""")
			def 					__magic_name__							(      self    :    Any):






										'''simple docstring'''







										pass



			def 					__magic_name__							(      self    :    str):






										'''simple docstring'''







										snake_case__  , snake_case__	  =       self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																	snake_case__	  =       model_class(UpperCamelCase__)
																	self.assertIsInstance(model.get_input_embeddings()			,		(nn.Module))
																	snake_case__	  =       model.get_output_embeddings()
																	self.assertTrue(x is None or isinstance(UpperCamelCase__			,		nn.Linear))



			def 					__magic_name__							(      self    :    Optional[Any]):






										'''simple docstring'''







										snake_case__  , snake_case__	  =       self.model_tester.prepare_config_and_inputs_for_common()

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

																	snake_case__	  =       ["""pixel_values"""]
																	self.assertListEqual(arg_names[:1]			,		UpperCamelCase__)



			@unittest.skip(reason="""MaskFormerSwin is only used as backbone and doesn\'t support output_attentions""")
			def 					__magic_name__							(      self    :    Optional[int]):






										'''simple docstring'''







										pass



			@unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone""")
			def 					__magic_name__							(      self    :    List[Any]):






										'''simple docstring'''







										pass



			def 					__magic_name__							(      self    :    Any			,		UpperCamelCase__    :    Any			,		UpperCamelCase__    :    Union[str, Any]			,		UpperCamelCase__    :    Tuple			,		UpperCamelCase__    :    List[str]):






										'''simple docstring'''







										snake_case__	  =       model_class(UpperCamelCase__)
										model.to(UpperCamelCase__)
										model.eval()

										with torch.no_grad():
																	snake_case__	  =       model(**self._prepare_for_class(UpperCamelCase__			,		UpperCamelCase__))

										snake_case__	  =       outputs.hidden_states

										snake_case__	  =       getattr(
										    self.model_tester			,		"""expected_num_hidden_layers"""			,		len(self.model_tester.depths) + 1)
										self.assertEqual(len(UpperCamelCase__)			,		UpperCamelCase__)

										# Swin has a different seq_length
										snake_case__	  =       (
										    config.patch_size
										    if isinstance(config.patch_size			,		collections.abc.Iterable)
										    else (config.patch_size, config.patch_size)
										)

										snake_case__	  =       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

										self.assertListEqual(
										    list(hidden_states[0].shape[-2:])			,		[num_patches, self.model_tester.embed_dim]			,		)



			def 					__magic_name__							(      self    :    Dict):






										'''simple docstring'''







										snake_case__  , snake_case__	  =       self.model_tester.prepare_config_and_inputs_for_common()

										snake_case__	  =       (
										    self.model_tester.image_size
										    if isinstance(self.model_tester.image_size			,		collections.abc.Iterable)
										    else (self.model_tester.image_size, self.model_tester.image_size)
										)

										for model_class in self.all_model_classes:
																	snake_case__	  =       True
																	self.check_hidden_states_output(UpperCamelCase__			,		UpperCamelCase__			,		UpperCamelCase__			,		UpperCamelCase__)

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

																	self.check_hidden_states_output(UpperCamelCase__			,		UpperCamelCase__			,		UpperCamelCase__			,		UpperCamelCase__)



			def 					__magic_name__							(      self    :    Optional[Any]):






										'''simple docstring'''







										snake_case__  , snake_case__	  =       self.model_tester.prepare_config_and_inputs_for_common()
										snake_case__	  =       3

										snake_case__	  =       (
										    self.model_tester.image_size
										    if isinstance(self.model_tester.image_size			,		collections.abc.Iterable)
										    else (self.model_tester.image_size, self.model_tester.image_size)
										)
										snake_case__	  =       (
										    config.patch_size
										    if isinstance(config.patch_size			,		collections.abc.Iterable)
										    else (config.patch_size, config.patch_size)
										)

										snake_case__	  =       image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
										snake_case__	  =       image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

										for model_class in self.all_model_classes:
																	snake_case__	  =       True
																	self.check_hidden_states_output(UpperCamelCase__			,		UpperCamelCase__			,		UpperCamelCase__			,		(padded_height, padded_width))

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	snake_case__	  =       True
																	self.check_hidden_states_output(UpperCamelCase__			,		UpperCamelCase__			,		UpperCamelCase__			,		(padded_height, padded_width))



			@unittest.skip(reason="""MaskFormerSwin doesn\'t have pretrained checkpoints""")
			def 					__magic_name__							(      self    :    List[str]):






										'''simple docstring'''







										pass



			@unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin""")
			def 					__magic_name__							(      self    :    Optional[Any]):






										'''simple docstring'''







										pass



			@unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin""")
			def 					__magic_name__							(      self    :    List[str]):






										'''simple docstring'''







										pass



			def 					__magic_name__							(      self    :    int):






										'''simple docstring'''







										snake_case__  , snake_case__	  =       self.model_tester.prepare_config_and_inputs_for_common()

										def set_nan_tensor_to_zero(UpperCamelCase__    :    Tuple):
																	snake_case__	  =       0
																	return t

										def check_equivalence(UpperCamelCase__    :    int			,		UpperCamelCase__    :    List[Any]			,		UpperCamelCase__    :    Optional[Any]			,		UpperCamelCase__    :    List[str]={}):
																	with torch.no_grad():
																								snake_case__	  =       model(**UpperCamelCase__			,		return_dict=UpperCamelCase__			,		**UpperCamelCase__)
																								snake_case__	  =       model(**UpperCamelCase__			,		return_dict=UpperCamelCase__			,		**UpperCamelCase__).to_tuple()

																								def recursive_check(UpperCamelCase__    :    Any			,		UpperCamelCase__    :    Optional[Any]):
																															if isinstance(UpperCamelCase__			,		(List, Tuple)):
																																						for tuple_iterable_value, dict_iterable_value in zip(UpperCamelCase__			,		UpperCamelCase__):
																																													recursive_check(UpperCamelCase__			,		UpperCamelCase__)
																															elif isinstance(UpperCamelCase__			,		UpperCamelCase__):
																																						for tuple_iterable_value, dict_iterable_value in zip(
																																						    tuple_object.values()			,		dict_object.values()):
																																													recursive_check(UpperCamelCase__			,		UpperCamelCase__)
																															elif tuple_object is None:
																																						return
																															else:
																																						self.assertTrue(
																																						    torch.allclose(
																																						        set_nan_tensor_to_zero(UpperCamelCase__)			,		set_nan_tensor_to_zero(UpperCamelCase__)			,		atol=1E-5)			,		msg=(
																																						        """Tuple and dict output are not equal. Difference:"""
																																						        F''' {torch.max(torch.abs(tuple_object - dict_object))}. Tuple has `nan`:'''
																																						        F''' {torch.isnan(UpperCamelCase__).any()} and `inf`: {torch.isinf(UpperCamelCase__)}. Dict has'''
																																						        F''' `nan`: {torch.isnan(UpperCamelCase__).any()} and `inf`: {torch.isinf(UpperCamelCase__)}.'''
																																						    )			,		)

																								recursive_check(UpperCamelCase__			,		UpperCamelCase__)

										for model_class in self.all_model_classes:
																	snake_case__	  =       model_class(UpperCamelCase__)
																	model.to(UpperCamelCase__)
																	model.eval()

																	snake_case__	  =       self._prepare_for_class(UpperCamelCase__			,		UpperCamelCase__)
																	snake_case__	  =       self._prepare_for_class(UpperCamelCase__			,		UpperCamelCase__)
																	check_equivalence(UpperCamelCase__			,		UpperCamelCase__			,		UpperCamelCase__)

																	snake_case__	  =       self._prepare_for_class(UpperCamelCase__			,		UpperCamelCase__			,		return_labels=UpperCamelCase__)
																	snake_case__	  =       self._prepare_for_class(UpperCamelCase__			,		UpperCamelCase__			,		return_labels=UpperCamelCase__)
																	check_equivalence(UpperCamelCase__			,		UpperCamelCase__			,		UpperCamelCase__)

																	snake_case__	  =       self._prepare_for_class(UpperCamelCase__			,		UpperCamelCase__)
																	snake_case__	  =       self._prepare_for_class(UpperCamelCase__			,		UpperCamelCase__)
																	check_equivalence(UpperCamelCase__			,		UpperCamelCase__			,		UpperCamelCase__			,		{"""output_hidden_states""": True})

																	snake_case__	  =       self._prepare_for_class(UpperCamelCase__			,		UpperCamelCase__			,		return_labels=UpperCamelCase__)
																	snake_case__	  =       self._prepare_for_class(UpperCamelCase__			,		UpperCamelCase__			,		return_labels=UpperCamelCase__)
																	check_equivalence(UpperCamelCase__			,		UpperCamelCase__			,		UpperCamelCase__			,		{"""output_hidden_states""": True})


@require_torch
class    _lowerCAmelCase			(		unittest.TestCase     ,      lowercase_      ):



			"""simple docstring"""



			_lowercase				:   List[str]      =  (MaskFormerSwinBackbone,) if is_torch_available() else ()
			_lowercase				:   str      =  MaskFormerSwinConfig



			def 					__magic_name__							(      self    :    Union[str, Any]):






										'''simple docstring'''







										snake_case__	  =       MaskFormerSwinModelTester(self)



			def 					__magic_name__							(      self    :    Dict):






										'''simple docstring'''







										snake_case__  , snake_case__	  =       self.model_tester.prepare_config_and_inputs_for_common()
										snake_case__	  =       inputs_dict["""pixel_values"""].shape[0]

										for backbone_class in self.all_model_classes:
																	snake_case__	  =       backbone_class(UpperCamelCase__)
																	backbone.to(UpperCamelCase__)
																	backbone.eval()

																	snake_case__	  =       backbone(**UpperCamelCase__)

																	# Test default outputs and verify feature maps
																	self.assertIsInstance(outputs.feature_maps			,		UpperCamelCase__)
																	self.assertTrue(len(outputs.feature_maps) == len(backbone.channels))
																	for feature_map, n_channels in zip(outputs.feature_maps			,		backbone.channels):
																								self.assertTrue(feature_map.shape[:2]			,		(batch_size, n_channels))
																	self.assertIsNone(outputs.hidden_states)
																	self.assertIsNone(outputs.attentions)

																	# Test output_hidden_states=True
																	snake_case__	  =       backbone(**UpperCamelCase__			,		output_hidden_states=UpperCamelCase__)
																	self.assertIsNotNone(outputs.hidden_states)
																	self.assertTrue(len(outputs.hidden_states)			,		len(backbone.stage_names))
																	# We skip the stem layer
																	for hidden_states, n_channels in zip(outputs.hidden_states[1:]			,		backbone.channels):
																								for hidden_state in hidden_states:
																															# Hidden states are in the format (batch_size, (height * width), n_channels)
																															snake_case__  , snake_case__  , snake_case__	  =       hidden_state.shape
																															self.assertTrue((h_batch_size, h_n_channels)			,		(batch_size, n_channels))

            # Test output_attentions=True
																	if self.has_attentions:
																								snake_case__	  =       backbone(**UpperCamelCase__			,		output_attentions=UpperCamelCase__)
																								self.assertIsNotNone(outputs.attentions)








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

import run_glue_deebert

from transformers.testing_utils import TestCasePlus, get_gpu_count, require_torch_non_multi_gpu, slow


logging.basicConfig(level=logging.DEBUG)

a__       =     logging.getLogger()

def _UpperCAmelCase   (	):
							snake_case__	  =       argparse.ArgumentParser()
							parser.add_argument("""-f""" )
							snake_case__	  =       parser.parse_args()
							return args.f



class    _lowerCAmelCase			(		lowercase_      ):



				"""simple docstring"""



				def 					__magic_name__							(      self    :    int):






											'''simple docstring'''







											snake_case__	  =       logging.StreamHandler(sys.stdout)
											logger.addHandler(UpperCamelCase__)



				def 					__magic_name__							(      self    :    Union[str, Any]			,		UpperCamelCase__    :    List[str]):






											'''simple docstring'''







											snake_case__	  =       get_gpu_count()

											if n_gpu > 1:
																		pass
																		# XXX: doesn't quite work with n_gpu > 1 https://github.com/huggingface/transformers/issues/10560
																		# script = f"{self.examples_dir_str}/research_projects/deebert/run_glue_deebert.py"
																		# distributed_args = f"-m torch.distributed.launch --nproc_per_node={n_gpu} {script}".split()
																		# cmd = [sys.executable] + distributed_args + args
																		# execute_subprocess_async(cmd, env=self.get_env())
																		# XXX: test the results - need to save them first into .json file
											else:
																		args.insert(0			,		"""run_glue_deebert.py""")
																		with patch.object(UpperCamelCase__			,		"""argv"""			,		UpperCamelCase__):
																									snake_case__	  =       run_glue_deebert.main()
																									for value in result.values():
																																self.assertGreaterEqual(UpperCamelCase__			,		0.6_66)



				@slow
				@require_torch_non_multi_gpu
				def 					__magic_name__							(      self    :    str):






											'''simple docstring'''







											snake_case__	  =       """
            --model_type roberta
            --model_name_or_path roberta-base
            --task_name MRPC
            --do_train
            --do_eval
            --do_lower_case
            --data_dir ./tests/fixtures/tests_samples/MRPC/
            --max_seq_length 128
            --per_gpu_eval_batch_size=1
            --per_gpu_train_batch_size=8
            --learning_rate 2e-4
            --num_train_epochs 3
            --overwrite_output_dir
            --seed 42
            --output_dir ./examples/deebert/saved_models/roberta-base/MRPC/two_stage
            --plot_data_dir ./examples/deebert/results/
            --save_steps 0
            --overwrite_cache
            --eval_after_first_stage
            """.split()
											self.run_and_check(UpperCamelCase__)

											snake_case__	  =       """
            --model_type roberta
            --model_name_or_path ./examples/deebert/saved_models/roberta-base/MRPC/two_stage
            --task_name MRPC
            --do_eval
            --do_lower_case
            --data_dir ./tests/fixtures/tests_samples/MRPC/
            --output_dir ./examples/deebert/saved_models/roberta-base/MRPC/two_stage
            --plot_data_dir ./examples/deebert/results/
            --max_seq_length 128
            --eval_each_highway
            --eval_highway
            --overwrite_cache
            --per_gpu_eval_batch_size=1
            """.split()
											self.run_and_check(UpperCamelCase__)

											snake_case__	  =       """
            --model_type roberta
            --model_name_or_path ./examples/deebert/saved_models/roberta-base/MRPC/two_stage
            --task_name MRPC
            --do_eval
            --do_lower_case
            --data_dir ./tests/fixtures/tests_samples/MRPC/
            --output_dir ./examples/deebert/saved_models/roberta-base/MRPC/two_stage
            --plot_data_dir ./examples/deebert/results/
            --max_seq_length 128
            --early_exit_entropy 0.1
            --eval_highway
            --overwrite_cache
            --per_gpu_eval_batch_size=1
            """.split()
											self.run_and_check(UpperCamelCase__)
