

"""simple docstring"""




import argparse
import logging
import os
import sys
import tempfile
from pathlib import Path

import lightning_base
import pytest
import pytorch_lightning as pl
import torch
from convert_pl_checkpoint_to_hf import convert_pl_to_hf
from distillation import distill_main
from finetune import SummarizationModule, main
from huggingface_hub import list_models
from parameterized import parameterized
from run_eval import generate_summaries_or_translations
from torch import nn

from transformers import AutoConfig, AutoModelForSeqaSeqLM
from transformers.testing_utils import CaptureStderr, CaptureStdout, TestCasePlus, require_torch_gpu, slow
from utils import label_smoothed_nll_loss, lmap, load_json


logging.basicConfig(level=logging.DEBUG)

__A  :					Any												=	logging.getLogger()
__A  :					Dict												=	torch.cuda.is_available()
__A  :					Optional[Any]												=	{
    'max_tokens_per_batch': None,
    'supervise_forward': True,
    'normalize_hidden': True,
    'label_smoothing': 0.2,
    'eval_max_gen_length': None,
    'eval_beams': 1,
    'val_metric': 'loss',
    'save_top_k': 1,
    'adafactor': True,
    'early_stopping_patience': 2,
    'logger_name': 'default',
    'length_penalty': 0.5,
    'cache_dir': '',
    'task': 'summarization',
    'num_workers': 2,
    'alpha_hid': 0,
    'freeze_embeds': True,
    'enc_only': False,
    'tgt_suffix': '',
    'resume_from_checkpoint': None,
    'sortish_sampler': True,
    'student_decoder_layers': 1,
    'val_check_interval': 1.0,
    'output_dir': '',
    'fp16': False,  # TODO(SS): set this to CUDA_AVAILABLE if ci installs apex or start using native amp
    'no_teacher': False,
    'fp16_opt_level': 'O1',
    'gpus': 1 if CUDA_AVAILABLE else 0,
    'n_tpu_cores': 0,
    'max_grad_norm': 1.0,
    'do_train': True,
    'do_predict': True,
    'accumulate_grad_batches': 1,
    'server_ip': '',
    'server_port': '',
    'seed': 42,
    'model_name_or_path': 'sshleifer/bart-tiny-random',
    'config_name': '',
    'tokenizer_name': 'facebook/bart-large',
    'do_lower_case': False,
    'learning_rate': 0.3,
    'lr_scheduler': 'linear',
    'weight_decay': 0.0,
    'adam_epsilon': 1E-08,
    'warmup_steps': 0,
    'max_epochs': 1,
    'train_batch_size': 2,
    'eval_batch_size': 2,
    'max_source_length': 12,
    'max_target_length': 12,
    'val_max_target_length': 12,
    'test_max_target_length': 12,
    'fast_dev_run': False,
    'no_cache': False,
    'n_train': -1,
    'n_val': -1,
    'n_test': -1,
    'student_encoder_layers': 1,
    'freeze_encoder': False,
    'auto_scale_batch_size': False,
    'overwrite_output_dir': False,
    'student': None,
}
def      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							lowercase__   ):
					"""simple docstring"""
					A    =      "\n".join(lowercase__   )
					Path(lowercase__   ).open("w"   ).writelines(lowercase__   )


__A  :					Dict												=	[' Sam ate lunch today.', 'Sams lunch ingredients.']
__A  :					Tuple												=	['A very interesting story about what I ate for lunch.', 'Avocado, celery, turkey, coffee']
__A  :					List[Any]												=	'patrickvonplaten/t5-tiny-random'
__A  :					Optional[int]												=	'sshleifer/t5-tinier-random'
__A  :					int												=	'sshleifer/bart-tiny-random'
__A  :					Tuple												=	'sshleifer/tiny-mbart'
__A  :					Dict												=	'sshleifer/tiny-marian-en-de'
__A  :					List[str]												=	'stas/tiny-wmt19-en-de'


