
"""simple docstring"""





import argparse
import logging
import os
from pathlib import Path
from typing import Any, Dict

import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_info

from transformers import (
    AdamW,
    AutoConfig,
    AutoModel,
    AutoModelForPreTraining,
    AutoModelForQuestionAnswering,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelWithLMHead,
    AutoTokenizer,
    PretrainedConfig,
    PreTrainedTokenizer,
)
from transformers.optimization import (
    Adafactor,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.utils.versions import require_version


_a									=				logging.getLogger(__name__)

require_version('pytorch_lightning>=1.0.4')

_a									=				{
    "base": AutoModel,
    "sequence-classification": AutoModelForSequenceClassification,
    "question-answering": AutoModelForQuestionAnswering,
    "pretraining": AutoModelForPreTraining,
    "token-classification": AutoModelForTokenClassification,
    "language-modeling": AutoModelWithLMHead,
    "summarization": AutoModelForSeqaSeqLM,
    "translation": AutoModelForSeqaSeqLM,
}


# update this and the import above to support new schedulers from transformers.optimization
_a									=				{
    "linear": get_linear_schedule_with_warmup,
    "cosine": get_cosine_schedule_with_warmup,
    "cosine_w_restarts": get_cosine_with_hard_restarts_schedule_with_warmup,
    "polynomial": get_polynomial_decay_schedule_with_warmup,
    # '': get_constant_schedule,             # not supported for now
    # '': get_constant_schedule_with_warmup, # not supported for now
}
_a									=				sorted(arg_to_scheduler.keys())
_a									=				"{" + ", ".join(arg_to_scheduler_choices) + "}"


class A_      (pl.LightningModule ):




  '''simple docstring'''







  def __init__(						self							,  lowercase_							,  lowercase_=None							,  lowercase_="base"							,  lowercase_=None							,  lowercase_=None							,  lowercase_=None							,  **lowercase_							,  ):

     """simple docstring"""
     super().__init__()
     # TODO: move to self.save_hyperparameters()
     # self.save_hyperparameters()
     # can also expand arguments into trainer signature for easier reading

     self.save_hyperparameters(_lowercase    )
     UpperCAmelCase_   :   Dict     	=       0
     UpperCAmelCase_   :   Union[str, Any]     	=       Path(self.hparams.output_dir    )
     UpperCAmelCase_   :   Tuple     	=       self.hparams.cache_dir if self.hparams.cache_dir else None
     if config is None:
        UpperCAmelCase_   :   Any     	=       AutoConfig.from_pretrained(
            self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path							,  **({"num_labels": num_labels} if num_labels is not None else {})							,  cache_dir=_lowercase							,  **_lowercase							,  )
     else:
        UpperCAmelCase_   :   PretrainedConfig     	=       config

     UpperCAmelCase_   :   List[str]     	=       ('encoder_layerdrop', 'decoder_layerdrop', 'dropout', 'attention_dropout')
     for p in extra_model_params:
        if getattr(self.hparams							,  _lowercase							,  _lowercase    ):
           assert hasattr(self.config							,  _lowercase    ), F"""model config doesn't have a `{p}` attribute"""
           setattr(self.config							,  _lowercase							,  getattr(self.hparams							,  _lowercase    )    )

     if tokenizer is None:
        UpperCAmelCase_   :   Optional[int]     	=       AutoTokenizer.from_pretrained(
            self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path							,  cache_dir=_lowercase							,  )
     else:
        UpperCAmelCase_   :   PreTrainedTokenizer     	=       tokenizer
     UpperCAmelCase_   :   List[Any]     	=       MODEL_MODES[mode]
     if model is None:
        UpperCAmelCase_   :   int     	=       self.model_type.from_pretrained(
            self.hparams.model_name_or_path							,  from_tf=bool(".ckpt" in self.hparams.model_name_or_path    )							,  config=self.config							,  cache_dir=_lowercase							,  )
     else:
        UpperCAmelCase_   :   str     	=       model







  def 			UpperCamelCase__   (						self							,  *lowercase_							,  **lowercase_    ):

     """simple docstring"""
     UpperCAmelCase_   :   Dict     	=       self.model_type.from_pretrained(*_lowercase							,  **_lowercase    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[int]     	=       arg_to_scheduler[self.hparams.lr_scheduler]
     UpperCAmelCase_   :   str     	=       get_schedule_func(
         self.opt							,  num_warmup_steps=self.hparams.warmup_steps							,  num_training_steps=self.total_steps()    )
     UpperCAmelCase_   :   Optional[int]     	=       {'scheduler': scheduler, 'interval': 'step', 'frequency': 1}
     return scheduler







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   List[str]     	=       self.model
     UpperCAmelCase_   :   Optional[int]     	=       ['bias', 'LayerNorm.weight']
     UpperCAmelCase_   :   List[str]     	=       [
         {
             'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay    )],
             'weight_decay': self.hparams.weight_decay,
         },
         {
             'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay    )],
             'weight_decay': 0.0,
         },
     ]
     if self.hparams.adafactor:
        UpperCAmelCase_   :   Any     	=       Adafactor(
            _lowercase							,  lr=self.hparams.learning_rate							,  scale_parameter=_lowercase							,  relative_step=_lowercase    )

     else:
        UpperCAmelCase_   :   List[str]     	=       AdamW(
            _lowercase							,  lr=self.hparams.learning_rate							,  eps=self.hparams.adam_epsilon    )
     UpperCAmelCase_   :   List[str]     	=       optimizer

     UpperCAmelCase_   :   List[Any]     	=       self.get_lr_scheduler()

     return [optimizer], [scheduler]







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_    ):

     """simple docstring"""
     return self.validation_step(_lowercase							,  _lowercase    )







  def 			UpperCamelCase__   (						self							,  lowercase_    ):

     """simple docstring"""
     return self.validation_end(_lowercase    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   List[Any]     	=       max(1							,  self.hparams.gpus    )  # TODO: consider num_tpu_cores
     UpperCAmelCase_   :   Any     	=       self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
     return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs







  def 			UpperCamelCase__   (						self							,  lowercase_    ):

     """simple docstring"""
     if mode == "test":
        UpperCAmelCase_   :   Any     	=       len(self.test_dataloader().dataset    )
     else:
        UpperCAmelCase_   :   str     	=       self.get_dataloader("train"							,  self.hparams.train_batch_size							,  shuffle=_lowercase    )
        UpperCAmelCase_   :   List[str]     	=       len(self.train_dataloader().dataset    )







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_							,  lowercase_ = False    ):

     """simple docstring"""
     raise NotImplementedError("You must implement this for your task"    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     return self.train_loader







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     return self.get_dataloader("dev"							,  self.hparams.eval_batch_size							,  shuffle=_lowercase    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     return self.get_dataloader("test"							,  self.hparams.eval_batch_size							,  shuffle=_lowercase    )







  def 			UpperCamelCase__   (						self							,  lowercase_    ):

     """simple docstring"""
     return os.path.join(
         self.hparams.data_dir							,  "cached_{}_{}_{}".format(
             _lowercase							,  list(filter(_lowercase							,  self.hparams.model_name_or_path.split("/"    )    )    ).pop()							,  str(self.hparams.max_seq_length    )							,  )							,  )







  @pl.utilities.rank_zero_only
  def 			UpperCamelCase__   (						self							,  lowercase_    ):

     """simple docstring"""
     UpperCAmelCase_   :   List[Any]     	=       self.output_dir.joinpath("best_tfmr"    )
     UpperCAmelCase_   :   Any     	=       self.step_count
     self.model.save_pretrained(_lowercase    )
     self.tokenizer.save_pretrained(_lowercase    )







  @staticmethod
  def 			UpperCamelCase__   (						lowercase_							,  lowercase_    ):

     """simple docstring"""
     parser.add_argument(
         "--model_name_or_path"							,  default=_lowercase							,  type=_lowercase							,  required=_lowercase							,  help="Path to pretrained model or model identifier from huggingface.co/models"							,  )
     parser.add_argument(
         "--config_name"							,  default=""							,  type=_lowercase							,  help="Pretrained config name or path if not the same as model_name"    )
     parser.add_argument(
         "--tokenizer_name"							,  default=_lowercase							,  type=_lowercase							,  help="Pretrained tokenizer name or path if not the same as model_name"							,  )
     parser.add_argument(
         "--cache_dir"							,  default=""							,  type=_lowercase							,  help="Where do you want to store the pre-trained models downloaded from huggingface.co"							,  )
     parser.add_argument(
         "--encoder_layerdrop"							,  type=_lowercase							,  help="Encoder layer dropout probability (Optional). Goes into model.config"							,  )
     parser.add_argument(
         "--decoder_layerdrop"							,  type=_lowercase							,  help="Decoder layer dropout probability (Optional). Goes into model.config"							,  )
     parser.add_argument(
         "--dropout"							,  type=_lowercase							,  help="Dropout probability (Optional). Goes into model.config"							,  )
     parser.add_argument(
         "--attention_dropout"							,  type=_lowercase							,  help="Attention dropout probability (Optional). Goes into model.config"							,  )
     parser.add_argument("--learning_rate"							,  default=5E-5							,  type=_lowercase							,  help="The initial learning rate for Adam."    )
     parser.add_argument(
         "--lr_scheduler"							,  default="linear"							,  choices=_lowercase							,  metavar=_lowercase							,  type=_lowercase							,  help="Learning rate scheduler"							,  )
     parser.add_argument("--weight_decay"							,  default=0.0							,  type=_lowercase							,  help="Weight decay if we apply some."    )
     parser.add_argument("--adam_epsilon"							,  default=1E-8							,  type=_lowercase							,  help="Epsilon for Adam optimizer."    )
     parser.add_argument("--warmup_steps"							,  default=0							,  type=_lowercase							,  help="Linear warmup over warmup_steps."    )
     parser.add_argument("--num_workers"							,  default=4							,  type=_lowercase							,  help="kwarg passed to DataLoader"    )
     parser.add_argument("--num_train_epochs"							,  dest="max_epochs"							,  default=3							,  type=_lowercase    )
     parser.add_argument("--train_batch_size"							,  default=32							,  type=_lowercase    )
     parser.add_argument("--eval_batch_size"							,  default=32							,  type=_lowercase    )
     parser.add_argument("--adafactor"							,  action="store_true"    )




class A_      (pl.Callback ):




  '''simple docstring'''







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_    ):

     """simple docstring"""
     UpperCAmelCase_   :   List[str]     	=       trainer.lr_schedulers[0]['scheduler']
     UpperCAmelCase_   :   Tuple     	=       {F"""lr_group_{i}""": lr for i, lr in enumerate(lr_scheduler.get_lr()    )}
     pl_module.logger.log_metrics(_lowercase    )







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_    ):

     """simple docstring"""
     rank_zero_info("***** Validation results *****"    )
     UpperCAmelCase_   :   Dict     	=       trainer.callback_metrics
     # Log results
     for key in sorted(_lowercase    ):
        if key not in ["log", "progress_bar"]:
           rank_zero_info("{} = {}\n".format(_lowercase							,  str(metrics[key]    )    )    )







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_    ):

     """simple docstring"""
     rank_zero_info("***** Test results *****"    )
     UpperCAmelCase_   :   Any     	=       trainer.callback_metrics
     # Log and save results to file
     UpperCAmelCase_   :   List[str]     	=       os.path.join(pl_module.hparams.output_dir							,  "test_results.txt"    )
     with open(_lowercase							,  "w"    ) as writer:
        for key in sorted(_lowercase    ):
           if key not in ["log", "progress_bar"]:
              rank_zero_info("{} = {}\n".format(_lowercase							,  str(metrics[key]    )    )    )
              writer.write("{} = {}\n".format(_lowercase							,  str(metrics[key]    )    )    )







