



"""simple docstring"""






import copy
import os
from typing import TYPE_CHECKING, List, Union


if TYPE_CHECKING:
   pass

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


lowerCAmelCase__        =				logging.get_logger(__name__)

lowerCAmelCase__        =				{
    '''kakaobrain/align-base''': '''https://huggingface.co/kakaobrain/align-base/resolve/main/config.json''',
}






class        __snake_case       (	_lowercase):
  snake_case__				:   Dict  			=						"align_text_model"




  def __init__( self     :						List[str]						,					__lowerCAmelCase     :						Union[str, Any]=3_0_5_2_2						,					__lowerCAmelCase     :						Optional[int]=7_6_8						,					__lowerCAmelCase     :						Dict=1_2						,					__lowerCAmelCase     :						Optional[int]=1_2						,					__lowerCAmelCase     :						Optional[Any]=3_0_7_2						,					__lowerCAmelCase     :						str="gelu"						,					__lowerCAmelCase     :						Union[str, Any]=0.1						,					__lowerCAmelCase     :						int=0.1						,					__lowerCAmelCase     :						Any=5_1_2						,					__lowerCAmelCase     :						Tuple=2						,					__lowerCAmelCase     :						Any=0.02						,					__lowerCAmelCase     :						List[str]=1E-12						,					__lowerCAmelCase     :						Union[str, Any]=0						,					__lowerCAmelCase     :						Optional[int]="absolute"						,					__lowerCAmelCase     :						Optional[Any]=True						,					**__lowerCAmelCase     :						Any						,					):






         """simple docstring"""






         super().__init__(**__lowerCAmelCase		)

         _lowerCamelCase						:				Tuple    			= vocab_size
         _lowerCamelCase						:				List[str]    			= hidden_size
         _lowerCamelCase						:				str    			= num_hidden_layers
         _lowerCamelCase						:				Union[str, Any]    			= num_attention_heads
         _lowerCamelCase						:				Dict    			= hidden_act
         _lowerCamelCase						:				Tuple    			= intermediate_size
         _lowerCamelCase						:				List[Any]    			= hidden_dropout_prob
         _lowerCamelCase						:				Tuple    			= attention_probs_dropout_prob
         _lowerCamelCase						:				int    			= max_position_embeddings
         _lowerCamelCase						:				Optional[Any]    			= type_vocab_size
         _lowerCamelCase						:				Any    			= initializer_range
         _lowerCamelCase						:				List[str]    			= layer_norm_eps
         _lowerCamelCase						:				List[Any]    			= position_embedding_type
         _lowerCamelCase						:				Union[str, Any]    			= use_cache
         _lowerCamelCase						:				Any    			= pad_token_id




  @classmethod
  def 						SCREAMING_SNAKE_CASE				( cls     :						List[Any]						,					__lowerCAmelCase     :						Union[str, os.PathLike]						,					**__lowerCAmelCase     :						Optional[Any]		):






         """simple docstring"""






         cls._set_token_in_kwargs(__lowerCAmelCase		)

         _lowerCamelCase			,    _lowerCamelCase						:				List[str]    			= cls.get_config_dict(__lowerCAmelCase						,					**__lowerCAmelCase		)

         # get the text config dict if we are loading from AlignConfig
         if config_dict.get('''model_type'''		) == "align":
                _lowerCamelCase						:				int    			= config_dict['''text_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(__lowerCAmelCase						,					**__lowerCAmelCase		)






class        __snake_case       (	_lowercase):
  snake_case__				:   Optional[Any]  			=						"align_vision_model"




  def __init__( self     :						int						,					__lowerCAmelCase     :						int = 3						,					__lowerCAmelCase     :						int = 6_0_0						,					__lowerCAmelCase     :						float = 2.0						,					__lowerCAmelCase     :						float = 3.1						,					__lowerCAmelCase     :						int = 8						,					__lowerCAmelCase     :						List[int] = [3, 3, 5, 3, 5, 5, 3]						,					__lowerCAmelCase     :						List[int] = [3_2, 1_6, 2_4, 4_0, 8_0, 1_1_2, 1_9_2]						,					__lowerCAmelCase     :						List[int] = [1_6, 2_4, 4_0, 8_0, 1_1_2, 1_9_2, 3_2_0]						,					__lowerCAmelCase     :						List[int] = []						,					__lowerCAmelCase     :						List[int] = [1, 2, 2, 2, 1, 2, 1]						,					__lowerCAmelCase     :						List[int] = [1, 2, 2, 3, 3, 4, 1]						,					__lowerCAmelCase     :						List[int] = [1, 6, 6, 6, 6, 6, 6]						,					__lowerCAmelCase     :						float = 0.25						,					__lowerCAmelCase     :						str = "swish"						,					__lowerCAmelCase     :						int = 2_5_6_0						,					__lowerCAmelCase     :						str = "mean"						,					__lowerCAmelCase     :						float = 0.02						,					__lowerCAmelCase     :						float = 0.0_01						,					__lowerCAmelCase     :						float = 0.99						,					__lowerCAmelCase     :						float = 0.2						,					**__lowerCAmelCase     :						List[str]						,					):






         """simple docstring"""






         super().__init__(**__lowerCAmelCase		)

         _lowerCamelCase						:				Optional[int]    			= num_channels
         _lowerCamelCase						:				str    			= image_size
         _lowerCamelCase						:				int    			= width_coefficient
         _lowerCamelCase						:				str    			= depth_coefficient
         _lowerCamelCase						:				int    			= depth_divisor
         _lowerCamelCase						:				Union[str, Any]    			= kernel_sizes
         _lowerCamelCase						:				Optional[Any]    			= in_channels
         _lowerCamelCase						:				Optional[Any]    			= out_channels
         _lowerCamelCase						:				List[Any]    			= depthwise_padding
         _lowerCamelCase						:				str    			= strides
         _lowerCamelCase						:				List[str]    			= num_block_repeats
         _lowerCamelCase						:				List[str]    			= expand_ratios
         _lowerCamelCase						:				Any    			= squeeze_expansion_ratio
         _lowerCamelCase						:				Any    			= hidden_act
         _lowerCamelCase						:				List[Any]    			= hidden_dim
         _lowerCamelCase						:				Dict    			= pooling_type
         _lowerCamelCase						:				Tuple    			= initializer_range
         _lowerCamelCase						:				Optional[int]    			= batch_norm_eps
         _lowerCamelCase						:				Dict    			= batch_norm_momentum
         _lowerCamelCase						:				List[Any]    			= drop_connect_rate
         _lowerCamelCase						:				int    			= sum(__lowerCAmelCase		) * 4




  @classmethod
  def 						SCREAMING_SNAKE_CASE				( cls     :						str						,					__lowerCAmelCase     :						Union[str, os.PathLike]						,					**__lowerCAmelCase     :						Tuple		):






         """simple docstring"""






         cls._set_token_in_kwargs(__lowerCAmelCase		)

         _lowerCamelCase			,    _lowerCamelCase						:				Dict    			= cls.get_config_dict(__lowerCAmelCase						,					**__lowerCAmelCase		)

         # get the vision config dict if we are loading from AlignConfig
         if config_dict.get('''model_type'''		) == "align":
                _lowerCamelCase						:				Dict    			= 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(__lowerCAmelCase						,					**__lowerCAmelCase		)






class        __snake_case       (	_lowercase):
  snake_case__				:   Tuple  			=						"align"
  snake_case__				:   List[str]  			=						True




  def __init__( self     :						Union[str, Any]						,					__lowerCAmelCase     :						Union[str, Any]=None						,					__lowerCAmelCase     :						Optional[int]=None						,					__lowerCAmelCase     :						Union[str, Any]=6_4_0						,					__lowerCAmelCase     :						int=1.0						,					__lowerCAmelCase     :						List[str]=0.02						,					**__lowerCAmelCase     :						Optional[Any]						,					):






         """simple docstring"""






         super().__init__(**__lowerCAmelCase		)

         if text_config is None:
                _lowerCamelCase						:				Optional[Any]    			= {}
                logger.info('''text_config is None. Initializing the AlignTextConfig with default values.'''		)

         if vision_config is None:
                _lowerCamelCase						:				List[str]    			= {}
                logger.info('''vision_config is None. Initializing the AlignVisionConfig with default values.'''		)

         _lowerCamelCase						:				List[str]    			= AlignTextConfig(**__lowerCAmelCase		)
         _lowerCamelCase						:				Any    			= AlignVisionConfig(**__lowerCAmelCase		)

         _lowerCamelCase						:				Any    			= projection_dim
         _lowerCamelCase						:				Any    			= temperature_init_value
         _lowerCamelCase						:				Any    			= initializer_range




  @classmethod
  def 						SCREAMING_SNAKE_CASE				( cls     :						Optional[Any]						,					__lowerCAmelCase     :						AlignTextConfig						,					__lowerCAmelCase     :						AlignVisionConfig						,					**__lowerCAmelCase     :						Optional[int]		):






         """simple docstring"""






         return cls(text_config=text_config.to_dict()						,					vision_config=vision_config.to_dict()						,					**__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE				( self     :						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:				Optional[int]    			= copy.deepcopy(self.__dict__		)
         _lowerCamelCase						:				List[str]    			= self.text_config.to_dict()
         _lowerCamelCase						:				Tuple    			= self.vision_config.to_dict()
         _lowerCamelCase						:				Union[str, Any]    			= self.__class__.model_type
         return output









from sklearn.metrics import fa_score

import datasets


A    :					Any =      '''
The F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:
F1 = 2 * (precision * recall) / (precision + recall)
'''


A    :					List[Any] =      '''
Args:
    predictions (`list` of `int`): Predicted labels.
    references (`list` of `int`): Ground truth labels.
    labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.
    pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.
    average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `\'binary\'`.

        - \'binary\': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.
        - \'micro\': Calculate metrics globally by counting the total true positives, false negatives and false positives.
        - \'macro\': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.
        - \'weighted\': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `\'macro\'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.
        - \'samples\': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).
    sample_weight (`list` of `float`): Sample weights Defaults to None.

Returns:
    f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.

Examples:

    Example 1-A simple binary example
        >>> f1_metric = datasets.load_metric("f1")
        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])
        >>> print(results)
        {\'f1\': 0.5}

    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.
        >>> f1_metric = datasets.load_metric("f1")
        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)
        >>> print(round(results[\'f1\'], 2))
        0.67

    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.
        >>> f1_metric = datasets.load_metric("f1")
        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])
        >>> print(round(results[\'f1\'], 2))
        0.35

    Example 4-A multiclass example, with different values for the `average` input.
        >>> predictions = [0, 2, 1, 0, 0, 1]
        >>> references = [0, 1, 2, 0, 1, 2]
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="macro")
        >>> print(round(results[\'f1\'], 2))
        0.27
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")
        >>> print(round(results[\'f1\'], 2))
        0.33
        >>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")
        >>> print(round(results[\'f1\'], 2))
        0.27
        >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)
        >>> print(results)
        {\'f1\': array([0.8, 0. , 0. ])}
'''


A    :					List[Any] =      '''
@article{scikit-learn,
    title={Scikit-learn: Machine Learning in {P}ython},
    author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
           and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
           and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
           Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
    journal={Journal of Machine Learning Research},
    volume={12},
    pages={2825--2830},
    year={2011}
}
'''


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   ,     _KWARGS_DESCRIPTION    )
class   A			(datasets.Metric    ):
			'''simple docstring'''




			def    a_       (			self   :    Optional[int]   )	->	List[Any]:







					"""simple docstring"""






					return datasets.MetricInfo(
					    description=_DESCRIPTION							,	citation=_CITATION							,	inputs_description=_KWARGS_DESCRIPTION							,	features=datasets.Features(
					        {
					            """predictions""": datasets.Sequence(datasets.Value("""int32"""   )   ),
					            """references""": datasets.Sequence(datasets.Value("""int32"""   )   ),
					        }
					        if self.config_name == """multilabel"""
					        else {
					            """predictions""": datasets.Value("""int32"""   ),
					            """references""": datasets.Value("""int32"""   ),
					        }   )							,	reference_urls=["""https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html"""]							,	)







			def    a_       (			self   :    Any							,	__lowerCAmelCase   :    Tuple							,	__lowerCAmelCase   :    Union[str, Any]							,	__lowerCAmelCase   :    Dict=None							,	__lowerCAmelCase   :    List[str]=1							,	__lowerCAmelCase   :    Any="binary"							,	__lowerCAmelCase   :    Optional[int]=None   )	->	List[Any]:







					"""simple docstring"""






					A__        =   fa_score(
					    __lowerCAmelCase							,	__lowerCAmelCase							,	labels=__lowerCAmelCase							,	pos_label=__lowerCAmelCase							,	average=__lowerCAmelCase							,	sample_weight=__lowerCAmelCase   )
					return {"f1": float(__lowerCAmelCase   ) if score.size == 1 else score}



