





import argparse
import glob
import logging
import os
import time
from argparse import Namespace

import numpy as np
import torch
from lightning_base import BaseTransformer, add_generic_args, generic_train
from torch.utils.data import DataLoader, TensorDataset

from transformers import glue_compute_metrics as compute_metrics
from transformers import glue_convert_examples_to_features as convert_examples_to_features
from transformers import glue_output_modes, glue_tasks_num_labels
from transformers import glue_processors as processors


SCREAMING_SNAKE_CASE_						       =	logging.getLogger(__name__)

class 		UpperCamelCase__			(				lowerCAmelCase_       ):



     '''simple docstring'''

     __snake_case   :     List[str]		     =      "sequence-classification"






     def __init__(							self						:   Dict						,lowerCamelCase__						:   Union[str, Any]	)					->		Tuple:




           '''simple docstring'''


           if type(lowerCamelCase__	) == dict:
                 SCREAMING_SNAKE_CASE		=						Namespace(**lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						glue_output_modes[hparams.task]
           SCREAMING_SNAKE_CASE		=						glue_tasks_num_labels[hparams.task]

           super().__init__(lowerCamelCase__						,lowerCamelCase__						,self.mode	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]						,**lowerCamelCase__						:   Optional[int]	)					->		Dict:




           '''simple docstring'''


           return self.model(**lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]						,lowerCamelCase__						:   List[Any]						,lowerCamelCase__						:   List[str]	)					->		Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						{"""input_ids""": batch[0], """attention_mask""": batch[1], """labels""": batch[3]}

           if self.config.model_type not in ["distilbert", "bart"]:
                 SCREAMING_SNAKE_CASE		=						batch[2] if self.config.model_type in ["""bert""", """xlnet""", """albert"""] else None

           SCREAMING_SNAKE_CASE		=						self(**lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						outputs[0]

           SCREAMING_SNAKE_CASE		=						self.trainer.lr_schedulers[0]["""scheduler"""]
           SCREAMING_SNAKE_CASE		=						{"""loss""": loss, """rate""": lr_scheduler.get_last_lr()[-1]}
           return {"loss": loss, "log": tensorboard_logs}






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[str]	)					->		Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.hparams
           SCREAMING_SNAKE_CASE		=						processors[args.task]()
           SCREAMING_SNAKE_CASE		=						processor.get_labels()

           for mode in ["train", "dev"]:
                 SCREAMING_SNAKE_CASE		=						self._feature_file(lowerCamelCase__	)
                 if os.path.exists(lowerCamelCase__	) and not args.overwrite_cache:
                       logger.info("""Loading features from cached file %s"""						,lowerCamelCase__	)
                 else:
                       logger.info("""Creating features from dataset file at %s"""						,args.data_dir	)
                       SCREAMING_SNAKE_CASE		=						(
                           processor.get_dev_examples(args.data_dir	)
                           if mode == """dev"""
                           else processor.get_train_examples(args.data_dir	)
                       )
                       SCREAMING_SNAKE_CASE		=						convert_examples_to_features(
                           lowerCamelCase__						,self.tokenizer						,max_length=args.max_seq_length						,label_list=self.labels						,output_mode=args.glue_output_mode						,)
                       logger.info("""Saving features into cached file %s"""						,lowerCamelCase__	)
                       torch.save(lowerCamelCase__						,lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]						,lowerCamelCase__						:   str						,lowerCamelCase__						:   int						,lowerCamelCase__						:   bool = False	)					->		DataLoader:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						"""dev""" if mode == """test""" else mode

           SCREAMING_SNAKE_CASE		=						self._feature_file(lowerCamelCase__	)
           logger.info("""Loading features from cached file %s"""						,lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						torch.load(lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						torch.tensor([f.input_ids for f in features]						,dtype=torch.long	)
           SCREAMING_SNAKE_CASE		=						torch.tensor([f.attention_mask for f in features]						,dtype=torch.long	)
           SCREAMING_SNAKE_CASE		=						torch.tensor([f.token_type_ids for f in features]						,dtype=torch.long	)
           if self.hparams.glue_output_mode == "classification":
                 SCREAMING_SNAKE_CASE		=						torch.tensor([f.label for f in features]						,dtype=torch.long	)
           elif self.hparams.glue_output_mode == "regression":
                 SCREAMING_SNAKE_CASE		=						torch.tensor([f.label for f in features]						,dtype=torch.float	)

           return DataLoader(
               TensorDataset(lowerCamelCase__						,lowerCamelCase__						,lowerCamelCase__						,lowerCamelCase__	)						,batch_size=lowerCamelCase__						,shuffle=lowerCamelCase__						,)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Dict						,lowerCamelCase__						:   Tuple						,lowerCamelCase__						:   str	)					->		Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						{"""input_ids""": batch[0], """attention_mask""": batch[1], """labels""": batch[3]}

           if self.config.model_type not in ["distilbert", "bart"]:
                 SCREAMING_SNAKE_CASE		=						batch[2] if self.config.model_type in ["""bert""", """xlnet""", """albert"""] else None

           SCREAMING_SNAKE_CASE		=						self(**lowerCamelCase__	)
           SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE		=						outputs[:2]
           SCREAMING_SNAKE_CASE		=						logits.detach().cpu().numpy()
           SCREAMING_SNAKE_CASE		=						inputs["""labels"""].detach().cpu().numpy()

           return {"val_loss": tmp_eval_loss.detach().cpu(), "pred": preds, "target": out_label_ids}






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[Any]						,lowerCamelCase__						:   Tuple	)					->		tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						torch.stack([x["""val_loss"""] for x in outputs]	).mean().detach().cpu().item()
           SCREAMING_SNAKE_CASE		=						np.concatenate([x["""pred"""] for x in outputs]						,axis=0	)

           if self.hparams.glue_output_mode == "classification":
                 SCREAMING_SNAKE_CASE		=						np.argmax(lowerCamelCase__						,axis=1	)
           elif self.hparams.glue_output_mode == "regression":
                 SCREAMING_SNAKE_CASE		=						np.squeeze(lowerCamelCase__	)

           SCREAMING_SNAKE_CASE		=						np.concatenate([x["""target"""] for x in outputs]						,axis=0	)
           SCREAMING_SNAKE_CASE		=						[[] for _ in range(out_label_ids.shape[0]	)]
           SCREAMING_SNAKE_CASE		=						[[] for _ in range(out_label_ids.shape[0]	)]

           SCREAMING_SNAKE_CASE		=						{**{"""val_loss""": val_loss_mean}, **compute_metrics(self.hparams.task						,lowerCamelCase__						,lowerCamelCase__	)}

           SCREAMING_SNAKE_CASE		=						dict(results.items()	)
           SCREAMING_SNAKE_CASE		=						results
           return ret, preds_list, out_label_list






     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]						,lowerCamelCase__						:   list	)					->		dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE		=						self._eval_end(lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						ret["""log"""]
           return {"val_loss": logs["val_loss"], "log": logs, "progress_bar": logs}






     def     SCREAMING_SNAKE_CASE__  (							self						:   Dict						,lowerCamelCase__						:   int	)					->		dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE		=						self._eval_end(lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						ret["""log"""]
           # `val_loss` is the key returned by `self._eval_end()` but actually refers to `test_loss`
           return {"avg_test_loss": logs["val_loss"], "log": logs, "progress_bar": logs}






     @staticmethod
     def     SCREAMING_SNAKE_CASE__  (							lowerCamelCase__						:   int						,lowerCamelCase__						:   List[Any]	)					->		Tuple:




           '''simple docstring'''


           BaseTransformer.add_model_specific_args(lowerCamelCase__						,lowerCamelCase__	)
           parser.add_argument(
               """--max_seq_length"""						,default=128						,type=lowerCamelCase__						,help=(
                   """The maximum total input sequence length after tokenization. Sequences longer """
                   """than this will be truncated, sequences shorter will be padded."""
               )						,)

           parser.add_argument(
               """--task"""						,default=""""""						,type=lowerCamelCase__						,required=lowerCamelCase__						,help="""The GLUE task to run"""						,)
           parser.add_argument(
               """--gpus"""						,default=0						,type=lowerCamelCase__						,help="""The number of GPUs allocated for this, it is by default 0 meaning none"""						,)

           parser.add_argument(
               """--overwrite_cache"""						,action="""store_true"""						,help="""Overwrite the cached training and evaluation sets"""	)

           return parser



def        __lowercase       (				)			->       Optional[Any]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						argparse.ArgumentParser()
      add_generic_args(_SCREAMING_SNAKE_CASE			,						os.getcwd()     )
      SCREAMING_SNAKE_CASE		=						GLUETransformer.add_model_specific_args(_SCREAMING_SNAKE_CASE			,						os.getcwd()     )
      SCREAMING_SNAKE_CASE		=						parser.parse_args()

      # If output_dir not provided, a folder will be generated in pwd
      if args.output_dir is None:
            SCREAMING_SNAKE_CASE		=						os.path.join(
                """./results"""			,						F"""{args.task}_{time.strftime('%Y%m%d_%H%M%S'     )}"""			,						)
            os.makedirs(args.output_dir     )

      SCREAMING_SNAKE_CASE		=						GLUETransformer(_SCREAMING_SNAKE_CASE     )
      SCREAMING_SNAKE_CASE		=						generic_train(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )

      # Optionally, predict on dev set and write to output_dir
      if args.do_predict:
            SCREAMING_SNAKE_CASE		=						sorted(glob.glob(os.path.join(args.output_dir			,						"""checkpoint-epoch=*.ckpt"""     )			,						recursive=_SCREAMING_SNAKE_CASE     )     )
            SCREAMING_SNAKE_CASE		=						model.load_from_checkpoint(checkpoints[-1]     )
            return trainer.test(_SCREAMING_SNAKE_CASE     )


if __name__ == "__main__":
      main()









import os
from pathlib import Path
from unittest.mock import patch

import pytest
import zstandard as zstd

from datasets.download.download_config import DownloadConfig
from datasets.utils.file_utils import (
    OfflineModeIsEnabled,
    cached_path,
    fsspec_get,
    fsspec_head,
    ftp_get,
    ftp_head,
    get_from_cache,
    http_get,
    http_head,
)


SCREAMING_SNAKE_CASE_						       =	"""\
    Text data.
    Second line of data."""

SCREAMING_SNAKE_CASE_						       =	"""file"""



@pytest.fixture(scope="""session"""     )
def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       Union[str, Any]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						tmp_path_factory.mktemp("""data"""     ) / (FILE_PATH + """.zstd""")
      SCREAMING_SNAKE_CASE		=						bytes(_SCREAMING_SNAKE_CASE			,						"""utf-8"""     )
      with zstd.open(_SCREAMING_SNAKE_CASE			,						"""wb"""     ) as f:
            f.write(_SCREAMING_SNAKE_CASE     )
      return path



@pytest.fixture
def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       List[Any]:


      '''simple docstring'''


      with open(os.path.join(tmpfs.local_root_dir			,						_SCREAMING_SNAKE_CASE     )			,						"""w"""     ) as f:
            f.write(_SCREAMING_SNAKE_CASE     )
      return FILE_PATH



@pytest.mark.parametrize("""compression_format"""			,						["""gzip""", """xz""", """zstd"""]     )
def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )			->       Tuple:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						{"""gzip""": gz_file, """xz""": xz_file, """zstd""": zstd_path}
      SCREAMING_SNAKE_CASE		=						input_paths[compression_format]
      SCREAMING_SNAKE_CASE		=						tmp_path / """cache"""
      SCREAMING_SNAKE_CASE		=						DownloadConfig(cache_dir=_SCREAMING_SNAKE_CASE			,						extract_compressed_file=_SCREAMING_SNAKE_CASE     )
      SCREAMING_SNAKE_CASE		=						cached_path(_SCREAMING_SNAKE_CASE			,						download_config=_SCREAMING_SNAKE_CASE     )
      with open(_SCREAMING_SNAKE_CASE     ) as f:
            SCREAMING_SNAKE_CASE		=						f.read()
      with open(_SCREAMING_SNAKE_CASE     ) as f:
            SCREAMING_SNAKE_CASE		=						f.read()
      assert extracted_file_content == expected_file_content



@pytest.mark.parametrize("""default_extracted"""			,						[True, False]     )
@pytest.mark.parametrize("""default_cache_dir"""			,						[True, False]     )
def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )			->       List[str]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						"""custom_cache"""
      SCREAMING_SNAKE_CASE		=						"""custom_extracted_dir"""
      SCREAMING_SNAKE_CASE		=						tmp_path / """custom_extracted_path"""
      if default_extracted:
            SCREAMING_SNAKE_CASE		=						("""downloads""" if default_cache_dir else custom_cache_dir, """extracted""")
      else:
            monkeypatch.setattr("""datasets.config.EXTRACTED_DATASETS_DIR"""			,						_SCREAMING_SNAKE_CASE     )
            monkeypatch.setattr("""datasets.config.EXTRACTED_DATASETS_PATH"""			,						str(_SCREAMING_SNAKE_CASE     )     )
            SCREAMING_SNAKE_CASE		=						custom_extracted_path.parts[-2:] if default_cache_dir else (custom_cache_dir, custom_extracted_dir)

      SCREAMING_SNAKE_CASE		=						xz_file
      SCREAMING_SNAKE_CASE		=						(
          DownloadConfig(extract_compressed_file=_SCREAMING_SNAKE_CASE     )
          if default_cache_dir
          else DownloadConfig(cache_dir=tmp_path / custom_cache_dir			,						extract_compressed_file=_SCREAMING_SNAKE_CASE     )
      )
      SCREAMING_SNAKE_CASE		=						cached_path(_SCREAMING_SNAKE_CASE			,						download_config=_SCREAMING_SNAKE_CASE     )
      assert Path(_SCREAMING_SNAKE_CASE     ).parent.parts[-2:] == expected



