




'''simple docstring'''



from sklearn.metrics import fa_score

import datasets


UpperCAmelCase_							:	Dict	     =		'''
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)
'''


UpperCAmelCase_							:	Union[str, 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. ])}
'''


UpperCAmelCase_							:	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      lowerCAmelCase (			datasets.Metric):


       def    lowerCAmelCase   ( self	)   ->	List[str]:



            '''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    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None     ,	__SCREAMING_SNAKE_CASE=1     ,	__SCREAMING_SNAKE_CASE="binary"     ,	__SCREAMING_SNAKE_CASE=None	)   ->	List[str]:



            '''simple docstring'''




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












'''simple docstring'''



import re
import time
from typing import Optional

import IPython.display as disp

from ..trainer_callback import TrainerCallback
from ..trainer_utils import IntervalStrategy, has_length







def       _UpperCamelCase			(_lowerCamelCase				:  Tuple						)-> List[str]:




     '''simple docstring'''





     __snake_case            =	int(_lowerCamelCase						)
     __snake_case       ,     __snake_case       ,     __snake_case            =	t // 36_00, (t // 60) % 60, t % 60
     return f'''{h}:{m:02d}:{s:02d}''' if h != 0 else f'''{m:02d}:{s:02d}'''







def       _UpperCamelCase			(_lowerCamelCase				:  Any ,						_lowerCamelCase				:  Union[str, Any] ,						_lowerCamelCase				:  str ,						_lowerCamelCase				:  int ,						_lowerCamelCase				:  List[Any]=3_00						)-> int:




     '''simple docstring'''





     return f'''
    <div>
      {prefix}
      <progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>
      {label}
    </div>
    '''







def       _UpperCamelCase			(_lowerCamelCase				:  int						)-> List[Any]:




     '''simple docstring'''





     __snake_case            =	'''<table border="1" class="dataframe">\n'''
     html_code += """  <thead>\n <tr style="text-align: left;">\n"""
     for i in items[0]:
          html_code += f'''      <th>{i}</th>\n'''
     html_code += "    </tr>\n  </thead>\n  <tbody>\n"
     for line in items[1:]:
          html_code += "    <tr>\n"
          for elt in line:
               __snake_case            =	f'''{elt:.6f}''' if isinstance(_lowerCamelCase ,						_lowerCamelCase						) else str(_lowerCamelCase						)
               html_code += f'''      <td>{elt}</td>\n'''
          html_code += "    </tr>\n"
     html_code += "  </tbody>\n</table><p>"
     return html_code





