



"""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
SCREAMING_SNAKE_CASE				:     List[Any]          =	'''\
@InProceedings{huggingface:dataset,
title = {A great new dataset},
author={huggingface, Inc.
},
year={2020}
}
'''

# TODO: Add description of the dataset here
# You can copy an official description
SCREAMING_SNAKE_CASE				:     List[str]          =	'''\
This new dataset is designed to solve this great NLP task and is crafted with a lot of care.
'''

# TODO: Add a link to an official homepage for the dataset here
SCREAMING_SNAKE_CASE				:     Union[str, Any]          =	''''''

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

# 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)
SCREAMING_SNAKE_CASE				:     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       __lowerCamelCase	(   datasets.GeneratorBasedBuilder    ):
   __UpperCamelCase									=   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									=   [
       datasets.BuilderConfig(name='first_domain'   ,							version=__lowercase   ,							description='This part of my dataset covers a first domain'    ),
       datasets.BuilderConfig(name='second_domain'   ,							version=__lowercase   ,							description='This part of my dataset covers a second domain'    ),
   ]

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







   def 							A__						(self				):




      '''simple docstring'''




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







   def 							A__						(self       ,	lowerCamelCase				):




      '''simple docstring'''




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







   def 							A__						(self       ,	lowerCamelCase       ,	lowerCamelCase				):




      '''simple docstring'''




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




"""simple docstring"""





import torch

from diffusers import HeunDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest


class       __lowerCamelCase	(   __lowercase    ):
   __UpperCamelCase									=   (HeunDiscreteScheduler,)
   __UpperCamelCase									=   10







   def 							A__						(self       ,	**lowerCamelCase				):




      '''simple docstring'''




      _lowerCAmelCase					     =		{
          """num_train_timesteps""": 1_100,
          """beta_start""": 0.0001,
          """beta_end""": 0.02,
          """beta_schedule""": """linear""",
      }

      config.update(**lowerCamelCase				)
      return config







   def 							A__						(self				):




      '''simple docstring'''




      for timesteps in [10, 50, 100, 1_000]:
         self.check_over_configs(num_train_timesteps=lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      for beta_start, beta_end in zip([0.0_0001, 0.0001, 0.001]       ,	[0.0002, 0.002, 0.02]				):
         self.check_over_configs(beta_start=lowerCamelCase       ,	beta_end=lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      for schedule in ["linear", "scaled_linear", "exp"]:
         self.check_over_configs(beta_schedule=lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      for clip_sample_range in [1.0, 2.0, 3.0]:
         self.check_over_configs(clip_sample_range=lowerCamelCase       ,	clip_sample=lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      for prediction_type in ["epsilon", "v_prediction", "sample"]:
         self.check_over_configs(prediction_type=lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.scheduler_classes[0]
      _lowerCAmelCase					     =		self.get_scheduler_config()
      _lowerCAmelCase					     =		scheduler_class(**lowerCamelCase				)

      scheduler.set_timesteps(self.num_inference_steps				)

      _lowerCAmelCase					     =		self.dummy_model()
      _lowerCAmelCase					     =		self.dummy_sample_deter * scheduler.init_noise_sigma
      _lowerCAmelCase					     =		sample.to(lowerCamelCase				)

      for i, t in enumerate(scheduler.timesteps				):
         _lowerCAmelCase					     =		scheduler.scale_model_input(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		model(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		scheduler.step(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				)
         _lowerCAmelCase					     =		output.prev_sample

      _lowerCAmelCase					     =		torch.sum(torch.abs(lowerCamelCase				)				)
      _lowerCAmelCase					     =		torch.mean(torch.abs(lowerCamelCase				)				)

      if torch_device in ["cpu", "mps"]:
         assert abs(result_sum.item() - 0.1233				) < 1e-2
         assert abs(result_mean.item() - 0.0002				) < 1e-3
      else:
         # CUDA
         assert abs(result_sum.item() - 0.1233				) < 1e-2
         assert abs(result_mean.item() - 0.0002				) < 1e-3







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.scheduler_classes[0]
      _lowerCAmelCase					     =		self.get_scheduler_config(prediction_type="""v_prediction"""				)
      _lowerCAmelCase					     =		scheduler_class(**lowerCamelCase				)

      scheduler.set_timesteps(self.num_inference_steps				)

      _lowerCAmelCase					     =		self.dummy_model()
      _lowerCAmelCase					     =		self.dummy_sample_deter * scheduler.init_noise_sigma
      _lowerCAmelCase					     =		sample.to(lowerCamelCase				)

      for i, t in enumerate(scheduler.timesteps				):
         _lowerCAmelCase					     =		scheduler.scale_model_input(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		model(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		scheduler.step(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				)
         _lowerCAmelCase					     =		output.prev_sample

      _lowerCAmelCase					     =		torch.sum(torch.abs(lowerCamelCase				)				)
      _lowerCAmelCase					     =		torch.mean(torch.abs(lowerCamelCase				)				)

      if torch_device in ["cpu", "mps"]:
         assert abs(result_sum.item() - 4.6934e-07				) < 1e-2
         assert abs(result_mean.item() - 6.1112e-10				) < 1e-3
      else:
         # CUDA
         assert abs(result_sum.item() - 4.693428650170972e-07				) < 1e-2
         assert abs(result_mean.item() - 0.0002				) < 1e-3







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.scheduler_classes[0]
      _lowerCAmelCase					     =		self.get_scheduler_config()
      _lowerCAmelCase					     =		scheduler_class(**lowerCamelCase				)

      scheduler.set_timesteps(self.num_inference_steps       ,	device=lowerCamelCase				)

      _lowerCAmelCase					     =		self.dummy_model()
      _lowerCAmelCase					     =		self.dummy_sample_deter.to(lowerCamelCase				) * scheduler.init_noise_sigma

      for t in scheduler.timesteps:
         _lowerCAmelCase					     =		scheduler.scale_model_input(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		model(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		scheduler.step(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				)
         _lowerCAmelCase					     =		output.prev_sample

      _lowerCAmelCase					     =		torch.sum(torch.abs(lowerCamelCase				)				)
      _lowerCAmelCase					     =		torch.mean(torch.abs(lowerCamelCase				)				)

      if str(lowerCamelCase				).startswith("""cpu"""				):
         # The following sum varies between 148 and 156 on mps. Why?
         assert abs(result_sum.item() - 0.1233				) < 1e-2
         assert abs(result_mean.item() - 0.0002				) < 1e-3
      elif str(lowerCamelCase				).startswith("""mps"""				):
         # Larger tolerance on mps
         assert abs(result_mean.item() - 0.0002				) < 1e-2
      else:
         # CUDA
         assert abs(result_sum.item() - 0.1233				) < 1e-2
         assert abs(result_mean.item() - 0.0002				) < 1e-3







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.scheduler_classes[0]
      _lowerCAmelCase					     =		self.get_scheduler_config()
      _lowerCAmelCase					     =		scheduler_class(**lowerCamelCase       ,	use_karras_sigmas=lowerCamelCase				)

      scheduler.set_timesteps(self.num_inference_steps       ,	device=lowerCamelCase				)

      _lowerCAmelCase					     =		self.dummy_model()
      _lowerCAmelCase					     =		self.dummy_sample_deter.to(lowerCamelCase				) * scheduler.init_noise_sigma
      _lowerCAmelCase					     =		sample.to(lowerCamelCase				)

      for t in scheduler.timesteps:
         _lowerCAmelCase					     =		scheduler.scale_model_input(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		model(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		scheduler.step(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				)
         _lowerCAmelCase					     =		output.prev_sample

      _lowerCAmelCase					     =		torch.sum(torch.abs(lowerCamelCase				)				)
      _lowerCAmelCase					     =		torch.mean(torch.abs(lowerCamelCase				)				)

      assert abs(result_sum.item() - 0.0_0015				) < 1e-2
      assert abs(result_mean.item() - 1.9869554535034695e-07				) < 1e-2