code: 
  
  
  from copy import deepcopy
  from pathlib import Path
  from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
  
  import torch
  from torch import nn
  from torch.utils.data import Dataset
  
  from .deepspeed import is_deepspeed_zeroa_enabled
  from .generation.configuration_utils import GenerationConfig
  from .trainer import Trainer
  from .utils import logging
  
  
  if TYPE_CHECKING:
  	from .data.data_collator import DataCollator
  	from .modeling_utils import PreTrainedModel
  	from .tokenization_utils_base import PreTrainedTokenizerBase
  	from .trainer_callback import TrainerCallback
  	from .trainer_utils import EvalPrediction, PredictionOutput
  	from .training_args import TrainingArguments
  
  
  lowerCAmelCase					 =	logging.get_logger(__name__)
  
  
  
  
  
  class    A					(     __UpperCAmelCase				):
  
  
  							def __init__(self   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = (None, None)   ,       lowerCAmelCase = None   ,       ):
  													super().__init__(
  													    model=lowerCamelCase__   ,       args=lowerCamelCase__   ,       data_collator=lowerCamelCase__   ,       train_dataset=lowerCamelCase__   ,       eval_dataset=lowerCamelCase__   ,       tokenizer=lowerCamelCase__   ,       model_init=lowerCamelCase__   ,       compute_metrics=lowerCamelCase__   ,       callbacks=lowerCamelCase__   ,       optimizers=lowerCamelCase__   ,       preprocess_logits_for_metrics=lowerCamelCase__   ,       )
  
  													# Override self.model.generation_config if a GenerationConfig is specified in args.
  													# Priority: args.generation_config > model.generation_config > default GenerationConfig.
  													if self.args.generation_config is not None:
  																			__lowercase=    self.load_generation_config(self.args.generation_config      )
  																			__lowercase=    gen_config
  
  
  							@staticmethod
  							def     _A (lowerCAmelCase      ):
  
  
  
  													if isinstance(lowerCamelCase__   ,       lowerCamelCase__      ):
  																			return deepcopy(lowerCamelCase__      )
  
  													# str or Path
  													__lowercase=    Path(lowerCamelCase__      ) if isinstance(lowerCamelCase__   ,       lowerCamelCase__      ) else gen_config_arg
  													__lowercase=    None
  
  													# Figuring if it is path pointing to a file, pointing to a directory or else a model id or URL
  													# This step is required in order to determine config_file_name
  													if pretrained_model_name.is_file():
  																			__lowercase=    pretrained_model_name.name
  																			__lowercase=    pretrained_model_name.parent
  													# dir path
  													elif pretrained_model_name.is_dir():
  																			pass
  													# model id or URL
  													else:
  																			__lowercase=    gen_config_arg
  
  													__lowercase=    GenerationConfig.from_pretrained(lowerCamelCase__   ,       lowerCamelCase__      )
  													return gen_config
  
  
  							def     _A (self   ,       lowerCAmelCase = None   ,       lowerCAmelCase = None   ,       lowerCAmelCase = "eval"   ,       **lowerCAmelCase   ,       ):
  													__lowercase=    gen_kwargs.copy()
  													if gen_kwargs.get('max_length'      ) is None and gen_kwargs.get('max_new_tokens'      ) is None:
  																			__lowercase=    self.args.generation_max_length
  													__lowercase=    (
  													    gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'      ) is not None else self.args.generation_num_beams
  													)
  													__lowercase=    gen_kwargs
  
  													return super().evaluate(lowerCamelCase__   ,       ignore_keys=lowerCamelCase__   ,       metric_key_prefix=lowerCamelCase__      )
  
  
  							def     _A (self   ,       lowerCAmelCase   ,       lowerCAmelCase = None   ,       lowerCAmelCase = "test"   ,       **lowerCAmelCase   ,       ):
  													__lowercase=    gen_kwargs.copy()
  													if gen_kwargs.get('max_length'      ) is None and gen_kwargs.get('max_new_tokens'      ) is None:
  																			__lowercase=    self.args.generation_max_length
  													__lowercase=    (
  													    gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'      ) is not None else self.args.generation_num_beams
  													)
  													__lowercase=    gen_kwargs
  
  													return super().predict(lowerCamelCase__   ,       ignore_keys=lowerCamelCase__   ,       metric_key_prefix=lowerCamelCase__      )
  
  
  							def     _A (self   ,       lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase   ,       lowerCAmelCase = None   ,       **lowerCAmelCase   ,       ):
  
  
  
  													if not self.args.predict_with_generate or prediction_loss_only:
  																			return super().prediction_step(
  																			    lowerCamelCase__   ,       lowerCamelCase__   ,       prediction_loss_only=lowerCamelCase__   ,       ignore_keys=lowerCamelCase__      )
  
  													__lowercase=    'labels' in inputs
  													__lowercase=    self._prepare_inputs(lowerCamelCase__      )
  
  													# XXX: adapt synced_gpus for fairscale as well
  													# Priority (handled in generate):
  													# gen_kwargs > model.generation_config > default GenerationConfig()
  
  													if len(lowerCamelCase__      ) == 0 and hasattr(self   ,       '_gen_kwargs'      ):
  																			__lowercase=    self._gen_kwargs.copy()
  
  													if gen_kwargs.get('max_length'      ) is None and gen_kwargs.get('max_new_tokens'      ) is None:
  																			__lowercase=    self.model.config.max_length
  													__lowercase=    (
  													    gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'      ) is not None else self.model.config.num_beams
  													)
  													__lowercase=    True if is_deepspeed_zeroa_enabled() else False
  													__lowercase=    (
  													    gen_kwargs['synced_gpus'] if gen_kwargs.get('synced_gpus'      ) is not None else default_synced_gpus
  													)
  
  													# If the `decoder_input_ids` was created from `labels`, evict the former, so that the model can freely generate
  													# (otherwise, it would continue generating from the padded `decoder_input_ids`)
  													if (
  													    "labels" in inputs
  													    and "decoder_input_ids" in inputs
  													    and inputs["labels"].shape == inputs["decoder_input_ids"].shape
  													):
  																			__lowercase=    {k: v for k, v in inputs.items() if k != 'decoder_input_ids'}
  													__lowercase=    self.model.generate(**lowerCamelCase__   ,       **lowerCamelCase__      )
  
  													# Temporary hack to ensure the generation config is not initialized for each iteration of the evaluation loop
  													# TODO: remove this hack when the legacy code that initializes generation_config from a model config is
  													# removed in https://github.com/huggingface/transformers/blob/98d88b23f54e5a23e741833f1e973fdf600cc2c5/src/transformers/generation/utils.py#L1183
  													if self.model.generation_config._from_model_config:
  																			__lowercase=    False
  
  													# Retrieves GenerationConfig from model.generation_config
  													__lowercase=    self.model.generation_config
  													# in case the batch is shorter than max length, the output should be padded
  													if generated_tokens.shape[-1] < gen_config.max_length:
  																			__lowercase=    self._pad_tensors_to_max_len(lowerCamelCase__   ,       gen_config.max_length      )
  													elif gen_config.max_new_tokens is not None and generated_tokens.shape[-1] < gen_config.max_new_tokens + 1:
  																			__lowercase=    self._pad_tensors_to_max_len(lowerCamelCase__   ,       gen_config.max_new_tokens + 1      )
  
  													with torch.no_grad():
  																			if has_labels:
  																									with self.compute_loss_context_manager():
  																															__lowercase=    model(**lowerCamelCase__      )
  																									if self.label_smoother is not None:
  																															__lowercase=    self.label_smoother(lowerCamelCase__   ,       inputs['labels']      ).mean().detach()
  																									else:
  																															__lowercase=    (outputs['loss'] if isinstance(lowerCamelCase__   ,       lowerCamelCase__      ) else outputs[0]).mean().detach()
  																			else:
  																									__lowercase=    None
  
  													if self.args.prediction_loss_only:
  																			return loss, None, None
  
  													if has_labels:
  																			__lowercase=    inputs['labels']
  																			if labels.shape[-1] < gen_config.max_length:
  																									__lowercase=    self._pad_tensors_to_max_len(lowerCamelCase__   ,       gen_config.max_length      )
  																			elif gen_config.max_new_tokens is not None and labels.shape[-1] < gen_config.max_new_tokens + 1:
  																									__lowercase=    self._pad_tensors_to_max_len(lowerCamelCase__   ,       gen_config.max_new_tokens + 1      )
  													else:
  																			__lowercase=    None
  
  													return loss, generated_tokens, labels
  
  
  
  
  
  
  
  							def     _A (self   ,       lowerCAmelCase   ,       lowerCAmelCase      ):
  
  
  
  													if self.tokenizer is not None and hasattr(self.tokenizer   ,       'pad_token_id'      ):
  																			# If PAD token is not defined at least EOS token has to be defined
  																			__lowercase=    (
  																			    self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else self.tokenizer.eos_token_id
  																			)
  													else:
  																			if self.model.config.pad_token_id is not None:
  																									__lowercase=    self.model.config.pad_token_id
  																			else:
  																									raise ValueError('Pad_token_id must be set in the configuration of the model, in order to pad tensors'      )
  
  													__lowercase=    pad_token_id * torch.ones(
  													    (tensor.shape[0], max_length)   ,       dtype=tensor.dtype   ,       device=tensor.device      )
  													__lowercase=    tensor
  													return padded_tensor
  
  
  
  
  
  
  
style_context: 
  
  
  from dataclasses import dataclass
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  from PIL import Image
  
  from ...utils import BaseOutput, is_torch_available, is_transformers_available
  
  
  
  
  
  @dataclass
  # Copied from diffusers.pipelines.stable_diffusion.__init__.StableDiffusionPipelineOutput with Stable->Alt
  class    A					(     A_				):
  							UpperCamelCase_     :							Union[List[PIL.Image.Image], np.ndarray]
  							UpperCamelCase_     :							Optional[List[bool]]
  
  
  if is_transformers_available() and is_torch_available():
  	from .modeling_roberta_series import RobertaSeriesModelWithTransformation
  	from .pipeline_alt_diffusion import AltDiffusionPipeline
  	from .pipeline_alt_diffusion_imgaimg import AltDiffusionImgaImgPipeline
  
  
  
  
  
  
  