



from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase__     = logging.get_logger(__name__)

UpperCAmelCase__     = {
    "s-JoL/Open-Llama-V1": "https://huggingface.co/s-JoL/Open-Llama-V1/blob/main/config.json",
}







class     __lowerCAmelCase					(    A		):
			UpperCamelCase           =  '''open-llama'''



			def __init__(		self     :						Dict				,	A     :						Optional[Any]=10_00_00				,	A     :						Any=40_96				,	A     :						Dict=1_10_08				,	A     :						Optional[Any]=32				,	A     :						List[Any]=32				,	A     :						List[Any]="silu"				,	A     :						Optional[Any]=20_48				,	A     :						Dict=0.0_2				,	A     :						Union[str, Any]=1E-6				,	A     :						str=True				,	A     :						List[str]=0				,	A     :						Tuple=1				,	A     :						str=2				,	A     :						Dict=False				,	A     :						Any=True				,	A     :						Any=0.1				,	A     :						Optional[Any]=0.1				,	A     :						int=True				,	A     :						Optional[int]=True				,	A     :						Optional[int]=None				,	**A     :						Optional[Any]				,	)     ->					List[Any]:



						"""simple docstring"""






						_UpperCAmelCase	 =     vocab_size
						_UpperCAmelCase	 =     max_position_embeddings
						_UpperCAmelCase	 =     hidden_size
						_UpperCAmelCase	 =     intermediate_size
						_UpperCAmelCase	 =     num_hidden_layers
						_UpperCAmelCase	 =     num_attention_heads
						_UpperCAmelCase	 =     hidden_act
						_UpperCAmelCase	 =     initializer_range
						_UpperCAmelCase	 =     rms_norm_eps
						_UpperCAmelCase	 =     use_cache
						_UpperCAmelCase	 =     kwargs.pop(
						    'use_memorry_efficient_attention'				,	A)
						_UpperCAmelCase	 =     hidden_dropout_prob
						_UpperCAmelCase	 =     attention_dropout_prob
						_UpperCAmelCase	 =     use_stable_embedding
						_UpperCAmelCase	 =     shared_input_output_embedding
						_UpperCAmelCase	 =     rope_scaling
						self._rope_scaling_validation()

						super().__init__(
						    pad_token_id=A				,	bos_token_id=A				,	eos_token_id=A				,	tie_word_embeddings=A				,	**A				,	)



			def 					_lowerCamelCase (		self     :						Tuple)     ->					Any:



						"""simple docstring"""






						if self.rope_scaling is None:
									return

						if not isinstance(self.rope_scaling				,	A) or len(self.rope_scaling) != 2:
									raise ValueError(
									    '`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, '
									    F"got {self.rope_scaling}")
						_UpperCAmelCase	 =     self.rope_scaling.get('type'				,	A)
						_UpperCAmelCase	 =     self.rope_scaling.get('factor'				,	A)
						if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]:
									raise ValueError(
									    F"`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}")
						if rope_scaling_factor is None or not isinstance(A				,	A) or rope_scaling_factor <= 1.0:
									raise ValueError(F"`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}")





import itertools
import json
import linecache
import os
import pickle
import re
import socket
import string
from collections import Counter
from logging import getLogger
from pathlib import Path
from typing import Callable, Dict, Iterable, List

import git
import torch
from torch.utils.data import Dataset

from transformers import BartTokenizer, RagTokenizer, TaTokenizer





def 							A			(  _UpperCAmelCase       :     List[str]							,     _UpperCAmelCase       :     Optional[Any]							,     _UpperCAmelCase       :     Union[str, Any]							,     _UpperCAmelCase       :     str							,     _UpperCAmelCase       :     Dict=True							,     _UpperCAmelCase       :     Tuple="pt"					)       ->				List[Any]:







			'''simple docstring'''
			_UpperCAmelCase	 =     {'add_prefix_space': True} if isinstance(_UpperCAmelCase							,     _UpperCAmelCase					) and not line.startswith(' '					) else {}
			_UpperCAmelCase	 =     padding_side
			return tokenizer(
			    [line]							,     max_length=_UpperCAmelCase							,     padding='max_length' if pad_to_max_length else None							,     truncation=_UpperCAmelCase							,     return_tensors=_UpperCAmelCase							,     add_special_tokens=_UpperCAmelCase							,     **_UpperCAmelCase							,     )





