
'''simple docstring'''





from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import (
    BaseOutput,
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_onnx_available,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)

@dataclass
class 						a   (				__magic_name__    ):
				_snake_case		    = 42
				_snake_case		    = 42


try:
						if not (is_transformers_available() and is_torch_available()):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
						from .pipeline_cycle_diffusion import CycleDiffusionPipeline
						from .pipeline_stable_diffusion import StableDiffusionPipeline
						from .pipeline_stable_diffusion_attend_and_excite import StableDiffusionAttendAndExcitePipeline
						from .pipeline_stable_diffusion_imgaimg import StableDiffusionImgaImgPipeline
						from .pipeline_stable_diffusion_inpaint import StableDiffusionInpaintPipeline
						from .pipeline_stable_diffusion_inpaint_legacy import StableDiffusionInpaintPipelineLegacy
						from .pipeline_stable_diffusion_instruct_pixapix import StableDiffusionInstructPixaPixPipeline
						from .pipeline_stable_diffusion_latent_upscale import StableDiffusionLatentUpscalePipeline
						from .pipeline_stable_diffusion_ldmad import StableDiffusionLDMaDPipeline
						from .pipeline_stable_diffusion_model_editing import StableDiffusionModelEditingPipeline
						from .pipeline_stable_diffusion_panorama import StableDiffusionPanoramaPipeline
						from .pipeline_stable_diffusion_paradigms import StableDiffusionParadigmsPipeline
						from .pipeline_stable_diffusion_sag import StableDiffusionSAGPipeline
						from .pipeline_stable_diffusion_upscale import StableDiffusionUpscalePipeline
						from .pipeline_stable_unclip import StableUnCLIPPipeline
						from .pipeline_stable_unclip_imgaimg import StableUnCLIPImgaImgPipeline
						from .safety_checker import StableDiffusionSafetyChecker
						from .stable_unclip_image_normalizer import StableUnCLIPImageNormalizer

try:
						if not (is_transformers_available() and is_torch_available() and is_transformers_version(">=", "4.25.0")):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ...utils.dummy_torch_and_transformers_objects import StableDiffusionImageVariationPipeline
else:
						from .pipeline_stable_diffusion_image_variation import StableDiffusionImageVariationPipeline


try:
						if not (is_transformers_available() and is_torch_available() and is_transformers_version(">=", "4.26.0")):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ...utils.dummy_torch_and_transformers_objects import (
						    StableDiffusionDepthaImgPipeline,
						    StableDiffusionDiffEditPipeline,
						    StableDiffusionPixaPixZeroPipeline,
						)
else:
						from .pipeline_stable_diffusion_depthaimg import StableDiffusionDepthaImgPipeline
						from .pipeline_stable_diffusion_diffedit import StableDiffusionDiffEditPipeline
						from .pipeline_stable_diffusion_pixapix_zero import StableDiffusionPixaPixZeroPipeline


try:
						if not (
						    is_torch_available()
						    and is_transformers_available()
						    and is_k_diffusion_available()
						    and is_k_diffusion_version(">=", "0.0.12")
						):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ...utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
						from .pipeline_stable_diffusion_k_diffusion import StableDiffusionKDiffusionPipeline

try:
						if not (is_transformers_available() and is_onnx_available()):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ...utils.dummy_onnx_objects import *  # noqa F403
else:
						from .pipeline_onnx_stable_diffusion import OnnxStableDiffusionPipeline, StableDiffusionOnnxPipeline
						from .pipeline_onnx_stable_diffusion_imgaimg import OnnxStableDiffusionImgaImgPipeline
						from .pipeline_onnx_stable_diffusion_inpaint import OnnxStableDiffusionInpaintPipeline
						from .pipeline_onnx_stable_diffusion_inpaint_legacy import OnnxStableDiffusionInpaintPipelineLegacy
						from .pipeline_onnx_stable_diffusion_upscale import OnnxStableDiffusionUpscalePipeline

