






'''simple docstring'''


import json
import os
import tempfile
import unittest

from transformers.modelcard import ModelCard




class 							lowerCAmelCase					(							unittest.TestCase   ):







   """simple docstring"""







   def    __magic_name__    ( self			)    ->   Tuple:
    __a    :	Any									=						{
        'model_details': {
            'Organization': 'testing',
            'Model date': 'today',
            'Model version': 'v2.1, Developed by Test Corp in 2019.',
            'Architecture': 'Convolutional Neural Network.',
        },
        'metrics': 'BLEU and ROUGE-1',
        'evaluation_data': {
            'Datasets': {'BLEU': 'My-great-dataset-v1', 'ROUGE-1': 'My-short-dataset-v2.1'},
            'Preprocessing': 'See details on https://arxiv.org/pdf/1810.03993.pdf',
        },
        'training_data': {
            'Dataset': 'English Wikipedia dump dated 2018-12-01',
            'Preprocessing': (
                'Using SentencePiece vocabulary of size 52k tokens. See details on'
                ' https://arxiv.org/pdf/1810.03993.pdf'
            ),
        },
        'quantitative_analyses': {'BLEU': 55.1, 'ROUGE-1': 76},
    }



   def    __magic_name__    ( self			)    ->   Tuple:
    __a    :	List[str]									=						ModelCard.from_dict(self.inputs_dict			)
    self.assertTrue(hasattr(a_   ,   'model_details'			)			)
    self.assertTrue(hasattr(a_   ,   'intended_use'			)			)
    self.assertTrue(hasattr(a_   ,   'factors'			)			)
    self.assertTrue(hasattr(a_   ,   'metrics'			)			)
    self.assertTrue(hasattr(a_   ,   'evaluation_data'			)			)
    self.assertTrue(hasattr(a_   ,   'training_data'			)			)
    self.assertTrue(hasattr(a_   ,   'quantitative_analyses'			)			)
    self.assertTrue(hasattr(a_   ,   'ethical_considerations'			)			)
    self.assertTrue(hasattr(a_   ,   'caveats_and_recommendations'			)			)



   def    __magic_name__    ( self			)    ->   int:
    __a    :	Optional[Any]									=						ModelCard.from_dict(self.inputs_dict			)
    __a    :	List[str]									=						json.loads(modelcard.to_json_string()			)
    for key, value in self.inputs_dict.items():
     self.assertEqual(obj[key]   ,   a_			)



   def    __magic_name__    ( self			)    ->   int:
    __a    :	Optional[Any]									=						ModelCard.from_dict(self.inputs_dict			)

    with tempfile.TemporaryDirectory() as tmpdirname:
     __a    :	str									=						os.path.join(a_   ,   'modelcard.json'			)
     model_card_first.to_json_file(a_			)
     __a    :	Optional[int]									=						ModelCard.from_json_file(a_			)

    self.assertEqual(model_card_second.to_dict()   ,   model_card_first.to_dict()			)



   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    __a    :	Optional[Any]									=						ModelCard.from_dict(self.inputs_dict			)

    with tempfile.TemporaryDirectory() as tmpdirname:
     model_card_first.save_pretrained(a_			)
     __a    :	Optional[Any]									=						ModelCard.from_pretrained(a_			)

    self.assertEqual(model_card_second.to_dict()   ,   model_card_first.to_dict()			)












'''simple docstring'''


import unittest

import numpy as np
import torch

from diffusers import DDPMPipeline, DDPMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow, torch_device


enable_full_determinism()