__A  :					Optional[int]												=	logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)
logging.disable(logging.CRITICAL)  # remove noisy download output from tracebacks
def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
					"""simple docstring"""
					for split in ["train", "val", "test"]:
										_dump_articles(os.path.join(lowercase__    ,							F"""{split}.source"""   )    ,							lowercase__   )
										_dump_articles(os.path.join(lowercase__    ,							F"""{split}.target"""   )    ,							lowercase__   )
					return tmp_dir





class     __UpperCamelCase				(     _A		):


		@classmethod
		def       SCREAMING_SNAKE_CASE__     (cls				:	int):
							logging.disable(logging.CRITICAL)  # remove noisy download output from tracebacks
							return cls


		@slow
		@require_torch_gpu
		def       SCREAMING_SNAKE_CASE__     (self				:	Union[str, Any]):
							A    =      list_models()
							A    =      "sshleifer"
							A    =      [x.modelId for x in model_list if x.modelId.startswith(__SCREAMING_SNAKE_CASE)]
							A    =      ["sshleifer/blenderbot-3B", "sshleifer/blenderbot-90M"]
							A    =      []
							for m in model_ids:
												if m in allowed_to_be_broken:
																	continue
												try:
																	AutoConfig.from_pretrained(__SCREAMING_SNAKE_CASE)
												except Exception:
																	failures.append(__SCREAMING_SNAKE_CASE)
							assert not failures, F"""The following models could not be loaded through AutoConfig: {failures}"""


		def       SCREAMING_SNAKE_CASE__     (self				:	Dict):
							A    =      {"student_encoder_layers": 2, "student_decoder_layers": 1, "no_teacher": True}
							self._test_distiller_cli(__SCREAMING_SNAKE_CASE)


		def       SCREAMING_SNAKE_CASE__     (self				:	Dict):
							A    =      {
							    "student_encoder_layers": 2,
							    "student_decoder_layers": 1,
							    "max_epochs": 4,
							    "val_check_interval": 0.2_5,
							    "alpha_hid": 2.0,
							    "model_name_or_path": "IGNORE_THIS_IT_DOESNT_GET_USED",
							}
							A    =      self._test_distiller_cli(__SCREAMING_SNAKE_CASE  ,  check_contents=__SCREAMING_SNAKE_CASE)

							A    =      list(Path(model.output_dir).glob("*.ckpt"))
							self.assertEqual(1  ,  len(__SCREAMING_SNAKE_CASE))
							A    =      list(Path(model.output_dir).glob("**/*.bin"))
							self.assertEqual(len(__SCREAMING_SNAKE_CASE)  ,  2)
							A    =      lmap(str.strip  ,  Path(model.hparams.data_dir).joinpath("test.source").open().readlines())
							A    =      tempfile.mktemp()  # XXX: not being cleaned up
							generate_summaries_or_translations(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE  ,  str(model.output_dir / "best_tfmr"))
							self.assertTrue(Path(__SCREAMING_SNAKE_CASE).exists())

							A    =      self.get_auto_remove_tmp_dir()
							convert_pl_to_hf(ckpts[0]  ,  transformer_ckpts[0].parent  ,  __SCREAMING_SNAKE_CASE)
							assert os.path.exists(os.path.join(__SCREAMING_SNAKE_CASE  ,  "pytorch_model.bin"))


		def       SCREAMING_SNAKE_CASE__     (self				:	Tuple):
							A    =      AutoModelForSeqaSeqLM.from_pretrained(__SCREAMING_SNAKE_CASE)
							A    ,					A    =      model.dummy_inputs["input_ids"], model.dummy_inputs["attention_mask"]
							A    =      torch.tensor([[0, 4, 8, 2], [0, 8, 2, 1]]  ,  dtype=torch.long  ,  device=model.device)
							A    =      target_ids[:, :-1].contiguous()  # Why this line?
							A    =      target_ids[:, 1:].clone()  # why clone?
							A    =      model(
							    __SCREAMING_SNAKE_CASE  ,  attention_mask=__SCREAMING_SNAKE_CASE  ,  decoder_input_ids=__SCREAMING_SNAKE_CASE  ,  labels=__SCREAMING_SNAKE_CASE  ,  use_cache=__SCREAMING_SNAKE_CASE).loss

							A    =      model(__SCREAMING_SNAKE_CASE  ,  attention_mask=__SCREAMING_SNAKE_CASE  ,  decoder_input_ids=__SCREAMING_SNAKE_CASE  ,  use_cache=__SCREAMING_SNAKE_CASE).logits

							A    =      nn.functional.log_softmax(__SCREAMING_SNAKE_CASE  ,  dim=-1)
							A    ,					A    =      label_smoothed_nll_loss(
							    __SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE  ,  0.1  ,  ignore_index=model.config.pad_token_id)
							with self.assertRaises(__SCREAMING_SNAKE_CASE):
												# TODO: understand why this breaks
												self.assertEqual(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE)


		def       SCREAMING_SNAKE_CASE__     (self				:	List[str]):
							A    =      {
							    "student_encoder_layers": 2,
							    "student_decoder_layers": 1,
							    "num_train_epochs": 4,
							    "val_check_interval": 0.2_5,
							    "alpha_hid": 2.0,
							    "task": "translation",
							    "model_name_or_path": "IGNORE_THIS_IT_DOESNT_GET_USED",
							    "tokenizer_name": MBART_TINY,
							    "teacher": MBART_TINY,
							    "src_lang": "en_XX",
							    "tgt_lang": "ro_RO",
							}
							A    =      self._test_distiller_cli(__SCREAMING_SNAKE_CASE  ,  check_contents=__SCREAMING_SNAKE_CASE)
							assert model.model.config.model_type == "mbart"

							A    =      list(Path(model.output_dir).glob("*.ckpt"))
							self.assertEqual(1  ,  len(__SCREAMING_SNAKE_CASE))
							A    =      list(Path(model.output_dir).glob("**/*.bin"))
							A    =      list(Path(model.output_dir).glob("best_tfmr/*"))
							assert len(__SCREAMING_SNAKE_CASE) > 2
							self.assertEqual(len(__SCREAMING_SNAKE_CASE)  ,  2)


		def       SCREAMING_SNAKE_CASE__     (self				:	Optional[int]):
							A    =      {
							    "student_encoder_layers": 1,
							    "student_decoder_layers": 1,
							    "alpha_hid": 2.0,
							    "teacher": T5_TINY,
							    "model_name_or_path": T5_TINY,
							    "tokenizer_name": T5_TINY,
							}
							self._test_distiller_cli(__SCREAMING_SNAKE_CASE)


		def       SCREAMING_SNAKE_CASE__     (self				:	Dict):
							A    =      {
							    "teacher": T5_TINY,
							    "student": T5_TINIER,
							    "model_name_or_path": T5_TINIER,
							    "tokenizer_name": T5_TINIER,
							}
							self._test_distiller_cli(__SCREAMING_SNAKE_CASE)


		def       SCREAMING_SNAKE_CASE__     (self				:	Tuple  ,  __SCREAMING_SNAKE_CASE				:	List[Any]  ,  __SCREAMING_SNAKE_CASE				:	List[Any]=True):
							A    =      {
							    "label_smoothing": 0.0,
							    "early_stopping_patience": -1,
							    "train_batch_size": 1,
							    "eval_batch_size": 2,
							    "max_epochs": 2,
							    "alpha_mlm": 0.2,
							    "alpha_ce": 0.8,
							    "do_predict": True,
							    "model_name_or_path": "sshleifer/tinier_bart",
							    "teacher": CHEAP_ARGS["model_name_or_path"],
							    "val_check_interval": 0.5,
							}
							default_updates.update(__SCREAMING_SNAKE_CASE)
							A    =      CHEAP_ARGS.copy()
							A    =      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir())
							A    =      self.get_auto_remove_tmp_dir()

							args_d.update(data_dir=__SCREAMING_SNAKE_CASE  ,  output_dir=__SCREAMING_SNAKE_CASE  ,  **__SCREAMING_SNAKE_CASE)
							A    =      distill_main(argparse.Namespace(**__SCREAMING_SNAKE_CASE))
							if not check_contents:
												return model
							A    =      os.listdir(__SCREAMING_SNAKE_CASE)
							A    =      {os.path.basename(__SCREAMING_SNAKE_CASE) for p in contents}
							A    =      [p for p in contents if p.endswith("ckpt")]
							assert len(__SCREAMING_SNAKE_CASE) > 0

							self.assertIn("test_generations.txt"  ,  __SCREAMING_SNAKE_CASE)
							self.assertIn("test_results.txt"  ,  __SCREAMING_SNAKE_CASE)

							A    =      load_json(model.metrics_save_path)
							A    =      metrics["val"][-1]
							self.assertGreaterEqual(last_step_stats["val_avg_gen_time"]  ,  0.0_1)
							self.assertGreaterEqual(1.0  ,  last_step_stats["val_avg_gen_time"])
							self.assertIsInstance(last_step_stats[F"""val_avg_{model.val_metric}"""]  ,  __SCREAMING_SNAKE_CASE)
							A    =      int(args_d["max_epochs"] * (1 / args_d["val_check_interval"]) + 1)
							self.assertEqual(len(metrics["val"])  ,  __SCREAMING_SNAKE_CASE)
							self.assertEqual(len(metrics["test"])  ,  1)
							return model