def 							A			(  _UpperCAmelCase       :     Dict							,     _UpperCAmelCase       :     List[Any]							,     _UpperCAmelCase       :     Dict=None							,     )       ->				Tuple:







			'''simple docstring'''
			_UpperCAmelCase	 =     input_ids.ne(_UpperCAmelCase					).any(dim=0					)
			if attention_mask is None:
						return input_ids[:, keep_column_mask]
			else:
						return (input_ids[:, keep_column_mask], attention_mask[:, keep_column_mask])







class     __lowerCAmelCase					(    A		):



			def __init__(		self     :						Union[str, Any]				,	A     :						Union[str, Any]				,	A     :						Optional[int]				,	A     :						str				,	A     :						Union[str, Any]				,	A     :						int="train"				,	A     :						List[Any]=None				,	A     :						int=None				,	A     :						Tuple=None				,	A     :						str=""				,	)     ->					List[Any]:



						"""simple docstring"""






						super().__init__()
						_UpperCAmelCase	 =     Path(A).joinpath(type_path + '.source')
						_UpperCAmelCase	 =     Path(A).joinpath(type_path + '.target')
						_UpperCAmelCase	 =     self.get_char_lens(self.src_file)
						_UpperCAmelCase	 =     max_source_length
						_UpperCAmelCase	 =     max_target_length
						assert min(self.src_lens) > 0, F"found empty line in {self.src_file}"
						_UpperCAmelCase	 =     tokenizer
						_UpperCAmelCase	 =     prefix
						if n_obs is not None:
									_UpperCAmelCase	 =     self.src_lens[:n_obs]
						_UpperCAmelCase	 =     src_lang
						_UpperCAmelCase	 =     tgt_lang



			def __len__(		self     :						Tuple)     ->					Optional[int]:



						"""simple docstring"""






						return len(self.src_lens)



			def __getitem__(		self     :						Any				,	A     :						Dict)     ->					Dict[str, torch.Tensor]:



						"""simple docstring"""






						_UpperCAmelCase	 =     index + 1  # linecache starts at 1
						_UpperCAmelCase	 =     self.prefix + linecache.getline(str(self.src_file)				,	A).rstrip('\n')
						_UpperCAmelCase	 =     linecache.getline(str(self.tgt_file)				,	A).rstrip('\n')
						assert source_line, F"empty source line for index {index}"
						assert tgt_line, F"empty tgt line for index {index}"

						# Need to add eos token manually for T5
						if isinstance(self.tokenizer				,	A):
									source_line += self.tokenizer.eos_token
									tgt_line += self.tokenizer.eos_token

						# Pad source and target to the right
						_UpperCAmelCase	 =     (
						    self.tokenizer.question_encoder if isinstance(self.tokenizer				,	A) else self.tokenizer
						)
						_UpperCAmelCase	 =     self.tokenizer.generator if isinstance(self.tokenizer				,	A) else self.tokenizer

						_UpperCAmelCase	 =     encode_line(A				,	A				,	self.max_source_length				,	'right')
						_UpperCAmelCase	 =     encode_line(A				,	A				,	self.max_target_length				,	'right')

						_UpperCAmelCase	 =     source_inputs['input_ids'].squeeze()
						_UpperCAmelCase	 =     target_inputs['input_ids'].squeeze()
						_UpperCAmelCase	 =     source_inputs['attention_mask'].squeeze()
						return {
						    "input_ids": source_ids,
						    "attention_mask": src_mask,
						    "decoder_input_ids": target_ids,
						}



			@staticmethod
			def 					_lowerCamelCase (		A     :						str)     ->					Tuple:



						"""simple docstring"""






						return [len(A) for x in Path(A).open().readlines()]



			def 					_lowerCamelCase (		self     :						int				,	A     :						int)     ->					Dict[str, torch.Tensor]:



						"""simple docstring"""






						_UpperCAmelCase	 =     torch.stack([x['input_ids'] for x in batch])
						_UpperCAmelCase	 =     torch.stack([x['attention_mask'] for x in batch])
						_UpperCAmelCase	 =     torch.stack([x['decoder_input_ids'] for x in batch])
						_UpperCAmelCase	 =     (
						    self.tokenizer.generator.pad_token_id
						    if isinstance(self.tokenizer				,	A)
						    else self.tokenizer.pad_token_id
						)
						_UpperCAmelCase	 =     (
						    self.tokenizer.question_encoder.pad_token_id
						    if isinstance(self.tokenizer				,	A)
						    else self.tokenizer.pad_token_id
						)
						_UpperCAmelCase	 =     trim_batch(A				,	A)
						_UpperCAmelCase ,  _UpperCAmelCase	 =     trim_batch(A				,	A				,	attention_mask=A)
						_UpperCAmelCase	 =     {
						    'input_ids': source_ids,
						    'attention_mask': source_mask,
						    'decoder_input_ids': y,
						}
						return batch





