




import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import datasets
import numpy as np
import tensorflow as tf

from transformers import (
    AutoConfig,
    AutoTokenizer,
    EvalPrediction,
    HfArgumentParser,
    PreTrainedTokenizer,
    TFAutoModelForSequenceClassification,
    TFTrainer,
    TFTrainingArguments,
)
from transformers.utils import logging as hf_logging


hf_logging.set_verbosity_info()
hf_logging.enable_default_handler()
hf_logging.enable_explicit_format()

def lowercase    (  SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE = None       ,    )			->							Union[str, Any]:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_								=						{}

			if train_file is not None:
						SCREAMING_SNAKE_CASE_								=						[train_file]
			if eval_file is not None:
						SCREAMING_SNAKE_CASE_								=						[eval_file]
			if test_file is not None:
						SCREAMING_SNAKE_CASE_								=						[test_file]

			SCREAMING_SNAKE_CASE_								=						datasets.load_dataset('csv'       ,    data_files=SCREAMING_SNAKE_CASE )
			SCREAMING_SNAKE_CASE_								=						list(ds[list(files.keys() )[0]].features.keys() )
			SCREAMING_SNAKE_CASE_								=						features_name.pop(SCREAMING_SNAKE_CASE )
			SCREAMING_SNAKE_CASE_								=						list(set(ds[list(files.keys() )[0]][label_name] ) )
			SCREAMING_SNAKE_CASE_								=						{label: i for i, label in enumerate(SCREAMING_SNAKE_CASE )}
			SCREAMING_SNAKE_CASE_								=						tokenizer.model_input_names
			SCREAMING_SNAKE_CASE_								=						{}

			if len(SCREAMING_SNAKE_CASE ) == 1:
						for k in files.keys():
									SCREAMING_SNAKE_CASE_								=						ds[k].map(
									    lambda SCREAMING_SNAKE_CASE : tokenizer.batch_encode_plus(
									        example[features_name[0]]       ,    truncation=SCREAMING_SNAKE_CASE       ,    max_length=SCREAMING_SNAKE_CASE       ,    padding='max_length' )       ,    batched=SCREAMING_SNAKE_CASE       ,    )
			elif len(SCREAMING_SNAKE_CASE ) == 2:
						for k in files.keys():
									SCREAMING_SNAKE_CASE_								=						ds[k].map(
									    lambda SCREAMING_SNAKE_CASE : tokenizer.batch_encode_plus(
									        (example[features_name[0]], example[features_name[1]])       ,    truncation=SCREAMING_SNAKE_CASE       ,    max_length=SCREAMING_SNAKE_CASE       ,    padding='max_length'       ,    )       ,    batched=SCREAMING_SNAKE_CASE       ,    )

			def gen_train():
						for ex in transformed_ds[datasets.Split.TRAIN]:
									SCREAMING_SNAKE_CASE_								=						{k: v for k, v in ex.items() if k in input_names}
									SCREAMING_SNAKE_CASE_								=						labelaid[ex[label_name]]
									yield (d, label)

			def gen_val():
						for ex in transformed_ds[datasets.Split.VALIDATION]:
									SCREAMING_SNAKE_CASE_								=						{k: v for k, v in ex.items() if k in input_names}
									SCREAMING_SNAKE_CASE_								=						labelaid[ex[label_name]]
									yield (d, label)

			def gen_test():
						for ex in transformed_ds[datasets.Split.TEST]:
									SCREAMING_SNAKE_CASE_								=						{k: v for k, v in ex.items() if k in input_names}
									SCREAMING_SNAKE_CASE_								=						labelaid[ex[label_name]]
									yield (d, label)

			SCREAMING_SNAKE_CASE_								=						(
			    tf.data.Dataset.from_generator(
			        SCREAMING_SNAKE_CASE       ,    ({k: tf.intaa for k in input_names}, tf.intaa)       ,    ({k: tf.TensorShape([None] ) for k in input_names}, tf.TensorShape([] ))       ,    )
			    if datasets.Split.TRAIN in transformed_ds
			    else None
			)

			if train_ds is not None:
						SCREAMING_SNAKE_CASE_								=						train_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TRAIN] ) ) )

			SCREAMING_SNAKE_CASE_								=						(
			    tf.data.Dataset.from_generator(
			        SCREAMING_SNAKE_CASE       ,    ({k: tf.intaa for k in input_names}, tf.intaa)       ,    ({k: tf.TensorShape([None] ) for k in input_names}, tf.TensorShape([] ))       ,    )
			    if datasets.Split.VALIDATION in transformed_ds
			    else None
			)

			if val_ds is not None:
						SCREAMING_SNAKE_CASE_								=						val_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.VALIDATION] ) ) )

			SCREAMING_SNAKE_CASE_								=						(
			    tf.data.Dataset.from_generator(
			        SCREAMING_SNAKE_CASE       ,    ({k: tf.intaa for k in input_names}, tf.intaa)       ,    ({k: tf.TensorShape([None] ) for k in input_names}, tf.TensorShape([] ))       ,    )
			    if datasets.Split.TEST in transformed_ds
			    else None
			)

			if test_ds is not None:
						SCREAMING_SNAKE_CASE_								=						test_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TEST] ) ) )

			return train_ds, val_ds, test_ds, labelaid


