
'''simple docstring'''





import comet  # From: unbabel-comet
import torch

import datasets


UpperCAmelCase    					=   datasets.logging.get_logger(__name__)

UpperCAmelCase    					=   "\\n@inproceedings{rei-EtAl:2020:WMT,\n   author    = {Rei, Ricardo  and  Stewart, Craig  and  Farinha, Ana C  and  Lavie, Alon},\n   title     = {Unbabel\'s Participation in the WMT20 Metrics Shared Task},\n   booktitle      = {Proceedings of the Fifth Conference on Machine Translation},\n   month          = {November},\n   year           = {2020},\n   address        = {Online},\n   publisher      = {Association for Computational Linguistics},\n   pages     = {909--918},\n}\n@inproceedings{rei-etal-2020-comet,\n   title = \"{COMET}: A Neural Framework for {MT} Evaluation\",\n   author = \"Rei, Ricardo  and\n      Stewart, Craig  and\n      Farinha, Ana C  and\n      Lavie, Alon\",\n   booktitle = \"Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)\",\n   month = nov,\n   year = \"2020\",\n   address = \"Online\",\n   publisher = \"Association for Computational Linguistics\",\n   url = \"https://www.aclweb.org/anthology/2020.emnlp-main.213\",\n   pages = \"2685--2702\",\n}\n"

UpperCAmelCase    					=   "\\nCrosslingual Optimized Metric for Evaluation of Translation (COMET) is an open-source framework used to train Machine Translation metrics that achieve high levels of correlation with different types of human judgments (HTER, DA\'s or MQM).\nWith the release of the framework the authors also released fully trained models that were used to compete in the WMT20 Metrics Shared Task achieving SOTA in that years competition.\n\nSee the [README.md] file at https://unbabel.github.io/COMET/html/models.html for more information.\n"

UpperCAmelCase    					=   "\nCOMET score.\n\nArgs:\n\n`sources` (list of str): Source sentences\n`predictions` (list of str): candidate translations\n`references` (list of str): reference translations\n`cuda` (bool): If set to True, runs COMET using GPU\n`show_progress` (bool): Shows progress\n`model`: COMET model to be used. Will default to `wmt-large-da-estimator-1719` if None.\n\nReturns:\n    `samples`: List of dictionaries with `src`, `mt`, `ref` and `score`.\n    `scores`: List of scores.\n\nExamples:\n\n    >>> comet_metric = datasets.load_metric(\'comet\')\n    >>> # comet_metric = load_metric(\'comet\', \'wmt20-comet-da\')  # you can also choose which model to use\n    >>> source = [\"Dem Feuer konnte Einhalt geboten werden\", \"Schulen und Kindergärten wurden eröffnet.\"]\n    >>> hypothesis = [\"The fire could be stopped\", \"Schools and kindergartens were open\"]\n    >>> reference = [\"They were able to control the fire.\", \"Schools and kindergartens opened\"]\n    >>> results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)\n    >>> print([round(v, 2) for v in results[\"scores\"]])\n    [0.19, 0.92]\n"

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION				,_KWARGS_DESCRIPTION    )
class 						a   (				datasets.Metric    ):




	def 	__snake_case							(							self	:				List[Any]      ):
							return datasets.MetricInfo(
							    description=_DESCRIPTION,    citation=_CITATION,    homepage='''https://unbabel.github.io/COMET/html/index.html''',    inputs_description=_KWARGS_DESCRIPTION,    features=datasets.Features(
							        {
							            '''sources''': datasets.Value('''string''',    id='''sequence'''      ),
							            '''predictions''': datasets.Value('''string''',    id='''sequence'''      ),
							            '''references''': datasets.Value('''string''',    id='''sequence'''      ),
							        }      ),    codebase_urls=['''https://github.com/Unbabel/COMET'''],    reference_urls=[
							        '''https://github.com/Unbabel/COMET''',
							        '''https://www.aclweb.org/anthology/2020.emnlp-main.213/''',
							        '''http://www.statmt.org/wmt20/pdf/2020.wmt-1.101.pdf6''',
							    ],    )




	def 	__snake_case							(							self	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				Optional[Any]      ):
							if self.config_name == "default":
													snake_case       :     str =    comet.load_from_checkpoint(comet.download_model('''wmt20-comet-da'''      )      )
							else:
													snake_case       :     Any =    comet.load_from_checkpoint(comet.download_model(self.config_name      )      )




	def 	__snake_case							(							self	:				Any,    SCREAMING_SNAKE_CASE_	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				Any=None,    SCREAMING_SNAKE_CASE_	:				Any=False      ):
							if gpus is None:
													snake_case       :     Union[str, Any] =    1 if torch.cuda.is_available() else 0
							snake_case       :     Optional[Any] =    {'''src''': sources, '''mt''': predictions, '''ref''': references}
							snake_case       :     Optional[int] =    [dict(zip(lowerCAmelCase_,    lowerCAmelCase_      )      ) for t in zip(*data.values()      )]
							snake_case,					snake_case       :     Optional[Any] =    self.scorer.predict(lowerCAmelCase_,    gpus=lowerCAmelCase_,    progress_bar=lowerCAmelCase_      )
							return {"mean_score": mean_score, "scores": scores}



