





import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import datasets
import numpy as np
import tensorflow as tf

from transformers import (
    AutoConfig,
    AutoTokenizer,
    EvalPrediction,
    HfArgumentParser,
    PreTrainedTokenizer,
    TFAutoModelForSequenceClassification,
    TFTrainer,
    TFTrainingArguments,
)
from transformers.utils import logging as hf_logging


hf_logging.set_verbosity_info()
hf_logging.enable_default_handler()
hf_logging.enable_explicit_format()


def _A       (   __magic_name__  , __magic_name__  , __magic_name__  , __magic_name__  , __magic_name__  , __magic_name__ = None  , ):
   lowercase__			       =  {}

   if train_file is not None:
      lowercase__			       =  [train_file]
   if eval_file is not None:
      lowercase__			       =  [eval_file]
   if test_file is not None:
      lowercase__			       =  [test_file]

   lowercase__			       =  datasets.load_dataset("csv"  , data_files=__magic_name__	)
   lowercase__			       =  list(ds[list(files.keys()	)[0]].features.keys()	)
   lowercase__			       =  features_name.pop(__magic_name__	)
   lowercase__			       =  list(set(ds[list(files.keys()	)[0]][label_name]	)	)
   lowercase__			       =  {label: i for i, label in enumerate(__magic_name__	)}
   lowercase__			       =  tokenizer.model_input_names
   lowercase__			       =  {}

   if len(__magic_name__	) == 1:
      for k in files.keys():
         lowercase__			       =  ds[k].map(
             lambda __magic_name__	: tokenizer.batch_encode_plus(
                 example[features_name[0]]  , truncation=__magic_name__  , max_length=__magic_name__  , padding="max_length"	)  , batched=__magic_name__  , )
   elif len(__magic_name__	) == 2:
      for k in files.keys():
         lowercase__			       =  ds[k].map(
             lambda __magic_name__	: tokenizer.batch_encode_plus(
                 (example[features_name[0]], example[features_name[1]])  , truncation=__magic_name__  , max_length=__magic_name__  , padding="max_length"  , )  , batched=__magic_name__  , )

   def gen_train():
      for ex in transformed_ds[datasets.Split.TRAIN]:
         lowercase__			       =  {k: v for k, v in ex.items() if k in input_names}
         lowercase__			       =  labelaid[ex[label_name]]
         yield (d, label)

   def gen_val():
      for ex in transformed_ds[datasets.Split.VALIDATION]:
         lowercase__			       =  {k: v for k, v in ex.items() if k in input_names}
         lowercase__			       =  labelaid[ex[label_name]]
         yield (d, label)

   def gen_test():
      for ex in transformed_ds[datasets.Split.TEST]:
         lowercase__			       =  {k: v for k, v in ex.items() if k in input_names}
         lowercase__			       =  labelaid[ex[label_name]]
         yield (d, label)

   lowercase__			       =  (
       tf.data.Dataset.from_generator(
           __magic_name__  , ({k: tf.intaa for k in input_names}, tf.intaa)  , ({k: tf.TensorShape([None]	) for k in input_names}, tf.TensorShape([]	))  , )
       if datasets.Split.TRAIN in transformed_ds
       else None
   )

   if train_ds is not None:
      lowercase__			       =  train_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TRAIN]	)	)	)

   lowercase__			       =  (
       tf.data.Dataset.from_generator(
           __magic_name__  , ({k: tf.intaa for k in input_names}, tf.intaa)  , ({k: tf.TensorShape([None]	) for k in input_names}, tf.TensorShape([]	))  , )
       if datasets.Split.VALIDATION in transformed_ds
       else None
   )

   if val_ds is not None:
      lowercase__			       =  val_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.VALIDATION]	)	)	)

   lowercase__			       =  (
       tf.data.Dataset.from_generator(
           __magic_name__  , ({k: tf.intaa for k in input_names}, tf.intaa)  , ({k: tf.TensorShape([None]	) for k in input_names}, tf.TensorShape([]	))  , )
       if datasets.Split.TEST in transformed_ds
       else None
   )

   if test_ds is not None:
      lowercase__			       =  test_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TEST]	)	)	)

   return train_ds, val_ds, test_ds, labelaid


_snake_case           =			logging.getLogger(__name__)





