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     :			Any    =logging.get_logger(__name__)
  
  class __UpperCamelCase    (							_a		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					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:
  							UpperCAmelCase__:  Tuple		       =   self.load_generation_config(self.args.generation_config	)
  							UpperCAmelCase__:  Optional[int]		       =   gen_config
  
  
  
  
  
  					@staticmethod
  					def       _UpperCAmelCase						(							lowerCamelCase__	):
  
  						# GenerationConfig provided, nothing to do
  						if isinstance(lowerCamelCase__							,			lowerCamelCase__	):
  							return deepcopy(lowerCamelCase__	)
  
  						# str or Path
  						UpperCAmelCase__:  Optional[int]		       =   Path(lowerCamelCase__	) if isinstance(lowerCamelCase__							,			lowerCamelCase__	) else gen_config_arg
  						UpperCAmelCase__:  List[Any]		       =   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():
  							UpperCAmelCase__:  Union[str, Any]		       =   pretrained_model_name.name
  							UpperCAmelCase__:  Tuple		       =   pretrained_model_name.parent
  						# dir path
  						elif pretrained_model_name.is_dir():
  							pass
  						# model id or URL
  						else:
  							UpperCAmelCase__:  Optional[int]		       =   gen_config_arg
  
  						UpperCAmelCase__:  str		       =   GenerationConfig.from_pretrained(lowerCamelCase__							,			lowerCamelCase__	)
  						return gen_config
  
  
  
  
  
  					def       _UpperCAmelCase						(							self							,			lowerCamelCase__ = None							,			lowerCamelCase__ = None							,			lowerCamelCase__ = "eval"							,			**lowerCamelCase__							,			):
  						UpperCAmelCase__:  Optional[Any]		       =   gen_kwargs.copy()
  						if gen_kwargs.get("max_length"	) is None and gen_kwargs.get("max_new_tokens"	) is None:
  							UpperCAmelCase__:  Dict		       =   self.args.generation_max_length
  						UpperCAmelCase__:  Any		       =   (
  						    gen_kwargs["num_beams"] if gen_kwargs.get("num_beams"	) is not None else self.args.generation_num_beams
  						)
  						UpperCAmelCase__:  int		       =   gen_kwargs
  
  						return super().evaluate(lowerCamelCase__							,			ignore_keys=lowerCamelCase__							,			metric_key_prefix=lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self							,			lowerCamelCase__							,			lowerCamelCase__ = None							,			lowerCamelCase__ = "test"							,			**lowerCamelCase__							,			):
  						UpperCAmelCase__:  Optional[Any]		       =   gen_kwargs.copy()
  						if gen_kwargs.get("max_length"	) is None and gen_kwargs.get("max_new_tokens"	) is None:
  							UpperCAmelCase__:  List[str]		       =   self.args.generation_max_length
  						UpperCAmelCase__:  List[Any]		       =   (
  						    gen_kwargs["num_beams"] if gen_kwargs.get("num_beams"	) is not None else self.args.generation_num_beams
  						)
  						UpperCAmelCase__:  Any		       =   gen_kwargs
  
  						return super().predict(lowerCamelCase__							,			ignore_keys=lowerCamelCase__							,			metric_key_prefix=lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							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__	)
  
  						UpperCAmelCase__:  Tuple		       =   "labels" in inputs
  						UpperCAmelCase__:  int		       =   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"	):
  							UpperCAmelCase__:  Union[str, Any]		       =   self._gen_kwargs.copy()
  
  						if gen_kwargs.get("max_length"	) is None and gen_kwargs.get("max_new_tokens"	) is None:
  							UpperCAmelCase__:  List[str]		       =   self.model.config.max_length
  						UpperCAmelCase__:  Dict		       =   (
  						    gen_kwargs["num_beams"] if gen_kwargs.get("num_beams"	) is not None else self.model.config.num_beams
  						)
  						UpperCAmelCase__:  Any		       =   True if is_deepspeed_zeroa_enabled() else False
  						UpperCAmelCase__:  List[Any]		       =   (
  						    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
  						):
  							UpperCAmelCase__:  int		       =   {k: v for k, v in inputs.items() if k != "decoder_input_ids"}
  						UpperCAmelCase__:  List[str]		       =   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:
  							UpperCAmelCase__:  List[str]		       =   False
  
  						# Retrieves GenerationConfig from model.generation_config
  						UpperCAmelCase__:  List[Any]		       =   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:
  							UpperCAmelCase__:  int		       =   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:
  							UpperCAmelCase__:  List[str]		       =   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():
  									UpperCAmelCase__:  Tuple		       =   model(**lowerCamelCase__	)
  								if self.label_smoother is not None:
  									UpperCAmelCase__:  Tuple		       =   self.label_smoother(lowerCamelCase__							,			inputs["labels"]	).mean().detach()
  								else:
  									UpperCAmelCase__:  Dict		       =   (outputs["loss"] if isinstance(lowerCamelCase__							,			lowerCamelCase__	) else outputs[0]).mean().detach()
  							else:
  								UpperCAmelCase__:  int		       =   None
  
  						if self.args.prediction_loss_only:
  							return loss, None, None
  
  						if has_labels:
  							UpperCAmelCase__:  Dict		       =   inputs["labels"]
  							if labels.shape[-1] < gen_config.max_length:
  								UpperCAmelCase__:  Union[str, Any]		       =   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:
  								UpperCAmelCase__:  Tuple		       =   self._pad_tensors_to_max_len(lowerCamelCase__							,			gen_config.max_new_tokens + 1	)
  						else:
  							UpperCAmelCase__:  Union[str, Any]		       =   None
  
  						return loss, generated_tokens, labels
  
  
  
  
  
  					def       _UpperCAmelCase						(							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
  							UpperCAmelCase__:  Optional[Any]		       =   (
  							    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:
  								UpperCAmelCase__:  Dict		       =   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"	)
  
  						UpperCAmelCase__:  Any		       =   pad_token_id * torch.ones(
  						    (tensor.shape[0], max_length)							,			dtype=tensor.dtype							,			device=tensor.device	)
  						UpperCAmelCase__:  str		       =   tensor
  						return padded_tensor
style_context: 
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,):
  	UpperCAmelCase__:  Tuple		       =   list(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  int		       =   list(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  Dict		       =   len(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  int		       =   len(SCREAMING_SNAKE_CASE			)
  
  	UpperCAmelCase__:  Any		       =   [
  	    [0 for _ in range(len_destination_seq + 1			)] for _ in range(len_source_seq + 1			)
  	]
  	UpperCAmelCase__:  List[Any]		       =   [
  	    ["0" for _ in range(len_destination_seq + 1			)] for _ in range(len_source_seq + 1			)
  	]
  
  	for i in range(1  ,len_source_seq + 1			):
  		UpperCAmelCase__:  List[Any]		       =   i * delete_cost
  		UpperCAmelCase__:  str		       =   f"D{source_seq[i - 1]:c}"
  
  	for i in range(1  ,len_destination_seq + 1			):
  		UpperCAmelCase__:  Union[str, Any]		       =   i * insert_cost
  		UpperCAmelCase__:  Optional[Any]		       =   f"I{destination_seq[i - 1]:c}"
  
  	for i in range(1  ,len_source_seq + 1			):
  		for j in range(1  ,len_destination_seq + 1			):
  			if source_seq[i - 1] == destination_seq[j - 1]:
  				UpperCAmelCase__:  Any		       =   costs[i - 1][j - 1] + copy_cost
  				UpperCAmelCase__:  Tuple		       =   f"C{source_seq[i - 1]:c}"
  			else:
  				UpperCAmelCase__:  Union[str, Any]		       =   costs[i - 1][j - 1] + replace_cost
  				UpperCAmelCase__:  Optional[int]		       =   f"R{source_seq[i - 1]:c}" + str(destination_seq[j - 1]			)
  
  			if costs[i - 1][j] + delete_cost < costs[i][j]:
  				UpperCAmelCase__:  Optional[int]		       =   costs[i - 1][j] + delete_cost
  				UpperCAmelCase__:  int		       =   f"D{source_seq[i - 1]:c}"
  
  			if costs[i][j - 1] + insert_cost < costs[i][j]:
  				UpperCAmelCase__:  Any		       =   costs[i][j - 1] + insert_cost
  				UpperCAmelCase__:  Tuple		       =   f"I{destination_seq[j - 1]:c}"
  
  	return costs, ops
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	if i == 0 and j == 0:
  		return []
  	else:
  		if ops[i][j][0] == "C" or ops[i][j][0] == "R":
  			UpperCAmelCase__:  Union[str, Any]		       =   assemble_transformation(SCREAMING_SNAKE_CASE  ,i - 1  ,j - 1			)
  			seq.append(ops[i][j]			)
  			return seq
  		elif ops[i][j][0] == "D":
  			UpperCAmelCase__:  Optional[Any]		       =   assemble_transformation(SCREAMING_SNAKE_CASE  ,i - 1  ,SCREAMING_SNAKE_CASE			)
  			seq.append(ops[i][j]			)
  			return seq
  		else:
  			UpperCAmelCase__:  Dict		       =   assemble_transformation(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,j - 1			)
  			seq.append(ops[i][j]			)
  			return seq
  
  
  if __name__ == "__main__":
  					_lowerCAmelCase   ,  _lowerCAmelCase     :			Dict    =compute_transform_tables("""Python""", """Algorithms""", -1, 1, 2, 2)
  
  					_lowerCAmelCase     :			List[Any]    =len(operations)
  					_lowerCAmelCase     :			Optional[int]    =len(operations[0])
  					_lowerCAmelCase     :			Dict    =assemble_transformation(operations, m - 1, n - 1)
  
  					_lowerCAmelCase     :			int    =list("""Python""")
  					_lowerCAmelCase     :			Optional[int]    =0
  					_lowerCAmelCase     :			List[Any]    =0
  
  					with open("""min_cost.txt""", """w""") as file:
  										for op in sequence:
  															print("""""".join(string))
  
  															if op[0] == "C":
  																				file.write("""%-16s""" % """Copy %c""" % op[1])
  																				file.write("""\t\t\t""" + """""".join(string))
  																				file.write("""\r\n""")
  
  																				cost -= 1
  															elif op[0] == "R":
  																				_lowerCAmelCase     :			Tuple    =op[2]
  
  																				file.write("""%-16s""" % ("""Replace %c""" % op[1] + """ with """ + str(op[2])))
  																				file.write("""\t\t""" + """""".join(string))
  																				file.write("""\r\n""")
  
  																				cost += 1
  															elif op[0] == "D":
  																				string.pop(i)
  
  																				file.write("""%-16s""" % """Delete %c""" % op[1])
  																				file.write("""\t\t\t""" + """""".join(string))
  																				file.write("""\r\n""")
  
  																				cost += 2
  															else:
  																				string.insert(i, op[1])
  
  																				file.write("""%-16s""" % """Insert %c""" % op[1])
  																				file.write("""\t\t\t""" + """""".join(string))
  																				file.write("""\r\n""")
  
  																				cost += 2
  
  															i += 1
  
  										print("""""".join(string))
  										print("""Cost: """, cost)
  
  										file.write("""\r\nMinimum cost: """ + str(cost))