





import csv
import json
import os

import datasets


# TODO: Add BibTeX citation
# Find for instance the citation on arxiv or on the dataset repo/website
_UpperCAmelCase				       = '\\n@InProceedings{huggingface:dataset,\ntitle = {A great new dataset},\nauthor={huggingface, Inc.\n},\nyear={2020}\n}\n'

# TODO: Add description of the dataset here
# You can copy an official description
_UpperCAmelCase				       = '\\nThis new dataset is designed to solve this great NLP task and is crafted with a lot of care.\n'

# TODO: Add a link to an official homepage for the dataset here
_UpperCAmelCase				       = ''

# TODO: Add the licence for the dataset here if you can find it
_UpperCAmelCase				       = ''

# TODO: Add link to the official dataset URLs here
# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
_UpperCAmelCase				       = {
    'first_domain': 'https://huggingface.co/great-new-dataset-first_domain.zip',
    'second_domain': 'https://huggingface.co/great-new-dataset-second_domain.zip',
}



class 							_UpperCamelCase    (		datasets.GeneratorBasedBuilder   ):
       _UpperCamelCase :    str   			=      datasets.Version('''1.1.0'''   )

       # This is an example of a dataset with multiple configurations.
       # If you don't want/need to define several sub-sets in your dataset,
       # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.

       # If you need to make complex sub-parts in the datasets with configurable options
       # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
       # BUILDER_CONFIG_CLASS = MyBuilderConfig

       # You will be able to load one or the other configurations in the following list with
       # data = datasets.load_dataset('my_dataset', 'first_domain')
       # data = datasets.load_dataset('my_dataset', 'second_domain')
       _UpperCamelCase :    Tuple   			=      [
           datasets.BuilderConfig(name='''first_domain'''     ,  version=lowerCAmelCase_     ,  description='''This part of my dataset covers a first domain'''   ),
           datasets.BuilderConfig(name='''second_domain'''     ,  version=lowerCAmelCase_     ,  description='''This part of my dataset covers a second domain'''   ),
       ]

       _UpperCamelCase :    Any   			=      '''first_domain'''  # It's not mandatory to have a default configuration. Just use one if it make sense.

       def lowercase       (						self:       Tuple						)				->       Optional[Any]:




              """simple docstring"""


              if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
                     UpperCamelCase_      				=     datasets.Features(
                         {
                             "sentence": datasets.Value("string"						),
                             "option1": datasets.Value("string"						),
                             "answer": datasets.Value("string"						)
                             # These are the features of your dataset like images, labels ...
                         }						)
              else:  # This is an example to show how to have different features for "first_domain" and "second_domain"
                     UpperCamelCase_      				=     datasets.Features(
                         {
                             "sentence": datasets.Value("string"						),
                             "option2": datasets.Value("string"						),
                             "second_domain_answer": datasets.Value("string"						)
                             # These are the features of your dataset like images, labels ...
                         }						)
              return datasets.DatasetInfo(
                  # This is the description that will appear on the datasets page.
                  description=_DESCRIPTION    ,      features=_SCREAMING_SNAKE_CASE    ,      homepage=_HOMEPAGE    ,      license=_LICENSE    ,      citation=_CITATION    ,      )

       def lowercase       (						self:       Any    ,      _SCREAMING_SNAKE_CASE:       Dict						)				->       Tuple:




              """simple docstring"""


              UpperCamelCase_      				=     _URLS[self.config.name]
              UpperCamelCase_      				=     dl_manager.download_and_extract(_SCREAMING_SNAKE_CASE						)
              return [
                  datasets.SplitGenerator(
                      name=datasets.Split.TRAIN    ,      gen_kwargs={
                          "filepath": os.path.join(_SCREAMING_SNAKE_CASE    ,      "train.jsonl"						),
                          "split": "train",
                      }    ,      ),
                  datasets.SplitGenerator(
                      name=datasets.Split.VALIDATION    ,      gen_kwargs={
                          "filepath": os.path.join(_SCREAMING_SNAKE_CASE    ,      "dev.jsonl"						),
                          "split": "dev",
                      }    ,      ),
                  datasets.SplitGenerator(
                      name=datasets.Split.TEST    ,      gen_kwargs={
                          "filepath": os.path.join(_SCREAMING_SNAKE_CASE    ,      "test.jsonl"						),
                          "split": "test"
                      }    ,      ),
              ]



       def lowercase       (						self:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       Optional[Any]    ,      _SCREAMING_SNAKE_CASE:       int						)				->       Optional[int]:




              """simple docstring"""


              with open(_SCREAMING_SNAKE_CASE    ,      encoding="utf-8"						) as f:
                     for key, row in enumerate(_SCREAMING_SNAKE_CASE						):
                            UpperCamelCase_      				=     json.loads(_SCREAMING_SNAKE_CASE						)
                            if self.config.name == "first_domain":
                                   # Yields examples as (key, example) tuples
                                   yield key, {
                                       "sentence": data["sentence"],
                                       "option1": data["option1"],
                                       "answer": "" if split == "test" else data["answer"],
                                   }
                            else:
                                   yield key, {
                                       "sentence": data["sentence"],
                                       "option2": data["option2"],
                                       "second_domain_answer": "" if split == "test" else data["second_domain_answer"],
                                   }








