





'''simple docstring'''




import argparse
import dataclasses
import json
import logging
import os
import shutil
from typing import List, Optional

import datasets
from accelerate import Accelerator
from datasets import load_dataset
from finetuning import finetune
from tqdm.auto import tqdm

import transformers
from transformers import AutoConfig, set_seed
from transformers.trainer_utils import IntervalStrategy


__SCREAMING_SNAKE_CASE     :int       =				logging.getLogger(__name__)

__SCREAMING_SNAKE_CASE     :Optional[int]       =				'''pytorch_model.bin'''







@dataclasses.dataclass
class   A_	:
 _lowerCamelCase  : str           =							dataclasses.field(
     metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models."""}			)
 _lowerCamelCase  : Optional[str]           =							dataclasses.field(
     default=lowerCAmelCase_							,						metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co."""}							,						)







@dataclasses.dataclass
class   A_	:
 _lowerCamelCase  : str           =							dataclasses.field(metadata={"""help""": """A csv or a json file containing the training data."""}			)
 _lowerCamelCase  : str           =							dataclasses.field(metadata={"""help""": """A csv or a json file containing the data to predict on."""}			)
 _lowerCamelCase  : Optional[str]           =							dataclasses.field(
     default=lowerCAmelCase_							,						metadata={"""help""": """A csv or a json file containing the validation data."""}			)
 _lowerCamelCase  : Optional[str]           =							dataclasses.field(
     default=lowerCAmelCase_							,						metadata={"""help""": """The name of the task to train on."""}							,						)
 _lowerCamelCase  : Optional[List[str]]           =							dataclasses.field(
     default=lowerCAmelCase_							,						metadata={"""help""": """The list of labels for the task."""}			)







@dataclasses.dataclass
class   A_	:
 _lowerCamelCase  : str           =							dataclasses.field(
     metadata={"""help""": """The output directory where the model predictions and checkpoints will be written."""}			)
 _lowerCamelCase  : Optional[str]           =							dataclasses.field(
     default="""accuracy"""							,						metadata={"""help""": """The evaluation metric used for the task."""}			)
 _lowerCamelCase  : Optional[str]           =							dataclasses.field(
     default="""no"""							,						metadata={
         """help""": """The evaluation strategy to adopt during training. Possible values are: [\"no\", \"step\", \"epoch]"""
     }							,						)
 _lowerCamelCase  : Optional[int]           =							dataclasses.field(
     default=10							,						metadata={"""help""": """Number of evaluation calls with no improvement after which training will be stopped."""}							,						)
 _lowerCamelCase  : Optional[float]           =							dataclasses.field(
     default=0.0							,						metadata={
         """help""": """How much the specified evaluation metric must improve to satisfy early stopping conditions."""
     }							,						)
 _lowerCamelCase  : Optional[bool]           =							dataclasses.field(
     default=lowerCAmelCase_							,						metadata={"""help""": """Whether to filter the pseudo-labeled data based on the confidence score."""}							,						)
 _lowerCamelCase  : Optional[bool]           =							dataclasses.field(
     default=lowerCAmelCase_							,						metadata={"""help""": """Whether to filter the pseudo-labeled data based on the validation performance."""}							,						)
 _lowerCamelCase  : Optional[bool]           =							dataclasses.field(
     default=lowerCAmelCase_							,						metadata={"""help""": """Whether to fine-tune on labeled data after pseudo training."""}							,						)
 _lowerCamelCase  : Optional[float]           =							dataclasses.field(
     default=0.0							,						metadata={"""help""": """Confidence threshold for pseudo-labeled data filtering."""}							,						)
 _lowerCamelCase  : Optional[int]           =							dataclasses.field(
     default=1_00							,						metadata={"""help""": """Number of evaluation calls with no improvement after which training will be stopped."""}							,						)
 _lowerCamelCase  : Optional[int]           =							dataclasses.field(
     default=lowerCAmelCase_							,						metadata={"""help""": """Random seed for initialization."""}							,						)