class     __UpperCamelCase				(     _A		):


		@parameterized.expand(
		    [T5_TINY, BART_TINY, MBART_TINY, MARIAN_TINY, FSMT_TINY]  ,  )
		def       SCREAMING_SNAKE_CASE__     (self				:	Tuple  ,  __SCREAMING_SNAKE_CASE				:	Union[str, Any]):
							A    =      CHEAP_ARGS.copy()
							A    =      "translation" if model in [MBART_TINY, MARIAN_TINY, FSMT_TINY] else "summarization"
							A    =      0.1 if task == "translation" else 0

							A    =      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir())
							A    =      self.get_auto_remove_tmp_dir()
							args_d.update(
							    data_dir=__SCREAMING_SNAKE_CASE  ,  model_name_or_path=__SCREAMING_SNAKE_CASE  ,  tokenizer_name=__SCREAMING_SNAKE_CASE  ,  train_batch_size=2  ,  eval_batch_size=2  ,  output_dir=__SCREAMING_SNAKE_CASE  ,  do_predict=__SCREAMING_SNAKE_CASE  ,  task=__SCREAMING_SNAKE_CASE  ,  src_lang="en_XX"  ,  tgt_lang="ro_RO"  ,  freeze_encoder=__SCREAMING_SNAKE_CASE  ,  freeze_embeds=__SCREAMING_SNAKE_CASE  ,  )
							assert "n_train" in args_d
							A    =      argparse.Namespace(**__SCREAMING_SNAKE_CASE)
							A    =      main(__SCREAMING_SNAKE_CASE)

							A    =      module.model.get_input_embeddings()
							assert not input_embeds.weight.requires_grad
							if model == T5_TINY:
												A    =      module.model.lm_head
												assert not lm_head.weight.requires_grad
												assert (lm_head.weight == input_embeds.weight).all().item()
							elif model == FSMT_TINY:
												A    =      module.model.model
												A    =      fsmt.decoder.embed_positions
												assert not embed_pos.weight.requires_grad
												assert not fsmt.decoder.embed_tokens.weight.requires_grad
												# check that embeds are not the same
												assert fsmt.decoder.embed_tokens != fsmt.encoder.embed_tokens
							else:
												A    =      module.model.model
												A    =      bart.decoder.embed_positions
												assert not embed_pos.weight.requires_grad
												assert not bart.shared.weight.requires_grad
												# check that embeds are the same
												assert bart.decoder.embed_tokens == bart.encoder.embed_tokens
												assert bart.decoder.embed_tokens == bart.shared

							A    =      load_json(module.output_dir / "text_batch.json")
							assert isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE)
							assert len(__SCREAMING_SNAKE_CASE) >= 4


		def       SCREAMING_SNAKE_CASE__     (self				:	Any):
							A    =      CHEAP_ARGS.copy()

							A    =      "summarization"
							A    =      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir())

							args_d.update(
							    data_dir=__SCREAMING_SNAKE_CASE  ,  tokenizer_name=__SCREAMING_SNAKE_CASE  ,  train_batch_size=2  ,  eval_batch_size=2  ,  do_predict=__SCREAMING_SNAKE_CASE  ,  task=__SCREAMING_SNAKE_CASE  ,  src_lang="en_XX"  ,  tgt_lang="ro_RO"  ,  freeze_encoder=__SCREAMING_SNAKE_CASE  ,  freeze_embeds=__SCREAMING_SNAKE_CASE  ,  )

							# test models whose config includes the extra_model_args
							A    =      BART_TINY
							A    =      self.get_auto_remove_tmp_dir()
							A    =      args_d.copy()
							args_da.update(
							    model_name_or_path=__SCREAMING_SNAKE_CASE  ,  output_dir=__SCREAMING_SNAKE_CASE  ,  )
							A    =      ("encoder_layerdrop", "decoder_layerdrop", "dropout", "attention_dropout")
							for p in extra_model_params:
												A    =      0.5
							A    =      argparse.Namespace(**__SCREAMING_SNAKE_CASE)
							A    =      main(__SCREAMING_SNAKE_CASE)
							for p in extra_model_params:
												assert getattr(model.config  ,  __SCREAMING_SNAKE_CASE) == 0.5, F"""failed to override the model config for param {p}"""

							# test models whose config doesn't include the extra_model_args
							A    =      T5_TINY
							A    =      self.get_auto_remove_tmp_dir()
							A    =      args_d.copy()
							args_da.update(
							    model_name_or_path=__SCREAMING_SNAKE_CASE  ,  output_dir=__SCREAMING_SNAKE_CASE  ,  )
							A    =      "encoder_layerdrop"
							A    =      0.5
							A    =      argparse.Namespace(**__SCREAMING_SNAKE_CASE)
							with pytest.raises(__SCREAMING_SNAKE_CASE) as excinfo:
												A    =      main(__SCREAMING_SNAKE_CASE)
							assert str(excinfo.value) == F"""model config doesn't have a `{unsupported_param}` attribute"""


		def       SCREAMING_SNAKE_CASE__     (self				:	Dict):
							A    =      CHEAP_ARGS.copy()

							A    =      "summarization"
							A    =      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir())

							A    =      BART_TINY
							A    =      self.get_auto_remove_tmp_dir()

							args_d.update(
							    data_dir=__SCREAMING_SNAKE_CASE  ,  model_name_or_path=__SCREAMING_SNAKE_CASE  ,  output_dir=__SCREAMING_SNAKE_CASE  ,  tokenizer_name=__SCREAMING_SNAKE_CASE  ,  train_batch_size=2  ,  eval_batch_size=2  ,  do_predict=__SCREAMING_SNAKE_CASE  ,  task=__SCREAMING_SNAKE_CASE  ,  src_lang="en_XX"  ,  tgt_lang="ro_RO"  ,  freeze_encoder=__SCREAMING_SNAKE_CASE  ,  freeze_embeds=__SCREAMING_SNAKE_CASE  ,  )

							# emulate finetune.py
							A    =      argparse.ArgumentParser()
							A    =      pl.Trainer.add_argparse_args(__SCREAMING_SNAKE_CASE)
							A    =      SummarizationModule.add_model_specific_args(__SCREAMING_SNAKE_CASE  ,  os.getcwd())
							A    =      {"--help": True}

							# --help test
							with pytest.raises(__SCREAMING_SNAKE_CASE) as excinfo:
												with CaptureStdout() as cs:
																	A    =      parser.parse_args(__SCREAMING_SNAKE_CASE)
												assert False, "--help is expected to sys.exit"
							assert excinfo.type == SystemExit
							A    =      lightning_base.arg_to_scheduler_metavar
							assert expected in cs.out, "--help is expected to list the supported schedulers"

							# --lr_scheduler=non_existing_scheduler test
							A    =      "non_existing_scheduler"
							A    =      {F"""--lr_scheduler={unsupported_param}"""}
							with pytest.raises(__SCREAMING_SNAKE_CASE) as excinfo:
												with CaptureStderr() as cs:
																	A    =      parser.parse_args(__SCREAMING_SNAKE_CASE)
												assert False, "invalid argument is expected to sys.exit"
							assert excinfo.type == SystemExit
							A    =      F"""invalid choice: '{unsupported_param}'"""
							assert expected in cs.err, F"""should have bailed on invalid choice of scheduler {unsupported_param}"""

							# --lr_scheduler=existing_scheduler test
							A    =      "cosine"
							A    =      args_d.copy()
							A    =      supported_param
							A    =      argparse.Namespace(**__SCREAMING_SNAKE_CASE)
							A    =      main(__SCREAMING_SNAKE_CASE)
							assert (
							    getattr(model.hparams  ,  "lr_scheduler") == supported_param
							), F"""lr_scheduler={supported_param} shouldn't fail"""