@dataclass
class  lowerCAmelCase							:
  __lowerCamelCase		=      field(metadata={'help': 'Which column contains the label'} )
  __lowerCamelCase		=      field(default=lowercase_							,							metadata={'help': 'The path of the training file'} )
  __lowerCamelCase		=      field(default=lowercase_							,							metadata={'help': 'The path of the development file'} )
  __lowerCamelCase		=      field(default=lowercase_							,							metadata={'help': 'The path of the test file'} )
  __lowerCamelCase		=      field(
      default=128							,							metadata={
          'help': (
              'The maximum total input sequence length after tokenization. Sequences longer '
              'than this will be truncated, sequences shorter will be padded.'
          )
      }							,							)
  __lowerCamelCase		=      field(
      default=lowercase_							,							metadata={'help': 'Overwrite the cached training and evaluation sets'} )





@dataclass
class  lowerCAmelCase							:
  __lowerCamelCase		=      field(
      metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'} )
  __lowerCamelCase		=      field(
      default=lowercase_							,							metadata={'help': 'Pretrained config name or path if not the same as model_name'} )
  __lowerCamelCase		=      field(
      default=lowercase_							,							metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'} )
  __lowerCamelCase		=      field(default=lowercase_							,							metadata={'help': 'Set this flag to use fast tokenization.'} )
  # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
  # or just modify its tokenizer_config.json.
  __lowerCamelCase		=      field(
      default=lowercase_							,							metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}							,							)


def _A       (   ):
   # See all possible arguments in src/transformers/training_args.py
   # or by passing the --help flag to this script.
   # We now keep distinct sets of args, for a cleaner separation of concerns.
   lowercase__			       =  HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments)	)
   lowercase__       ,							lowercase__       ,							lowercase__			       =  parser.parse_args_into_dataclasses()

   if (
       os.path.exists(training_args.output_dir	)
       and os.listdir(training_args.output_dir	)
       and training_args.do_train
       and not training_args.overwrite_output_dir
   ):
      raise ValueError(
          f'''Output directory ({training_args.output_dir}) already exists and is not empty. Use'''
          " --overwrite_output_dir to overcome."	)

   # Setup logging
   logging.basicConfig(
       format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"  , datefmt="%m/%d/%Y %H:%M:%S"  , level=logging.INFO  , )
   logger.info(
       f'''n_replicas: {training_args.n_replicas}, distributed training: {bool(training_args.n_replicas > 1	)}, '''
       f'''16-bits training: {training_args.fpaa}'''	)
   logger.info(f'''Training/evaluation parameters {training_args}'''	)

   # Load pretrained model and tokenizer
   #
   # Distributed training:
   # The .from_pretrained methods guarantee that only one local process can concurrently
   # download model & vocab.

   lowercase__			       =  AutoTokenizer.from_pretrained(
       model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path  , cache_dir=model_args.cache_dir  , )

   lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__			       =  get_tfds(
       train_file=data_args.train_file  , eval_file=data_args.dev_file  , test_file=data_args.test_file  , tokenizer=__magic_name__  , label_column_id=data_args.label_column_id  , max_seq_length=data_args.max_seq_length  , )

   lowercase__			       =  AutoConfig.from_pretrained(
       model_args.config_name if model_args.config_name else model_args.model_name_or_path  , num_labels=len(__magic_name__	)  , labelaid=__magic_name__  , idalabel={id: label for label, id in labelaid.items()}  , finetuning_task="text-classification"  , cache_dir=model_args.cache_dir  , )

   with training_args.strategy.scope():
      lowercase__			       =  TFAutoModelForSequenceClassification.from_pretrained(
          model_args.model_name_or_path  , from_pt=bool(".bin" in model_args.model_name_or_path	)  , config=__magic_name__  , cache_dir=model_args.cache_dir  , )

   def compute_metrics(__magic_name__	) -> Dict:
      lowercase__			       =  np.argmax(p.predictions  , axis=1	)

      return {"acc": (preds == p.label_ids).mean()}

   # Initialize our Trainer
   lowercase__			       =  TFTrainer(
       model=__magic_name__  , args=__magic_name__  , train_dataset=__magic_name__  , eval_dataset=__magic_name__  , compute_metrics=__magic_name__  , )

   # Training
   if training_args.do_train:
      trainer.train()
      trainer.save_model()
      tokenizer.save_pretrained(training_args.output_dir	)

   # Evaluation
   lowercase__			       =  {}
   if training_args.do_eval:
      logger.info("*** Evaluate ***"	)
      lowercase__			       =  trainer.evaluate()
      lowercase__			       =  os.path.join(training_args.output_dir  , "eval_results.txt"	)

      with open(__magic_name__  , "w"	) as writer:
         logger.info("***** Eval results *****"	)

         for key, value in result.items():
            logger.info(f'''  {key} = {value}'''	)
            writer.write(f'''{key} = {value}\n'''	)

         results.update(__magic_name__	)

   return results


if __name__ == "__main__":
  main()













import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
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 ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


def _A       (   __magic_name__	):
   lowercase__			       =  [tensor.shape for tensor in tensor_list]
   return all(shape == shapes[0] for shape in shapes[1:]	)





class  lowerCAmelCase							(       lowercase_							,							lowercase_							,							lowercase_							,							unittest.TestCase ):
  __lowerCamelCase		=      StableDiffusionLatentUpscalePipeline
  __lowerCamelCase		=      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
      'height',
      'width',
      'cross_attention_kwargs',
      'negative_prompt_embeds',
      'prompt_embeds',
  }
  __lowerCamelCase		=      PipelineTesterMixin.required_optional_params - {'num_images_per_prompt'}
  __lowerCamelCase		=      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
  __lowerCamelCase		=      frozenset(
      [] )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
  __lowerCamelCase		=      frozenset([] )

  __lowerCamelCase		=      True







  @property
  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





     lowercase__			       =  1
     lowercase__			       =  4
     lowercase__			       =  (16, 16)

     lowercase__			       =  floats_tensor((batch_size, num_channels) + sizes   ,							rng=random.Random(0 ) ).to(_lowercase )
     return image







  def   UpperCAmelCase					(      self  :Dict ):






     '''simple docstring'''





     torch.manual_seed(0 )
     lowercase__			       =  UNetaDConditionModel(
         act_fn="gelu"   ,							attention_head_dim=8   ,							norm_num_groups=_lowercase   ,							block_out_channels=[32, 32, 64, 64]   ,							time_cond_proj_dim=1_60   ,							conv_in_kernel=1   ,							conv_out_kernel=1   ,							cross_attention_dim=32   ,							down_block_types=(
             "KDownBlock2D",
             "KCrossAttnDownBlock2D",
             "KCrossAttnDownBlock2D",
             "KCrossAttnDownBlock2D",
         )   ,							in_channels=8   ,							mid_block_type=_lowercase   ,							only_cross_attention=_lowercase   ,							out_channels=5   ,							resnet_time_scale_shift="scale_shift"   ,							time_embedding_type="fourier"   ,							timestep_post_act="gelu"   ,							up_block_types=("KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KUpBlock2D")   ,							)
     lowercase__			       =  AutoencoderKL(
         block_out_channels=[32, 32, 64, 64]   ,							in_channels=3   ,							out_channels=3   ,							down_block_types=[
             "DownEncoderBlock2D",
             "DownEncoderBlock2D",
             "DownEncoderBlock2D",
             "DownEncoderBlock2D",
         ]   ,							up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"]   ,							latent_channels=4   ,							)
     lowercase__			       =  EulerDiscreteScheduler(prediction_type="sample" )
     lowercase__			       =  CLIPTextConfig(
         bos_token_id=0   ,							eos_token_id=2   ,							hidden_size=32   ,							intermediate_size=37   ,							layer_norm_eps=1e-05   ,							num_attention_heads=4   ,							num_hidden_layers=5   ,							pad_token_id=1   ,							vocab_size=10_00   ,							hidden_act="quick_gelu"   ,							projection_dim=5_12   ,							)
     lowercase__			       =  CLIPTextModel(_lowercase )
     lowercase__			       =  CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

     lowercase__			       =  {
         "unet": model.eval(),
         "vae": vae.eval(),
         "scheduler": scheduler,
         "text_encoder": text_encoder,
         "tokenizer": tokenizer,
     }

     return components







  def   UpperCAmelCase					(      self  :Dict   ,							_lowercase  :Union[str, Any]   ,							_lowercase  :int=0 ):






     '''simple docstring'''





     if str(_lowercase ).startswith("mps" ):
        lowercase__			       =  torch.manual_seed(_lowercase )
     else:
        lowercase__			       =  torch.Generator(device=_lowercase ).manual_seed(_lowercase )
     lowercase__			       =  {
         "prompt": "A painting of a squirrel eating a burger",
         "image": self.dummy_image.cpu(),
         "generator": generator,
         "num_inference_steps": 2,
         "output_type": "numpy",
     }
     return inputs







  def   UpperCAmelCase					(      self  :List[Any] ):






     '''simple docstring'''





     lowercase__			       =  "cpu"

     lowercase__			       =  self.get_dummy_components()
     lowercase__			       =  self.pipeline_class(**_lowercase )
     pipe.to(_lowercase )
     pipe.set_progress_bar_config(disable=_lowercase )

     lowercase__			       =  self.get_dummy_inputs(_lowercase )
     lowercase__			       =  pipe(**_lowercase ).images
     lowercase__			       =  image[0, -3:, -3:, -1]

     self.assertEqual(image.shape   ,							(1, 2_56, 2_56, 3) )
     lowercase__			       =  np.array(
         [0.47222412, 0.41921633, 0.44717434, 0.46874192, 0.42588258, 0.46150726, 0.4677534, 0.45583832, 0.48579055] )
     lowercase__			       =  np.abs(image_slice.flatten() - expected_slice ).max()
     self.assertLessEqual(_lowercase   ,							1e-3 )







  def   UpperCAmelCase					(      self  :Any ):






     '''simple docstring'''





     super().test_attention_slicing_forward_pass(expected_max_diff=7e-3 )







  def   UpperCAmelCase					(      self  :List[Any] ):






     '''simple docstring'''





     super().test_cpu_offload_forward_pass(expected_max_diff=3e-3 )







  def   UpperCAmelCase					(      self  :int ):






     '''simple docstring'''





     super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3 )







  def   UpperCAmelCase					(      self  :List[Any] ):






     '''simple docstring'''





     super().test_inference_batch_single_identical(expected_max_diff=7e-3 )







  def   UpperCAmelCase					(      self  :List[Any] ):






     '''simple docstring'''





     super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3e-3 )







  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     super().test_save_load_local(expected_max_difference=3e-3 )







  def   UpperCAmelCase					(      self  :Tuple ):






     '''simple docstring'''





     super().test_save_load_optional_components(expected_max_difference=3e-3 )







  def   UpperCAmelCase					(      self  :Dict ):






     '''simple docstring'''





     lowercase__			       =  [
         "DDIMScheduler",
         "DDPMScheduler",
         "PNDMScheduler",
         "HeunDiscreteScheduler",
         "EulerAncestralDiscreteScheduler",
         "KDPM2DiscreteScheduler",
         "KDPM2AncestralDiscreteScheduler",
         "DPMSolverSDEScheduler",
     ]
     lowercase__			       =  self.get_dummy_components()
     lowercase__			       =  self.pipeline_class(**_lowercase )

     # make sure that PNDM does not need warm-up
     pipe.scheduler.register_to_config(skip_prk_steps=_lowercase )

     pipe.to(_lowercase )
     pipe.set_progress_bar_config(disable=_lowercase )
     lowercase__			       =  self.get_dummy_inputs(_lowercase )
     lowercase__			       =  2

     lowercase__			       =  []
     for scheduler_enum in KarrasDiffusionSchedulers:
        if scheduler_enum.name in skip_schedulers:
           # no sigma schedulers are not supported
           # no schedulers
           continue

        lowercase__			       =  getattr(_lowercase   ,							scheduler_enum.name )
        lowercase__			       =  scheduler_cls.from_config(pipe.scheduler.config )
        lowercase__			       =  pipe(**_lowercase )[0]
        outputs.append(_lowercase )

     assert check_same_shape(_lowercase )





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







  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





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







  def   UpperCAmelCase					(      self  :str ):






     '''simple docstring'''





     lowercase__			       =  torch.manual_seed(33 )

     lowercase__			       =  StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"   ,							torch_dtype=torch.floataa )
     pipe.to("cuda" )

     lowercase__			       =  StableDiffusionLatentUpscalePipeline.from_pretrained(
         "stabilityai/sd-x2-latent-upscaler"   ,							torch_dtype=torch.floataa )
     upscaler.to("cuda" )

     lowercase__			       =  "a photo of an astronaut high resolution, unreal engine, ultra realistic"

     lowercase__			       =  pipe(_lowercase   ,							generator=_lowercase   ,							output_type="latent" ).images

     lowercase__			       =  upscaler(
         prompt=_lowercase   ,							image=_lowercase   ,							num_inference_steps=20   ,							guidance_scale=0   ,							generator=_lowercase   ,							output_type="np"   ,							).images[0]

     lowercase__			       =  load_numpy(
         "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy" )
     assert np.abs((expected_image - image).mean() ) < 5e-2







  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





     lowercase__			       =  torch.manual_seed(33 )

     lowercase__			       =  StableDiffusionLatentUpscalePipeline.from_pretrained(
         "stabilityai/sd-x2-latent-upscaler"   ,							torch_dtype=torch.floataa )
     upscaler.to("cuda" )

     lowercase__			       =  "the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas"

     lowercase__			       =  load_image(
         "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png" )

     lowercase__			       =  upscaler(
         prompt=_lowercase   ,							image=_lowercase   ,							num_inference_steps=20   ,							guidance_scale=0   ,							generator=_lowercase   ,							output_type="np"   ,							).images[0]

     lowercase__			       =  load_numpy(
         "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy" )
     assert np.abs((expected_image - image).max() ) < 5e-2