if is_transformers_available() and is_flax_available():
						import flax

						@flax.struct.dataclass
						class 						a   (				__magic_name__    ):
										_snake_case		    = 42
										_snake_case		    = 42




						from ...schedulers.scheduling_pndm_flax import PNDMSchedulerState
						from .pipeline_flax_stable_diffusion import FlaxStableDiffusionPipeline
						from .pipeline_flax_stable_diffusion_imgaimg import FlaxStableDiffusionImgaImgPipeline
						from .pipeline_flax_stable_diffusion_inpaint import FlaxStableDiffusionInpaintPipeline
						from .safety_checker_flax import FlaxStableDiffusionSafetyChecker



'''simple docstring'''





import argparse
import json
import logging
import os
import shutil
import sys
import tempfile
import unittest
from unittest import mock

import torch
from accelerate.utils import write_basic_config

from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device
from transformers.utils import is_apex_available


logging.basicConfig(level=logging.DEBUG)

UpperCAmelCase    					=   logging.getLogger()

def      A (       ):
						snake_case       :     Dict =    argparse.ArgumentParser()
						parser.add_argument('''-f'''       )
						snake_case       :     Any =    parser.parse_args()
						return args.f

def      A (       A_							:					str       ):
						snake_case       :     str =    {}
						snake_case       :     Union[str, Any] =    os.path.join(A_    ,							'''all_results.json'''       )
						if os.path.exists(A_       ):
												with open(A_    ,							'''r'''       ) as f:
																		snake_case       :     List[str] =    json.load(A_       )
						else:
												raise ValueError(F"""can't find {path}"""       )
						return results

def      A (       ):
						snake_case       :     Any =    torch.cuda.is_available() and torch_device == '''cuda'''
						return is_using_cuda and is_apex_available()


UpperCAmelCase    					=   logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)