UpperCAmelCase__     = getLogger(__name__)





def 							A			(  _UpperCAmelCase       :     List[List]					)       ->				Union[str, Any]:







			'''simple docstring'''
			return list(itertools.chain.from_iterable(_UpperCAmelCase					)					)





def 							A			(  _UpperCAmelCase       :     str					)       ->				None:







			'''simple docstring'''
			_UpperCAmelCase	 =     get_git_info()
			save_json(_UpperCAmelCase							,     os.path.join(_UpperCAmelCase							,     'git_log.json'					)					)





def 							A			(  _UpperCAmelCase       :     List[Any]							,     _UpperCAmelCase       :     List[str]							,     _UpperCAmelCase       :     Optional[int]=4							,     **_UpperCAmelCase       :     Optional[Any]					)       ->				Dict:







			'''simple docstring'''
			with open(_UpperCAmelCase							,     'w'					) as f:
						json.dump(_UpperCAmelCase							,     _UpperCAmelCase							,     indent=_UpperCAmelCase							,     **_UpperCAmelCase					)





def 							A			(  _UpperCAmelCase       :     List[str]					)       ->				Optional[Any]:







			'''simple docstring'''
			with open(_UpperCAmelCase					) as f:
						return json.load(_UpperCAmelCase					)





def 							A			(  )       ->				str:







			'''simple docstring'''
			_UpperCAmelCase	 =     git.Repo(search_parent_directories=_UpperCAmelCase					)
			_UpperCAmelCase	 =     {
			    'repo_id': str(_UpperCAmelCase					),
			    'repo_sha': str(repo.head.object.hexsha					),
			    'repo_branch': str(repo.active_branch					),
			    'hostname': str(socket.gethostname()					),
			}
			return repo_infos





def 							A			(  _UpperCAmelCase       :     Callable							,     _UpperCAmelCase       :     Iterable					)       ->				List:







			'''simple docstring'''
			return list(map(_UpperCAmelCase							,     _UpperCAmelCase					)					)





def 							A			(  _UpperCAmelCase       :     Optional[int]							,     _UpperCAmelCase       :     Union[str, Any]					)       ->				Union[str, Any]:







			'''simple docstring'''
			with open(_UpperCAmelCase							,     'wb'					) as f:
						return pickle.dump(_UpperCAmelCase							,     _UpperCAmelCase					)





