





import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyInpaintPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()





class UpperCAmelCase_				( _SCREAMING_SNAKE_CASE     ,		unittest.TestCase ):
  __lowerCAmelCase   :						Optional[Any]							=   KandinskyInpaintPipeline
  __lowerCAmelCase   :						Tuple							=   ["""prompt""", """image_embeds""", """negative_image_embeds""", """image""", """mask_image"""]
  __lowerCAmelCase   :						Any							=   [
      """prompt""",
      """negative_prompt""",
      """image_embeds""",
      """negative_image_embeds""",
      """image""",
      """mask_image""",
  ]
  __lowerCAmelCase   :						Any							=   [
      """generator""",
      """height""",
      """width""",
      """latents""",
      """guidance_scale""",
      """negative_prompt""",
      """num_inference_steps""",
      """return_dict""",
      """guidance_scale""",
      """num_images_per_prompt""",
      """output_type""",
      """return_dict""",
  ]
  __lowerCAmelCase   :						Any							=   False


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return 3_2


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return 3_2


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return self.time_input_dim


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return self.time_input_dim * 4


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return 1_0_0


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base''' )
       return tokenizer


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       torch.manual_seed(0 )
       A_          =       MCLIPConfig(
           numDims=self.cross_attention_dim ,transformerDimensions=self.text_embedder_hidden_size ,hidden_size=self.text_embedder_hidden_size ,intermediate_size=3_7 ,num_attention_heads=4 ,num_hidden_layers=5 ,vocab_size=1_0_0_5 ,)

       A_          =       MultilingualCLIP(__snake_case )
       A_          =       text_encoder.eval()

       return text_encoder


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       torch.manual_seed(0 )

       A_          =       {
           '''in_channels''': 9,
           # Out channels is double in channels because predicts mean and variance
           '''out_channels''': 8,
           '''addition_embed_type''': '''text_image''',
           '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
           '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
           '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
           '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
           '''layers_per_block''': 1,
           '''encoder_hid_dim''': self.text_embedder_hidden_size,
           '''encoder_hid_dim_type''': '''text_image_proj''',
           '''cross_attention_dim''': self.cross_attention_dim,
           '''attention_head_dim''': 4,
           '''resnet_time_scale_shift''': '''scale_shift''',
           '''class_embed_type''': None,
       }

       A_          =       UNetaDConditionModel(**__snake_case )
       return model


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return {
           "block_out_channels": [3_2, 6_4],
           "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
           "in_channels": 3,
           "latent_channels": 4,
           "layers_per_block": 1,
           "norm_num_groups": 8,
           "norm_type": "spatial",
           "num_vq_embeddings": 1_2,
           "out_channels": 3,
           "up_block_types": [
               "AttnUpDecoderBlock2D",
               "UpDecoderBlock2D",
           ],
           "vq_embed_dim": 4,
       }


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       torch.manual_seed(0 )
       A_          =       VQModel(**self.dummy_movq_kwargs )
       return model


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self.dummy_text_encoder
       A_          =       self.dummy_tokenizer
       A_          =       self.dummy_unet
       A_          =       self.dummy_movq

       A_          =       DDIMScheduler(
           num_train_timesteps=1_0_0_0 ,beta_schedule='''linear''' ,beta_start=0.0_0085 ,beta_end=0.012 ,clip_sample=__snake_case ,set_alpha_to_one=__snake_case ,steps_offset=1 ,prediction_type='''epsilon''' ,thresholding=__snake_case ,)

       A_          =       {
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''movq''': movq,
       }

       return components


  def 						__UpperCAmelCase     (							self ,__snake_case ,__snake_case=0 ):



       """simple docstring"""





       A_          =       floats_tensor((1, self.cross_attention_dim) ,rng=random.Random(__snake_case ) ).to(__snake_case )
       A_          =       floats_tensor((1, self.cross_attention_dim) ,rng=random.Random(seed + 1 ) ).to(__snake_case )
       # create init_image
       A_          =       floats_tensor((1, 3, 6_4, 6_4) ,rng=random.Random(__snake_case ) ).to(__snake_case )
       A_          =       image.cpu().permute(0 ,2 ,3 ,1 )[0]
       A_          =       Image.fromarray(np.uinta(__snake_case ) ).convert('''RGB''' ).resize((2_5_6, 2_5_6) )
       # create mask
       A_          =       np.ones((6_4, 6_4) ,dtype=np.floataa )
       A_          =       0

       if str(__snake_case ).startswith('''mps''' ):
            A_          =       torch.manual_seed(__snake_case )
       else:
            A_          =       torch.Generator(device=__snake_case ).manual_seed(__snake_case )
       A_          =       {
           '''prompt''': '''horse''',
           '''image''': init_image,
           '''mask_image''': mask,
           '''image_embeds''': image_embeds,
           '''negative_image_embeds''': negative_image_embeds,
           '''generator''': generator,
           '''height''': 6_4,
           '''width''': 6_4,
           '''num_inference_steps''': 2,
           '''guidance_scale''': 4.0,
           '''output_type''': '''np''',
       }
       return inputs


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       '''cpu'''

       A_          =       self.get_dummy_components()

       A_          =       self.pipeline_class(**__snake_case )
       A_          =       pipe.to(__snake_case )

       pipe.set_progress_bar_config(disable=__snake_case )

       A_          =       pipe(**self.get_dummy_inputs(__snake_case ) )
       A_          =       output.images

       A_          =       pipe(
           **self.get_dummy_inputs(__snake_case ) ,return_dict=__snake_case ,)[0]

       A_          =       image[0, -3:, -3:, -1]
       A_          =       image_from_tuple[0, -3:, -3:, -1]

       print(f'image.shape {image.shape}' )

       assert image.shape == (1, 6_4, 6_4, 3)

       A_          =       np.array(
           [0.832_6919, 0.7379_0467, 0.2091_8581, 0.930_9612, 0.551_1791, 0.4371_3328, 0.551_3321, 0.4992_2934, 0.5949_7786] )

       assert (
           np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
       ), f' expected_slice {expected_slice}, but got {image_slice.flatten()}'
       assert (
           np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2
       ), f' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'




  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       super().test_inference_batch_single_identical(expected_max_diff=3E-3 )





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


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()




  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/kandinsky/kandinsky_inpaint_cat_with_hat_fp16.npy''' )

       A_          =       load_image(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png''' )
       A_          =       np.ones((7_6_8, 7_6_8) ,dtype=np.floataa )
       A_          =       0

       A_          =       '''a hat'''

       A_          =       KandinskyPriorPipeline.from_pretrained(
           '''kandinsky-community/kandinsky-2-1-prior''' ,torch_dtype=torch.floataa )
       pipe_prior.to(__snake_case )

       A_          =       KandinskyInpaintPipeline.from_pretrained(
           '''kandinsky-community/kandinsky-2-1-inpaint''' ,torch_dtype=torch.floataa )
       A_          =       pipeline.to(__snake_case )
       pipeline.set_progress_bar_config(disable=__snake_case )

       A_          =       torch.Generator(device='''cpu''' ).manual_seed(0 )
       A_   ,    A_          =       pipe_prior(
           __snake_case ,generator=__snake_case ,num_inference_steps=5 ,negative_prompt='''''' ,).to_tuple()

       A_          =       pipeline(
           __snake_case ,image=__snake_case ,mask_image=__snake_case ,image_embeds=__snake_case ,negative_image_embeds=__snake_case ,generator=__snake_case ,num_inference_steps=1_0_0 ,height=7_6_8 ,width=7_6_8 ,output_type='''np''' ,)

       A_          =       output.images[0]

       assert image.shape == (7_6_8, 7_6_8, 3)

       assert_mean_pixel_difference(__snake_case ,__snake_case )










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)