class 						a   (				__magic_name__    ):




				@classmethod
				def 	__snake_case							(							cls	:				Tuple      ):
										# Write Accelerate config, will pick up on CPU, GPU, and multi-GPU
										snake_case       :     int =    tempfile.mkdtemp()
										snake_case       :     Optional[Any] =    os.path.join(cls.tmpdir,    '''default_config.yml'''      )
										write_basic_config(save_location=cls.configPath      )
										snake_case       :     Tuple =    ['''accelerate''', '''launch''', '''--config_file''', cls.configPath]




				@classmethod
				def 	__snake_case							(							cls	:				Optional[int]      ):
										shutil.rmtree(cls.tmpdir      )




				@mock.patch.dict(os.environ,    {'''WANDB_MODE''': '''offline'''}      )
				def 	__snake_case							(							self	:				Any      ):
										snake_case       :     Any =    self.get_auto_remove_tmp_dir()
										snake_case       :     Optional[Any] =    F"""
            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py
            --model_name_or_path distilbert-base-uncased
            --output_dir {tmp_dir}
            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv
            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --learning_rate=1e-4
            --seed=42
            --checkpointing_steps epoch
            --with_tracking
        """.split()

										if is_cuda_and_apex_available():
																testargs.append('''--fp16'''      )

										run_command(self._launch_args + testargs      )
										snake_case       :     int =    get_results(SCREAMING_SNAKE_CASE_      )
										self.assertGreaterEqual(result['''eval_accuracy'''],    0.75      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''epoch_0'''      )      )      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''glue_no_trainer'''      )      )      )




				@mock.patch.dict(os.environ,    {'''WANDB_MODE''': '''offline'''}      )
				def 	__snake_case							(							self	:				Tuple      ):
										snake_case       :     int =    self.get_auto_remove_tmp_dir()
										snake_case       :     str =    F"""
            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py
            --model_name_or_path distilgpt2
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --block_size 128
            --per_device_train_batch_size 5
            --per_device_eval_batch_size 5
            --num_train_epochs 2
            --output_dir {tmp_dir}
            --checkpointing_steps epoch
            --with_tracking
        """.split()

										if torch.cuda.device_count() > 1:
																# Skipping because there are not enough batches to train the model + would need a drop_last to work.
																return

										run_command(self._launch_args + testargs      )
										snake_case       :     List[str] =    get_results(SCREAMING_SNAKE_CASE_      )
										self.assertLess(result['''perplexity'''],    1_00      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''epoch_0'''      )      )      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''clm_no_trainer'''      )      )      )




				@mock.patch.dict(os.environ,    {'''WANDB_MODE''': '''offline'''}      )
				def 	__snake_case							(							self	:				List[Any]      ):
										snake_case       :     Union[str, Any] =    self.get_auto_remove_tmp_dir()
										snake_case       :     int =    F"""
            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py
            --model_name_or_path distilroberta-base
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --output_dir {tmp_dir}
            --num_train_epochs=1
            --checkpointing_steps epoch
            --with_tracking
        """.split()

										run_command(self._launch_args + testargs      )
										snake_case       :     List[Any] =    get_results(SCREAMING_SNAKE_CASE_      )
										self.assertLess(result['''perplexity'''],    42      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''epoch_0'''      )      )      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''mlm_no_trainer'''      )      )      )




				@mock.patch.dict(os.environ,    {'''WANDB_MODE''': '''offline'''}      )
				def 	__snake_case							(							self	:				Dict      ):
										# with so little data distributed training needs more epochs to get the score on par with 0/1 gpu
										snake_case       :     Any =    7 if get_gpu_count() > 1 else 2

										snake_case       :     Optional[int] =    self.get_auto_remove_tmp_dir()
										snake_case       :     str =    F"""
            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/conll/sample.json
            --validation_file tests/fixtures/tests_samples/conll/sample.json
            --output_dir {tmp_dir}
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=2
            --num_train_epochs={epochs}
            --seed 7
            --checkpointing_steps epoch
            --with_tracking
        """.split()

										run_command(self._launch_args + testargs      )
										snake_case       :     Optional[int] =    get_results(SCREAMING_SNAKE_CASE_      )
										self.assertGreaterEqual(result['''eval_accuracy'''],    0.75      )
										self.assertLess(result['''train_loss'''],    0.5      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''epoch_0'''      )      )      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''ner_no_trainer'''      )      )      )




				@unittest.skip(reason='''Fix me @muellerzr'''      )
				@mock.patch.dict(os.environ,    {'''WANDB_MODE''': '''offline'''}      )
				def 	__snake_case							(							self	:				Tuple      ):
										snake_case       :     Tuple =    self.get_auto_remove_tmp_dir()
										snake_case       :     Optional[int] =    F"""
            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py
            --model_name_or_path bert-base-uncased
            --version_2_with_negative
            --train_file tests/fixtures/tests_samples/SQUAD/sample.json
            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json
            --output_dir {tmp_dir}
            --seed=42
            --max_train_steps=10
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
            --with_tracking
        """.split()

										run_command(self._launch_args + testargs      )
										snake_case       :     str =    get_results(SCREAMING_SNAKE_CASE_      )
										# Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics.
										self.assertGreaterEqual(result['''eval_f1'''],    28      )
										self.assertGreaterEqual(result['''eval_exact'''],    28      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''epoch_0'''      )      )      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''qa_no_trainer'''      )      )      )




				@mock.patch.dict(os.environ,    {'''WANDB_MODE''': '''offline'''}      )
				def 	__snake_case							(							self	:				Optional[int]      ):
										snake_case       :     Any =    self.get_auto_remove_tmp_dir()
										snake_case       :     List[Any] =    F"""
            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/swag/sample.json
            --validation_file tests/fixtures/tests_samples/swag/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=20
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --with_tracking
        """.split()

										run_command(self._launch_args + testargs      )
										snake_case       :     Union[str, Any] =    get_results(SCREAMING_SNAKE_CASE_      )
										self.assertGreaterEqual(result['''eval_accuracy'''],    0.8      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''swag_no_trainer'''      )      )      )




				@slow
				@mock.patch.dict(os.environ,    {'''WANDB_MODE''': '''offline'''}      )
				def 	__snake_case							(							self	:				str      ):
										snake_case       :     str =    self.get_auto_remove_tmp_dir()
										snake_case       :     Any =    F"""
            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py
            --model_name_or_path t5-small
            --train_file tests/fixtures/tests_samples/xsum/sample.json
            --validation_file tests/fixtures/tests_samples/xsum/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=50
            --num_warmup_steps=8
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
            --with_tracking
        """.split()

										run_command(self._launch_args + testargs      )
										snake_case       :     str =    get_results(SCREAMING_SNAKE_CASE_      )
										self.assertGreaterEqual(result['''eval_rouge1'''],    10      )
										self.assertGreaterEqual(result['''eval_rouge2'''],    2      )
										self.assertGreaterEqual(result['''eval_rougeL'''],    7      )
										self.assertGreaterEqual(result['''eval_rougeLsum'''],    7      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''epoch_0'''      )      )      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''summarization_no_trainer'''      )      )      )




				@slow
				@mock.patch.dict(os.environ,    {'''WANDB_MODE''': '''offline'''}      )
				def 	__snake_case							(							self	:				int      ):
										snake_case       :     Any =    self.get_auto_remove_tmp_dir()
										snake_case       :     Optional[int] =    F"""
            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py
            --model_name_or_path sshleifer/student_marian_en_ro_6_1
            --source_lang en
            --target_lang ro
            --train_file tests/fixtures/tests_samples/wmt16/sample.json
            --validation_file tests/fixtures/tests_samples/wmt16/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=50
            --num_warmup_steps=8
            --num_beams=6
            --learning_rate=3e-3
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --source_lang en_XX
            --target_lang ro_RO
            --checkpointing_steps epoch
            --with_tracking
        """.split()

										run_command(self._launch_args + testargs      )
										snake_case       :     Optional[int] =    get_results(SCREAMING_SNAKE_CASE_      )
										self.assertGreaterEqual(result['''eval_bleu'''],    30      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''epoch_0'''      )      )      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''translation_no_trainer'''      )      )      )




				@slow
				def 	__snake_case							(							self	:				Union[str, Any]      ):
										snake_case       :     Any =    logging.StreamHandler(sys.stdout      )
										logger.addHandler(SCREAMING_SNAKE_CASE_      )

										snake_case       :     Union[str, Any] =    self.get_auto_remove_tmp_dir()
										snake_case       :     Dict =    F"""
            {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py
            --dataset_name huggingface/semantic-segmentation-test-sample
            --output_dir {tmp_dir}
            --max_train_steps=10
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
        """.split()

										run_command(self._launch_args + testargs      )
										snake_case       :     List[Any] =    get_results(SCREAMING_SNAKE_CASE_      )
										self.assertGreaterEqual(result['''eval_overall_accuracy'''],    0.10      )




				@mock.patch.dict(os.environ,    {'''WANDB_MODE''': '''offline'''}      )
				def 	__snake_case							(							self	:				Union[str, Any]      ):
										snake_case       :     str =    self.get_auto_remove_tmp_dir()
										snake_case       :     Optional[Any] =    F"""
            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py
            --model_name_or_path google/vit-base-patch16-224-in21k
            --dataset_name hf-internal-testing/cats_vs_dogs_sample
            --learning_rate 1e-4
            --per_device_train_batch_size 2
            --per_device_eval_batch_size 1
            --max_train_steps 2
            --train_val_split 0.1
            --seed 42
            --output_dir {tmp_dir}
            --with_tracking
            --checkpointing_steps 1
        """.split()

										if is_cuda_and_apex_available():
																testargs.append('''--fp16'''      )

										run_command(self._launch_args + testargs      )
										snake_case       :     Tuple =    get_results(SCREAMING_SNAKE_CASE_      )
										# The base model scores a 25%
										self.assertGreaterEqual(result['''eval_accuracy'''],    0.6      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''step_1'''      )      )      )
										self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE_,    '''image_classification_no_trainer'''      )      )      )