def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       int:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						str(Path(_SCREAMING_SNAKE_CASE     ).resolve()     )
      assert cached_path(_SCREAMING_SNAKE_CASE     ) == text_file
      # relative path
      SCREAMING_SNAKE_CASE		=						str(Path(_SCREAMING_SNAKE_CASE     ).resolve().relative_to(Path(os.getcwd()     )     )     )
      assert cached_path(_SCREAMING_SNAKE_CASE     ) == text_file



def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       Dict:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						str(tmp_path.resolve() / """__missing_file__.txt"""     )
      with pytest.raises(_SCREAMING_SNAKE_CASE     ):
            cached_path(_SCREAMING_SNAKE_CASE     )
      # relative path
      SCREAMING_SNAKE_CASE		=						"""./__missing_file__.txt"""
      with pytest.raises(_SCREAMING_SNAKE_CASE     ):
            cached_path(_SCREAMING_SNAKE_CASE     )



def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       str:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						get_from_cache(F"""tmp://{tmpfs_file}"""     )
      with open(_SCREAMING_SNAKE_CASE     ) as f:
            SCREAMING_SNAKE_CASE		=						f.read()
      assert output_file_content == FILE_CONTENT



@patch("""datasets.config.HF_DATASETS_OFFLINE"""			,						_SCREAMING_SNAKE_CASE     )
def        __lowercase       (				)			->       Dict:


      '''simple docstring'''


      with pytest.raises(_SCREAMING_SNAKE_CASE     ):
            cached_path("""https://huggingface.co"""     )