class 							lowerCAmelCase					(							unittest.TestCase   ):







   """simple docstring"""







   @property
   def    __magic_name__    ( self			)    ->   Any:
    torch.manual_seed(0			)
    __a    :	Optional[Any]									=						UNetaDModel(
        block_out_channels=(32, 64)   ,   layers_per_block=2   ,   sample_size=32   ,   in_channels=3   ,   out_channels=3   ,   down_block_types=('DownBlock2D', 'AttnDownBlock2D')   ,   up_block_types=('AttnUpBlock2D', 'UpBlock2D')   ,   )
    return model



   def    __magic_name__    ( self			)    ->   Tuple:
    __a    :	Union[str, Any]									=						'cpu'
    __a    :	Tuple									=						self.dummy_uncond_unet
    __a    :	str									=						DDPMScheduler()

    __a    :	int									=						DDPMPipeline(unet=_A   ,   scheduler=_A			)
    ddpm.to(_A			)
    ddpm.set_progress_bar_config(disable=_A			)

    __a    :	str									=						torch.Generator(device=_A			).manual_seed(0			)
    __a    :	int									=						ddpm(generator=_A   ,   num_inference_steps=2   ,   output_type='numpy'			).images

    __a    :	Union[str, Any]									=						torch.Generator(device=_A			).manual_seed(0			)
    __a    :	Optional[int]									=						ddpm(generator=_A   ,   num_inference_steps=2   ,   output_type='numpy'   ,   return_dict=_A			)[0]

    __a    :	List[str]									=						image[0, -3:, -3:, -1]
    __a    :	List[str]									=						image_from_tuple[0, -3:, -3:, -1]

    assert image.shape == (1, 32, 32, 3)
    __a    :	List[Any]									=						np.array(
        [9.9_5_6E-0_1, 5.7_8_5E-0_1, 4.6_7_5E-0_1, 9.9_3_0E-0_1, 0.0, 1.000, 1.1_9_9E-0_3, 2.6_4_8E-0_4, 5.1_0_1E-0_4]			)

    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
    assert np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1E-2



   def    __magic_name__    ( self			)    ->   Tuple:
    __a    :	Optional[Any]									=						self.dummy_uncond_unet
    __a    :	List[str]									=						DDPMScheduler(prediction_type='sample'			)

    __a    :	List[str]									=						DDPMPipeline(unet=_A   ,   scheduler=_A			)
    ddpm.to(_A			)
    ddpm.set_progress_bar_config(disable=_A			)

    __a    :	Optional[Any]									=						torch.manual_seed(0			)
    __a    :	int									=						ddpm(generator=_A   ,   num_inference_steps=2   ,   output_type='numpy'			).images

    __a    :	Union[str, Any]									=						torch.manual_seed(0			)
    __a    :	int									=						ddpm(generator=_A   ,   num_inference_steps=2   ,   output_type='numpy'			)[0]

    __a    :	Dict									=						image[0, -3:, -3:, -1]
    __a    :	int									=						image_eps[0, -3:, -3:, -1]

    assert image.shape == (1, 32, 32, 3)
    __a    :	int									=						1E-2 if torch_device != 'mps' else 3E-2
    assert np.abs(image_slice.flatten() - image_eps_slice.flatten()			).max() < tolerance




@slow
@require_torch_gpu
class 							lowerCAmelCase					(							unittest.TestCase   ):







   """simple docstring"""







   def    __magic_name__    ( self			)    ->   List[str]:
    __a    :	Union[str, Any]									=						'google/ddpm-cifar10-32'

    __a    :	str									=						UNetaDModel.from_pretrained(_A			)
    __a    :	List[str]									=						DDPMScheduler.from_pretrained(_A			)

    __a    :	List[str]									=						DDPMPipeline(unet=_A   ,   scheduler=_A			)
    ddpm.to(_A			)
    ddpm.set_progress_bar_config(disable=_A			)

    __a    :	int									=						torch.manual_seed(0			)
    __a    :	Optional[Any]									=						ddpm(generator=_A   ,   output_type='numpy'			).images

    __a    :	int									=						image[0, -3:, -3:, -1]

    assert image.shape == (1, 32, 32, 3)
    __a    :	Optional[Any]									=						np.array([0.4_200, 0.3_588, 0.1_939, 0.3_847, 0.3_382, 0.2_647, 0.4_155, 0.3_582, 0.3_385]			)
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2




