





"""simple docstring"""





import copy
import os
from typing import Union

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


_UpperCamelCase					      =   logging.get_logger(__name__)

_UpperCamelCase					      =   {
    'BAAI/AltCLIP': 'https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json',
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}
class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							Optional[int]									=		"""altclip_text_model"""




				def __init__(  self	:Tuple    ,     __lowercase	:Dict=25_0002    ,     __lowercase	:Union[str, Any]=1024    ,     __lowercase	:Optional[int]=24    ,     __lowercase	:List[Any]=16    ,     __lowercase	:int=4096    ,     __lowercase	:Union[str, Any]="gelu"    ,     __lowercase	:Optional[int]=0.1    ,     __lowercase	:Optional[int]=0.1    ,     __lowercase	:Union[str, Any]=514    ,     __lowercase	:Dict=1    ,     __lowercase	:int=0.02    ,     __lowercase	:Optional[int]=0.02    ,     __lowercase	:Optional[Any]=1e-0_5    ,     __lowercase	:str=1    ,     __lowercase	:Tuple=0    ,     __lowercase	:List[str]=2    ,     __lowercase	:str="absolute"    ,     __lowercase	:Tuple=True    ,     __lowercase	:Optional[int]=768    ,     **__lowercase	:Union[str, Any]    ,     ):
											super().__init__(pad_token_id=__lowercase    ,     bos_token_id=__lowercase    ,     eos_token_id=__lowercase    ,     **__lowercase      )

											__lowerCamelCase   :   int       =vocab_size
											__lowerCamelCase   :   int       =hidden_size
											__lowerCamelCase   :   Dict       =num_hidden_layers
											__lowerCamelCase   :   Optional[int]       =num_attention_heads
											__lowerCamelCase   :   str       =hidden_act
											__lowerCamelCase   :   Optional[Any]       =intermediate_size
											__lowerCamelCase   :   Tuple       =hidden_dropout_prob
											__lowerCamelCase   :   str       =attention_probs_dropout_prob
											__lowerCamelCase   :   Optional[int]       =max_position_embeddings
											__lowerCamelCase   :   Dict       =type_vocab_size
											__lowerCamelCase   :   Tuple       =initializer_range
											__lowerCamelCase   :   int       =initializer_factor
											__lowerCamelCase   :   List[Any]       =layer_norm_eps
											__lowerCamelCase   :   List[Any]       =position_embedding_type
											__lowerCamelCase   :   str       =use_cache
											__lowerCamelCase   :   str       =project_dim