SCREAMING_SNAKE_CASE__     :     Union[str, Any]		    =       logging.getLogger(__name__)



@dataclass
class       a_       :
	A    							= field(metadata={'''help''': '''Which column contains the label'''}     )
	A    							= field(default=SCREAMING_SNAKE_CASE__  ,    metadata={'''help''': '''The path of the training file'''}     )
	A    							= field(default=SCREAMING_SNAKE_CASE__  ,    metadata={'''help''': '''The path of the development file'''}     )
	A    							= field(default=SCREAMING_SNAKE_CASE__  ,    metadata={'''help''': '''The path of the test file'''}     )
	A    							= field(
	    default=128  ,    metadata={
	        '''help''': (
	            '''The maximum total input sequence length after tokenization. Sequences longer '''
	            '''than this will be truncated, sequences shorter will be padded.'''
	        )
	    }  ,    )
	A    							= field(
	    default=SCREAMING_SNAKE_CASE__  ,    metadata={'''help''': '''Overwrite the cached training and evaluation sets'''}     )




@dataclass
class       a_       :
	A    							= field(
	    metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}     )
	A    							= field(
	    default=SCREAMING_SNAKE_CASE__  ,    metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''}     )
	A    							= field(
	    default=SCREAMING_SNAKE_CASE__  ,    metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''}     )
	A    							= field(default=SCREAMING_SNAKE_CASE__  ,    metadata={'''help''': '''Set this flag to use fast tokenization.'''}     )
	# If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
	# or just modify its tokenizer_config.json.
	A    							= field(
	    default=SCREAMING_SNAKE_CASE__  ,    metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}  ,    )




