


'''simple docstring'''






import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Optional

import numpy as np
import torch
from datasets import load_dataset
from torchvision.transforms import Compose, Lambda, Normalize, RandomHorizontalFlip, RandomResizedCrop, ToTensor

import transformers
from transformers import (
    CONFIG_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    AutoModelForMaskedImageModeling,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
)
from transformers.trainer_utils import get_last_checkpoint
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version
__A   :    Any											= logging.getLogger(__name__)

# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version("4.31.0")

require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/image-pretraining/requirements.txt")

__A   :    Any											= list(MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING.keys())
__A   :    List[str]											= tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)






@dataclass
class   __snake_case			:







    """simple docstring"""



    lowercase  					=   field(
        default='cifar10'      ,metadata={'help': 'Name of a dataset from the datasets package'})
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'})
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={'help': 'The column name of the images in the files. If not set, will try to use \'image\' or \'img\'.'}      ,)
    lowercase  					=   field(default=__UpperCamelCase      ,metadata={'help': 'A folder containing the training data.'})
    lowercase  					=   field(default=__UpperCamelCase      ,metadata={'help': 'A folder containing the validation data.'})
    lowercase  					=   field(
        default=0.15      ,metadata={'help': 'Percent to split off of train for validation.'})
    lowercase  					=   field(default=32      ,metadata={'help': 'The size of the square patches to use for masking.'})
    lowercase  					=   field(
        default=0.6      ,metadata={'help': 'Percentage of patches to mask.'}      ,)
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={
            'help': (
                'For debugging purposes or quicker training, truncate the number of training examples to this '
                'value if set.'
            )
        }      ,)
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={
            'help': (
                'For debugging purposes or quicker training, truncate the number of evaluation examples to this '
                'value if set.'
            )
        }      ,)

    def __lowercase  (  self       :    Any						)  ->    List[str]:
      lowerCAmelCase_     : Dict     =  {}
      if self.train_dir is not None:
        lowerCAmelCase_     : int     =  self.train_dir
      if self.validation_dir is not None:
        lowerCAmelCase_     : int     =  self.validation_dir
      lowerCAmelCase_     : Dict     =  data_files if data_files else None







@dataclass
class   __snake_case			:







    """simple docstring"""



    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={
            'help': (
                'The model checkpoint for weights initialization. Can be a local path to a pytorch_model.bin or a '
                'checkpoint identifier on the hub. '
                'Don\'t set if you want to train a model from scratch.'
            )
        }      ,)
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={'help': 'If training from scratch, pass a model type from the list: ' + ', '.join(__UpperCamelCase)}      ,)
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={'help': 'Pretrained config name or path if not the same as model_name'})
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={
            'help': (
                'Override some existing default config settings when a model is trained from scratch. Example: '
                'n_embd=10,resid_pdrop=0.2,scale_attn_weights=false,summary_type=cls_index'
            )
        }      ,)
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={'help': 'Where do you want to store (cache) the pretrained models/datasets downloaded from the hub'}      ,)
    lowercase  					=   field(
        default='main'      ,metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'}      ,)
    lowercase  					=   field(default=__UpperCamelCase      ,metadata={'help': 'Name or path of preprocessor config.'})
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={
            'help': (
                'Will use the token generated when running `huggingface-cli login` (necessary to use this script '
                'with private models).'
            )
        }      ,)
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={
            'help': (
                'The size (resolution) of each image. If not specified, will use `image_size` of the configuration.'
            )
        }      ,)
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={
            'help': (
                'The size (resolution) of each patch. If not specified, will use `patch_size` of the configuration.'
            )
        }      ,)
    lowercase  					=   field(
        default=__UpperCamelCase      ,metadata={'help': 'Stride to use for the encoder.'}      ,)







class   __snake_case			:







    """simple docstring"""



    def __init__(  self       :    str       ,		lowerCamelCase       :    Union[str, Any]=1_92       ,		lowerCamelCase       :    str=32       ,		lowerCamelCase       :    str=4       ,		lowerCamelCase       :    Optional[Any]=0.6						)  ->    Optional[Any]:
      lowerCAmelCase_     : List[Any]     =  input_size
      lowerCAmelCase_     : int     =  mask_patch_size
      lowerCAmelCase_     : Optional[Any]     =  model_patch_size
      lowerCAmelCase_     : Any     =  mask_ratio

      if self.input_size % self.mask_patch_size != 0:
        raise ValueError("""Input size must be divisible by mask patch size"""						)
      if self.mask_patch_size % self.model_patch_size != 0:
        raise ValueError("""Mask patch size must be divisible by model patch size"""						)

      lowerCAmelCase_     : Optional[Any]     =  self.input_size // self.mask_patch_size
      lowerCAmelCase_     : Union[str, Any]     =  self.mask_patch_size // self.model_patch_size

      lowerCAmelCase_     : str     =  self.rand_size**2
      lowerCAmelCase_     : Tuple     =  int(np.ceil(self.token_count * self.mask_ratio						)						)





    def __call__(  self       :    Optional[Any]						)  ->    int:
      lowerCAmelCase_     : Optional[int]     =  np.random.permutation(self.token_count						)[: self.mask_count]
      lowerCAmelCase_     : int     =  np.zeros(self.token_count       ,		dtype=lowerCamelCase						)
      lowerCAmelCase_     : Dict     =  1

      lowerCAmelCase_     : Any     =  mask.reshape((self.rand_size, self.rand_size)						)
      lowerCAmelCase_     : List[str]     =  mask.repeat(self.scale       ,		axis=0						).repeat(self.scale       ,		axis=1						)

      return torch.tensor(mask.flatten()						)







