


"""simple docstring"""


import logging
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union

import librosa
import torch
from datasets import DatasetDict, load_dataset
from packaging import version
from torch import nn

from transformers import (
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaForPreTraining,
    is_apex_available,
    trainer_utils,
)
from transformers.models.wavaveca.modeling_wavaveca import _compute_mask_indices


if is_apex_available():
   from apex import amp

if version.parse(version.parse(torch.__version__).base_version) >= version.parse("1.6"):
   _snake_case          =							True
   from torch.cuda.amp import autocast


_snake_case          =							logging.getLogger(__name__)



@dataclass
class   _a      :
    a_    :				str             =    field(
        metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'} )
    a_    :				Optional[str]             =    field(
        default=SCREAMING_SNAKE_CASE_		,		metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}		,		)
    a_    :				Optional[bool]             =    field(
        default=SCREAMING_SNAKE_CASE_		,		metadata={'help': 'Whether to freeze the feature extractor layers of the model.'} )
    a_    :				Optional[bool]             =    field(
        default=SCREAMING_SNAKE_CASE_		,		metadata={'help': 'Whether to log verbose messages or not.'}		,		)
    a_    :				Optional[float]             =    field(
        default=2.0		,		metadata={'help': 'Maximum temperature for gumbel softmax.'} )
    a_    :				Optional[float]             =    field(
        default=0.5		,		metadata={'help': 'Minimum temperature for gumbel softmax.'} )
    a_    :				Optional[float]             =    field(
        default=0.999995		,		metadata={'help': 'Decay of gumbel temperature during training.'} )