def lowercase    (  )			->							Optional[int]:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_								=						HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments) )
			SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_								=						parser.parse_args_into_dataclasses()

			if (
			    os.path.exists(training_args.output_dir )
			    and os.listdir(training_args.output_dir )
			    and training_args.do_train
			    and not training_args.overwrite_output_dir
			):
						raise ValueError(
						    F'Output directory ({training_args.output_dir}) already exists and is not empty. Use'
						    ' --overwrite_output_dir to overcome.' )

			# Setup logging
			logging.basicConfig(
			    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'       ,    datefmt='%m/%d/%Y %H:%M:%S'       ,    level=logging.INFO       ,    )
			logger.info(
			    F'n_replicas: {training_args.n_replicas}, distributed training: {bool(training_args.n_replicas > 1 )}, '
			    F'16-bits training: {training_args.fpaa}' )
			logger.info(F'Training/evaluation parameters {training_args}' )

			# Load pretrained model and tokenizer
			#
			# Distributed training:
			# The .from_pretrained methods guarantee that only one local process can concurrently
			# download model & vocab.

			SCREAMING_SNAKE_CASE_								=						AutoTokenizer.from_pretrained(
			    model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path       ,    cache_dir=model_args.cache_dir       ,    )

			SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_								=						get_tfds(
			    train_file=data_args.train_file       ,    eval_file=data_args.dev_file       ,    test_file=data_args.test_file       ,    tokenizer=SCREAMING_SNAKE_CASE       ,    label_column_id=data_args.label_column_id       ,    max_seq_length=data_args.max_seq_length       ,    )

			SCREAMING_SNAKE_CASE_								=						AutoConfig.from_pretrained(
			    model_args.config_name if model_args.config_name else model_args.model_name_or_path       ,    num_labels=len(SCREAMING_SNAKE_CASE )       ,    labelaid=SCREAMING_SNAKE_CASE       ,    idalabel={id: label for label, id in labelaid.items()}       ,    finetuning_task='text-classification'       ,    cache_dir=model_args.cache_dir       ,    )

			with training_args.strategy.scope():
						SCREAMING_SNAKE_CASE_								=						TFAutoModelForSequenceClassification.from_pretrained(
						    model_args.model_name_or_path       ,    from_pt=bool('.bin' in model_args.model_name_or_path )       ,    config=SCREAMING_SNAKE_CASE       ,    cache_dir=model_args.cache_dir       ,    )

			def compute_metrics(SCREAMING_SNAKE_CASE ) -> Dict:
						SCREAMING_SNAKE_CASE_								=						np.argmax(p.predictions       ,    axis=1 )

						return {"acc": (preds == p.label_ids).mean()}

			# Initialize our Trainer
			SCREAMING_SNAKE_CASE_								=						TFTrainer(
			    model=SCREAMING_SNAKE_CASE       ,    args=SCREAMING_SNAKE_CASE       ,    train_dataset=SCREAMING_SNAKE_CASE       ,    eval_dataset=SCREAMING_SNAKE_CASE       ,    compute_metrics=SCREAMING_SNAKE_CASE       ,    )

			# Training
			if training_args.do_train:
						trainer.train()
						trainer.save_model()
						tokenizer.save_pretrained(training_args.output_dir )

			# Evaluation
			SCREAMING_SNAKE_CASE_								=						{}
			if training_args.do_eval:
						logger.info('*** Evaluate ***' )
						SCREAMING_SNAKE_CASE_								=						trainer.evaluate()
						SCREAMING_SNAKE_CASE_								=						os.path.join(training_args.output_dir       ,    'eval_results.txt' )

						with open(SCREAMING_SNAKE_CASE       ,    'w' ) as writer:
									logger.info('***** Eval results *****' )

									for key, value in result.items():
												logger.info(F'  {key} = {value}' )
												writer.write(F'{key} = {value}\n' )

									results.update(SCREAMING_SNAKE_CASE )

			return results


if __name__ == "__main__":
				main()






import argparse

import torch

from transformers import FunnelBaseModel, FunnelConfig, FunnelModel, load_tf_weights_in_funnel
from transformers.utils import logging


logging.set_verbosity_info()

def lowercase    (  SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE )			->							Union[str, Any]:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_								=						FunnelConfig.from_json_file(SCREAMING_SNAKE_CASE )
			print(F'Building PyTorch model from configuration: {config}' )
			SCREAMING_SNAKE_CASE_								=						FunnelBaseModel(SCREAMING_SNAKE_CASE ) if base_model else FunnelModel(SCREAMING_SNAKE_CASE )

			# Load weights from tf checkpoint
			load_tf_weights_in_funnel(SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE )

			# Save pytorch-model
			print(F'Save PyTorch model to {pytorch_dump_path}' )
			torch.save(model.state_dict()       ,    SCREAMING_SNAKE_CASE )


if __name__ == "__main__":
				SCREAMING_SNAKE_CASE__     :     Union[str, Any]		    =       argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
				)
				parser.add_argument(
				    "--config_file",
				    default=None,
				    type=str,
				    required=True,
				    help="The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.",
				)
				parser.add_argument(
				    "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
				)
				parser.add_argument(
				    "--base_model", action="store_true", help="Whether you want just the base model (no decoder) or not."
				)
				SCREAMING_SNAKE_CASE__     :     List[Any]		    =       parser.parse_args()
				convert_tf_checkpoint_to_pytorch(
				    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.base_model
				)