def       __a	(						__lowerCamelCase,						__lowerCamelCase    ):
   parser.add_argument(
       "--output_dir",						default=__lowerCamelCase,						type=__lowerCamelCase,						required=__lowerCamelCase,						help="The output directory where the model predictions and checkpoints will be written.",						)
   parser.add_argument(
       "--fp16",						action="store_true",						help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit",						)

   parser.add_argument(
       "--fp16_opt_level",						type=__lowerCamelCase,						default="O2",						help=(
           "For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\']."
           "See details at https://nvidia.github.io/apex/amp.html"
       ),						)
   parser.add_argument("--n_tpu_cores",						dest="tpu_cores",						type=__lowerCamelCase    )
   parser.add_argument("--max_grad_norm",						dest="gradient_clip_val",						default=1.0,						type=__lowerCamelCase,						help="Max gradient norm"    )
   parser.add_argument("--do_train",						action="store_true",						help="Whether to run training."    )
   parser.add_argument("--do_predict",						action="store_true",						help="Whether to run predictions on the test set."    )
   parser.add_argument(
       "--gradient_accumulation_steps",						dest="accumulate_grad_batches",						type=__lowerCamelCase,						default=1,						help="Number of updates steps to accumulate before performing a backward/update pass.",						)
   parser.add_argument("--seed",						type=__lowerCamelCase,						default=42,						help="random seed for initialization"    )
   parser.add_argument(
       "--data_dir",						default=__lowerCamelCase,						type=__lowerCamelCase,						required=__lowerCamelCase,						help="The input data dir. Should contain the training files for the CoNLL-2003 NER task.",						)







def       __a	(						__lowerCamelCase,						__lowerCamelCase,						__lowerCamelCase=None,						__lowerCamelCase=True,						__lowerCamelCase=[],						__lowerCamelCase=None,						__lowerCamelCase=None,						**__lowerCamelCase,						):
   pl.seed_everything(args.seed    )

   # init model
   UpperCAmelCase_   :   int     	=       Path(model.hparams.output_dir    )
   odir.mkdir(exist_ok=__lowerCamelCase    )

   # add custom checkpoints
   if checkpoint_callback is None:
      UpperCAmelCase_   :   str     	=       pl.callbacks.ModelCheckpoint(
          filepath=args.output_dir,						prefix="checkpoint",						monitor="val_loss",						mode="min",						save_top_k=1    )
   if early_stopping_callback:
      extra_callbacks.append(__lowerCamelCase    )
   if logging_callback is None:
      UpperCAmelCase_   :   Optional[Any]     	=       LoggingCallback()

   UpperCAmelCase_   :   Optional[int]     	=       {}

   # TODO: remove with PyTorch 1.6 since pl uses native amp
   if args.fpaa:
      UpperCAmelCase_   :   Any     	=       16
      UpperCAmelCase_   :   Optional[int]     	=       args.fpaa_opt_level

   if args.gpus > 1:
      UpperCAmelCase_   :   Union[str, Any]     	=       'ddp'

   UpperCAmelCase_   :   Any     	=       args.accumulate_grad_batches
   UpperCAmelCase_   :   Optional[Any]     	=       extra_train_kwargs.get("accelerator",						__lowerCamelCase    )
   UpperCAmelCase_   :   Any     	=       extra_train_kwargs.get("profiler",						__lowerCamelCase    )

   UpperCAmelCase_   :   List[str]     	=       pl.Trainer.from_argparse_args(
       __lowerCamelCase,						weights_summary=__lowerCamelCase,						callbacks=[logging_callback] + extra_callbacks,						logger=__lowerCamelCase,						checkpoint_callback=__lowerCamelCase,						**__lowerCamelCase,						)

   if args.do_train:
      trainer.fit(__lowerCamelCase    )

   return trainer










'''simple docstring'''

from collections.abc import Callable
from math import log
from os import name, system
from random import gauss, seed
from typing import TypeVar






def 						_UpperCAmelCase     (	a		:						float    ,      a		:						float    ,      a		:						int				)      ->      list:





						"""simple docstring"""
						seed(1				)
						return [gauss(a    ,      a				) for _ in range(a				)]






def 						_UpperCAmelCase     (	a		:						int    ,      a		:						list				)      ->      list:





						"""simple docstring"""
						return [k for k in range(a				) for _ in range(instance_count[k]				)]






def 						_UpperCAmelCase     (	a		:						int    ,      a		:						list				)      ->      float:





						"""simple docstring"""
						return sum(a				) / instance_count






def 						_UpperCAmelCase     (	a		:						int    ,      a		:						int				)      ->      float:





						"""simple docstring"""
						return instance_count / total_count






def 						_UpperCAmelCase     (	a		:						list    ,      a		:						list    ,      a		:						int				)      ->      float:





						"""simple docstring"""
						lowercase_   : str   	=      []  # An empty list to store all squared differences
						# iterate over number of elements in items
						for i in range(len(a				)				):
												# for loop iterates over number of elements in inner layer of items
												for j in range(len(items[i]				)				):
																		# appending squared differences to 'squared_diff' list
																		squared_diff.append((items[i][j] - means[i]) ** 2				)

    # one divided by (the number of all instances - number of classes) multiplied by
    # sum of all squared differences
						lowercase_   : Tuple   	=      len(a				)  # Number of classes in dataset
						return 1 / (total_count - n_classes) * sum(a				)






def 						_UpperCAmelCase     (	a		:						list    ,      a		:						list    ,      a		:						float    ,      a		:						list				)      ->      list:





						"""simple docstring"""
						lowercase_   : str   	=      []
						# for loop iterates over number of elements in list
						for i in range(len(a				)				):
												# for loop iterates over number of inner items of each element
												for j in range(len(x_items[i]				)				):
																		lowercase_   : Any   	=      []  # to store all discriminant values of each item as a list
																		# for loop iterates over number of classes we have in our dataset
																		for k in range(len(a				)				):
																								# appending values of discriminants for each class to 'temp' list
																								temp.append(
																								    x_items[i][j] * (means[k] / variance)
																								    - (means[k] ** 2 / (2 * variance))
																								    + log(probabilities[k]				)				)
																		# appending discriminant values of each item to 'results' list
																		results.append(a				)

						return [result.index(max(a				)				) for result in results]






def 						_UpperCAmelCase     (	a		:						list    ,      a		:						list				)      ->      float:





						"""simple docstring"""
						lowercase_   : Optional[Any]   	=      sum(1 for i, j in zip(a    ,      a				) if i == j				)
						# percentage of accuracy equals to number of correct predictions divided by number
						# of all data and multiplied by 100
						return (correct / len(a				)) * 1_0_0


A:   Union[str, Any]						=					TypeVar("num")






def 						_UpperCAmelCase     (	a		:						Callable[[object], num]    ,      a		:						str    ,      a		:						str    ,      a		:						Callable[[num], bool] = lambda a				: True    ,      a		:						str | None = None    ,      )      ->      num:





						"""simple docstring"""
						while True:
												try:
																		lowercase_   : int   	=      input_type(input(a				).strip() or default				)
																		if condition(a				):
																								return user_input
																		else:
																								print(f"{user_input}: {err_msg}"				)
																								continue
												except ValueError:
																		print(
																		    f"{user_input}: Incorrect input type, expected {input_type.__name__!r}"				)






def 						_UpperCAmelCase     (	)      ->      List[str]:





						"""simple docstring"""
						while True:
												print(' Linear Discriminant Analysis '.center(5_0    ,      '*'				)				)
												print('*' * 5_0    ,      '\n'				)
												print('First of all we should specify the number of classes that'				)
												print('we want to generate as training dataset'				)
												# Trying to get number of classes
												lowercase_   : Dict   	=      valid_input(
												    input_type=a    ,      condition=lambda a				: x > 0    ,      input_msg='Enter the number of classes (Data Groupings): '    ,      err_msg='Number of classes should be positive!'    ,      )

												print('-' * 1_0_0				)

												# Trying to get the value of standard deviation
												lowercase_   : List[Any]   	=      valid_input(
												    input_type=a    ,      condition=lambda a				: x >= 0    ,      input_msg=(
												        'Enter the value of standard deviation'
												        '(Default value is 1.0 for all classes): '
												    )    ,      err_msg='Standard deviation should not be negative!'    ,      default='1.0'    ,      )

												print('-' * 1_0_0				)

												# Trying to get number of instances in classes and theirs means to generate
												# dataset
												lowercase_   : Any   	=      []  # An empty list to store instance counts of classes in dataset
												for i in range(a				):
																		lowercase_   : Union[str, Any]   	=      valid_input(
																		    input_type=a    ,      condition=lambda a				: x > 0    ,      input_msg=(f"Enter The number of instances for class_{i+1}: ")    ,      err_msg='Number of instances should be positive!'    ,      )
																		counts.append(a				)
												print('-' * 1_0_0				)

												# An empty list to store values of user-entered means of classes
												lowercase_   : int   	=      []
												for a in range(a				):
																		lowercase_   : Union[str, Any]   	=      valid_input(
																		    input_type=a    ,      input_msg=(f"Enter the value of mean for class_{a+1}: ")    ,      err_msg='This is an invalid value.'    ,      )
																		user_means.append(a				)
												print('-' * 1_0_0				)

												print('Standard deviation: '    ,      a				)
												# print out the number of instances in classes in separated line
												for i, count in enumerate(a    ,      1				):
																		print(f"Number of instances in class_{i} is: {count}"				)
												print('-' * 1_0_0				)

												# print out mean values of classes separated line
												for i, user_mean in enumerate(a    ,      1				):
																		print(f"Mean of class_{i} is: {user_mean}"				)
												print('-' * 1_0_0				)

												# Generating training dataset drawn from gaussian distribution
												lowercase_   : Optional[int]   	=      [
												    gaussian_distribution(user_means[j]    ,      a    ,      counts[j]				)
												    for j in range(a				)
												]
												print('Generated Normal Distribution: \n'    ,      a				)
												print('-' * 1_0_0				)

												# Generating Ys to detecting corresponding classes
												lowercase_   : Optional[int]   	=      y_generator(a    ,      a				)
												print('Generated Corresponding Ys: \n'    ,      a				)
												print('-' * 1_0_0				)

												# Calculating the value of actual mean for each class
												lowercase_   : str   	=      [calculate_mean(counts[k]    ,      x[k]				) for k in range(a				)]
												# for loop iterates over number of elements in 'actual_means' list and print
												# out them in separated line
												for i, actual_mean in enumerate(a    ,      1				):
																		print(f"Actual(Real) mean of class_{i} is: {actual_mean}"				)
												print('-' * 1_0_0				)

												# Calculating the value of probabilities for each class
												lowercase_   : Union[str, Any]   	=      [
												    calculate_probabilities(counts[i]    ,      sum(a				)				) for i in range(a				)
												]

												# for loop iterates over number of elements in 'probabilities' list and print
												# out them in separated line
												for i, probability in enumerate(a    ,      1				):
																		print(f"Probability of class_{i} is: {probability}"				)
												print('-' * 1_0_0				)

												# Calculating the values of variance for each class
												lowercase_   : List[str]   	=      calculate_variance(a    ,      a    ,      sum(a				)				)
												print('Variance: '    ,      a				)
												print('-' * 1_0_0				)

												# Predicting Y values
												# storing predicted Y values in 'pre_indexes' variable
												lowercase_   : Tuple   	=      predict_y_values(a    ,      a    ,      a    ,      a				)
												print('-' * 1_0_0				)

												# Calculating Accuracy of the model
												print(f"Accuracy: {accuracy(a    ,      a				)}"				)
												print('-' * 1_0_0				)
												print(' DONE '.center(1_0_0    ,      '+'				)				)

												if input('Press any key to restart or \'q\' for quit: '				).strip().lower() == "q":
																		print('\n' + 'GoodBye!'.center(1_0_0    ,      '-'				) + '\n'				)
																		break
												system('cls' if name == 'nt' else 'clear'				)  # noqa: S605


if __name__ == "__main__":
						main()