"""simple docstring"""




import os

from ...utils import logging
from .utils import DataProcessor, InputExample


__A  :					List[Any]												=	logging.get_logger(__name__)





class     __UpperCamelCase				(     _A		):


		def __init__(self				:	Dict  ,  __SCREAMING_SNAKE_CASE				:	int  ,  __SCREAMING_SNAKE_CASE				:	Any=None):
							A    =      language
							A    =      train_language


		def       SCREAMING_SNAKE_CASE__     (self				:	Tuple  ,  __SCREAMING_SNAKE_CASE				:	Tuple):
							A    =      self.language if self.train_language is None else self.train_language
							A    =      self._read_tsv(os.path.join(__SCREAMING_SNAKE_CASE  ,  F"""XNLI-MT-1.0/multinli/multinli.train.{lg}.tsv"""))
							A    =      []
							for i, line in enumerate(__SCREAMING_SNAKE_CASE):
												if i == 0:
																	continue
												A    =      F"""train-{i}"""
												A    =      line[0]
												A    =      line[1]
												A    =      "contradiction" if line[2] == "contradictory" else line[2]
												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
																	raise ValueError(F"""Training input {text_a} is not a string""")
												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
																	raise ValueError(F"""Training input {text_b} is not a string""")
												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
																	raise ValueError(F"""Training label {label} is not a string""")
												examples.append(InputExample(guid=__SCREAMING_SNAKE_CASE  ,  text_a=__SCREAMING_SNAKE_CASE  ,  text_b=__SCREAMING_SNAKE_CASE  ,  label=__SCREAMING_SNAKE_CASE))
							return examples


		def       SCREAMING_SNAKE_CASE__     (self				:	List[str]  ,  __SCREAMING_SNAKE_CASE				:	Tuple):
							A    =      self._read_tsv(os.path.join(__SCREAMING_SNAKE_CASE  ,  "XNLI-1.0/xnli.test.tsv"))
							A    =      []
							for i, line in enumerate(__SCREAMING_SNAKE_CASE):
												if i == 0:
																	continue
												A    =      line[0]
												if language != self.language:
																	continue
												A    =      F"""test-{i}"""
												A    =      line[6]
												A    =      line[7]
												A    =      line[1]
												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
																	raise ValueError(F"""Training input {text_a} is not a string""")
												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
																	raise ValueError(F"""Training input {text_b} is not a string""")
												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
																	raise ValueError(F"""Training label {label} is not a string""")
												examples.append(InputExample(guid=__SCREAMING_SNAKE_CASE  ,  text_a=__SCREAMING_SNAKE_CASE  ,  text_b=__SCREAMING_SNAKE_CASE  ,  label=__SCREAMING_SNAKE_CASE))
							return examples


		def       SCREAMING_SNAKE_CASE__     (self				:	str):
							return ["contradiction", "entailment", "neutral"]

__A  :					Optional[int]												=	{
    'xnli': XnliProcessor,
}

__A  :					Union[str, Any]												=	{
    'xnli': 'classification',
}

__A  :					Tuple												=	{
    'xnli': 3,
}





