




"""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  SCREAMING_SNAKE_CASE__   (   pl.LightningModule   ):


      def __init__(							self			:     Any  ,  lowerCAmelCase			:     argparse.Namespace  ,  lowerCAmelCase			:     Union[str, Any]=None  ,  lowerCAmelCase			:     Union[str, Any]="base"  ,  lowerCAmelCase			:     Optional[Any]=None  ,  lowerCAmelCase			:     List[str]=None  ,  lowerCAmelCase			:     Optional[int]=None  ,  **lowerCAmelCase			:     Union[str, Any]  ,  ):
          super().__init__()
          # TODO: move to self.save_hyperparameters()
          # self.save_hyperparameters()
          # can also expand arguments into trainer signature for easier reading

          self.save_hyperparameters(lowerCAmelCase   )
          lowerCAmelCase		=			0
          lowerCAmelCase		=			Path(self.hparams.output_dir   )
          lowerCAmelCase		=			self.hparams.cache_dir if self.hparams.cache_dir else None
          if config is None:
              lowerCAmelCase		=			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=lowerCAmelCase  ,  **lowerCAmelCase  ,  )
          else:
              lowerCAmelCase		=			config

          lowerCAmelCase		=			("""encoder_layerdrop""", """decoder_layerdrop""", """dropout""", """attention_dropout""")
          for p in extra_model_params:
              if getattr(self.hparams  ,  lowerCAmelCase  ,  lowerCAmelCase   ):
                  assert hasattr(self.config  ,  lowerCAmelCase   ), f'''model config doesn\'t have a `{p}` attribute'''
                  setattr(self.config  ,  lowerCAmelCase  ,  getattr(self.hparams  ,  lowerCAmelCase   )   )

          if tokenizer is None:
              lowerCAmelCase		=			AutoTokenizer.from_pretrained(
                  self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path  ,  cache_dir=lowerCAmelCase  ,  )
          else:
              lowerCAmelCase		=			tokenizer
          lowerCAmelCase		=			MODEL_MODES[mode]
          if model is None:
              lowerCAmelCase		=			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=lowerCAmelCase  ,  )
          else:
              lowerCAmelCase		=			model


      def 					__lowercase	(							self			:     Optional[Any]  ,  *lowerCAmelCase			:     str  ,  **lowerCAmelCase			:     List[str]   ):
          lowerCAmelCase		=			self.model_type.from_pretrained(*lowerCAmelCase  ,  **lowerCAmelCase   )


      def 					__lowercase	(							self			:     int   ):
          lowerCAmelCase		=			arg_to_scheduler[self.hparams.lr_scheduler]
          lowerCAmelCase		=			get_schedule_func(
              self.opt  ,  num_warmup_steps=self.hparams.warmup_steps  ,  num_training_steps=self.total_steps()   )
          lowerCAmelCase		=			{"""scheduler""": scheduler, """interval""": """step""", """frequency""": 1}
          return scheduler


      def 					__lowercase	(							self			:     Tuple   ):
          lowerCAmelCase		=			self.model
          lowerCAmelCase		=			["""bias""", """LayerNorm.weight"""]
          lowerCAmelCase		=			[
              {
                  """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:
              lowerCAmelCase		=			Adafactor(
                  lowerCAmelCase  ,  lr=self.hparams.learning_rate  ,  scale_parameter=lowerCAmelCase  ,  relative_step=lowerCAmelCase   )

          else:
              lowerCAmelCase		=			AdamW(
                  lowerCAmelCase  ,  lr=self.hparams.learning_rate  ,  eps=self.hparams.adam_epsilon   )
          lowerCAmelCase		=			optimizer

          lowerCAmelCase		=			self.get_lr_scheduler()

          return [optimizer], [scheduler]


      def 					__lowercase	(							self			:     str  ,  lowerCAmelCase			:     Tuple  ,  lowerCAmelCase			:     Union[str, Any]   ):
          return self.validation_step(lowerCAmelCase  ,  lowerCAmelCase   )


      def 					__lowercase	(							self			:     int  ,  lowerCAmelCase			:     Optional[int]   ):
          return self.validation_end(lowerCAmelCase   )


      def 					__lowercase	(							self			:     Optional[int]   ):
          lowerCAmelCase		=			max(1  ,  self.hparams.gpus   )  # TODO: consider num_tpu_cores
          lowerCAmelCase		=			self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
          return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs


      def 					__lowercase	(							self			:     Optional[Any]  ,  lowerCAmelCase			:     Optional[Any]   ):
          if mode == "test":
              lowerCAmelCase		=			len(self.test_dataloader().dataset   )
          else:
              lowerCAmelCase		=			self.get_dataloader("""train"""  ,  self.hparams.train_batch_size  ,  shuffle=lowerCAmelCase   )
              lowerCAmelCase		=			len(self.train_dataloader().dataset   )


      def 					__lowercase	(							self			:     Dict  ,  lowerCAmelCase			:     str  ,  lowerCAmelCase			:     int  ,  lowerCAmelCase			:     bool = False   ):
          raise NotImplementedError("""You must implement this for your task"""   )


      def 					__lowercase	(							self			:     List[str]   ):
          return self.train_loader


      def 					__lowercase	(							self			:     Dict   ):
          return self.get_dataloader("""dev"""  ,  self.hparams.eval_batch_size  ,  shuffle=lowerCAmelCase   )


      def 					__lowercase	(							self			:     Optional[Any]   ):
          return self.get_dataloader("""test"""  ,  self.hparams.eval_batch_size  ,  shuffle=lowerCAmelCase   )


      def 					__lowercase	(							self			:     List[Any]  ,  lowerCAmelCase			:     Dict   ):
          return os.path.join(
              self.hparams.data_dir  ,  """cached_{}_{}_{}""".format(
                  lowerCAmelCase  ,  list(filter(lowerCAmelCase  ,  self.hparams.model_name_or_path.split("""/"""   )   )   ).pop()  ,  str(self.hparams.max_seq_length   )  ,  )  ,  )


      @pl.utilities.rank_zero_only
      def 					__lowercase	(							self			:     Union[str, Any]  ,  lowerCAmelCase			:     Dict[str, Any]   ):
          lowerCAmelCase		=			self.output_dir.joinpath("""best_tfmr"""   )
          lowerCAmelCase		=			self.step_count
          self.model.save_pretrained(lowerCAmelCase   )
          self.tokenizer.save_pretrained(lowerCAmelCase   )




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