def 	UpperCAmelCase_							(					__lowercase							:      Any			,     __lowercase							:      List[Any]			,     __lowercase							:      Optional[Any]			,     __lowercase							:      List[str]			,     __lowercase							:      str			,     __lowercase							:      str       )		->       Optional[int]:


     '''simple docstring'''



     _UpperCAmelCase     							=   datasets.concatenate_datasets([infer_input, infer_output]			,     axis=1       )

     if args.do_filter_by_confidence:
          _UpperCAmelCase     							=   dataset.filter(lambda __lowercase       : example["probability"] > args.confidence_threshold       )

     if args.do_filter_by_val_performance:
          assert eval_result >= 0.0 and eval_result <= 1.0
          _UpperCAmelCase     							=   int(eval_result * len(__lowercase       )       )
          print(__lowercase       )
          _UpperCAmelCase     							=   dataset.sort("probability"			,     reverse=__lowercase       )
          _UpperCAmelCase     							=   dataset.select(range(__lowercase       )       )

     _UpperCAmelCase     							=   dataset.remove_columns(["label", "probability"]       )
     _UpperCAmelCase     							=   dataset.rename_column("prediction"			,     "label"       )
     _UpperCAmelCase     							=   dataset.map(lambda __lowercase       : {"label": idalabel[example["label"]]}       )
     _UpperCAmelCase     							=   dataset.shuffle(seed=args.seed       )

     _UpperCAmelCase     							=   os.path.join(__lowercase			,     f'train_pseudo.{args.data_file_extension}'       )
     if args.data_file_extension == "csv":
          dataset.to_csv(__lowercase			,     index=__lowercase       )
     else:
          dataset.to_json(__lowercase       )






