






"""simple docstring"""


import itertools
from dataclasses import dataclass
from typing import List, Optional

import pyarrow as pa
import pyarrow.parquet as pq

import datasets
from datasets.table import table_cast


UpperCAmelCase__  		=						datasets.utils.logging.get_logger(__name__)


@dataclass
class        a				(		datasets.BuilderConfig   ):
    _snake_case     :  int     							=							1_00_00
    _snake_case     :  Optional[List[str]]     							=							None
    _snake_case     :  Optional[datasets.Features]     							=							None



class        a				(		datasets.ArrowBasedBuilder   ):
    _snake_case     :  Tuple     							=							ParquetConfig


    def      lowerCAmelCase_  (					self	:  Dict					):
      return datasets.DatasetInfo(features=self.config.features					)


    def      lowerCAmelCase_  (					self	:  Tuple   ,				__lowerCAmelCase	:  List[Any]					):
      if not self.config.data_files:
        raise ValueError(f'''At least one data file must be specified, but got data_files={self.config.data_files}'''					)
      _UpperCAmelCase						 =      dl_manager.download_and_extract(self.config.data_files					)
      if isinstance(__lowerCAmelCase   ,				(str, list, tuple)					):
        _UpperCAmelCase						 =      data_files
        if isinstance(__lowerCAmelCase   ,				__lowerCAmelCase					):
          _UpperCAmelCase						 =      [files]
        # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
        _UpperCAmelCase						 =      [dl_manager.iter_files(__lowerCAmelCase					) for file in files]
        return [datasets.SplitGenerator(name=datasets.Split.TRAIN   ,				gen_kwargs={"""files""": files}					)]
      _UpperCAmelCase						 =      []
      for split_name, files in data_files.items():
        if isinstance(__lowerCAmelCase   ,				__lowerCAmelCase					):
          _UpperCAmelCase						 =      [files]
        # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
        _UpperCAmelCase						 =      [dl_manager.iter_files(__lowerCAmelCase					) for file in files]
        # Infer features is they are stoed in the arrow schema
        if self.info.features is None:
          for file in itertools.chain.from_iterable(__lowerCAmelCase					):
            with open(__lowerCAmelCase   ,				"""rb"""					) as f:
              _UpperCAmelCase						 =      datasets.Features.from_arrow_schema(pq.read_schema(__lowerCAmelCase					)					)
            break
        splits.append(datasets.SplitGenerator(name=__lowerCAmelCase   ,				gen_kwargs={"""files""": files}					)					)
      return splits


    def      lowerCAmelCase_  (					self	:  List[Any]   ,				__lowerCAmelCase	:  pa.Table					):
      if self.info.features is not None:
        # more expensive cast to support nested features with keys in a different order
        # allows str <-> int/float or str to Audio for example
        _UpperCAmelCase						 =      table_cast(__lowerCAmelCase   ,				self.info.features.arrow_schema					)
      return pa_table


    def      lowerCAmelCase_  (					self	:  List[Any]   ,				__lowerCAmelCase	:  Tuple					):
      _UpperCAmelCase						 =      self.info.features.arrow_schema if self.info.features is not None else None
      if self.info.features is not None and self.config.columns is not None:
        if sorted(field.name for field in schema					) != sorted(self.config.columns					):
          raise ValueError(
              f'''Tried to load parquet data with columns \'{self.config.columns}\' with mismatching features \'{self.info.features}\''''					)
      for file_idx, file in enumerate(itertools.chain.from_iterable(__lowerCAmelCase					)					):
        with open(__lowerCAmelCase   ,				"""rb"""					) as f:
          _UpperCAmelCase						 =      pq.ParquetFile(__lowerCAmelCase					)
          try:
            for batch_idx, record_batch in enumerate(
                parquet_file.iter_batches(batch_size=self.config.batch_size   ,				columns=self.config.columns					)					):
              _UpperCAmelCase						 =      pa.Table.from_batches([record_batch]					)
              # Uncomment for debugging (will print the Arrow table size and elements)
              # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
              # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
              yield f'''{file_idx}_{batch_idx}''', self._cast_table(__lowerCAmelCase					)
          except ValueError as e:
            logger.error(f'''Failed to read file \'{file}\' with error {type(__lowerCAmelCase					)}: {e}'''					)
            raise