class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							List[Any]									=		"""altclip_vision_model"""




				def __init__(  self	:Dict    ,     __lowercase	:Optional[int]=768    ,     __lowercase	:Dict=3072    ,     __lowercase	:Dict=512    ,     __lowercase	:Optional[Any]=12    ,     __lowercase	:Tuple=12    ,     __lowercase	:Optional[int]=3    ,     __lowercase	:Any=224    ,     __lowercase	:List[Any]=32    ,     __lowercase	:Optional[Any]="quick_gelu"    ,     __lowercase	:Optional[int]=1e-5    ,     __lowercase	:List[Any]=0.0    ,     __lowercase	:Dict=0.02    ,     __lowercase	:Optional[int]=1.0    ,     **__lowercase	:Dict    ,     ):
											super().__init__(**__lowercase      )

											__lowerCamelCase   :   Tuple       =hidden_size
											__lowerCamelCase   :   List[Any]       =intermediate_size
											__lowerCamelCase   :   int       =projection_dim
											__lowerCamelCase   :   Union[str, Any]       =num_hidden_layers
											__lowerCamelCase   :   Optional[int]       =num_attention_heads
											__lowerCamelCase   :   Tuple       =num_channels
											__lowerCamelCase   :   str       =patch_size
											__lowerCamelCase   :   str       =image_size
											__lowerCamelCase   :   str       =initializer_range
											__lowerCamelCase   :   Optional[int]       =initializer_factor
											__lowerCamelCase   :   int       =attention_dropout
											__lowerCamelCase   :   Dict       =layer_norm_eps
											__lowerCamelCase   :   Optional[Any]       =hidden_act




				@classmethod
				def        __lowercase	(  cls	:str    ,     __lowercase	:Union[str, os.PathLike]    ,     **__lowercase	:Dict      ):
											cls._set_token_in_kwargs(__lowercase      )

											__lowerCamelCase     ,    __lowerCamelCase   :   List[Any]       =cls.get_config_dict(__lowercase    ,     **__lowercase      )

											# get the vision config dict if we are loading from AltCLIPConfig
											if config_dict.get('''model_type'''      ) == "altclip":
																		__lowerCamelCase   :   str       =config_dict['''vision_config''']

											if "model_type" in config_dict and hasattr(cls    ,     '''model_type'''      ) and config_dict["model_type"] != cls.model_type:
																		logger.warning(
																		    f'You are using a model of type {config_dict["model_type"]} to instantiate a model of type '
																		    f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'      )

											return cls.from_dict(__lowercase    ,     **__lowercase      )

class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							Dict									=		"""altclip"""
				__snake_case :							Optional[Any]									=		True




				def __init__(  self	:Any    ,     __lowercase	:Union[str, Any]=None    ,     __lowercase	:str=None    ,     __lowercase	:Tuple=768    ,     __lowercase	:Any=2.6592    ,     **__lowercase	:Any      ):
											# If `_config_dict` exist, we use them for the backward compatibility.
											# We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
											# of confusion!).
											__lowerCamelCase   :   Union[str, Any]       =kwargs.pop('''text_config_dict'''    ,     __lowercase      )
											__lowerCamelCase   :   List[str]       =kwargs.pop('''vision_config_dict'''    ,     __lowercase      )

											super().__init__(**__lowercase      )

											# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
											# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
											# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
											if text_config_dict is not None:
																		if text_config is None:
																									__lowerCamelCase   :   Any       ={}

																		# This is the complete result when using `text_config_dict`.
																		__lowerCamelCase   :   Any       =AltCLIPTextConfig(**__lowercase      ).to_dict()

																		# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
																		for key, value in _text_config_dict.items():
																									if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
																																# If specified in `text_config_dict`
																																if key in text_config_dict:
																																							__lowerCamelCase   :   Dict       =(
																																							    f'`{key}` is found in both `text_config_dict` and `text_config` but with different values. '
																																							    f'The value `text_config_dict["{key}"]` will be used instead.'
																																							)
																																# If inferred from default argument values (just to be super careful)
																																else:
																																							__lowerCamelCase   :   Dict       =(
																																							    f'`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '
																																							    f'value `text_config["{key}"]` will be overriden.'
																																							)
																																logger.warning(__lowercase      )

            # Update all values in `text_config` with the ones in `_text_config_dict`.
																		text_config.update(_text_config_dict      )

											if vision_config_dict is not None:
																		if vision_config is None:
																									__lowerCamelCase   :   int       ={}

																		# This is the complete result when using `vision_config_dict`.
																		__lowerCamelCase   :   Dict       =AltCLIPVisionConfig(**__lowercase      ).to_dict()
																		# convert keys to string instead of integer
																		if "id2label" in _vision_config_dict:
																									__lowerCamelCase   :   Any       ={
																									    str(__lowercase      ): value for key, value in _vision_config_dict['''id2label'''].items()
																									}

																		# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
																		for key, value in _vision_config_dict.items():
																									if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
																																# If specified in `vision_config_dict`
																																if key in vision_config_dict:
																																							__lowerCamelCase   :   List[str]       =(
																																							    f'`{key}` is found in both `vision_config_dict` and `vision_config` but with different '
																																							    f'values. The value `vision_config_dict["{key}"]` will be used instead.'
																																							)
																																# If inferred from default argument values (just to be super careful)
																																else:
																																							__lowerCamelCase   :   Union[str, Any]       =(
																																							    f'`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '
																																							    f'The value `vision_config["{key}"]` will be overriden.'
																																							)
																																logger.warning(__lowercase      )

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
																		vision_config.update(_vision_config_dict      )

											if text_config is None:
																		__lowerCamelCase   :   Any       ={}
																		logger.info('''`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values.'''      )

											if vision_config is None:
																		__lowerCamelCase   :   int       ={}
																		logger.info('''`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values.'''      )

											__lowerCamelCase   :   Any       =AltCLIPTextConfig(**__lowercase      )
											__lowerCamelCase   :   Union[str, Any]       =AltCLIPVisionConfig(**__lowercase      )

											__lowerCamelCase   :   Tuple       =projection_dim
											__lowerCamelCase   :   Tuple       =logit_scale_init_value
											__lowerCamelCase   :   Tuple       =1.0




				@classmethod
				def        __lowercase	(  cls	:Union[str, Any]    ,     __lowercase	:AltCLIPTextConfig    ,     __lowercase	:AltCLIPVisionConfig    ,     **__lowercase	:List[str]      ):
											return cls(text_config=text_config.to_dict()    ,     vision_config=vision_config.to_dict()    ,     **__lowercase      )




				def        __lowercase	(  self	:List[str]      ):
											__lowerCamelCase   :   int       =copy.deepcopy(self.__dict__      )
											__lowerCamelCase   :   int       =self.text_config.to_dict()
											__lowerCamelCase   :   int       =self.vision_config.to_dict()
											__lowerCamelCase   :   Optional[int]       =self.__class__.model_type
											return output











"""simple docstring"""





from dataclasses import dataclass, field
from typing import Optional
@dataclass
class 		SCREAMING_SNAKE_CASE_				:
				"""simple docstring"""
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot/codeparrot"""							,	metadata={"""help""": """Model name or path of model to be trained."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""./"""							,	metadata={"""help""": """Save dir where model repo is cloned and models updates are saved to."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot/codeparrot-clean-train"""							,	metadata={"""help""": """Name or path of training dataset."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot/codeparrot-clean-valid"""							,	metadata={"""help""": """Name or path of validation dataset."""} )
				__snake_case :							Optional[int]									=		field(default=2							,	metadata={"""help""": """Batch size for training."""} )
				__snake_case :							Optional[int]									=		field(default=2							,	metadata={"""help""": """Batch size for evaluation."""} )
				__snake_case :							Optional[float]									=		field(default=0.1							,	metadata={"""help""": """Value of weight decay."""} )
				__snake_case :							Optional[int]									=		field(
				    default=1_00_00							,	metadata={"""help""": """Size of buffer used to shuffle streaming dataset."""} )
				__snake_case :							Optional[float]									=		field(default=2e-4							,	metadata={"""help""": """Learning rate fo training."""} )
				__snake_case :							Optional[str]									=		field(default="""cosine"""							,	metadata={"""help""": """Learning rate."""} )
				__snake_case :							Optional[int]									=		field(
				    default=7_50							,	metadata={"""help""": """Number of warmup steps in the learning rate schedule."""} )
				__snake_case :							Optional[int]									=		field(
				    default=16							,	metadata={"""help""": """Number of gradient accumulation steps."""} )
				__snake_case :							Optional[bool]									=		field(
				    default=snake_case__							,	metadata={"""help""": """Use gradient checkpointing to reduce memory footprint."""} )
				__snake_case :							Optional[int]									=		field(default=5_00_00							,	metadata={"""help""": """Maximum number of training steps."""} )
				__snake_case :							Optional[int]									=		field(
				    default=-1							,	metadata={"""help""": """Maximum number of evaluation steps. If -1 the full dataset is evaluated."""} )
				__snake_case :							Optional[int]									=		field(default=10_24							,	metadata={"""help""": """Sequence lengths used for training."""} )
				__snake_case :							Optional[int]									=		field(default=1							,	metadata={"""help""": """Training seed."""} )
				__snake_case :							Optional[int]									=		field(
				    default=10_24							,	metadata={"""help""": """Interval to save checkpoints. Measured as number of forward passes not training steps."""}							,	)
				__snake_case :							Optional[str]									=		field(
				    default=snake_case__							,	metadata={"""help""": """States path if the training should continue from a checkpoint folder."""} )
				__snake_case :							Optional[bool]									=		field(default=snake_case__							,	metadata={"""help""": """If True the data is pretokenized."""} )

@dataclass
class 		SCREAMING_SNAKE_CASE_				:
				"""simple docstring"""
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot/codeparrot"""							,	metadata={"""help""": """Model name or path of model to be evaluated."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot/codeparrot-clean-valid"""							,	metadata={"""help""": """Name or path of validation dataset."""} )
				__snake_case :							Optional[int]									=		field(default=2							,	metadata={"""help""": """Batch size used for evaluation."""} )
				__snake_case :							Optional[int]									=		field(
				    default=-1							,	metadata={"""help""": """Maximum number of evaluation steps. If -1 the full dataset is evaluated."""} )
				__snake_case :							Optional[int]									=		field(default=10_24							,	metadata={"""help""": """Length of sequences to be evaluated."""} )
				__snake_case :							Optional[int]									=		field(default=1							,	metadata={"""help""": """Random seed used for evaluation."""} )

@dataclass
class 		SCREAMING_SNAKE_CASE_				:
				"""simple docstring"""
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot/codeparrot"""							,	metadata={"""help""": """Model name or path of model to be evaluated."""} )
				__snake_case :							Optional[int]									=		field(default=snake_case__							,	metadata={"""help""": """Number of workers used for code evaluation."""} )
				__snake_case :							Optional[int]									=		field(
				    default=snake_case__							,	metadata={"""help""": """The number of human-eval tasks to run. If not included all tasks are evaluated."""}							,	)
				__snake_case :							Optional[bool]									=		field(
				    default=snake_case__							,	metadata={"""help""": """Sample from the language model's output distribution."""} )
				__snake_case :							Optional[float]									=		field(default=0.2							,	metadata={"""help""": """Sampling temperature used for generation."""} )
				__snake_case :							Optional[int]									=		field(default=2_56							,	metadata={"""help""": """Maximum number of newly generated tokens."""} )
				__snake_case :							Optional[int]									=		field(default=0							,	metadata={"""help""": """Top-k parameter used for generation."""} )
				__snake_case :							Optional[float]									=		field(default=0.95							,	metadata={"""help""": """Top-p parameter used for nucleus sampling."""} )
				__snake_case :							Optional[int]									=		field(default=10							,	metadata={"""help""": """Number of generations to run in parallel."""} )
				__snake_case :							Optional[int]									=		field(
				    default=2_00							,	metadata={"""help""": """Number of completions to generate for each sample."""} )
				__snake_case :							Optional[int]									=		field(default=1							,	metadata={"""help""": """Random seed used for evaluation."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""eval_results.json"""							,	metadata={"""help""": """Random seed used for evaluation."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""0"""							,	metadata={"""help""": """Allow `code_eval` to execute Python code on machine"""} )
				__snake_case :							Optional[int]									=		field(
				    default=-1							,	metadata={
				        """help""": (
				            """Determine which device to run the `text-generation` Pipeline on. -1 is CPU and any zero or positive"""
				            """ number corresponds to which GPU device id to run on."""
				        )
				    }							,	)

@dataclass
class 		SCREAMING_SNAKE_CASE_				:
				"""simple docstring"""
				__snake_case :							Optional[int]									=		field(
				    default=snake_case__							,	metadata={
				        """help""": """The number of CPU cores to use for parallel preprocessing. Default uses the maximum available."""
				    }							,	)
				__snake_case :							Optional[str]									=		field(
				    default="""transformersbook/codeparrot"""							,	metadata={"""help""": """Folder or name of dataset to process."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot-clean"""							,	metadata={"""help""": """Folder to save processed processed dataset."""} )
				__snake_case :							Optional[int]									=		field(
				    default=10_00_00							,	metadata={"""help""": """Number of files to save per JSON output file."""} )
				__snake_case :							Optional[str]									=		field(default="""content"""							,	metadata={"""help""": """Column containing text data to process."""} )
				__snake_case :							Optional[float]									=		field(
				    default=10_00							,	metadata={"""help""": """Maximum line length in file, otherwise file is filtered."""} )
				__snake_case :							Optional[float]									=		field(
				    default=1_00							,	metadata={"""help""": """Maximum mean line length in file, otherwise file is filtered."""} )
				__snake_case :							Optional[float]									=		field(
				    default=0.25							,	metadata={"""help""": """Maximum fraction of non-alphanumeric characters, otherwise file is filtered."""} )
				__snake_case :							Optional[float]									=		field(
				    default=1.5							,	metadata={"""help""": """Minimum character token ratio for the file, otherwise file is filtered."""} )
				__snake_case :							Optional[float]									=		field(
				    default=0.7							,	metadata={"""help""": """Probability for filtering config, test and uncommon files."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot/codeparrot"""							,	metadata={"""help""": """Name or path to the tokenizer."""}							,	)
				__snake_case :							Optional[bool]									=		field(
				    default=snake_case__							,	metadata={"""help""": """If True, near-duplicate samples are removed."""} )
				__snake_case :							Optional[float]									=		field(
				    default=0.85							,	metadata={"""help""": """Jaccard threshold for near-duplicate samples."""} )

@dataclass
class 		SCREAMING_SNAKE_CASE_				:
				"""simple docstring"""
				__snake_case :							Optional[str]									=		field(
				    default="""gpt2"""							,	metadata={"""help""": """Base tokenizer to build new tokenizer from."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""transformersbook/codeparrot-train"""							,	metadata={"""help""": """Dataset to train tokenizer on."""} )
				__snake_case :							Optional[str]									=		field(default="""content"""							,	metadata={"""help""": """Column containing text data to process."""} )
				__snake_case :							Optional[int]									=		field(default=20_00_00							,	metadata={"""help""": """Number of examples to train tokenizer on."""} )
				__snake_case :							Optional[int]									=		field(
				    default=3_27_68							,	metadata={"""help""": """Number of examples to train the tokenizer on."""} )
				__snake_case :							Optional[str]									=		field(default="""codeparrot"""							,	metadata={"""help""": """Name of new tokenizer."""} )
				__snake_case :							Optional[bool]									=		field(default=snake_case__							,	metadata={"""help""": """Push saved tokenizer to the hub."""} )

@dataclass
class 		SCREAMING_SNAKE_CASE_				:
				"""simple docstring"""
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot/codeparrot"""							,	metadata={"""help""": """Name or path to the tokenizer."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot/codeparrot-clean-train"""							,	metadata={"""help""": """Name or path to the dataset to pretokenize."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""tokenized-codeparrot-train"""							,	metadata={"""help""": """Repo name of the pretokenized data."""} )
				__snake_case :							Optional[int]									=		field(default=snake_case__							,	metadata={"""help""": """Number of workers used for code evaluation."""} )

@dataclass
class 		SCREAMING_SNAKE_CASE_				:
				"""simple docstring"""
				__snake_case :							Optional[str]									=		field(
				    default="""gpt2-large"""							,	metadata={"""help""": """Configuration to use for model initialization."""} )
				__snake_case :							Optional[str]									=		field(
				    default="""codeparrot/codeparrot"""							,	metadata={"""help""": """Tokenizer attached to model."""} )
				__snake_case :							Optional[str]									=		field(default="""codeparrot"""							,	metadata={"""help""": """Name of the created model."""} )
				__snake_case :							Optional[bool]									=		field(default=snake_case__							,	metadata={"""help""": """Push saved tokenizer to the hub."""} )