def 							UpperCamelCase_     (       A__   :  Optional[Any]   ):
  '''simple docstring'''





  lowerCAmelCase_     : int     =  torch.stack([example["""pixel_values"""] for example in examples]   )
  lowerCAmelCase_     : Any     =  torch.stack([example["""mask"""] for example in examples]   )
  return {"pixel_values": pixel_values, "bool_masked_pos": mask}







def 							UpperCamelCase_     (       ):
  '''simple docstring'''





  lowerCAmelCase_     : List[str]     =  HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)   )
  if len(sys.argv   ) == 2 and sys.argv[1].endswith(""".json"""   ):
    # If we pass only one argument to the script and it's the path to a json file,
    # let's parse it to get our arguments.
    lowerCAmelCase_,				lowerCAmelCase_,				lowerCAmelCase_     : List[Any]     =  parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]   )   )
  else:
    lowerCAmelCase_,				lowerCAmelCase_,				lowerCAmelCase_     : Optional[Any]     =  parser.parse_args_into_dataclasses()

  # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
  # information sent is the one passed as arguments along with your Python/PyTorch versions.
  send_example_telemetry("""run_mim"""				,       __lowerCAmelCase				,       __lowerCAmelCase   )

  # Setup logging
  logging.basicConfig(
      format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s"""				,       datefmt="""%m/%d/%Y %H:%M:%S"""				,       handlers=[logging.StreamHandler(sys.stdout   )]				,       )

  if training_args.should_log:
    # The default of training_args.log_level is passive, so we set log level at info here to have that default.
    transformers.utils.logging.set_verbosity_info()

  lowerCAmelCase_     : int     =  training_args.get_process_log_level()
  logger.setLevel(__lowerCAmelCase   )
  transformers.utils.logging.set_verbosity(__lowerCAmelCase   )
  transformers.utils.logging.enable_default_handler()
  transformers.utils.logging.enable_explicit_format()

  # Log on each process the small summary:
  logger.warning(
      f'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}'
      + f'distributed training: {bool(training_args.local_rank != -1   )}, 16-bits training: {training_args.fpaa}'   )
  logger.info(f'Training/evaluation parameters {training_args}'   )

  # Detecting last checkpoint.
  lowerCAmelCase_     : List[str]     =  None
  if os.path.isdir(training_args.output_dir   ) and training_args.do_train and not training_args.overwrite_output_dir:
    lowerCAmelCase_     : List[Any]     =  get_last_checkpoint(training_args.output_dir   )
    if last_checkpoint is None and len(os.listdir(training_args.output_dir   )   ) > 0:
      raise ValueError(
          f'Output directory ({training_args.output_dir}) already exists and is not empty. '
          """Use --overwrite_output_dir to overcome."""   )
    elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
      logger.info(
          f'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change '
          """the `--output_dir` or add `--overwrite_output_dir` to train from scratch."""   )

    # Initialize our dataset.
  lowerCAmelCase_     : Optional[int]     =  load_dataset(
      data_args.dataset_name				,       data_args.dataset_config_name				,       data_files=data_args.data_files				,       cache_dir=model_args.cache_dir				,       use_auth_token=True if model_args.use_auth_token else None				,       )

  # If we don't have a validation split, split off a percentage of train as validation.
  lowerCAmelCase_     : Tuple     =  None if """validation""" in ds.keys() else data_args.train_val_split
  if isinstance(data_args.train_val_split				,       __lowerCAmelCase   ) and data_args.train_val_split > 0.0:
    lowerCAmelCase_     : List[Any]     =  ds["""train"""].train_test_split(data_args.train_val_split   )
    lowerCAmelCase_     : List[Any]     =  split["""train"""]
    lowerCAmelCase_     : Optional[Any]     =  split["""test"""]

  # Create config
  # Distributed training:
  # The .from_pretrained methods guarantee that only one local process can concurrently
  # download model & vocab.
  lowerCAmelCase_     : List[Any]     =  {
      """cache_dir""": model_args.cache_dir,
      """revision""": model_args.model_revision,
      """use_auth_token""": True if model_args.use_auth_token else None,
  }
  if model_args.config_name_or_path:
    lowerCAmelCase_     : Optional[Any]     =  AutoConfig.from_pretrained(model_args.config_name_or_path				,       **__lowerCAmelCase   )
  elif model_args.model_name_or_path:
    lowerCAmelCase_     : Optional[Any]     =  AutoConfig.from_pretrained(model_args.model_name_or_path				,       **__lowerCAmelCase   )
  else:
    lowerCAmelCase_     : str     =  CONFIG_MAPPING[model_args.model_type]()
    logger.warning("""You are instantiating a new config instance from scratch."""   )
    if model_args.config_overrides is not None:
      logger.info(f'Overriding config: {model_args.config_overrides}'   )
      config.update_from_string(model_args.config_overrides   )
      logger.info(f'New config: {config}'   )

    # make sure the decoder_type is "simmim" (only relevant for BEiT)
  if hasattr(__lowerCAmelCase				,       """decoder_type"""   ):
    lowerCAmelCase_     : Optional[int]     =  """simmim"""

  # adapt config
  lowerCAmelCase_     : Union[str, Any]     =  model_args.image_size if model_args.image_size is not None else config.image_size
  lowerCAmelCase_     : Union[str, Any]     =  model_args.patch_size if model_args.patch_size is not None else config.patch_size
  lowerCAmelCase_     : Optional[Any]     =  (
      model_args.encoder_stride if model_args.encoder_stride is not None else config.encoder_stride
  )

  config.update(
      {
          """image_size""": model_args.image_size,
          """patch_size""": model_args.patch_size,
          """encoder_stride""": model_args.encoder_stride,
      }   )

  # create image processor
  if model_args.image_processor_name:
    lowerCAmelCase_     : Optional[Any]     =  AutoImageProcessor.from_pretrained(model_args.image_processor_name				,       **__lowerCAmelCase   )
  elif model_args.model_name_or_path:
    lowerCAmelCase_     : List[str]     =  AutoImageProcessor.from_pretrained(model_args.model_name_or_path				,       **__lowerCAmelCase   )
  else:
    lowerCAmelCase_     : List[Any]     =  {
        conf.model_type: image_processor_class for conf, image_processor_class in IMAGE_PROCESSOR_MAPPING.items()
    }
    lowerCAmelCase_     : Optional[int]     =  IMAGE_PROCESSOR_TYPES[model_args.model_type]()

  # create model
  if model_args.model_name_or_path:
    lowerCAmelCase_     : Optional[Any]     =  AutoModelForMaskedImageModeling.from_pretrained(
        model_args.model_name_or_path				,       from_tf=bool(""".ckpt""" in model_args.model_name_or_path   )				,       config=__lowerCAmelCase				,       cache_dir=model_args.cache_dir				,       revision=model_args.model_revision				,       use_auth_token=True if model_args.use_auth_token else None				,       )
  else:
    logger.info("""Training new model from scratch"""   )
    lowerCAmelCase_     : Optional[int]     =  AutoModelForMaskedImageModeling.from_config(__lowerCAmelCase   )

  if training_args.do_train:
    lowerCAmelCase_     : Optional[Any]     =  ds["""train"""].column_names
  else:
    lowerCAmelCase_     : Optional[int]     =  ds["""validation"""].column_names

  if data_args.image_column_name is not None:
    lowerCAmelCase_     : str     =  data_args.image_column_name
  elif "image" in column_names:
    lowerCAmelCase_     : str     =  """image"""
  elif "img" in column_names:
    lowerCAmelCase_     : Dict     =  """img"""
  else:
    lowerCAmelCase_     : Any     =  column_names[0]

  # transformations as done in original SimMIM paper
  # source: https://github.com/microsoft/SimMIM/blob/main/data/data_simmim.py
  lowerCAmelCase_     : str     =  Compose(
      [
          Lambda(lambda A__   : img.convert("""RGB"""   ) if img.mode != "RGB" else img   ),
          RandomResizedCrop(model_args.image_size				,       scale=(0.67, 1.0)				,       ratio=(3.0 / 4.0, 4.0 / 3.0)   ),
          RandomHorizontalFlip(),
          ToTensor(),
          Normalize(mean=image_processor.image_mean				,       std=image_processor.image_std   ),
      ]   )

  # create mask generator
  lowerCAmelCase_     : Union[str, Any]     =  MaskGenerator(
      input_size=model_args.image_size				,       mask_patch_size=data_args.mask_patch_size				,       model_patch_size=model_args.patch_size				,       mask_ratio=data_args.mask_ratio				,       )

  def preprocess_images(A__   :  Tuple   ):
    lowerCAmelCase_     : Optional[int]     =  [transforms(__lowerCAmelCase   ) for image in examples[image_column_name]]
    lowerCAmelCase_     : str     =  [mask_generator() for i in range(len(examples[image_column_name]   )   )]

    return examples

  if training_args.do_train:
    if "train" not in ds:
      raise ValueError("""--do_train requires a train dataset"""   )
    if data_args.max_train_samples is not None:
      lowerCAmelCase_     : int     =  ds["""train"""].shuffle(seed=training_args.seed   ).select(range(data_args.max_train_samples   )   )
    # Set the training transforms
    ds["train"].set_transform(__lowerCAmelCase   )

  if training_args.do_eval:
    if "validation" not in ds:
      raise ValueError("""--do_eval requires a validation dataset"""   )
    if data_args.max_eval_samples is not None:
      lowerCAmelCase_     : str     =  (
          ds["""validation"""].shuffle(seed=training_args.seed   ).select(range(data_args.max_eval_samples   )   )
      )
    # Set the validation transforms
    ds["validation"].set_transform(__lowerCAmelCase   )

  # Initialize our trainer
  lowerCAmelCase_     : Union[str, Any]     =  Trainer(
      model=__lowerCAmelCase				,       args=__lowerCAmelCase				,       train_dataset=ds["""train"""] if training_args.do_train else None				,       eval_dataset=ds["""validation"""] if training_args.do_eval else None				,       tokenizer=__lowerCAmelCase				,       data_collator=__lowerCAmelCase				,       )

  # Training
  if training_args.do_train:
    lowerCAmelCase_     : str     =  None
    if training_args.resume_from_checkpoint is not None:
      lowerCAmelCase_     : List[Any]     =  training_args.resume_from_checkpoint
    elif last_checkpoint is not None:
      lowerCAmelCase_     : Optional[Any]     =  last_checkpoint
    lowerCAmelCase_     : Dict     =  trainer.train(resume_from_checkpoint=__lowerCAmelCase   )
    trainer.save_model()
    trainer.log_metrics("""train"""				,       train_result.metrics   )
    trainer.save_metrics("""train"""				,       train_result.metrics   )
    trainer.save_state()

  # Evaluation
  if training_args.do_eval:
    lowerCAmelCase_     : List[Any]     =  trainer.evaluate()
    trainer.log_metrics("""eval"""				,       __lowerCAmelCase   )
    trainer.save_metrics("""eval"""				,       __lowerCAmelCase   )

  # Write model card and (optionally) push to hub
  lowerCAmelCase_     : Tuple     =  {
      """finetuned_from""": model_args.model_name_or_path,
      """tasks""": """masked-image-modeling""",
      """dataset""": data_args.dataset_name,
      """tags""": ["""masked-image-modeling"""],
  }
  if training_args.push_to_hub:
    trainer.push_to_hub(**__lowerCAmelCase   )
  else:
    trainer.create_model_card(**__lowerCAmelCase   )


if __name__ == "__main__":
  main()





import os
from datetime import datetime as dt

from github import Github


__magic_name__  							=	[
    '''good first issue''',
    '''feature request''',
    '''wip''',
]





def 						SCREAMING_SNAKE_CASE__     (   ):
    snake_case__    =					Github(os.environ["GITHUB_TOKEN"]				)
    snake_case__    =					g.get_repo("huggingface/accelerate"				)
    snake_case__    =					repo.get_issues(state="open"				)

    for issue in open_issues:
        snake_case__    =					sorted([comment for comment in issue.get_comments()]     ,		key=lambda __lowerCAmelCase				: i.created_at     ,		reverse=__lowerCAmelCase				)
        snake_case__    =					comments[0] if len(__lowerCAmelCase				) > 0 else None
        snake_case__    =					dt.utcnow()
        snake_case__    =					(current_time - issue.updated_at).days
        snake_case__    =					(current_time - issue.created_at).days
        if (
            last_comment is not None
            and last_comment.user.login == "github-actions[bot]"
            and days_since_updated > 7
            and days_since_creation >= 30
            and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()				)
        ):
            # Close issue since it has been 7 days of inactivity since bot mention.
            issue.edit(state="closed"				)
        elif (
            days_since_updated > 23
            and days_since_creation >= 30
            and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()				)
        ):
            # Add stale comment
            issue.create_comment(
                "This issue has been automatically marked as stale because it has not had "
                "recent activity. If you think this still needs to be addressed "
                "please comment on this thread.\n\nPlease note that issues that do not follow the "
                "[contributing guidelines](https://github.com/huggingface/accelerate/blob/main/CONTRIBUTING.md) "
                "are likely to be ignored."				)


if __name__ == "__main__":
     main()