"""simple docstring"""


from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


UpperCAmelCase__  		=						logging.get_logger(__name__)

UpperCAmelCase__  		=						{
    """shi-labs/nat-mini-in1k-224""": """https://huggingface.co/shi-labs/nat-mini-in1k-224/resolve/main/config.json""",
    # See all Nat models at https://huggingface.co/models?filter=nat
}


class        a				(		lowerCAmelCase_	,							lowerCAmelCase_   ):
    _snake_case     :  Union[str, Any]     							=							'nat'

    _snake_case     :  List[str]     							=							{
        'num_attention_heads': 'num_heads',
        'num_hidden_layers': 'num_layers',
    }


    def __init__(					self	:  List[Any]   ,				__lowerCAmelCase	:  int=4   ,				__lowerCAmelCase	:  Union[str, Any]=3   ,				__lowerCAmelCase	:  Dict=64   ,				__lowerCAmelCase	:  int=[3, 4, 6, 5]   ,				__lowerCAmelCase	:  List[str]=[2, 4, 8, 16]   ,				__lowerCAmelCase	:  Tuple=7   ,				__lowerCAmelCase	:  List[str]=3.0   ,				__lowerCAmelCase	:  int=True   ,				__lowerCAmelCase	:  int=0.0   ,				__lowerCAmelCase	:  Tuple=0.0   ,				__lowerCAmelCase	:  Any=0.1   ,				__lowerCAmelCase	:  List[str]="gelu"   ,				__lowerCAmelCase	:  List[Any]=0.02   ,				__lowerCAmelCase	:  Union[str, Any]=1e-5   ,				__lowerCAmelCase	:  List[Any]=0.0   ,				__lowerCAmelCase	:  Tuple=None   ,				__lowerCAmelCase	:  Optional[int]=None   ,				**__lowerCAmelCase	:  Optional[Any]   ,				):
      super().__init__(**__lowerCAmelCase					)

      _UpperCAmelCase						 =      patch_size
      _UpperCAmelCase						 =      num_channels
      _UpperCAmelCase						 =      embed_dim
      _UpperCAmelCase						 =      depths
      _UpperCAmelCase						 =      len(__lowerCAmelCase					)
      _UpperCAmelCase						 =      num_heads
      _UpperCAmelCase						 =      kernel_size
      _UpperCAmelCase						 =      mlp_ratio
      _UpperCAmelCase						 =      qkv_bias
      _UpperCAmelCase						 =      hidden_dropout_prob
      _UpperCAmelCase						 =      attention_probs_dropout_prob
      _UpperCAmelCase						 =      drop_path_rate
      _UpperCAmelCase						 =      hidden_act
      _UpperCAmelCase						 =      layer_norm_eps
      _UpperCAmelCase						 =      initializer_range
      # we set the hidden_size attribute in order to make Nat work with VisionEncoderDecoderModel
      # this indicates the channel dimension after the last stage of the model
      _UpperCAmelCase						 =      int(embed_dim * 2 ** (len(__lowerCAmelCase					) - 1)					)
      _UpperCAmelCase						 =      layer_scale_init_value
      _UpperCAmelCase						 =      ["""stem"""] + [f'''stage{idx}''' for idx in range(1   ,				len(__lowerCAmelCase					) + 1					)]
      _UpperCAmelCase ,				_UpperCAmelCase						 =      get_aligned_output_features_output_indices(
          out_features=__lowerCAmelCase   ,				out_indices=__lowerCAmelCase   ,				stage_names=self.stage_names					)