class  SCREAMING_SNAKE_CASE__   (   pl.Callback   ):


      def 					__lowercase	(							self			:     Union[str, Any]  ,  lowerCAmelCase			:     Tuple  ,  lowerCAmelCase			:     Union[str, Any]   ):
          lowerCAmelCase		=			trainer.lr_schedulers[0]["""scheduler"""]
          lowerCAmelCase		=			{f'''lr_group_{i}''': lr for i, lr in enumerate(lr_scheduler.get_lr()   )}
          pl_module.logger.log_metrics(lowerCAmelCase   )


      def 					__lowercase	(							self			:     Optional[int]  ,  lowerCAmelCase			:     pl.Trainer  ,  lowerCAmelCase			:     pl.LightningModule   ):
          rank_zero_info("""***** Validation results *****"""   )
          lowerCAmelCase		=			trainer.callback_metrics
          # Log results
          for key in sorted(lowerCAmelCase   ):
              if key not in ["log", "progress_bar"]:
                  rank_zero_info("""{} = {}\n""".format(lowerCAmelCase  ,  str(metrics[key]   )   )   )




      def 					__lowercase	(							self			:     str  ,  lowerCAmelCase			:     pl.Trainer  ,  lowerCAmelCase			:     pl.LightningModule   ):
          rank_zero_info("""***** Test results *****"""   )
          lowerCAmelCase		=			trainer.callback_metrics
          # Log and save results to file
          lowerCAmelCase		=			os.path.join(pl_module.hparams.output_dir  ,  """test_results.txt"""   )
          with open(lowerCAmelCase  ,  """w"""   ) as writer:
              for key in sorted(lowerCAmelCase   ):
                  if key not in ["log", "progress_bar"]:
                      rank_zero_info("""{} = {}\n""".format(lowerCAmelCase  ,  str(metrics[key]   )   )   )
                      writer.write("""{} = {}\n""".format(lowerCAmelCase  ,  str(metrics[key]   )   )   )