@patch("""datasets.config.HF_DATASETS_OFFLINE"""			,						_SCREAMING_SNAKE_CASE     )
def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       Union[str, Any]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						tmp_path_factory.mktemp("""data"""     ) / """file.html"""
      with pytest.raises(_SCREAMING_SNAKE_CASE     ):
            http_get("""https://huggingface.co"""			,						temp_file=_SCREAMING_SNAKE_CASE     )
      with pytest.raises(_SCREAMING_SNAKE_CASE     ):
            http_head("""https://huggingface.co"""     )



@patch("""datasets.config.HF_DATASETS_OFFLINE"""			,						_SCREAMING_SNAKE_CASE     )
def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       Optional[int]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						tmp_path_factory.mktemp("""data"""     ) / """file.html"""
      with pytest.raises(_SCREAMING_SNAKE_CASE     ):
            ftp_get("""ftp://huggingface.co"""			,						temp_file=_SCREAMING_SNAKE_CASE     )
      with pytest.raises(_SCREAMING_SNAKE_CASE     ):
            ftp_head("""ftp://huggingface.co"""     )



@patch("""datasets.config.HF_DATASETS_OFFLINE"""			,						_SCREAMING_SNAKE_CASE     )
def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       int:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						tmp_path_factory.mktemp("""data"""     ) / """file.html"""
      with pytest.raises(_SCREAMING_SNAKE_CASE     ):
            fsspec_get("""s3://huggingface.co"""			,						temp_file=_SCREAMING_SNAKE_CASE     )
      with pytest.raises(_SCREAMING_SNAKE_CASE     ):
            fsspec_head("""s3://huggingface.co"""     )