def   snake_case						(				_a:     ModelArguments		,   _a:     TrainingArguments							)->		Dict:
      '''simple docstring'''


      logging.basicConfig(
          format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'		,   datefmt='%m/%d/%Y %H:%M:%S'		,   handlers=[logging.StreamHandler(sys.stdout							)]		,   )
      lowerCamelCase__           =		logging.WARNING
      if model_args.verbose_logging:
            lowerCamelCase__           =		logging.DEBUG
      elif trainer_utils.is_main_process(training_args.local_rank							):
            lowerCamelCase__           =		logging.INFO
      logger.setLevel(_a							)



@dataclass
class   _a      :
    a_    :				str             =    field(
        default=SCREAMING_SNAKE_CASE_		,		metadata={'help': 'The name of the dataset to use (via the datasets library).'} )
    a_    :				Optional[str]             =    field(
        default=SCREAMING_SNAKE_CASE_		,		metadata={'help': 'The configuration name of the dataset to use (via the datasets library).'} )
    a_    :				Optional[str]             =    field(
        default='train'		,		metadata={
            'help': 'The name of the training data set split to use (via the datasets library). Defaults to \'train\''
        }		,		)
    a_    :				Optional[str]             =    field(
        default='validation'		,		metadata={
            'help': (
                'The name of the validation data set split to use (via the datasets library). Defaults to \'validation\''
            )
        }		,		)
    a_    :				Optional[str]             =    field(
        default='file'		,		metadata={'help': 'Column in the dataset that contains speech file path. Defaults to \'file\''}		,		)
    a_    :				bool             =    field(
        default=SCREAMING_SNAKE_CASE_		,		metadata={'help': 'Overwrite the cached preprocessed datasets or not.'} )
    a_    :				Optional[int]             =    field(
        default=1		,		metadata={
            'help': 'The percentage of the train set used as validation set in case there\'s no validation split'
        }		,		)
    a_    :				Optional[int]             =    field(
        default=SCREAMING_SNAKE_CASE_		,		metadata={'help': 'The number of processes to use for the preprocessing.'}		,		)
    a_    :				Optional[float]             =    field(
        default=20.0		,		metadata={'help': 'Filter audio files that are longer than `max_duration_in_seconds` seconds'} )





@dataclass
class   _a      :
    a_    :				WavaVecaForPreTraining
    a_    :				WavaVecaFeatureExtractor
    a_    :				Union[bool, str]             =    "longest"
    a_    :				Optional[int]             =    None
    a_    :				Optional[int]             =    None
    def __call__( self							:					Dict							,					SCREAMING_SNAKE_CASE__							:					List[Dict[str, Union[List[int], torch.Tensor]]]				):
          # reformat list to dict and set to pytorch format
          lowerCamelCase__           =		self.feature_extractor.pad(
              SCREAMING_SNAKE_CASE__							,					max_length=self.max_length							,					padding=self.padding							,					pad_to_multiple_of=self.pad_to_multiple_of							,					return_tensors='pt'							,					)
          lowerCamelCase__           =		self.model._get_feat_extract_output_lengths(batch['input_values'].shape[-1]				)

          lowerCamelCase__           =		batch['input_values'].shape[0]

          # make sure that no loss is computed on padded inputs
          if batch["attention_mask"] is not None:
                # compute real output lengths according to convolution formula
                lowerCamelCase__           =		self.model._get_feat_extract_output_lengths(batch['attention_mask'].sum(-1				)				).to(
                    torch.long				)

                lowerCamelCase__           =		torch.zeros(
                    (batch_size, mask_indices_seq_length)							,					dtype=torch.long							,					device=batch['input_values'].device				)

                # these two operations makes sure that all values
                # before the output lengths indices are attended to
                lowerCamelCase__           =		1
                lowerCamelCase__           =		attention_mask.flip([-1]				).cumsum(-1				).flip([-1]				).bool()

          # sample randomly masked indices
          lowerCamelCase__           =		_compute_mask_indices(
              (batch_size, mask_indices_seq_length)							,					self.model.config.mask_time_prob							,					self.model.config.mask_time_length							,					attention_mask=SCREAMING_SNAKE_CASE__							,					min_masks=2							,					)

          return batch





class   _a      (      SCREAMING_SNAKE_CASE_ ):
    def __init__( self							:					Union[str, Any]							,					*SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					List[Any]=1							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]=0							,					SCREAMING_SNAKE_CASE__							:					Optional[int]=1.0							,					**SCREAMING_SNAKE_CASE__							:					List[str]				):
          super().__init__(*SCREAMING_SNAKE_CASE__							,					**SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		0
          lowerCamelCase__           =		max_gumbel_temp
          lowerCamelCase__           =		min_gumbel_temp
          lowerCamelCase__           =		gumbel_temp_decay


    def      _UpperCamelCase       ( self							:					int							,					SCREAMING_SNAKE_CASE__							:					nn.Module							,					SCREAMING_SNAKE_CASE__							:					Dict[str, Union[torch.Tensor, Any]]				):
          model.train()
          lowerCamelCase__           =		self._prepare_inputs(SCREAMING_SNAKE_CASE__				)

          if self.use_amp:
                with autocast():
                      lowerCamelCase__           =		self.compute_loss(SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__				)
          else:
                lowerCamelCase__           =		self.compute_loss(SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__				)

          if self.args.n_gpu > 1 or self.deepspeed:
                if model.module.config.ctc_loss_reduction == "mean":
                      lowerCamelCase__           =		loss.mean()
                elif model.module.config.ctc_loss_reduction == "sum":
                      lowerCamelCase__           =		loss.sum() / (inputs['mask_time_indices']).sum()
                else:
                      raise ValueError(F'{model.config.ctc_loss_reduction} is not valid. Choose one of [\'mean\', \'sum\']'				)

          if self.args.gradient_accumulation_steps > 1:
                lowerCamelCase__           =		loss / self.args.gradient_accumulation_steps

          if self.use_amp:
                self.scaler.scale(SCREAMING_SNAKE_CASE__				).backward()
          elif self.use_apex:
                with amp.scale_loss(SCREAMING_SNAKE_CASE__							,					self.optimizer				) as scaled_loss:
                      scaled_loss.backward()
          elif self.deepspeed:
                self.deepspeed.backward(SCREAMING_SNAKE_CASE__				)
          else:
                loss.backward()

          self.num_update_step += 1
          # make sure gumbel softmax temperature is decayed
          if self.args.n_gpu > 1 or self.deepspeed:
                model.module.set_gumbel_temperature(
                    max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step							,					self.min_gumbel_temp				)				)
          else:
                model.set_gumbel_temperature(
                    max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step							,					self.min_gumbel_temp				)				)

          return loss.detach()





