





"""simple docstring"""





import tempfile

import numpy as np
import torch
from transformers import AutoTokenizer, TaEncoderModel

from diffusers import DDPMScheduler, UNetaDConditionModel
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.pipelines.deepfloyd_if import IFWatermarker
from diffusers.utils.testing_utils import torch_device

from ..test_pipelines_common import to_np




class 							snake_case							:

      '''simple docstring'''



      def       A_					(							self       :      Any ):


        '''simple docstring'''




        torch.manual_seed(0 )
        __UpperCAmelCase    :						Optional[int]       =						TaEncoderModel.from_pretrained('''hf-internal-testing/tiny-random-t5''' )

        torch.manual_seed(0 )
        __UpperCAmelCase    :						Any       =						AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-t5''' )

        torch.manual_seed(0 )
        __UpperCAmelCase    :						Any       =						UNetaDConditionModel(
            sample_size=32						,				layers_per_block=1						,				block_out_channels=[32, 64]						,				down_block_types=[
                '''ResnetDownsampleBlock2D''',
                '''SimpleCrossAttnDownBlock2D''',
            ]						,				mid_block_type='''UNetMidBlock2DSimpleCrossAttn'''						,				up_block_types=['''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D''']						,				in_channels=3						,				out_channels=6						,				cross_attention_dim=32						,				encoder_hid_dim=32						,				attention_head_dim=8						,				addition_embed_type='''text'''						,				addition_embed_type_num_heads=2						,				cross_attention_norm='''group_norm'''						,				resnet_time_scale_shift='''scale_shift'''						,				act_fn='''gelu'''						,				)
        unet.set_attn_processor(AttnAddedKVProcessor() )  # For reproducibility tests

        torch.manual_seed(0 )
        __UpperCAmelCase    :						List[str]       =						DDPMScheduler(
            num_train_timesteps=1_000						,				beta_schedule='''squaredcos_cap_v2'''						,				beta_start=0.0_0_0_1						,				beta_end=0.0_2						,				thresholding=__lowercase						,				dynamic_thresholding_ratio=0.9_5						,				sample_max_value=1.0						,				prediction_type='''epsilon'''						,				variance_type='''learned_range'''						,				)

        torch.manual_seed(0 )
        __UpperCAmelCase    :						int       =						IFWatermarker()

        return {
            "text_encoder": text_encoder,
            "tokenizer": tokenizer,
            "unet": unet,
            "scheduler": scheduler,
            "watermarker": watermarker,
            "safety_checker": None,
            "feature_extractor": None,
        }

      def       A_					(							self       :      Optional[int] ):


        '''simple docstring'''




        torch.manual_seed(0 )
        __UpperCAmelCase    :						Optional[int]       =						TaEncoderModel.from_pretrained('''hf-internal-testing/tiny-random-t5''' )

        torch.manual_seed(0 )
        __UpperCAmelCase    :						List[str]       =						AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-t5''' )

        torch.manual_seed(0 )
        __UpperCAmelCase    :						str       =						UNetaDConditionModel(
            sample_size=32						,				layers_per_block=[1, 2]						,				block_out_channels=[32, 64]						,				down_block_types=[
                '''ResnetDownsampleBlock2D''',
                '''SimpleCrossAttnDownBlock2D''',
            ]						,				mid_block_type='''UNetMidBlock2DSimpleCrossAttn'''						,				up_block_types=['''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D''']						,				in_channels=6						,				out_channels=6						,				cross_attention_dim=32						,				encoder_hid_dim=32						,				attention_head_dim=8						,				addition_embed_type='''text'''						,				addition_embed_type_num_heads=2						,				cross_attention_norm='''group_norm'''						,				resnet_time_scale_shift='''scale_shift'''						,				act_fn='''gelu'''						,				class_embed_type='''timestep'''						,				mid_block_scale_factor=1.4_1_4						,				time_embedding_act_fn='''gelu'''						,				time_embedding_dim=32						,				)
        unet.set_attn_processor(AttnAddedKVProcessor() )  # For reproducibility tests

        torch.manual_seed(0 )
        __UpperCAmelCase    :						Optional[Any]       =						DDPMScheduler(
            num_train_timesteps=1_000						,				beta_schedule='''squaredcos_cap_v2'''						,				beta_start=0.0_0_0_1						,				beta_end=0.0_2						,				thresholding=__lowercase						,				dynamic_thresholding_ratio=0.9_5						,				sample_max_value=1.0						,				prediction_type='''epsilon'''						,				variance_type='''learned_range'''						,				)

        torch.manual_seed(0 )
        __UpperCAmelCase    :						Dict       =						DDPMScheduler(
            num_train_timesteps=1_000						,				beta_schedule='''squaredcos_cap_v2'''						,				beta_start=0.0_0_0_1						,				beta_end=0.0_2						,				)

        torch.manual_seed(0 )
        __UpperCAmelCase    :						List[str]       =						IFWatermarker()

        return {
            "text_encoder": text_encoder,
            "tokenizer": tokenizer,
            "unet": unet,
            "scheduler": scheduler,
            "image_noising_scheduler": image_noising_scheduler,
            "watermarker": watermarker,
            "safety_checker": None,
            "feature_extractor": None,
        }

      def       A_					(							self       :      Optional[int] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Any       =						self.get_dummy_components()
        __UpperCAmelCase    :						Optional[Any]       =						self.pipeline_class(**__lowercase )
        pipe.to(__lowercase )
        pipe.set_progress_bar_config(disable=__lowercase )

        __UpperCAmelCase    :						Optional[Any]       =						self.get_dummy_inputs(__lowercase )

        __UpperCAmelCase    :						List[Any]       =						inputs['''prompt''']
        __UpperCAmelCase    :						Optional[int]       =						inputs['''generator''']
        __UpperCAmelCase    :						Optional[int]       =						inputs['''num_inference_steps''']
        __UpperCAmelCase    :						List[str]       =						inputs['''output_type''']

        if "image" in inputs:
          __UpperCAmelCase    :						int       =						inputs['''image''']
        else:
          __UpperCAmelCase    :						Any       =						None

        if "mask_image" in inputs:
          __UpperCAmelCase    :						List[str]       =						inputs['''mask_image''']
        else:
          __UpperCAmelCase    :						str       =						None

        if "original_image" in inputs:
          __UpperCAmelCase    :						Union[str, Any]       =						inputs['''original_image''']
        else:
          __UpperCAmelCase    :						int       =						None

        __UpperCAmelCase       ,     __UpperCAmelCase    :						Union[str, Any]       =						pipe.encode_prompt(__lowercase )

        # inputs with prompt converted to embeddings
        __UpperCAmelCase    :						int       =						{
            '''prompt_embeds''': prompt_embeds,
            '''negative_prompt_embeds''': negative_prompt_embeds,
            '''generator''': generator,
            '''num_inference_steps''': num_inference_steps,
            '''output_type''': output_type,
        }

        if image is not None:
          __UpperCAmelCase    :						Any       =						image

        if mask_image is not None:
          __UpperCAmelCase    :						int       =						mask_image

        if original_image is not None:
          __UpperCAmelCase    :						List[Any]       =						original_image

        # set all optional components to None
        for optional_component in pipe._optional_components:
          setattr(__lowercase						,				__lowercase						,				__lowercase )

        __UpperCAmelCase    :						Optional[Any]       =						pipe(**__lowercase )[0]

        with tempfile.TemporaryDirectory() as tmpdir:
          pipe.save_pretrained(__lowercase )
          __UpperCAmelCase    :						Optional[int]       =						self.pipeline_class.from_pretrained(__lowercase )
          pipe_loaded.to(__lowercase )
          pipe_loaded.set_progress_bar_config(disable=__lowercase )

        pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor() )  # For reproducibility tests

        for optional_component in pipe._optional_components:
          self.assertTrue(
              getattr(__lowercase						,				__lowercase ) is None						,				f'''`{optional_component}` did not stay set to None after loading.'''						,				)

        __UpperCAmelCase    :						str       =						self.get_dummy_inputs(__lowercase )

        __UpperCAmelCase    :						Union[str, Any]       =						inputs['''generator''']
        __UpperCAmelCase    :						str       =						inputs['''num_inference_steps''']
        __UpperCAmelCase    :						Any       =						inputs['''output_type''']

        # inputs with prompt converted to embeddings
        __UpperCAmelCase    :						List[Any]       =						{
            '''prompt_embeds''': prompt_embeds,
            '''negative_prompt_embeds''': negative_prompt_embeds,
            '''generator''': generator,
            '''num_inference_steps''': num_inference_steps,
            '''output_type''': output_type,
        }

        if image is not None:
          __UpperCAmelCase    :						Union[str, Any]       =						image

        if mask_image is not None:
          __UpperCAmelCase    :						Tuple       =						mask_image

        if original_image is not None:
          __UpperCAmelCase    :						Optional[int]       =						original_image

        __UpperCAmelCase    :						Tuple       =						pipe_loaded(**__lowercase )[0]

        __UpperCAmelCase    :						Optional[Any]       =						np.abs(to_np(__lowercase ) - to_np(__lowercase ) ).max()
        self.assertLess(__lowercase						,				1e-4 )







      def       A_					(							self       :      Dict ):


        '''simple docstring'''




        __UpperCAmelCase    :						Any       =						self.get_dummy_components()
        __UpperCAmelCase    :						Union[str, Any]       =						self.pipeline_class(**__lowercase )
        pipe.to(__lowercase )
        pipe.set_progress_bar_config(disable=__lowercase )

        __UpperCAmelCase    :						List[str]       =						self.get_dummy_inputs(__lowercase )
        __UpperCAmelCase    :						int       =						pipe(**__lowercase )[0]

        with tempfile.TemporaryDirectory() as tmpdir:
          pipe.save_pretrained(__lowercase )
          __UpperCAmelCase    :						str       =						self.pipeline_class.from_pretrained(__lowercase )
          pipe_loaded.to(__lowercase )
          pipe_loaded.set_progress_bar_config(disable=__lowercase )

        pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor() )  # For reproducibility tests

        __UpperCAmelCase    :						List[Any]       =						self.get_dummy_inputs(__lowercase )
        __UpperCAmelCase    :						Optional[Any]       =						pipe_loaded(**__lowercase )[0]

        __UpperCAmelCase    :						Tuple       =						np.abs(to_np(__lowercase ) - to_np(__lowercase ) ).max()
        self.assertLess(__lowercase						,				1e-4 )






"""simple docstring"""





# coding=utf-8
# Copyright 2020 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import sys

import transformers


lowercase__				:int				   =       '3'

print('Python version:', sys.version)
print('transformers version:', transformers.__version__)

try:
  import torch

  print('Torch version:', torch.__version__)
  print('Cuda available:', torch.cuda.is_available())
  print('Cuda version:', torch.version.cuda)
  print('CuDNN version:', torch.backends.cudnn.version())
  print('Number of GPUs available:', torch.cuda.device_count())
  print('NCCL version:', torch.cuda.nccl.version())
except ImportError:
  print('Torch version:', None)

try:
  import deepspeed

  print('DeepSpeed version:', deepspeed.__version__)
except ImportError:
  print('DeepSpeed version:', None)

try:
  import tensorflow as tf

  print('TensorFlow version:', tf.__version__)
  print('TF GPUs available:', bool(tf.config.list_physical_devices('GPU')))
  print('Number of TF GPUs available:', len(tf.config.list_physical_devices('GPU')))
except ImportError:
  print('TensorFlow version:', None)