






from __future__ import annotations

from fractions import Fraction






def 							A     (       a_							,a_					)     ->						bool:
					return (
					    num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
					)






def 							A     (       a_					)     ->						list[str]:
					__UpperCamelCase      :					Dict       		=[]
					__UpperCamelCase      :					Union[str, Any]       		=11
					__UpperCamelCase      :					List[str]       		=int('1' + '0' * digit_len					)
					for num in range(a_							,a_					):
										while den <= 99:
															if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
																				if is_digit_cancelling(a_							,a_					):
																									solutions.append(F'{num}/{den}'					)
															den += 1
										num += 1
										__UpperCamelCase      :					Any       		=10
					return solutions






def 							A     (       a_ = 2					)     ->						int:
					__UpperCamelCase      :					Optional[Any]       		=1.0
					for fraction in fraction_list(a_					):
										__UpperCamelCase      :					int       		=Fraction(a_					)
										result *= frac.denominator / frac.numerator
					return int(a_					)


if __name__ == "__main__":
							print(solution())








import argparse
import glob
import logging
import os
from argparse import Namespace
from importlib import import_module

import numpy as np
import torch
from lightning_base import BaseTransformer, add_generic_args, generic_train
from seqeval.metrics import accuracy_score, fa_score, precision_score, recall_score
from torch.nn import CrossEntropyLoss
from torch.utils.data import DataLoader, TensorDataset
from utils_ner import TokenClassificationTask


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