def   snake_case						(				)->		List[str]:
      '''simple docstring'''


      lowerCamelCase__           =		HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)							)

      lowerCamelCase__    ,  lowerCamelCase__    ,  lowerCamelCase__           =		parser.parse_args_into_dataclasses()
      configure_logger(_a		,   _a							)

      # Downloading and loading a dataset from the hub.
      lowerCamelCase__           =		load_dataset(data_args.dataset_name		,   data_args.dataset_config_name		,   cache_dir=model_args.cache_dir							)

      if "validation" not in datasets.keys():
            # make sure only "validation" and "train" keys remain"
            lowerCamelCase__           =		DatasetDict()
            lowerCamelCase__           =		load_dataset(
                data_args.dataset_name		,   data_args.dataset_config_name		,   split=F'{data_args.train_split_name}[:{data_args.validation_split_percentage}%]'		,   cache_dir=model_args.cache_dir		,   )
            lowerCamelCase__           =		load_dataset(
                data_args.dataset_name		,   data_args.dataset_config_name		,   split=F'{data_args.train_split_name}[{data_args.validation_split_percentage}%:]'		,   cache_dir=model_args.cache_dir		,   )
      else:
            # make sure only "validation" and "train" keys remain"
            lowerCamelCase__           =		DatasetDict()
            lowerCamelCase__           =		load_dataset(
                data_args.dataset_name		,   data_args.dataset_config_name		,   split='validation'		,   cache_dir=model_args.cache_dir		,   )
            lowerCamelCase__           =		load_dataset(
                data_args.dataset_name		,   data_args.dataset_config_name		,   split=F'{data_args.train_split_name}'		,   cache_dir=model_args.cache_dir		,   )

      # only normalized-inputs-training is supported
      lowerCamelCase__           =		WavaVecaFeatureExtractor.from_pretrained(
          model_args.model_name_or_path		,   cache_dir=model_args.cache_dir		,   do_normalize=_a							)

      def prepare_dataset(_a:     List[Any]							):
            # check that all files have the correct sampling rate
            lowerCamelCase__    ,  lowerCamelCase__           =		librosa.load(batch[data_args.speech_file_column]		,   sr=feature_extractor.sampling_rate							)
            return batch

      # load audio files into numpy arrays
      lowerCamelCase__           =		datasets.map(
          _a		,   num_proc=data_args.preprocessing_num_workers		,   remove_columns=datasets['train'].column_names							)

      # filter audio files that are too long
      lowerCamelCase__           =		vectorized_datasets.filter(
          lambda _a							: len(data['speech']							) < int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate							)							)

      def normalize(_a:     List[str]							):
            return feature_extractor(batch['speech']		,   sampling_rate=feature_extractor.sampling_rate							)

      # normalize and transform to `BatchFeatures`
      lowerCamelCase__           =		vectorized_datasets.map(
          _a		,   batched=_a		,   num_proc=data_args.preprocessing_num_workers		,   load_from_cache_file=not data_args.overwrite_cache		,   remove_columns=vectorized_datasets['train'].column_names		,   )

      # pretraining is only supported for "newer" stable layer norm architecture
      # apply_spec_augment has to be True, mask_feature_prob has to be 0.0
      lowerCamelCase__           =		WavaVecaConfig.from_pretrained(
          model_args.model_name_or_path		,   cache_dir=model_args.cache_dir		,   gradient_checkpointing=training_args.gradient_checkpointing		,   )

      if not config.do_stable_layer_norm or config.feat_extract_norm != "layer":
            raise ValueError(
                'PreTraining is only supported for ``config.do_stable_layer_norm=True`` and'
                ' ``config.feat_extract_norm=\'layer\''							)

      lowerCamelCase__           =		WavaVecaForPreTraining(_a							)

      lowerCamelCase__           =		DataCollatorForWavaVecaPretraining(model=_a		,   feature_extractor=_a							)

      lowerCamelCase__           =		WavaVecaPreTrainer(
          model=_a		,   data_collator=_a		,   args=_a		,   train_dataset=vectorized_datasets['train']		,   eval_dataset=vectorized_datasets['validation']		,   tokenizer=_a		,   max_gumbel_temp=model_args.max_gumbel_temperature		,   min_gumbel_temp=model_args.min_gumbel_temperature		,   gumbel_temp_decay=model_args.gumbel_temperature_decay		,   )
      trainer.train()


if __name__ == "__main__":
   main()







"""simple docstring"""


from ...utils import (
    OptionalDependencyNotAvailable,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)


try:
   if not (is_transformers_available() and is_torch_available()):
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   from ...utils.dummy_torch_and_transformers_objects import ShapEPipeline
else:
   from .camera import create_pan_cameras
   from .pipeline_shap_e import ShapEPipeline
   from .pipeline_shap_e_img2img import ShapEImgaImgPipeline
   from .renderer import (
       BoundingBoxVolume,
       ImportanceRaySampler,
       MLPNeRFModelOutput,
       MLPNeRSTFModel,
       ShapEParamsProjModel,
       ShapERenderer,
       StratifiedRaySampler,
       VoidNeRFModel,
   )