def 							lowercase   (snake_case__				:	Optional[int] ,    snake_case__				:	Any	)       ->					None:


    '''simple docstring'''






    parser.add_argument(
        """--output_dir""" ,    default=snake_case__ ,    type=snake_case__ ,    required=snake_case__ ,    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=snake_case__ ,    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=snake_case__	)
    parser.add_argument("""--max_grad_norm""" ,    dest="""gradient_clip_val""" ,    default=1.0 ,    type=snake_case__ ,    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=snake_case__ ,    default=1 ,    help="""Number of updates steps to accumulate before performing a backward/update pass.""" ,    )
    parser.add_argument("""--seed""" ,    type=snake_case__ ,    default=42 ,    help="""random seed for initialization"""	)
    parser.add_argument(
        """--data_dir""" ,    default=snake_case__ ,    type=snake_case__ ,    required=snake_case__ ,    help="""The input data dir. Should contain the training files for the CoNLL-2003 NER task.""" ,    )






def 							lowercase   (snake_case__				:	BaseTransformer ,    snake_case__				:	argparse.Namespace ,    snake_case__				:	Optional[int]=None ,    snake_case__				:	Any=True ,    snake_case__				:	Union[str, Any]=[] ,    snake_case__				:	Tuple=None ,    snake_case__				:	Tuple=None ,    **snake_case__				:	Any ,    )       ->					Dict:


    '''simple docstring'''






    pl.seed_everything(args.seed	)

    # init model
    lowerCAmelCase		=			Path(model.hparams.output_dir	)
    odir.mkdir(exist_ok=snake_case__	)

    # add custom checkpoints
    if checkpoint_callback is None:
        lowerCAmelCase		=			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(snake_case__	)
    if logging_callback is None:
        lowerCAmelCase		=			LoggingCallback()

    lowerCAmelCase		=			{}

    # TODO: remove with PyTorch 1.6 since pl uses native amp
    if args.fpaa:
        lowerCAmelCase		=			16
        lowerCAmelCase		=			args.fpaa_opt_level

    if args.gpus > 1:
        lowerCAmelCase		=			"""ddp"""

    lowerCAmelCase		=			args.accumulate_grad_batches
    lowerCAmelCase		=			extra_train_kwargs.get("""accelerator""" ,    snake_case__	)
    lowerCAmelCase		=			extra_train_kwargs.get("""profiler""" ,    snake_case__	)

    lowerCAmelCase		=			pl.Trainer.from_argparse_args(
        snake_case__ ,    weights_summary=snake_case__ ,    callbacks=[logging_callback] + extra_callbacks ,    logger=snake_case__ ,    checkpoint_callback=snake_case__ ,    **snake_case__ ,    )

    if args.do_train:
        trainer.fit(snake_case__	)

    return trainer











"""simple docstring"""







import colorsys
import io

import cva
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import numpy as np
import torch
from matplotlib.backends.backend_agg import FigureCanvasAgg

from utils import img_tensorize


a								=							1_0_0_0