'''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      A (       A_							:					str       ):
						snake_case       :     List[str] =    int(A_       )
						snake_case,					snake_case,					snake_case       :     Any =    t // 3600, (t // 60) % 60, t % 60
						return F"""{h}:{m:02d}:{s:02d}""" if h != 0 else F"""{m:02d}:{s:02d}"""

def      A (       A_							:					Optional[int]    ,							A_							:					int    ,							A_							:					List[str]    ,							A_							:					Optional[int]    ,							A_							:					Optional[int]=300       ):
						# docstyle-ignore
						return F"""
    <div>
      {prefix}
      <progress value='{value}' max='{total}' style='width:{width}px; height:20px; vertical-align: middle;'></progress>
      {label}
    </div>
    """

def      A (       A_							:					Dict       ):
						snake_case       :     Tuple =    '''<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       :     List[str] =    F"""{elt:.6f}""" if isinstance(A_    ,							A_       ) else str(A_       )
																		html_code += F"""      <td>{elt}</td>\n"""
												html_code += "    </tr>\n"
						html_code += "  </tbody>\n</table><p>"
						return html_code

class 						a   :
				_snake_case		    = 5
				_snake_case		    = 0.2




				def __init__(							self	:				Union[str, Any],    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				Optional[str] = None,    SCREAMING_SNAKE_CASE_	:				bool = True,    SCREAMING_SNAKE_CASE_	:				Optional["NotebookTrainingTracker"] = None,    SCREAMING_SNAKE_CASE_	:				int = 3_00,    ):
										snake_case       :     List[Any] =    total
										snake_case       :     Union[str, Any] =    '''''' if prefix is None else prefix
										snake_case       :     List[Any] =    leave
										snake_case       :     int =    parent
										snake_case       :     List[str] =    width
										snake_case       :     Optional[int] =    None
										snake_case       :     Optional[Any] =    None
										snake_case       :     Tuple =    None




				def 	__snake_case							(							self	:				Any,    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				bool = False,    SCREAMING_SNAKE_CASE_	:				str = None      ):
										snake_case       :     List[Any] =    value
										if comment is not None:
																snake_case       :     Tuple =    comment
										if self.last_value is None:
																snake_case       :     str =    time.time()
																snake_case       :     List[str] =    value
																snake_case       :     str =    None
																snake_case       :     Dict =    self.warmup
																snake_case       :     Tuple =    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       :     Tuple =    time.time()
																snake_case       :     str =    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       :     Any =    self.elapsed_time / (value - self.start_value)
																else:
																						snake_case       :     List[str] =    None
																if value >= self.total:
																						snake_case       :     List[Any] =    self.total
																						snake_case       :     Tuple =    None
																						if not self.leave:
																												self.close()
																elif self.average_time_per_item is not None:
																						snake_case       :     Optional[int] =    self.average_time_per_item * (self.total - value)
																self.update_bar(SCREAMING_SNAKE_CASE_      )
																snake_case       :     List[str] =    value
																snake_case       :     List[Any] =    current_time
																if self.average_time_per_item is None:
																						snake_case       :     List[str] =    1
																else:
																						snake_case       :     Optional[int] =    max(int(self.update_every / self.average_time_per_item      ),    1      )




				def 	__snake_case							(							self	:				Any,    SCREAMING_SNAKE_CASE_	:				List[str],    SCREAMING_SNAKE_CASE_	:				Optional[Any]=None      ):
										snake_case       :     Optional[Any] =    ''' ''' * (len(str(self.total      )      ) - len(str(SCREAMING_SNAKE_CASE_      )      )) + str(SCREAMING_SNAKE_CASE_      )
										if self.elapsed_time is None:
																snake_case       :     int =    F"""[{spaced_value}/{self.total} : < :"""
										elif self.predicted_remaining is None:
																snake_case       :     List[str] =    F"""[{spaced_value}/{self.total} {format_time(self.elapsed_time      )}"""
										else:
																snake_case       :     Optional[int] =    (
																    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 	__snake_case							(							self	:				Optional[int]      ):
										snake_case       :     str =    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       :     Any =    disp.display(disp.HTML(self.html_code      ),    display_id=SCREAMING_SNAKE_CASE_      )
										else:
																self.output.update(disp.HTML(self.html_code      )      )




				def 	__snake_case							(							self	:				Optional[int]      ):
										if self.parent is None and self.output is not None:
																self.output.update(disp.HTML(''''''      )      )




class 						a   (				__magic_name__    ):




				def __init__(							self	:				List[str],    SCREAMING_SNAKE_CASE_	:				List[str],    SCREAMING_SNAKE_CASE_	:				Optional[int]=None      ):
										super().__init__(SCREAMING_SNAKE_CASE_      )
										snake_case       :     Tuple =    None if column_names is None else [column_names]
										snake_case       :     str =    None




				def 	__snake_case							(							self	:				Dict      ):
										snake_case       :     Tuple =    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       :     List[Any] =    disp.display(disp.HTML(self.html_code      ),    display_id=SCREAMING_SNAKE_CASE_      )
										else:
																self.output.update(disp.HTML(self.html_code      )      )




				def 	__snake_case							(							self	:				List[str],    SCREAMING_SNAKE_CASE_	:				Any      ):
										if self.inner_table is None:
																snake_case       :     Optional[Any] =    [list(values.keys()      ), list(values.values()      )]
										else:
																snake_case       :     Tuple =    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       :     int =    columns
																self.inner_table.append([values[c] for c in columns]      )




				def 	__snake_case							(							self	:				Tuple,    SCREAMING_SNAKE_CASE_	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				int=None,    SCREAMING_SNAKE_CASE_	:				str=3_00      ):
										snake_case       :     int =    NotebookProgressBar(SCREAMING_SNAKE_CASE_,    prefix=SCREAMING_SNAKE_CASE_,    parent=self,    width=SCREAMING_SNAKE_CASE_      )
										return self.child_bar




				def 	__snake_case							(							self	:				Union[str, Any]      ):
										snake_case       :     int =    None
										self.display()




class 						a   (				__magic_name__    ):




				def __init__(							self	:				Optional[Any]      ):
										snake_case       :     Dict =    None
										snake_case       :     Union[str, Any] =    None
										snake_case       :     Dict =    False




				def 	__snake_case							(							self	:				List[str],    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				str,    **SCREAMING_SNAKE_CASE_	:				List[str]      ):
										snake_case       :     str =    '''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
										snake_case       :     List[str] =    0
										snake_case       :     Dict =    0
										snake_case       :     List[Any] =    [self.first_column] + ['''Training Loss''']
										if args.evaluation_strategy != IntervalStrategy.NO:
																column_names.append('''Validation Loss'''      )
										snake_case       :     Tuple =    NotebookTrainingTracker(state.max_steps,    SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				Tuple,    SCREAMING_SNAKE_CASE_	:				List[Any],    SCREAMING_SNAKE_CASE_	:				Dict,    SCREAMING_SNAKE_CASE_	:				str,    **SCREAMING_SNAKE_CASE_	:				Union[str, Any]      ):
										snake_case       :     Tuple =    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       :     str =    False




				def 	__snake_case							(							self	:				Tuple,    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				Union[str, Any],    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				Tuple=None,    **SCREAMING_SNAKE_CASE_	:				Tuple      ):
										if not has_length(SCREAMING_SNAKE_CASE_      ):
																return
										if self.prediction_bar is None:
																if self.training_tracker is not None:
																						snake_case       :     Dict =    self.training_tracker.add_child(len(SCREAMING_SNAKE_CASE_      )      )
																else:
																						snake_case       :     Optional[Any] =    NotebookProgressBar(len(SCREAMING_SNAKE_CASE_      )      )
																self.prediction_bar.update(1      )
										else:
																self.prediction_bar.update(self.prediction_bar.value + 1      )




				def 	__snake_case							(							self	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				Dict,    SCREAMING_SNAKE_CASE_	:				Union[str, Any],    **SCREAMING_SNAKE_CASE_	:				List[Any]      ):
										if self.prediction_bar is not None:
																self.prediction_bar.close()
										snake_case       :     Optional[int] =    None




				def 	__snake_case							(							self	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				List[str],    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				Optional[int]=None,    **SCREAMING_SNAKE_CASE_	:				Union[str, Any]      ):
										# Only for when there is no evaluation
										if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
																snake_case       :     List[str] =    {'''Training Loss''': logs['''loss''']}
																# First column is necessarily Step sine we're not in epoch eval strategy
																snake_case       :     List[Any] =    state.global_step
																self.training_tracker.write_line(SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				Any,    SCREAMING_SNAKE_CASE_	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				List[str],    SCREAMING_SNAKE_CASE_	:				List[str],    SCREAMING_SNAKE_CASE_	:				Optional[Any]=None,    **SCREAMING_SNAKE_CASE_	:				Any      ):
										if self.training_tracker is not None:
																snake_case       :     List[Any] =    {'''Training Loss''': '''No log''', '''Validation Loss''': '''No log'''}
																for log in reversed(state.log_history      ):
																						if "loss" in log:
																												snake_case       :     Union[str, Any] =    log['''loss''']
																												break

																if self.first_column == "Epoch":
																						snake_case       :     Optional[int] =    int(state.epoch      )
																else:
																						snake_case       :     Optional[int] =    state.global_step
																snake_case       :     Optional[int] =    '''eval'''
																for k in metrics:
																						if k.endswith('''_loss'''      ):
																												snake_case       :     str =    re.sub(R'''\_loss$''',    '''''',    SCREAMING_SNAKE_CASE_      )
																snake_case       :     str =    metrics.pop('''total_flos''',    SCREAMING_SNAKE_CASE_      )
																snake_case       :     int =    metrics.pop('''epoch''',    SCREAMING_SNAKE_CASE_      )
																snake_case       :     List[str] =    metrics.pop(F"""{metric_key_prefix}_runtime""",    SCREAMING_SNAKE_CASE_      )
																snake_case       :     Union[str, Any] =    metrics.pop(F"""{metric_key_prefix}_samples_per_second""",    SCREAMING_SNAKE_CASE_      )
																snake_case       :     Any =    metrics.pop(F"""{metric_key_prefix}_steps_per_second""",    SCREAMING_SNAKE_CASE_      )
																snake_case       :     Dict =    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       :     Optional[int] =    v
																						else:
																												snake_case       :     int =    k.split('''_'''      )
																												snake_case       :     Any =    ''' '''.join([part.capitalize() for part in splits[1:]]      )
																												snake_case       :     Tuple =    v
																self.training_tracker.write_line(SCREAMING_SNAKE_CASE_      )
																self.training_tracker.remove_child()
																snake_case       :     Any =    None
																# Evaluation takes a long time so we should force the next update.
																snake_case       :     Optional[int] =    True




				def 	__snake_case							(							self	:				List[str],    SCREAMING_SNAKE_CASE_	:				List[Any],    SCREAMING_SNAKE_CASE_	:				List[str],    SCREAMING_SNAKE_CASE_	:				Dict,    **SCREAMING_SNAKE_CASE_	:				str      ):
										self.training_tracker.update(
										    state.global_step,    comment=F"""Epoch {int(state.epoch      )}/{state.num_train_epochs}""",    force_update=SCREAMING_SNAKE_CASE_      )
										snake_case       :     Tuple =    None