class     __snake_case       (							__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     """token-classification"""




       def __init__(  self :    Union[str, Any]							,				A :    List[Any]		):
         if type(A		) == dict:
           __snake_case:						str   =						Namespace(**A		)
         __snake_case:						str   =						import_module("""tasks"""		)
         try:
           __snake_case:						Tuple   =						getattr(A							,				hparams.task_type		)
           __snake_case:						TokenClassificationTask   =						token_classification_task_clazz()
         except AttributeError:
           raise ValueError(
               f'''Task {hparams.task_type} needs to be defined as a TokenClassificationTask subclass in {module}. '''
               f'''Available tasks classes are: {TokenClassificationTask.__subclasses__()}'''		)
         __snake_case:						Optional[int]   =						self.token_classification_task.get_labels(hparams.labels		)
         __snake_case:						str   =						CrossEntropyLoss().ignore_index
         super().__init__(A							,				len(self.labels		)							,				self.mode		)




       def 							UpperCAmelCase__ (  self :    Union[str, Any]							,				**A :    Union[str, Any]		):
         return self.model(**A		)




       def 							UpperCAmelCase__ (  self :    Any							,				A :    Optional[int]							,				A :    str		):
         __snake_case:						str   =						{"""input_ids""": batch[0], """attention_mask""": batch[1], """labels""": batch[3]}
         if self.config.model_type != "distilbert":
           __snake_case:						List[str]   =						(
               batch[2] if self.config.model_type in ["""bert""", """xlnet"""] else None
           )  # XLM and RoBERTa don"t use token_type_ids

         __snake_case:						Any   =						self(**A		)
         __snake_case:						Any   =						outputs[0]
         # tensorboard_logs = {"loss": loss, "rate": self.lr_scheduler.get_last_lr()[-1]}
         return {"loss": loss}




       def 							UpperCAmelCase__ (  self :    List[str]		):
         __snake_case:						Tuple   =						self.hparams
         for mode in ["train", "dev", "test"]:
           __snake_case:						Union[str, Any]   =						self._feature_file(A		)
           if os.path.exists(A		) and not args.overwrite_cache:
             logger.info("""Loading features from cached file %s"""							,				A		)
             __snake_case:						Tuple   =						torch.load(A		)
           else:
             logger.info("""Creating features from dataset file at %s"""							,				args.data_dir		)
             __snake_case:						List[Any]   =						self.token_classification_task.read_examples_from_file(args.data_dir							,				A		)
             __snake_case:						Optional[int]   =						self.token_classification_task.convert_examples_to_features(
                 A							,				self.labels							,				args.max_seq_length							,				self.tokenizer							,				cls_token_at_end=bool(self.config.model_type in ["""xlnet"""]		)							,				cls_token=self.tokenizer.cls_token							,				cls_token_segment_id=2 if self.config.model_type in ["""xlnet"""] else 0							,				sep_token=self.tokenizer.sep_token							,				sep_token_extra=A							,				pad_on_left=bool(self.config.model_type in ["""xlnet"""]		)							,				pad_token=self.tokenizer.pad_token_id							,				pad_token_segment_id=self.tokenizer.pad_token_type_id							,				pad_token_label_id=self.pad_token_label_id							,				)
             logger.info("""Saving features into cached file %s"""							,				A		)
             torch.save(A							,				A		)




       def 							UpperCAmelCase__ (  self :    List[str]							,				A :    int							,				A :    int							,				A :    bool = False		):
         __snake_case:						List[str]   =						self._feature_file(A		)
         logger.info("""Loading features from cached file %s"""							,				A		)
         __snake_case:						int   =						torch.load(A		)
         __snake_case:						Optional[int]   =						torch.tensor([f.input_ids for f in features]							,				dtype=torch.long		)
         __snake_case:						Optional[Any]   =						torch.tensor([f.attention_mask for f in features]							,				dtype=torch.long		)
         if features[0].token_type_ids is not None:
           __snake_case:						Dict   =						torch.tensor([f.token_type_ids for f in features]							,				dtype=torch.long		)
         else:
           __snake_case:						Tuple   =						torch.tensor([0 for f in features]							,				dtype=torch.long		)
           # HACK(we will not use this anymore soon)
         __snake_case:						Optional[int]   =						torch.tensor([f.label_ids for f in features]							,				dtype=torch.long		)
         return DataLoader(
             TensorDataset(A							,				A							,				A							,				A		)							,				batch_size=A		)




       def 							UpperCAmelCase__ (  self :    Tuple							,				A :    Optional[Any]							,				A :    int		):
         """Compute validation""" ""
         __snake_case:						List[str]   =						{"""input_ids""": batch[0], """attention_mask""": batch[1], """labels""": batch[3]}
         if self.config.model_type != "distilbert":
           __snake_case:						Union[str, Any]   =						(
               batch[2] if self.config.model_type in ["""bert""", """xlnet"""] else None
           )  # XLM and RoBERTa don"t use token_type_ids
         __snake_case:						List[str]   =						self(**A		)
         __snake_case  ,   __snake_case:						int   =						outputs[:2]
         __snake_case:						List[str]   =						logits.detach().cpu().numpy()
         __snake_case:						Any   =						inputs["""labels"""].detach().cpu().numpy()
         return {"val_loss": tmp_eval_loss.detach().cpu(), "pred": preds, "target": out_label_ids}




       def 							UpperCAmelCase__ (  self :    Dict							,				A :    Dict		):
         __snake_case:						Union[str, Any]   =						torch.stack([x["""val_loss"""] for x in outputs]		).mean()
         __snake_case:						Tuple   =						np.concatenate([x["""pred"""] for x in outputs]							,				axis=0		)
         __snake_case:						List[str]   =						np.argmax(A							,				axis=2		)
         __snake_case:						Optional[Any]   =						np.concatenate([x["""target"""] for x in outputs]							,				axis=0		)

         __snake_case:						Tuple   =						dict(enumerate(self.labels		)		)
         __snake_case:						Dict   =						[[] for _ in range(out_label_ids.shape[0]		)]
         __snake_case:						Tuple   =						[[] for _ in range(out_label_ids.shape[0]		)]

         for i in range(out_label_ids.shape[0]		):
           for j in range(out_label_ids.shape[1]		):
             if out_label_ids[i, j] != self.pad_token_label_id:
               out_label_list[i].append(label_map[out_label_ids[i][j]]		)
               preds_list[i].append(label_map[preds[i][j]]		)

         __snake_case:						Dict   =						{
             """val_loss""": val_loss_mean,
             """accuracy_score""": accuracy_score(A							,				A		),
             """precision""": precision_score(A							,				A		),
             """recall""": recall_score(A							,				A		),
             """f1""": fa_score(A							,				A		),
         }

         __snake_case:						Dict   =						dict(results.items()		)
         __snake_case:						Dict   =						results
         return ret, preds_list, out_label_list




       def 							UpperCAmelCase__ (  self :    Tuple							,				A :    int		):
         # when stable
         __snake_case  ,   __snake_case  ,   __snake_case:						List[str]   =						self._eval_end(A		)
         __snake_case:						int   =						ret["""log"""]
         return {"val_loss": logs["val_loss"], "log": logs, "progress_bar": logs}




       def 							UpperCAmelCase__ (  self :    Dict							,				A :    Optional[int]		):
         # updating to test_epoch_end instead of deprecated test_end
         __snake_case  ,   __snake_case  ,   __snake_case:						int   =						self._eval_end(A		)

         # Converting to the dict required by pl
         # https://github.com/PyTorchLightning/pytorch-lightning/blob/master/\
         # pytorch_lightning/trainer/logging.py#L139
         __snake_case:						List[Any]   =						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 							UpperCAmelCase__ (  A :    Any							,				A :    int		):
         # Add NER specific options
         BaseTransformer.add_model_specific_args(A							,				A		)
         parser.add_argument(
             """--task_type"""							,				default="""NER"""							,				type=A							,				help="""Task type to fine tune in training (e.g. NER, POS, etc)"""		)
         parser.add_argument(
             """--max_seq_length"""							,				default=128							,				type=A							,				help=(
                 """The maximum total input sequence length after tokenization. Sequences longer """
                 """than this will be truncated, sequences shorter will be padded."""
             )							,				)

         parser.add_argument(
             """--labels"""							,				default=""""""							,				type=A							,				help="""Path to a file containing all labels. If not specified, CoNLL-2003 labels are used."""							,				)
         parser.add_argument(
             """--gpus"""							,				default=0							,				type=A							,				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


if __name__ == "__main__":
      __UpperCAmelCase       :   Tuple				       =							argparse.ArgumentParser()
      add_generic_args(parser, os.getcwd())
      __UpperCAmelCase       :   Tuple				       =							NERTransformer.add_model_specific_args(parser, os.getcwd())
      __UpperCAmelCase       :   List[str]				       =							parser.parse_args()
      __UpperCAmelCase       :   Optional[int]				       =							NERTransformer(args)
      __UpperCAmelCase       :   Tuple				       =							generic_train(model, args)

      if args.do_predict:
            # See https://github.com/huggingface/transformers/issues/3159
            # pl use this default format to create a checkpoint:
            # https://github.com/PyTorchLightning/pytorch-lightning/blob/master\
            # /pytorch_lightning/callbacks/model_checkpoint.py#L322
            __UpperCAmelCase       :   int				       =							sorted(glob.glob(os.path.join(args.output_dir, "checkpoint-epoch=*.ckpt"), recursive=True))
            __UpperCAmelCase       :   Any				       =							model.load_from_checkpoint(checkpoints[-1])
            trainer.test(model)






