
'''simple docstring'''





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
a__		: Optional[int]  							=							"\\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
a__		: int  							=							"\\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
a__		: Dict  							=							""

# TODO: Add the licence for the dataset here if you can find it
a__		: Dict  							=							""

# 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)
a__		: Optional[int]  							=							{
    "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__     :     Tuple    					=       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__     :     Optional[int]    					=       [
     datasets.BuilderConfig(name='first_domain'   ,  version=SCREAMING_SNAKE_CASE   ,  description='This part of my dataset covers a first domain'),
     datasets.BuilderConfig(name='second_domain'   ,  version=SCREAMING_SNAKE_CASE   ,  description='This part of my dataset covers a second domain'),
 ]

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






 def 						lowercase_    (      self	:str      )					->      Optional[Any]:







       '''simple docstring'''



       if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
             __A													=      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"
             __A													=      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=_A						,					homepage=_HOMEPAGE						,					license=_LICENSE						,					citation=_CITATION						,					)






 def 						lowercase_    (      self	:Optional[Any]						,					_A	:str      )					->      Union[str, Any]:







       '''simple docstring'''



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






 def 						lowercase_    (      self	:str						,					_A	:str						,					_A	:Union[str, Any]      )					->      Union[str, Any]:







       '''simple docstring'''



       with open(_A						,					encoding='utf-8'      ) as f:
             for key, row in enumerate(_A      ):
                   __A													=      json.loads(_A      )
                   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"],
                         }










import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
       import tensorflow as tf

       from transformers.activations_tf import get_tf_activation





@require_tf
class 			lowerCAmelCase__(     unittest.TestCase    ):






    '''simple docstring'''





    def        _lowerCamelCase			(						self					: Optional[int]						):





       '''simple docstring'''
       UpperCAmelCase_				:   str							= tf.constant([-100, -1.0, -0.1, 0, 0.1, 1.0, 100.0]						)
       UpperCAmelCase_				:   List[Any]							= get_tf_activation('''gelu'''						)
       UpperCAmelCase_				:   Any							= get_tf_activation('''gelu_10'''						)

       UpperCAmelCase_				:   int							= gelu(__snake_case						)
       UpperCAmelCase_				:   Union[str, Any]							= geluaa(__snake_case						)

       UpperCAmelCase_				:   Union[str, Any]							= tf.where(y_gelu_aa < 10.0							, 1.0							, 0.0						)

       self.assertEqual(tf.math.reduce_max(__snake_case						).numpy().item()							, 10.0						)
       self.assertTrue(np.allclose(y_gelu * clipped_mask							, y_gelu_aa * clipped_mask						)						)





    def        _lowerCamelCase			(						self					: Dict						):





       '''simple docstring'''
       get_tf_activation('''gelu'''						)
       get_tf_activation('''gelu_10'''						)
       get_tf_activation('''gelu_fast'''						)
       get_tf_activation('''gelu_new'''						)
       get_tf_activation('''glu'''						)
       get_tf_activation('''mish'''						)
       get_tf_activation('''quick_gelu'''						)
       get_tf_activation('''relu'''						)
       get_tf_activation('''sigmoid'''						)
       get_tf_activation('''silu'''						)
       get_tf_activation('''swish'''						)
       get_tf_activation('''tanh'''						)
       with self.assertRaises(__snake_case						):
          get_tf_activation('''bogus'''						)
       with self.assertRaises(__snake_case						):
          get_tf_activation(__snake_case						)