code: 
  
  
  
  
  
  from copy import deepcopy
  from pathlib import Path
  from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
  
  import torch
  from torch import nn
  from torch.utils.data import Dataset
  
  from .deepspeed import is_deepspeed_zeroa_enabled
  from .generation.configuration_utils import GenerationConfig
  from .trainer import Trainer
  from .utils import logging
  
  
  if TYPE_CHECKING:
     from .data.data_collator import DataCollator
     from .modeling_utils import PreTrainedModel
     from .tokenization_utils_base import PreTrainedTokenizerBase
     from .trainer_callback import TrainerCallback
     from .trainer_utils import EvalPrediction, PredictionOutput
     from .training_args import TrainingArguments
  
  
  lowerCAmelCase_   =   logging.get_logger(__name__)
  
  class 				A    (_a				):
  
  
  
        def __init__(					self     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = (None, None)     ,  lowercase_ = None     ,  )      ->   List[Any]:
  
  
  
               '''simple docstring'''
  
               super().__init__(
                   model=lowerCamelCase__     ,  args=lowerCamelCase__     ,  data_collator=lowerCamelCase__     ,  train_dataset=lowerCamelCase__     ,  eval_dataset=lowerCamelCase__     ,  tokenizer=lowerCamelCase__     ,  model_init=lowerCamelCase__     ,  compute_metrics=lowerCamelCase__     ,  callbacks=lowerCamelCase__     ,  optimizers=lowerCamelCase__     ,  preprocess_logits_for_metrics=lowerCamelCase__     ,  )
  
               # Override self.model.generation_config if a GenerationConfig is specified in args.
               # Priority: args.generation_config > model.generation_config > default GenerationConfig.
               if self.args.generation_config is not None:
                      _snake_case      :							Tuple     				=						self.load_generation_config(self.args.generation_config					)
                      _snake_case      :							Optional[int]     				=						gen_config
  
  
  
        @staticmethod
        def    __a (					lowercase_					)      ->   int:
  
  
  
               '''simple docstring'''
  
               if isinstance(lowerCamelCase__     ,  lowerCamelCase__					):
                      return deepcopy(lowerCamelCase__					)
  
               # str or Path
               _snake_case      :							Optional[int]     				=						Path(lowerCamelCase__					) if isinstance(lowerCamelCase__     ,  lowerCamelCase__					) else gen_config_arg
               _snake_case      :							List[Any]     				=						None
  
               # Figuring if it is path pointing to a file, pointing to a directory or else a model id or URL
               # This step is required in order to determine config_file_name
               if pretrained_model_name.is_file():
                      _snake_case      :							Union[str, Any]     				=						pretrained_model_name.name
                      _snake_case      :							Tuple     				=						pretrained_model_name.parent
               # dir path
               elif pretrained_model_name.is_dir():
                      pass
               # model id or URL
               else:
                      _snake_case      :							Optional[int]     				=						gen_config_arg
  
               _snake_case      :							str     				=						GenerationConfig.from_pretrained(lowerCamelCase__     ,  lowerCamelCase__					)
               return gen_config
  
  
  
        def    __a (					self     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = "eval"     ,  **lowercase_     ,  )      ->   int:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[Any]     				=						gen_kwargs.copy()
               if gen_kwargs.get('''max_length'''					) is None and gen_kwargs.get('''max_new_tokens'''					) is None:
                      _snake_case      :							Dict     				=						self.args.generation_max_length
               _snake_case      :							Any     				=						(
                   gen_kwargs["num_beams"] if gen_kwargs.get('''num_beams'''					) is not None else self.args.generation_num_beams
               )
               _snake_case      :							int     				=						gen_kwargs
  
               return super().evaluate(lowerCamelCase__     ,  ignore_keys=lowerCamelCase__     ,  metric_key_prefix=lowerCamelCase__					)
  
  
  
        def    __a (					self     ,  lowercase_     ,  lowercase_ = None     ,  lowercase_ = "test"     ,  **lowercase_     ,  )      ->   List[str]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[Any]     				=						gen_kwargs.copy()
               if gen_kwargs.get('''max_length'''					) is None and gen_kwargs.get('''max_new_tokens'''					) is None:
                      _snake_case      :							List[str]     				=						self.args.generation_max_length
               _snake_case      :							List[Any]     				=						(
                   gen_kwargs["num_beams"] if gen_kwargs.get('''num_beams'''					) is not None else self.args.generation_num_beams
               )
               _snake_case      :							Any     				=						gen_kwargs
  
               return super().predict(lowerCamelCase__     ,  ignore_keys=lowerCamelCase__     ,  metric_key_prefix=lowerCamelCase__					)
  
  
  
        def    __a (					self     ,  lowercase_     ,  lowercase_     ,  lowercase_     ,  lowercase_ = None     ,  **lowercase_     ,  )      ->   str:
  
  
  
               '''simple docstring'''
  
               if not self.args.predict_with_generate or prediction_loss_only:
                      return super().prediction_step(
                          lowerCamelCase__     ,  lowerCamelCase__     ,  prediction_loss_only=lowerCamelCase__     ,  ignore_keys=lowerCamelCase__					)
  
               _snake_case      :							Tuple     				=						"labels" in inputs
               _snake_case      :							int     				=						self._prepare_inputs(lowerCamelCase__					)
  
               # XXX: adapt synced_gpus for fairscale as well
               # Priority (handled in generate):
               # gen_kwargs > model.generation_config > default GenerationConfig()
  
               if len(lowerCamelCase__					) == 0 and hasattr(self     ,  '''_gen_kwargs'''					):
                      _snake_case      :							Union[str, Any]     				=						self._gen_kwargs.copy()
  
               if gen_kwargs.get('''max_length'''					) is None and gen_kwargs.get('''max_new_tokens'''					) is None:
                      _snake_case      :							List[str]     				=						self.model.config.max_length
               _snake_case      :							Dict     				=						(
                   gen_kwargs["num_beams"] if gen_kwargs.get('''num_beams'''					) is not None else self.model.config.num_beams
               )
               _snake_case      :							Any     				=						True if is_deepspeed_zeroa_enabled() else False
               _snake_case      :							List[Any]     				=						(
                   gen_kwargs["synced_gpus"] if gen_kwargs.get('''synced_gpus'''					) is not None else default_synced_gpus
               )
  
               # If the `decoder_input_ids` was created from `labels`, evict the former, so that the model can freely generate
               # (otherwise, it would continue generating from the padded `decoder_input_ids`)
               if (
                   "labels" in inputs
                   and "decoder_input_ids" in inputs
                   and inputs["labels"].shape == inputs["decoder_input_ids"].shape
               ):
                      _snake_case      :							int     				=						{k: v for k, v in inputs.items() if k != "decoder_input_ids"}
               _snake_case      :							List[str]     				=						self.model.generate(**lowerCamelCase__     ,  **lowerCamelCase__					)
  
               # Temporary hack to ensure the generation config is not initialized for each iteration of the evaluation loop
               # TODO: remove this hack when the legacy code that initializes generation_config from a model config is
               # removed in https://github.com/huggingface/transformers/blob/98d88b23f54e5a23e741833f1e973fdf600cc2c5/src/transformers/generation/utils.py#L1183
               if self.model.generation_config._from_model_config:
                      _snake_case      :							List[str]     				=						False
  
               # Retrieves GenerationConfig from model.generation_config
               _snake_case      :							List[Any]     				=						self.model.generation_config
               # in case the batch is shorter than max length, the output should be padded
               if generated_tokens.shape[-1] < gen_config.max_length:
                      _snake_case      :							int     				=						self._pad_tensors_to_max_len(lowerCamelCase__     ,  gen_config.max_length					)
               elif gen_config.max_new_tokens is not None and generated_tokens.shape[-1] < gen_config.max_new_tokens + 1:
                      _snake_case      :							List[str]     				=						self._pad_tensors_to_max_len(lowerCamelCase__     ,  gen_config.max_new_tokens + 1					)
  
               with torch.no_grad():
                      if has_labels:
                             with self.compute_loss_context_manager():
                                    _snake_case      :							Tuple     				=						model(**lowerCamelCase__					)
                             if self.label_smoother is not None:
                                    _snake_case      :							Tuple     				=						self.label_smoother(lowerCamelCase__     ,  inputs['''labels''']					).mean().detach()
                             else:
                                    _snake_case      :							Dict     				=						(outputs["loss"] if isinstance(lowerCamelCase__     ,  lowerCamelCase__					) else outputs[0]).mean().detach()
                      else:
                             _snake_case      :							int     				=						None
  
               if self.args.prediction_loss_only:
                      return loss, None, None
  
               if has_labels:
                      _snake_case      :							Dict     				=						inputs["labels"]
                      if labels.shape[-1] < gen_config.max_length:
                             _snake_case      :							Union[str, Any]     				=						self._pad_tensors_to_max_len(lowerCamelCase__     ,  gen_config.max_length					)
                      elif gen_config.max_new_tokens is not None and labels.shape[-1] < gen_config.max_new_tokens + 1:
                             _snake_case      :							Tuple     				=						self._pad_tensors_to_max_len(lowerCamelCase__     ,  gen_config.max_new_tokens + 1					)
               else:
                      _snake_case      :							Union[str, Any]     				=						None
  
               return loss, generated_tokens, labels
  
  
  
        def    __a (					self     ,  lowercase_     ,  lowercase_					)      ->   List[str]:
  
  
  
               '''simple docstring'''
  
               if self.tokenizer is not None and hasattr(self.tokenizer     ,  '''pad_token_id'''					):
                      # If PAD token is not defined at least EOS token has to be defined
                      _snake_case      :							Optional[Any]     				=						(
                          self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else self.tokenizer.eos_token_id
                      )
               else:
                      if self.model.config.pad_token_id is not None:
                             _snake_case      :							Dict     				=						self.model.config.pad_token_id
                      else:
                             raise ValueError('''Pad_token_id must be set in the configuration of the model, in order to pad tensors'''					)
  
               _snake_case      :							Any     				=						pad_token_id * torch.ones(
                   (tensor.shape[0], max_length)     ,  dtype=tensor.dtype     ,  device=tensor.device					)
               _snake_case      :							str     				=						tensor
               return padded_tensor
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  import cva
  import numpy as np
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_      ,		lowercase_  )			->						int:
  
         try:
                return int(image[x_coordinate][y_coordinate] >= center  )
         except (IndexError, TypeError):
                return 0
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_  )			->						int:
         _snake_case      :							List[str]     				=						image[x_coordinate][y_coordinate]
         _snake_case      :							List[str]     				=						[1, 2, 4, 8, 16, 32, 64, 128]
  
         # skip get_neighbors_pixel if center is null
         if center is None:
                return 0
  
         # Starting from the top right, assigning value to pixels clockwise
         _snake_case      :							Any     				=						[
             get_neighbors_pixel(lowercase_      ,		x_coordinate - 1      ,		y_coordinate + 1      ,		lowercase_  ),
             get_neighbors_pixel(lowercase_      ,		lowercase_      ,		y_coordinate + 1      ,		lowercase_  ),
             get_neighbors_pixel(lowercase_      ,		x_coordinate - 1      ,		lowercase_      ,		lowercase_  ),
             get_neighbors_pixel(lowercase_      ,		x_coordinate + 1      ,		y_coordinate + 1      ,		lowercase_  ),
             get_neighbors_pixel(lowercase_      ,		x_coordinate + 1      ,		lowercase_      ,		lowercase_  ),
             get_neighbors_pixel(lowercase_      ,		x_coordinate + 1      ,		y_coordinate - 1      ,		lowercase_  ),
             get_neighbors_pixel(lowercase_      ,		lowercase_      ,		y_coordinate - 1      ,		lowercase_  ),
             get_neighbors_pixel(lowercase_      ,		x_coordinate - 1      ,		y_coordinate - 1      ,		lowercase_  ),
         ]
  
         # Converting the binary value to decimal.
         return sum(
             binary_value * power for binary_value, power in zip(lowercase_      ,		lowercase_  )  )
  
  
  if __name__ == "__main__":
     # Reading the image and converting it to grayscale.
     lowerCAmelCase_   =   cva.imread(
         "digital_image_processing/image_data/lena.jpg", cva.IMREAD_GRAYSCALE
     )
  
     # Create a numpy array as the same height and width of read image
     lowerCAmelCase_   =   np.zeros((image.shape[0], image.shape[1]))
  
     # Iterating through the image and calculating the
     # local binary pattern value for each pixel.
     for i in range(0, image.shape[0]):
        for j in range(0, image.shape[1]):
           lowerCAmelCase_   =   local_binary_value(image, i, j)
  
     cva.imshow("local binary pattern", lbp_image)
     cva.waitKey(0)
     cva.destroyAllWindows()
  
  
  
  
  
  
  