class      lowerCAmelCase :
       __lowercase	:   str										=      5
       __lowercase	:   Optional[Any]										=      0.2


       def __init__( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = 300     ,	)   ->	List[Any]:



            '''simple docstring'''




            __snake_case            =	total
            __snake_case            =	'''''' if prefix is None else prefix
            __snake_case            =	leave
            __snake_case            =	parent
            __snake_case            =	width
            __snake_case            =	None
            __snake_case            =	None
            __snake_case            =	None


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE = False     ,	__SCREAMING_SNAKE_CASE = None	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	value
            if comment is not None:
                 __snake_case            =	comment
            if self.last_value is None:
                 __snake_case            =	__snake_case            =	time.time()
                 __snake_case            =	__snake_case            =	value
                 __snake_case            =	__snake_case            =	None
                 __snake_case            =	self.warmup
                 __snake_case            =	1
                 self.update_bar(__SCREAMING_SNAKE_CASE	)
            elif value <= self.last_value and not force_update:
                 return
            elif force_update or self.first_calls > 0 or value >= min(self.last_value + self.wait_for     ,	self.total	):
                 if self.first_calls > 0:
                      self.first_calls -= 1
                 __snake_case            =	time.time()
                 __snake_case            =	current_time - self.start_time
                 # We could have value = self.start_value if the update is called twixe with the same start value.
                 if value > self.start_value:
                      __snake_case            =	self.elapsed_time / (value - self.start_value)
                 else:
                      __snake_case            =	None
                 if value >= self.total:
                      __snake_case            =	self.total
                      __snake_case            =	None
                      if not self.leave:
                           self.close()
                 elif self.average_time_per_item is not None:
                      __snake_case            =	self.average_time_per_item * (self.total - value)
                 self.update_bar(__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	value
                 __snake_case            =	current_time
                 if self.average_time_per_item is None:
                      __snake_case            =	1
                 else:
                      __snake_case            =	max(int(self.update_every / self.average_time_per_item	)     ,	1	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None	)   ->	List[str]:



            '''simple docstring'''




            __snake_case            =	''' ''' * (len(str(self.total	)	) - len(str(__SCREAMING_SNAKE_CASE	)	)) + str(__SCREAMING_SNAKE_CASE	)
            if self.elapsed_time is None:
                 __snake_case            =	F'''[{spaced_value}/{self.total} : < :'''
            elif self.predicted_remaining is None:
                 __snake_case            =	F'''[{spaced_value}/{self.total} {format_time(self.elapsed_time	)}'''
            else:
                 __snake_case            =	(
                     F'''[{spaced_value}/{self.total} {format_time(self.elapsed_time	)} <'''
                     F''' {format_time(self.predicted_remaining	)}'''
                 )
                 self.label += F''', {1/self.average_time_per_item:.2f} it/s'''
            self.label += "]" if self.comment is None or len(self.comment	) == 0 else F''', {self.comment}]'''
            self.display()


       def    lowerCAmelCase   ( self	)   ->	List[Any]:



            '''simple docstring'''




            __snake_case            =	html_progress_bar(self.value     ,	self.total     ,	self.prefix     ,	self.label     ,	self.width	)
            if self.parent is not None:
                 # If this is a child bar, the parent will take care of the display.
                 self.parent.display()
                 return
            if self.output is None:
                 __snake_case            =	disp.display(disp.HTML(self.html_code	)     ,	display_id=__SCREAMING_SNAKE_CASE	)
            else:
                 self.output.update(disp.HTML(self.html_code	)	)




       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            if self.parent is None and self.output is not None:
                 self.output.update(disp.HTML(''''''	)	)





class      lowerCAmelCase (			__lowerCAmelCase):


       def __init__( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None	)   ->	Any:



            '''simple docstring'''




            super().__init__(__SCREAMING_SNAKE_CASE	)
            __snake_case            =	None if column_names is None else [column_names]
            __snake_case            =	None


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	html_progress_bar(self.value     ,	self.total     ,	self.prefix     ,	self.label     ,	self.width	)
            if self.inner_table is not None:
                 self.html_code += text_to_html_table(self.inner_table	)
            if self.child_bar is not None:
                 self.html_code += self.child_bar.html_code
            if self.output is None:
                 __snake_case            =	disp.display(disp.HTML(self.html_code	)     ,	display_id=__SCREAMING_SNAKE_CASE	)
            else:
                 self.output.update(disp.HTML(self.html_code	)	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE	)   ->	Dict:



            '''simple docstring'''




            if self.inner_table is None:
                 __snake_case            =	[list(values.keys()	), list(values.values()	)]
            else:
                 __snake_case            =	self.inner_table[0]
                 if len(self.inner_table	) == 1:
                      # We give a chance to update the column names at the first iteration
                      for key in values.keys():
                           if key not in columns:
                                columns.append(__SCREAMING_SNAKE_CASE	)
                      __snake_case            =	columns
                 self.inner_table.append([values[c] for c in columns]	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None     ,	__SCREAMING_SNAKE_CASE=300	)   ->	List[str]:



            '''simple docstring'''




            __snake_case            =	NotebookProgressBar(__SCREAMING_SNAKE_CASE     ,	prefix=__SCREAMING_SNAKE_CASE     ,	parent=self     ,	width=__SCREAMING_SNAKE_CASE	)
            return self.child_bar




       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	None
            self.display()





class      lowerCAmelCase (			__lowerCAmelCase):


       def __init__( self	)   ->	str:



            '''simple docstring'''




            __snake_case            =	None
            __snake_case            =	None
            __snake_case            =	False


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	'''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
            __snake_case            =	0
            __snake_case            =	0
            __snake_case            =	[self.first_column] + ['''Training Loss''']
            if args.evaluation_strategy != IntervalStrategy.NO:
                 column_names.append('''Validation Loss'''	)
            __snake_case            =	NotebookTrainingTracker(state.max_steps     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)   ->	List[Any]:



            '''simple docstring'''




            __snake_case            =	int(state.epoch	) if int(state.epoch	) == state.epoch else F'''{state.epoch:.2f}'''
            self.training_tracker.update(
                state.global_step + 1     ,	comment=F'''Epoch {epoch}/{state.num_train_epochs}'''     ,	force_update=self._force_next_update     ,	)
            __snake_case            =	False


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None     ,	**__SCREAMING_SNAKE_CASE	)   ->	Optional[int]:



            '''simple docstring'''




            if not has_length(__SCREAMING_SNAKE_CASE	):
                 return
            if self.prediction_bar is None:
                 if self.training_tracker is not None:
                      __snake_case            =	self.training_tracker.add_child(len(__SCREAMING_SNAKE_CASE	)	)
                 else:
                      __snake_case            =	NotebookProgressBar(len(__SCREAMING_SNAKE_CASE	)	)
                 self.prediction_bar.update(1	)
            else:
                 self.prediction_bar.update(self.prediction_bar.value + 1	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)   ->	Optional[int]:



            '''simple docstring'''




            if self.prediction_bar is not None:
                 self.prediction_bar.close()
            __snake_case            =	None


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None     ,	**__SCREAMING_SNAKE_CASE	)   ->	List[Any]:



            '''simple docstring'''




            if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
                 __snake_case            =	{'''Training Loss''': logs['''loss''']}
                 # First column is necessarily Step sine we're not in epoch eval strategy
                 __snake_case            =	state.global_step
                 self.training_tracker.write_line(__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None     ,	**__SCREAMING_SNAKE_CASE	)   ->	Optional[Any]:



            '''simple docstring'''




            if self.training_tracker is not None:
                 __snake_case            =	{'''Training Loss''': '''No log''', '''Validation Loss''': '''No log'''}
                 for log in reversed(state.log_history	):
                      if "loss" in log:
                           __snake_case            =	log['''loss''']
                           break

                 if self.first_column == "Epoch":
                      __snake_case            =	int(state.epoch	)
                 else:
                      __snake_case            =	state.global_step
                 __snake_case            =	'''eval'''
                 for k in metrics:
                      if k.endswith('''_loss'''	):
                           __snake_case            =	re.sub(r'''\_loss$'''     ,	''''''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop('''total_flos'''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop('''epoch'''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop(F'''{metric_key_prefix}_runtime'''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop(F'''{metric_key_prefix}_samples_per_second'''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop(F'''{metric_key_prefix}_steps_per_second'''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop(F'''{metric_key_prefix}_jit_compilation_time'''     ,	__SCREAMING_SNAKE_CASE	)
                 for k, v in metrics.items():
                      if k == F'''{metric_key_prefix}_loss''':
                           __snake_case            =	v
                      else:
                           __snake_case            =	k.split('''_'''	)
                           __snake_case            =	''' '''.join([part.capitalize() for part in splits[1:]]	)
                           __snake_case            =	v
                 self.training_tracker.write_line(__SCREAMING_SNAKE_CASE	)
                 self.training_tracker.remove_child()
                 __snake_case            =	None
                 # Evaluation takes a long time so we should force the next update.
                 __snake_case            =	True




       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)   ->	Optional[int]:



            '''simple docstring'''




            self.training_tracker.update(
                state.global_step     ,	comment=F'''Epoch {int(state.epoch	)}/{state.num_train_epochs}'''     ,	force_update=__SCREAMING_SNAKE_CASE	)
            __snake_case            =	None