def 							A			(  _UpperCAmelCase       :     int					)       ->				str:







			'''simple docstring'''

			def remove_articles(_UpperCAmelCase       :     Optional[int]					):
						return re.sub(R'\b(a|an|the)\b'							,     ' '							,     _UpperCAmelCase					)

			def white_space_fix(_UpperCAmelCase       :     Optional[int]					):
						return " ".join(text.split()					)

			def remove_punc(_UpperCAmelCase       :     Tuple					):
						_UpperCAmelCase	 =     set(string.punctuation					)
						return "".join(ch for ch in text if ch not in exclude					)

			def lower(_UpperCAmelCase       :     str					):
						return text.lower()

			return white_space_fix(remove_articles(remove_punc(lower(_UpperCAmelCase					)					)					)					)





def 							A			(  _UpperCAmelCase       :     str							,     _UpperCAmelCase       :     Any					)       ->				Union[str, Any]:







			'''simple docstring'''
			_UpperCAmelCase	 =     normalize_answer(_UpperCAmelCase					).split()
			_UpperCAmelCase	 =     normalize_answer(_UpperCAmelCase					).split()
			_UpperCAmelCase	 =     Counter(_UpperCAmelCase					) & Counter(_UpperCAmelCase					)
			_UpperCAmelCase	 =     sum(common.values()					)
			if num_same == 0:
						return 0
			_UpperCAmelCase	 =     1.0 * num_same / len(_UpperCAmelCase					)
			_UpperCAmelCase	 =     1.0 * num_same / len(_UpperCAmelCase					)
			_UpperCAmelCase	 =     (2 * precision * recall) / (precision + recall)
			return fa





def 							A			(  _UpperCAmelCase       :     Optional[Any]							,     _UpperCAmelCase       :     str					)       ->				List[Any]:







			'''simple docstring'''
			return normalize_answer(_UpperCAmelCase					) == normalize_answer(_UpperCAmelCase					)





def 							A			(  _UpperCAmelCase       :     List[str]							,     _UpperCAmelCase       :     List[str]					)       ->				Dict:







			'''simple docstring'''
			assert len(_UpperCAmelCase					) == len(_UpperCAmelCase					)
			_UpperCAmelCase	 =     0
			for hypo, pred in zip(_UpperCAmelCase							,     _UpperCAmelCase					):
						em += exact_match_score(_UpperCAmelCase							,     _UpperCAmelCase					)
			if len(_UpperCAmelCase					) > 0:
						em /= len(_UpperCAmelCase					)
			return {"em": em}





def 							A			(  _UpperCAmelCase       :     Union[str, Any]					)       ->				int:







			'''simple docstring'''
			return model_prefix.startswith('rag'					)





def 							A			(  _UpperCAmelCase       :     str							,     _UpperCAmelCase       :     Any							,     _UpperCAmelCase       :     str					)       ->				Union[str, Any]:







			'''simple docstring'''
			_UpperCAmelCase	 =     {p: p for p in extra_params}
			# T5 models don't have `dropout` param, they have `dropout_rate` instead
			_UpperCAmelCase	 =     'dropout_rate'
			for p in extra_params:
						if getattr(_UpperCAmelCase							,     _UpperCAmelCase							,     _UpperCAmelCase					):
									if not hasattr(_UpperCAmelCase							,     _UpperCAmelCase					) and not hasattr(_UpperCAmelCase							,     equivalent_param[p]					):
												logger.info('config doesn\'t have a `{}` attribute'.format(_UpperCAmelCase					)					)
												delattr(_UpperCAmelCase							,     _UpperCAmelCase					)
												continue
									_UpperCAmelCase	 =     p if hasattr(_UpperCAmelCase							,     _UpperCAmelCase					) else equivalent_param[p]
									setattr(_UpperCAmelCase							,     _UpperCAmelCase							,     getattr(_UpperCAmelCase							,     _UpperCAmelCase					)					)
									delattr(_UpperCAmelCase							,     _UpperCAmelCase					)
			return hparams, config