def 	UpperCAmelCase_							(					__lowercase							:      List[Any]			,     __lowercase							:      int			,     __lowercase							:      Dict			,     __lowercase							:      List[str]			,     **__lowercase							:      Optional[int]       )		->       List[Any]:


     '''simple docstring'''



     _UpperCAmelCase     							=   Accelerator()
     # Make one log on every process with the configuration for debugging.
     logging.basicConfig(
         format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"			,     datefmt="%m/%d/%Y %H:%M:%S"			,     level=logging.INFO			,     )
     logger.info(accelerator.state       )

     # Setup logging, we only want one process per machine to log things on the
     # screen. accelerator.is_local_main_process is only True for one process per
     # machine.
     logger.setLevel(logging.INFO if accelerator.is_local_main_process else logging.ERROR       )

     if accelerator.is_local_main_process:
          datasets.utils.logging.set_verbosity_warning()
          transformers.utils.logging.set_verbosity_info()
     else:
          datasets.utils.logging.set_verbosity_error()
          transformers.utils.logging.set_verbosity_error()

     _UpperCAmelCase     							=   STModelArguments(model_name_or_path=__lowercase       )
     _UpperCAmelCase     							=   STDataArguments(train_file=__lowercase			,     infer_file=__lowercase       )
     _UpperCAmelCase     							=   STTrainingArguments(output_dir=__lowercase       )
     _UpperCAmelCase     							=   argparse.Namespace()

     for arg_class in (model_args, data_args, training_args):
          for key, value in vars(__lowercase       ).items():
               setattr(__lowercase			,     __lowercase			,     __lowercase       )

     for key, value in kwargs.items():
          if hasattr(__lowercase			,     __lowercase       ):
               setattr(__lowercase			,     __lowercase			,     __lowercase       )

    # Sanity checks
     _UpperCAmelCase     							=   {}
     _UpperCAmelCase     							=   None

     # You need to provide the training data and the data to predict on
     assert args.train_file is not None
     assert args.infer_file is not None
     _UpperCAmelCase     							=   args.train_file
     _UpperCAmelCase     							=   args.infer_file

     if args.evaluation_strategy != IntervalStrategy.NO.value:
          assert args.eval_file is not None
          _UpperCAmelCase     							=   args.eval_file

     for key in data_files:
          _UpperCAmelCase     							=   data_files[key].split("."       )[-1]
          assert extension in ["csv", "json"], f'`{key}_file` should be a csv or a json file.'
          if args.data_file_extension is None:
               _UpperCAmelCase     							=   extension
          else:
               assert extension == args.data_file_extension, f'`{key}_file` should be a {args.data_file_extension} file`.'

     assert (
         args.eval_metric in datasets.list_metrics()
     ), f'{args.eval_metric} not in the list of supported metrics {datasets.list_metrics()}.'

     # If passed along, set the training seed now.
     if args.seed is not None:
          set_seed(args.seed       )

     logger.info("Creating the initial data directory for self-training..."       )
     _UpperCAmelCase     							=   f'{args.output_dir}/self-train_iter-{{}}'.format
     _UpperCAmelCase     							=   data_dir_format(0       )

     if accelerator.is_main_process:
          if args.output_dir is not None:
               os.makedirs(args.output_dir			,     exist_ok=__lowercase       )
               os.makedirs(__lowercase			,     exist_ok=__lowercase       )
     accelerator.wait_for_everyone()

     _UpperCAmelCase     							=   None
     _UpperCAmelCase     							=   None
     _UpperCAmelCase     							=   0
     _UpperCAmelCase     							=   False
     # Show the progress bar
     _UpperCAmelCase     							=   tqdm(range(args.max_selftrain_iterations       )			,     disable=not accelerator.is_local_main_process       )

     # Self-train
     for iteration in range(0			,     int(args.max_selftrain_iterations       )       ):
          _UpperCAmelCase     							=   data_dir_format(__lowercase       )
          assert os.path.exists(__lowercase       )

          # Stage 1: initial fine-tuning for iteration = 0 or pseudo-training for
          # iteration > 0
          _UpperCAmelCase     							=   os.path.join(__lowercase			,     "stage-1"       )
          _UpperCAmelCase     							=   {
              "accelerator": accelerator,
              "model_name_or_path": args.model_name_or_path,
              "cache_dir": args.cache_dir,
              "do_train": True,
              "train_file": data_files["train"] if iteration == 0 else data_files["train_pseudo"],
              "do_eval": True if args.eval_file is not None else False,
              "eval_file": data_files["eval"],
              "do_predict": True,
              "infer_file": data_files["infer"],
              "task_name": args.task_name,
              "label_list": args.label_list,
              "output_dir": current_output_dir,
              "eval_metric": args.eval_metric,
              "evaluation_strategy": args.evaluation_strategy,
              "early_stopping_patience": args.early_stopping_patience,
              "early_stopping_threshold": args.early_stopping_threshold,
              "seed": args.seed,
          }
          # Add additional training arguments
          for key, value in kwargs.items():
               if key not in arguments_dict and not hasattr(__lowercase			,     __lowercase       ):
                    arguments_dict.update({key: value}       )

          _UpperCAmelCase     							=   os.path.join(__lowercase			,     "best-checkpoint"			,     __lowercase       )
          if os.path.exists(__lowercase       ):
               logger.info(
                   "Found existing model checkpoint at %s. Skipping self-training: iteration: %d, stage: 1."			,     __lowercase			,     __lowercase			,     )
          else:
               logger.info("***** Running self-training: iteration: %d, stage: 1 *****"			,     __lowercase       )
               finetune(**__lowercase       )
               accelerator.wait_for_everyone()
               assert os.path.exists(__lowercase       )
               logger.info("Self-training job completed: iteration: %d, stage: 1."			,     __lowercase       )

          if iteration > 0 and args.finetune_on_labeled_data:
               # Stage 2 (optional): fine-tuning on the original labeled data
               _UpperCAmelCase     							=   os.path.join(__lowercase			,     "best-checkpoint"       )
               _UpperCAmelCase     							=   os.path.join(__lowercase			,     "stage-2"       )
               # Update arguments_dict
               _UpperCAmelCase     							=   model_path
               _UpperCAmelCase     							=   data_files["train"]
               _UpperCAmelCase     							=   current_output_dir

               _UpperCAmelCase     							=   os.path.join(__lowercase			,     "best-checkpoint"			,     __lowercase       )
               if os.path.exists(__lowercase       ):
                    logger.info(
                        "Found existing model checkpoint at %s. Skipping self-training: iteration: %d, stage: 2."			,     __lowercase			,     __lowercase			,     )
               else:
                    logger.info("***** Running self-training: iteration: %d, stage: 2 *****"			,     __lowercase       )
                    finetune(**__lowercase       )
                    accelerator.wait_for_everyone()
                    assert os.path.exists(__lowercase       )
                    logger.info("Self-training job completed: iteration: %d, stage: 2."			,     __lowercase       )

          _UpperCAmelCase     							=   iteration
          _UpperCAmelCase     							=   data_dir_format(iteration + 1       )

          _UpperCAmelCase     							=   AutoConfig.from_pretrained(os.path.join(__lowercase			,     "best-checkpoint"       )       )
          _UpperCAmelCase     							=   config.idalabel
          _UpperCAmelCase     							=   os.path.join(__lowercase			,     "eval_results_best-checkpoint.json"       )
          _UpperCAmelCase     							=   os.path.join(__lowercase			,     "test_results_best-checkpoint.json"       )
          assert os.path.exists(__lowercase       )

          with open(__lowercase			,     "r"       ) as f:
               _UpperCAmelCase     							=   float(json.load(__lowercase       )[args.eval_metric]       )
          _UpperCAmelCase     							=   os.path.join(__lowercase			,     "infer_output_best-checkpoint.csv"       )
          assert os.path.exists(__lowercase       )
          # Loading the dataset from local csv or json files.
          _UpperCAmelCase     							=   load_dataset(args.data_file_extension			,     data_files={"data": data_files["infer"]}       )["data"]
          _UpperCAmelCase     							=   load_dataset("csv"			,     data_files={"data": infer_output_file}       )["data"]

          if accelerator.is_main_process:
               os.makedirs(__lowercase			,     exist_ok=__lowercase       )
               shutil.copy(__lowercase			,     os.path.join(__lowercase			,     f'eval_results_iter-{iteration}.json'       )       )
               if os.path.exists(__lowercase       ):
                    shutil.copy(__lowercase			,     os.path.join(__lowercase			,     f'test_results_iter-{iteration}.json'       )       )
               create_pseudo_labeled_data(__lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase       )
          accelerator.wait_for_everyone()

          _UpperCAmelCase     							=   os.path.join(__lowercase			,     f'train_pseudo.{args.data_file_extension}'       )

          if args.evaluation_strategy != IntervalStrategy.NO.value:
               _UpperCAmelCase     							=   eval_result

               if best_iteration is None:
                    _UpperCAmelCase     							=   new_iteration
                    _UpperCAmelCase     							=   new_eval_result
               else:
                    if new_eval_result - best_eval_result > args.early_stopping_threshold:
                         _UpperCAmelCase     							=   new_iteration
                         _UpperCAmelCase     							=   new_eval_result
                         _UpperCAmelCase     							=   0
                    else:
                         if new_eval_result == best_eval_result:
                              _UpperCAmelCase     							=   new_iteration
                              _UpperCAmelCase     							=   new_eval_result
                         early_stopping_patience_counter += 1

                    if early_stopping_patience_counter >= args.early_stopping_patience:
                         _UpperCAmelCase     							=   True

          progress_bar.update(1       )

          if should_training_stop:
               break

     if best_iteration is not None:
          # Save the best iteration
          logger.info("Best iteration: %d"			,     __lowercase       )
          logger.info("Best evaluation result: %s = %f"			,     args.eval_metric			,     __lowercase       )
          accelerator.wait_for_everyone()
          if accelerator.is_main_process:
               shutil.copy(
                   os.path.join(__lowercase			,     f'eval_results_iter-{iteration}.json'       )			,     os.path.join(__lowercase			,     "eval_results_best-iteration.json"       )			,     )
     else:
          # Assume that the last iteration is the best
          logger.info("Best iteration: %d"			,     args.max_selftrain_iterations - 1       )
          logger.info("Best evaluation result: %s = %f"			,     args.eval_metric			,     __lowercase       )
          accelerator.wait_for_everyone()
          if accelerator.is_main_process:
               shutil.copy(
                   os.path.join(__lowercase			,     f'eval_results_iter-{args.max_selftrain_iterations - 1}.json'       )			,     os.path.join(__lowercase			,     "eval_results_best-iteration.json"       )			,     )









"""simple docstring"""







from __future__ import annotations

import unittest

from transformers import is_tf_available, is_torch_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, is_pt_tf_cross_test, slow


if is_tf_available():
							from transformers import (
							    AutoConfig,
							    BertConfig,
							    GPTaConfig,
							    TaConfig,
							    TFAutoModel,
							    TFAutoModelForCausalLM,
							    TFAutoModelForMaskedLM,
							    TFAutoModelForPreTraining,
							    TFAutoModelForQuestionAnswering,
							    TFAutoModelForSeqaSeqLM,
							    TFAutoModelForSequenceClassification,
							    TFAutoModelWithLMHead,
							    TFBertForMaskedLM,
							    TFBertForPreTraining,
							    TFBertForQuestionAnswering,
							    TFBertForSequenceClassification,
							    TFBertModel,
							    TFGPTaLMHeadModel,
							    TFRobertaForMaskedLM,
							    TFTaForConditionalGeneration,
							)
							from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
							from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
							from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST

if is_torch_available():
							from transformers import (
							    AutoModel,
							    AutoModelForCausalLM,
							    AutoModelForMaskedLM,
							    AutoModelForPreTraining,
							    AutoModelForQuestionAnswering,
							    AutoModelForSeqaSeqLM,
							    AutoModelForSequenceClassification,
							    AutoModelWithLMHead,
							    BertForMaskedLM,
							    BertForPreTraining,
							    BertForQuestionAnswering,
							    BertForSequenceClassification,
							    BertModel,
							    GPTaLMHeadModel,
							    RobertaForMaskedLM,
							    TaForConditionalGeneration,
							)
@is_pt_tf_cross_test
class        __A       (	unittest.TestCase    ):







		'''simple docstring'''





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






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    Tuple				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Dict				=			TFAutoModel.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			AutoModel.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







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






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    Dict				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    str				=			TFAutoModelForPreTraining.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Optional[Any]				=			AutoModelForPreTraining.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Dict:






				"""simple docstring"""



				for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Any				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			TFAutoModelForCausalLM.from_pretrained(_snake_case			,from_pt=_snake_case						)
						lowercase__		,			lowercase__   :    Optional[Any]				=			TFAutoModelForCausalLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Union[str, Any]				=			AutoModelForCausalLM.from_pretrained(_snake_case			,from_tf=_snake_case						)
						lowercase__		,			lowercase__   :    Optional[Any]				=			AutoModelForCausalLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Any						)					->		Tuple:






				"""simple docstring"""



				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Any				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Optional[Any]				=			TFAutoModelWithLMHead.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			AutoModelWithLMHead.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  List[str]						)					->		Optional[Any]:






				"""simple docstring"""



				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    str				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Union[str, Any]				=			TFAutoModelForMaskedLM.from_pretrained(_snake_case			,from_pt=_snake_case						)
						lowercase__		,			lowercase__   :    str				=			TFAutoModelForMaskedLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			AutoModelForMaskedLM.from_pretrained(_snake_case			,from_tf=_snake_case						)
						lowercase__		,			lowercase__   :    Any				=			AutoModelForMaskedLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		Dict:






				"""simple docstring"""



				for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Union[str, Any]				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			TFAutoModelForSeqaSeqLM.from_pretrained(_snake_case			,from_pt=_snake_case						)
						lowercase__		,			lowercase__   :    List[str]				=			TFAutoModelForSeqaSeqLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			AutoModelForSeqaSeqLM.from_pretrained(_snake_case			,from_tf=_snake_case						)
						lowercase__		,			lowercase__   :    Optional[int]				=			AutoModelForSeqaSeqLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







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






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    Tuple				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			TFAutoModelForSequenceClassification.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Union[str, Any]				=			AutoModelForSequenceClassification.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Optional[Any]:






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    List[Any]				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    str				=			TFAutoModelForQuestionAnswering.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			AutoModelForQuestionAnswering.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			TFAutoModelWithLMHead.from_pretrained(_snake_case			,from_pt=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)

				lowercase__   :    Union[str, Any]				=			AutoModelWithLMHead.from_pretrained(_snake_case			,from_tf=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)







		def 					UpperCAmelCase    (	self						:  int						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			TFAutoModelWithLMHead.from_pretrained(_snake_case			,from_pt=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)

				lowercase__   :    int				=			AutoModelWithLMHead.from_pretrained(_snake_case			,from_tf=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)