class  SCREAMING_SNAKE_CASE__   :


						def __init__(							self			:     Any  ,  lowerCAmelCase			:     List[Any]  ,  lowerCAmelCase			:     Tuple=1.2  ,  lowerCAmelCase			:     str="g"  ,  lowerCAmelCase			:     List[Any]=0.5  ,  lowerCAmelCase			:     List[Any]="-"  ,  lowerCAmelCase			:     Optional[int]="test_out.jpg"  ,  lowerCAmelCase			:     Union[str, Any]=True  ,  lowerCAmelCase			:     Tuple=False  ,  lowerCAmelCase			:     Optional[int]=None  ,  lowerCAmelCase			:     Tuple=None  ,  lowerCAmelCase			:     str=0.7  ,  ):
										if isinstance(lowerCAmelCase  ,  torch.Tensor   ):
														lowerCAmelCase		=			img.numpy().astype("""np.uint8"""   )
										if isinstance(lowerCAmelCase  ,  lowerCAmelCase   ):
														lowerCAmelCase		=			img_tensorize(lowerCAmelCase   )
										assert isinstance(lowerCAmelCase  ,  np.ndarray   )

										lowerCAmelCase	,  lowerCAmelCase		=			img.shape[1], img.shape[0]
										lowerCAmelCase		=			mplfigure.Figure(frameon=lowerCAmelCase   )
										lowerCAmelCase		=			fig.get_dpi()
										lowerCAmelCase		=			(width * scale + 1e-2) / dpi
										lowerCAmelCase		=			(height * scale + 1e-2) / dpi
										fig.set_size_inches(lowerCAmelCase  ,  lowerCAmelCase   )
										lowerCAmelCase		=			fig.add_axes([0.0, 0.0, 1.0, 1.0]   )
										ax.axis("""off"""   )
										ax.set_xlim(0.0  ,  lowerCAmelCase   )
										ax.set_ylim(lowerCAmelCase   )

										lowerCAmelCase		=			saveas
										lowerCAmelCase		=			rgb
										lowerCAmelCase		=			pynb
										lowerCAmelCase		=			img
										lowerCAmelCase		=			edgecolor
										lowerCAmelCase		=			0.5
										lowerCAmelCase		=			linestyle
										lowerCAmelCase		=			int(np.sqrt(min(lowerCAmelCase  ,  lowerCAmelCase   )   ) * scale // 3   )
										lowerCAmelCase		=			width
										lowerCAmelCase		=			height
										lowerCAmelCase		=			scale
										lowerCAmelCase		=			fig
										lowerCAmelCase		=			ax
										lowerCAmelCase		=			pad
										lowerCAmelCase		=			idaobj
										lowerCAmelCase		=			idaattr
										lowerCAmelCase		=			FigureCanvasAgg(lowerCAmelCase   )


						def 					__lowercase	(							self			:     str  ,  lowerCAmelCase			:     Optional[int]  ,  lowerCAmelCase			:     List[str]=None   ):
										if color is None:
														lowerCAmelCase		=			self.edgecolor
										((lowerCAmelCase)	,  (lowerCAmelCase)	,  (lowerCAmelCase)	,  (lowerCAmelCase))		=			box
										lowerCAmelCase		=			xa - xa
										lowerCAmelCase		=			ya - ya
										self.ax.add_patch(
										    mpl.patches.Rectangle(
										        (xa, ya)  ,  lowerCAmelCase  ,  lowerCAmelCase  ,  fill=lowerCAmelCase  ,  edgecolor=lowerCAmelCase  ,  linewidth=self.font_size // 3  ,  alpha=self.alpha  ,  linestyle=self.linestyle  ,  )   )


						def 					__lowercase	(							self			:     int  ,  lowerCAmelCase			:     Any  ,  lowerCAmelCase			:     int=None  ,  lowerCAmelCase			:     Tuple=None  ,  lowerCAmelCase			:     Optional[Any]=None  ,  lowerCAmelCase			:     Dict=None   ):
										if len(boxes.shape   ) > 2:
														lowerCAmelCase		=			boxes[0]
										if len(obj_ids.shape   ) > 1:
														lowerCAmelCase		=			obj_ids[0]
										if len(obj_scores.shape   ) > 1:
														lowerCAmelCase		=			obj_scores[0]
										if len(attr_ids.shape   ) > 1:
														lowerCAmelCase		=			attr_ids[0]
										if len(attr_scores.shape   ) > 1:
														lowerCAmelCase		=			attr_scores[0]
										if isinstance(lowerCAmelCase  ,  torch.Tensor   ):
														lowerCAmelCase		=			boxes.numpy()
										if isinstance(lowerCAmelCase  ,  lowerCAmelCase   ):
														lowerCAmelCase		=			np.array(lowerCAmelCase   )
										assert isinstance(lowerCAmelCase  ,  np.ndarray   )
										lowerCAmelCase		=			np.prod(boxes[:, 2:] - boxes[:, :2]  ,  axis=1   )
										lowerCAmelCase		=			np.argsort(-areas   ).tolist()
										lowerCAmelCase		=			boxes[sorted_idxs] if boxes is not None else None
										lowerCAmelCase		=			obj_ids[sorted_idxs] if obj_ids is not None else None
										lowerCAmelCase		=			obj_scores[sorted_idxs] if obj_scores is not None else None
										lowerCAmelCase		=			attr_ids[sorted_idxs] if attr_ids is not None else None
										lowerCAmelCase		=			attr_scores[sorted_idxs] if attr_scores is not None else None

										lowerCAmelCase		=			[self._random_color(maximum=1   ) for _ in range(len(lowerCAmelCase   )   )]
										lowerCAmelCase		=			[assigned_colors[idx] for idx in sorted_idxs]
										if obj_ids is not None:
														lowerCAmelCase		=			self._create_text_labels_attr(lowerCAmelCase  ,  lowerCAmelCase  ,  lowerCAmelCase  ,  lowerCAmelCase   )
														for i in range(len(lowerCAmelCase   )   ):
																		lowerCAmelCase		=			assigned_colors[i]
																		self.add_box(boxes[i]  ,  lowerCAmelCase   )
																		self.draw_labels(labels[i]  ,  boxes[i]  ,  lowerCAmelCase   )


						def 					__lowercase	(							self			:     int  ,  lowerCAmelCase			:     Optional[Any]  ,  lowerCAmelCase			:     Any  ,  lowerCAmelCase			:     Dict   ):
										lowerCAmelCase	,  lowerCAmelCase	,  lowerCAmelCase	,  lowerCAmelCase		=			box
										lowerCAmelCase		=			(xa, ya)
										lowerCAmelCase		=			(ya - ya) * (xa - xa)
										lowerCAmelCase		=			_SMALL_OBJ * self.scale
										if instance_area < small or ya - ya < 40 * self.scale:
														if ya >= self.height - 5:
																		lowerCAmelCase		=			(xa, ya)
														else:
																		lowerCAmelCase		=			(xa, ya)

										lowerCAmelCase		=			(ya - ya) / np.sqrt(self.height * self.width   )
										lowerCAmelCase		=			self._change_color_brightness(lowerCAmelCase  ,  brightness_factor=0.7   )
										lowerCAmelCase		=			np.clip((height_ratio - 0.02) / 0.08 + 1  ,  1.2  ,  2   )
										font_size *= 0.75 * self.font_size

										self.draw_text(
										    text=lowerCAmelCase  ,  position=lowerCAmelCase  ,  color=lowerCAmelCase  ,  )


						def 					__lowercase	(							self			:     str  ,  lowerCAmelCase			:     List[str]  ,  lowerCAmelCase			:     Optional[int]  ,  lowerCAmelCase			:     Optional[int]="g"  ,  lowerCAmelCase			:     Optional[int]="left"  ,  ):
										lowerCAmelCase		=			0
										lowerCAmelCase		=			self.font_size
										lowerCAmelCase		=			np.maximum(list(mplc.to_rgb(lowerCAmelCase   )   )  ,  0.2   )
										lowerCAmelCase		=			max(0.8  ,  np.max(lowerCAmelCase   )   )
										lowerCAmelCase		=			{
										    """facecolor""": """black""",
										    """alpha""": self.alpha,
										    """pad""": self.pad,
										    """edgecolor""": """none""",
										}
										lowerCAmelCase	,  lowerCAmelCase		=			position
										self.ax.text(
										    lowerCAmelCase  ,  lowerCAmelCase  ,  lowerCAmelCase  ,  size=font_size * self.scale  ,  family="""sans-serif"""  ,  bbox=lowerCAmelCase  ,  verticalalignment="""top"""  ,  horizontalalignment=lowerCAmelCase  ,  color=lowerCAmelCase  ,  zorder=10  ,  rotation=lowerCAmelCase  ,  )


						def 					__lowercase	(							self			:     str  ,  lowerCAmelCase			:     Tuple=None   ):
										if saveas is None:
														lowerCAmelCase		=			self.saveas
										if saveas.lower().endswith(""".jpg"""   ) or saveas.lower().endswith(""".png"""   ):
														cva.imwrite(
														    lowerCAmelCase  ,  self._get_buffer()[:, :, ::-1]  ,  )
										else:
														self.fig.savefig(lowerCAmelCase   )


						def 					__lowercase	(							self			:     str  ,  lowerCAmelCase			:     int  ,  lowerCAmelCase			:     List[str]  ,  lowerCAmelCase			:     Any  ,  lowerCAmelCase			:     Optional[Any]   ):
										lowerCAmelCase		=			[self.idaobj[i] for i in classes]
										lowerCAmelCase		=			[self.idaattr[i] for i in attr_classes]
										lowerCAmelCase		=			[
										    f'''{label} {score:.2f} {attr} {attr_score:.2f}'''
										    for label, score, attr, attr_score in zip(lowerCAmelCase  ,  lowerCAmelCase  ,  lowerCAmelCase  ,  lowerCAmelCase   )
										]
										return labels


						def 					__lowercase	(							self			:     Any  ,  lowerCAmelCase			:     Dict  ,  lowerCAmelCase			:     Union[str, Any]   ):
										lowerCAmelCase		=			[self.idaobj[i] for i in classes]
										if scores is not None:
														if labels is None:
																		lowerCAmelCase		=			["""{:.0f}%""".format(s * 100   ) for s in scores]
														else:
																		lowerCAmelCase		=			["""{} {:.0f}%""".format(lowerCAmelCase  ,  s * 100   ) for li, s in zip(lowerCAmelCase  ,  lowerCAmelCase   )]
										return labels


						def 					__lowercase	(							self			:     Any  ,  lowerCAmelCase			:     str=255   ):
										lowerCAmelCase		=			np.random.randint(0  ,  len(_COLORS   )   )
										lowerCAmelCase		=			_COLORS[idx] * maximum
										if not self.rgb:
														lowerCAmelCase		=			ret[::-1]
										return ret


						def 					__lowercase	(							self			:     List[str]   ):
										if not self.pynb:
														lowerCAmelCase	,  lowerCAmelCase		=			self.canvas.print_to_buffer()
														if (width, height) != (self.width, self.height):
																		lowerCAmelCase		=			cva.resize(self.img  ,  (width, height)   )
														else:
																		lowerCAmelCase		=			self.img
										else:
														lowerCAmelCase		=			io.BytesIO()  # works for cairo backend
														self.canvas.print_rgba(lowerCAmelCase   )
														lowerCAmelCase	,  lowerCAmelCase		=			self.width, self.height
														lowerCAmelCase		=			buf.getvalue()
														lowerCAmelCase		=			self.img

										lowerCAmelCase		=			np.frombuffer(lowerCAmelCase  ,  dtype="""uint8"""   )
										lowerCAmelCase		=			buffer.reshape(lowerCAmelCase  ,  lowerCAmelCase  ,  4   )
										lowerCAmelCase	,  lowerCAmelCase		=			np.split(lowerCAmelCase  ,  [3]  ,  axis=2   )

										try:
														import numexpr as ne  # fuse them with numexpr

														lowerCAmelCase		=			ne.evaluate("""img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)"""   )
										except ImportError:
														lowerCAmelCase		=			alpha.astype("""float32"""   ) / 255.0
														lowerCAmelCase		=			img * (1 - alpha) + rgb * alpha

										return visualized_image.astype("""uint8"""   )




						def 					__lowercase	(							self			:     List[str]  ,  lowerCAmelCase			:     Optional[Any]  ,  lowerCAmelCase			:     Optional[int]   ):
										assert brightness_factor >= -1.0 and brightness_factor <= 1.0
										lowerCAmelCase		=			mplc.to_rgb(lowerCAmelCase   )
										lowerCAmelCase		=			colorsys.rgb_to_hls(*mplc.to_rgb(lowerCAmelCase   )   )
										lowerCAmelCase		=			polygon_color[1] + (brightness_factor * polygon_color[1])
										lowerCAmelCase		=			0.0 if modified_lightness < 0.0 else modified_lightness
										lowerCAmelCase		=			1.0 if modified_lightness > 1.0 else modified_lightness
										lowerCAmelCase		=			colorsys.hls_to_rgb(polygon_color[0]  ,  lowerCAmelCase  ,  polygon_color[2]   )
										return modified_color





a								=							(
    np.array(
        [
            0.000,
            0.447,
            0.741,
            0.850,
            0.325,
            0.098,
            0.929,
            0.694,
            0.125,
            0.494,
            0.184,
            0.556,
            0.466,
            0.674,
            0.188,
            0.301,
            0.745,
            0.933,
            0.635,
            0.078,
            0.184,
            0.300,
            0.300,
            0.300,
            0.600,
            0.600,
            0.600,
            1.000,
            0.000,
            0.000,
            1.000,
            0.500,
            0.000,
            0.749,
            0.749,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.333,
            0.333,
            0.000,
            0.333,
            0.667,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            0.333,
            0.000,
            0.667,
            0.667,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            1.000,
            0.000,
            0.000,
            0.333,
            0.500,
            0.000,
            0.667,
            0.500,
            0.000,
            1.000,
            0.500,
            0.333,
            0.000,
            0.500,
            0.333,
            0.333,
            0.500,
            0.333,
            0.667,
            0.500,
            0.333,
            1.000,
            0.500,
            0.667,
            0.000,
            0.500,
            0.667,
            0.333,
            0.500,
            0.667,
            0.667,
            0.500,
            0.667,
            1.000,
            0.500,
            1.000,
            0.000,
            0.500,
            1.000,
            0.333,
            0.500,
            1.000,
            0.667,
            0.500,
            1.000,
            1.000,
            0.500,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.333,
            0.333,
            1.000,
            0.333,
            0.667,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.667,
            0.333,
            1.000,
            0.667,
            0.667,
            1.000,
            0.667,
            1.000,
            1.000,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            1.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.143,
            0.143,
            0.143,
            0.857,
            0.857,
            0.857,
            1.000,
            1.000,
            1.000,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)