a__      :     Any         =		logging.getLogger()

def      UpperCAmelCase_    (    )	->				Any:
     '''simple docstring'''


     A_          =       argparse.ArgumentParser()
     parser.add_argument('''-f'''				)
     A_          =       parser.parse_args()
     return args.f

def      UpperCAmelCase_    (    _UpperCAmelCase							:Union[str, Any]				)	->				str:
     '''simple docstring'''


     A_          =       {}
     A_          =       os.path.join(_UpperCAmelCase  ,						'''all_results.json'''				)
     if os.path.exists(_UpperCAmelCase				):
          with open(_UpperCAmelCase  ,						'''r'''				) as f:
               A_          =       json.load(_UpperCAmelCase				)
     else:
          raise ValueError(f'can\'t find {path}'				)
     return results

def      UpperCAmelCase_    (    )	->				Union[str, Any]:
     '''simple docstring'''


     A_          =       torch.cuda.is_available() and torch_device == '''cuda'''
     return is_using_cuda and is_apex_available()


a__      :     List[Any]         =		logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)





class UpperCAmelCase_				( _SCREAMING_SNAKE_CASE ):


  @classmethod
  def 						__UpperCAmelCase     (							cls ):



       """simple docstring"""





       A_          =       tempfile.mkdtemp()
       A_          =       os.path.join(cls.tmpdir ,'''default_config.yml''' )
       write_basic_config(save_location=cls.configPath )
       A_          =       ['''accelerate''', '''launch''', '''--config_file''', cls.configPath]


  @classmethod
  def 						__UpperCAmelCase     (							cls ):



       """simple docstring"""





       shutil.rmtree(cls.tmpdir )


  @mock.patch.dict(os.environ ,{'''WANDB_MODE''': '''offline'''} )
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self.get_auto_remove_tmp_dir()
       A_          =       f'\n            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py\n            --model_name_or_path distilbert-base-uncased\n            --output_dir {tmp_dir}\n            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --learning_rate=1e-4\n            --seed=42\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

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

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


  @mock.patch.dict(os.environ ,{'''WANDB_MODE''': '''offline'''} )
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self.get_auto_remove_tmp_dir()
       A_          =       f'\n            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py\n            --model_name_or_path distilgpt2\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --block_size 128\n            --per_device_train_batch_size 5\n            --per_device_eval_batch_size 5\n            --num_train_epochs 2\n            --output_dir {tmp_dir}\n            --checkpointing_steps epoch\n            --with_tracking\n        '.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 )
       A_          =       get_results(__snake_case )
       self.assertLess(result['''perplexity'''] ,1_0_0 )
       self.assertTrue(os.path.exists(os.path.join(__snake_case ,'''epoch_0''' ) ) )
       self.assertTrue(os.path.exists(os.path.join(__snake_case ,'''clm_no_trainer''' ) ) )


  @mock.patch.dict(os.environ ,{'''WANDB_MODE''': '''offline'''} )
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self.get_auto_remove_tmp_dir()
       A_          =       f'\n            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py\n            --model_name_or_path distilroberta-base\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --output_dir {tmp_dir}\n            --num_train_epochs=1\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

       run_command(self._launch_args + testargs )
       A_          =       get_results(__snake_case )
       self.assertLess(result['''perplexity'''] ,4_2 )
       self.assertTrue(os.path.exists(os.path.join(__snake_case ,'''epoch_0''' ) ) )
       self.assertTrue(os.path.exists(os.path.join(__snake_case ,'''mlm_no_trainer''' ) ) )


  @mock.patch.dict(os.environ ,{'''WANDB_MODE''': '''offline'''} )
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       7 if get_gpu_count() > 1 else 2

       A_          =       self.get_auto_remove_tmp_dir()
       A_          =       f'\n            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/conll/sample.json\n            --validation_file tests/fixtures/tests_samples/conll/sample.json\n            --output_dir {tmp_dir}\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=2\n            --num_train_epochs={epochs}\n            --seed 7\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

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


  @unittest.skip(reason='''Fix me @muellerzr''' )
  @mock.patch.dict(os.environ ,{'''WANDB_MODE''': '''offline'''} )
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self.get_auto_remove_tmp_dir()
       A_          =       f'\n            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --version_2_with_negative\n            --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --output_dir {tmp_dir}\n            --seed=42\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

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


  @mock.patch.dict(os.environ ,{'''WANDB_MODE''': '''offline'''} )
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self.get_auto_remove_tmp_dir()
       A_          =       f'\n            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/swag/sample.json\n            --validation_file tests/fixtures/tests_samples/swag/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=20\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --with_tracking\n        '.split()

       run_command(self._launch_args + testargs )
       A_          =       get_results(__snake_case )
       self.assertGreaterEqual(result['''eval_accuracy'''] ,0.8 )
       self.assertTrue(os.path.exists(os.path.join(__snake_case ,'''swag_no_trainer''' ) ) )


  @slow
  @mock.patch.dict(os.environ ,{'''WANDB_MODE''': '''offline'''} )
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self.get_auto_remove_tmp_dir()
       A_          =       f'\n            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py\n            --model_name_or_path t5-small\n            --train_file tests/fixtures/tests_samples/xsum/sample.json\n            --validation_file tests/fixtures/tests_samples/xsum/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

       run_command(self._launch_args + testargs )
       A_          =       get_results(__snake_case )
       self.assertGreaterEqual(result['''eval_rouge1'''] ,1_0 )
       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(__snake_case ,'''epoch_0''' ) ) )
       self.assertTrue(os.path.exists(os.path.join(__snake_case ,'''summarization_no_trainer''' ) ) )


  @slow
  @mock.patch.dict(os.environ ,{'''WANDB_MODE''': '''offline'''} )
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self.get_auto_remove_tmp_dir()
       A_          =       f'\n            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py\n            --model_name_or_path sshleifer/student_marian_en_ro_6_1\n            --source_lang en\n            --target_lang ro\n            --train_file tests/fixtures/tests_samples/wmt16/sample.json\n            --validation_file tests/fixtures/tests_samples/wmt16/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --num_beams=6\n            --learning_rate=3e-3\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --source_lang en_XX\n            --target_lang ro_RO\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

       run_command(self._launch_args + testargs )
       A_          =       get_results(__snake_case )
       self.assertGreaterEqual(result['''eval_bleu'''] ,3_0 )
       self.assertTrue(os.path.exists(os.path.join(__snake_case ,'''epoch_0''' ) ) )
       self.assertTrue(os.path.exists(os.path.join(__snake_case ,'''translation_no_trainer''' ) ) )


  @slow
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       logging.StreamHandler(sys.stdout )
       logger.addHandler(__snake_case )

       A_          =       self.get_auto_remove_tmp_dir()
       A_          =       f'\n            {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py\n            --dataset_name huggingface/semantic-segmentation-test-sample\n            --output_dir {tmp_dir}\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n        '.split()

       run_command(self._launch_args + testargs )
       A_          =       get_results(__snake_case )
       self.assertGreaterEqual(result['''eval_overall_accuracy'''] ,0.10 )




  @mock.patch.dict(os.environ ,{'''WANDB_MODE''': '''offline'''} )
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self.get_auto_remove_tmp_dir()
       A_          =       f'\n            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py\n            --model_name_or_path google/vit-base-patch16-224-in21k\n            --dataset_name hf-internal-testing/cats_vs_dogs_sample\n            --learning_rate 1e-4\n            --per_device_train_batch_size 2\n            --per_device_eval_batch_size 1\n            --max_train_steps 2\n            --train_val_split 0.1\n            --seed 42\n            --output_dir {tmp_dir}\n            --with_tracking\n            --checkpointing_steps 1\n        '.split()

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

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