from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCAmelCase				       = logging.get_logger(__name__)

_UpperCAmelCase				       = {
    'MCG-NJU/videomae-base': 'https://huggingface.co/MCG-NJU/videomae-base/resolve/main/config.json',
}



class 							_UpperCamelCase    (		lowerCAmelCase_   ):
       _UpperCamelCase :    List[Any]   			=      '''videomae'''

       def __init__(						self:       Optional[Any]    ,      _SCREAMING_SNAKE_CASE:       List[str]=224    ,      _SCREAMING_SNAKE_CASE:       Dict=16    ,      _SCREAMING_SNAKE_CASE:       List[Any]=3    ,      _SCREAMING_SNAKE_CASE:       Tuple=16    ,      _SCREAMING_SNAKE_CASE:       Tuple=2    ,      _SCREAMING_SNAKE_CASE:       Optional[Any]=768    ,      _SCREAMING_SNAKE_CASE:       str=12    ,      _SCREAMING_SNAKE_CASE:       List[Any]=12    ,      _SCREAMING_SNAKE_CASE:       Dict=3072    ,      _SCREAMING_SNAKE_CASE:       Tuple="gelu"    ,      _SCREAMING_SNAKE_CASE:       List[Any]=0.0    ,      _SCREAMING_SNAKE_CASE:       List[Any]=0.0    ,      _SCREAMING_SNAKE_CASE:       Tuple=0.02    ,      _SCREAMING_SNAKE_CASE:       Optional[int]=1e-12    ,      _SCREAMING_SNAKE_CASE:       Dict=True    ,      _SCREAMING_SNAKE_CASE:       Dict=True    ,      _SCREAMING_SNAKE_CASE:       List[str]=6    ,      _SCREAMING_SNAKE_CASE:       Dict=384    ,      _SCREAMING_SNAKE_CASE:       Any=4    ,      _SCREAMING_SNAKE_CASE:       Dict=1536    ,      _SCREAMING_SNAKE_CASE:       Optional[int]=True    ,      **_SCREAMING_SNAKE_CASE:       str    ,      )				->       Dict:




              """simple docstring"""


              super().__init__(**_SCREAMING_SNAKE_CASE						)

              UpperCamelCase_      				=     image_size
              UpperCamelCase_      				=     patch_size
              UpperCamelCase_      				=     num_channels
              UpperCamelCase_      				=     num_frames
              UpperCamelCase_      				=     tubelet_size

              UpperCamelCase_      				=     hidden_size
              UpperCamelCase_      				=     num_hidden_layers
              UpperCamelCase_      				=     num_attention_heads
              UpperCamelCase_      				=     intermediate_size
              UpperCamelCase_      				=     hidden_act
              UpperCamelCase_      				=     hidden_dropout_prob
              UpperCamelCase_      				=     attention_probs_dropout_prob
              UpperCamelCase_      				=     initializer_range
              UpperCamelCase_      				=     layer_norm_eps
              UpperCamelCase_      				=     qkv_bias
              UpperCamelCase_      				=     use_mean_pooling

              UpperCamelCase_      				=     decoder_num_attention_heads
              UpperCamelCase_      				=     decoder_hidden_size
              UpperCamelCase_      				=     decoder_num_hidden_layers
              UpperCamelCase_      				=     decoder_intermediate_size
              UpperCamelCase_      				=     norm_pix_loss

