






from .constants import (
    MODEL_NAME,
    OPTIMIZER_NAME,
    RNG_STATE_NAME,
    SAFE_WEIGHTS_INDEX_NAME,
    SAFE_WEIGHTS_NAME,
    SCALER_NAME,
    SCHEDULER_NAME,
    TORCH_LAUNCH_PARAMS,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
)
from .dataclasses import (
    BnbQuantizationConfig,
    ComputeEnvironment,
    CustomDtype,
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    DynamoBackend,
    FPaRecipeKwargs,
    FullyShardedDataParallelPlugin,
    GradientAccumulationPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    KwargsHandler,
    LoggerType,
    MegatronLMPlugin,
    PrecisionType,
    ProjectConfiguration,
    RNGType,
    SageMakerDistributedType,
    TensorInformation,
    TorchDynamoPlugin,
)
from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env
from .imports import (
    get_ccl_version,
    is_abit_bnb_available,
    is_abit_bnb_available,
    is_aim_available,
    is_bfaa_available,
    is_bnb_available,
    is_botoa_available,
    is_ccl_available,
    is_comet_ml_available,
    is_datasets_available,
    is_deepspeed_available,
    is_fpa_available,
    is_ipex_available,
    is_megatron_lm_available,
    is_mlflow_available,
    is_mps_available,
    is_npu_available,
    is_rich_available,
    is_safetensors_available,
    is_sagemaker_available,
    is_tensorboard_available,
    is_tpu_available,
    is_transformers_available,
    is_wandb_available,
    is_xpu_available,
)
from .modeling import (
    check_device_map,
    check_tied_parameters_in_config,
    check_tied_parameters_on_same_device,
    compute_module_sizes,
    convert_file_size_to_int,
    dtype_byte_size,
    find_tied_parameters,
    get_balanced_memory,
    get_max_layer_size,
    get_max_memory,
    get_mixed_precision_context_manager,
    id_tensor_storage,
    infer_auto_device_map,
    load_checkpoint_in_model,
    load_offloaded_weights,
    load_state_dict,
    named_module_tensors,
    retie_parameters,
    set_module_tensor_to_device,
    shard_checkpoint,
)
from .offload import (
    OffloadedWeightsLoader,
    PrefixedDataset,
    extract_submodules_state_dict,
    load_offloaded_weight,
    offload_state_dict,
    offload_weight,
    save_offload_index,
)
from .operations import (
    broadcast,
    broadcast_object_list,
    concatenate,
    convert_outputs_to_fpaa,
    convert_to_fpaa,
    find_batch_size,
    find_device,
    gather,
    gather_object,
    get_data_structure,
    honor_type,
    initialize_tensors,
    is_namedtuple,
    is_tensor_information,
    is_torch_tensor,
    listify,
    pad_across_processes,
    recursively_apply,
    reduce,
    send_to_device,
    slice_tensors,
)
from .versions import compare_versions, is_torch_version


if is_deepspeed_available():
					from .deepspeed import (
					    DeepSpeedEngineWrapper,
					    DeepSpeedOptimizerWrapper,
					    DeepSpeedSchedulerWrapper,
					    DummyOptim,
					    DummyScheduler,
					    HfDeepSpeedConfig,
					)

from .bnb import has_abit_bnb_layers, load_and_quantize_model
from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer
from .launch import (
    PrepareForLaunch,
    _filter_args,
    prepare_deepspeed_cmd_env,
    prepare_multi_gpu_env,
    prepare_sagemager_args_inputs,
    prepare_simple_launcher_cmd_env,
    prepare_tpu,
)
from .megatron_lm import (
    AbstractTrainStep,
    BertTrainStep,
    GPTTrainStep,
    MegatronEngine,
    MegatronLMDummyDataLoader,
    MegatronLMDummyScheduler,
    MegatronLMOptimizerWrapper,
    MegatronLMSchedulerWrapper,
    TaTrainStep,
    avg_losses_across_data_parallel_group,
    gather_across_data_parallel_groups,
)
from .megatron_lm import initialize as megatron_lm_initialize
from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader
from .megatron_lm import prepare_model as megatron_lm_prepare_model
from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer
from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler
from .memory import find_executable_batch_size, release_memory
from .other import (
    extract_model_from_parallel,
    get_pretty_name,
    is_port_in_use,
    merge_dicts,
    patch_environment,
    save,
    wait_for_everyone,
    write_basic_config,
)
from .random import set_seed, synchronize_rng_state, synchronize_rng_states
from .torch_xla import install_xla
from .tqdm import tqdm
from .transformer_engine import convert_model, has_transformer_engine_layers













import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionTextToImagePipeline
from diffusers.utils.testing_utils import nightly, require_torch_gpu, torch_device


UpperCamelCase__           =			False

class 							__SCREAMING_SNAKE_CASE       (  unittest.TestCase							):
							pass






@nightly
@require_torch_gpu
class 							__SCREAMING_SNAKE_CASE       (  unittest.TestCase							):






							def 					_lowerCamelCase		(    self	):
														# clean up the VRAM after each test
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      VersatileDiffusionTextToImagePipeline.from_pretrained("""shi-labs/versatile-diffusion"""	)
														# remove text_unet
														pipe.remove_unused_weights()
														pipe.to(__lowerCAmelCase	)
														pipe.set_progress_bar_config(disable=__lowerCAmelCase	)

														UpperCamelCase__					  =      """A painting of a squirrel eating a burger """
														UpperCamelCase__					  =      torch.manual_seed(0	)
														UpperCamelCase__					  =      pipe(
														    prompt=__lowerCAmelCase	,			generator=__lowerCAmelCase	,			guidance_scale=7.5	,			num_inference_steps=2	,			output_type="""numpy"""	).images

														with tempfile.TemporaryDirectory() as tmpdirname:
																					pipe.save_pretrained(__lowerCAmelCase	)
																					UpperCamelCase__					  =      VersatileDiffusionTextToImagePipeline.from_pretrained(__lowerCAmelCase	)
														pipe.to(__lowerCAmelCase	)
														pipe.set_progress_bar_config(disable=__lowerCAmelCase	)

														UpperCamelCase__					  =      generator.manual_seed(0	)
														UpperCamelCase__					  =      pipe(
														    prompt=__lowerCAmelCase	,			generator=__lowerCAmelCase	,			guidance_scale=7.5	,			num_inference_steps=2	,			output_type="""numpy"""	).images

														assert np.abs(image - new_image	).sum() < 1E-5, "Models don't have the same forward pass"







							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      VersatileDiffusionTextToImagePipeline.from_pretrained(
														    """shi-labs/versatile-diffusion"""	,			torch_dtype=torch.floataa	)
														pipe.to(__lowerCAmelCase	)
														pipe.set_progress_bar_config(disable=__lowerCAmelCase	)

														UpperCamelCase__					  =      """A painting of a squirrel eating a burger """
														UpperCamelCase__					  =      torch.manual_seed(0	)
														UpperCamelCase__					  =      pipe(
														    prompt=__lowerCAmelCase	,			generator=__lowerCAmelCase	,			guidance_scale=7.5	,			num_inference_steps=50	,			output_type="""numpy"""	).images

														UpperCamelCase__					  =      image[0, 253:256, 253:256, -1]

														assert image.shape == (1, 512, 512, 3)
														UpperCamelCase__					  =      np.array([0.3367, 0.3169, 0.2656, 0.3870, 0.4790, 0.3796, 0.4009, 0.4878, 0.4778]	)

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




