Update Space (evaluate main: e4a27243)

bertscore.py

@@ -15,6 +15,8 @@
 
 import functools
 from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import List, Optional, Union
 
 import bert_score
 import datasets
@@ -97,14 +99,42 @@ Examples:
 """
 
 
+@dataclass
+class BERTScoreConfig(evaluate.info.Config):
+
+    name: str = "default"
+
+    pos_label: Union[str, int] = 1
+    average: str = "binary"
+    lang: Optional[str] = None
+    sample_weight: Optional[List[float]] = None
+
+    lang: Optional[str] = None
+    model_type: Optional[str] = None
+    num_layers: Optional[int] = None
+    verbose: bool = False
+    idf = bool = False
+    device: Optional[str] = None
+    batch_size: int = 64
+    nthreads: int = 4
+    all_layers: bool = False
+    rescale_with_baseline: bool = False
+    baseline_path: Optional[str] = None
+    use_fast_tokenizer: bool = False
+
+
 @evaluate.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
 class BERTScore(evaluate.Metric):
-    def _info(self):
+    CONFIG_CLASS = BERTScoreConfig
+    ALLOWED_CONFIG_NAMES = ["default"]
+
+    def _info(self, config):
         return evaluate.MetricInfo(
             description=_DESCRIPTION,
             citation=_CITATION,
             homepage="https://github.com/Tiiiger/bert_score",
             inputs_description=_KWARGS_DESCRIPTION,
+            config=config,
             features=[
                 datasets.Features(
                     {
@@ -130,24 +160,12 @@ class BERTScore(evaluate.Metric):
         self,
         predictions,
         references,
-        lang=None,
-        model_type=None,
-        num_layers=None,
-        verbose=False,
-        idf=False,
-        device=None,
-        batch_size=64,
-        nthreads=4,
-        all_layers=False,
-        rescale_with_baseline=False,
-        baseline_path=None,
-        use_fast_tokenizer=False,
     ):
 
         if isinstance(references[0], str):
             references = [[ref] for ref in references]
 
-        if idf:
+        if self.config.idf:
             idf_sents = [r for ref in references for r in ref]
         else:
             idf_sents = None
@@ -156,32 +174,34 @@ class BERTScore(evaluate.Metric):
         scorer = bert_score.BERTScorer
 
         if version.parse(bert_score.__version__) >= version.parse("0.3.10"):
-            get_hash = functools.partial(get_hash, use_fast_tokenizer=use_fast_tokenizer)
-            scorer = functools.partial(scorer, use_fast_tokenizer=use_fast_tokenizer)
-        elif use_fast_tokenizer:
+            get_hash = functools.partial(get_hash, use_fast_tokenizer=self.config.use_fast_tokenizer)
+            scorer = functools.partial(scorer, use_fast_tokenizer=self.config.use_fast_tokenizer)
+        elif self.config.use_fast_tokenizer:
             raise ImportWarning(
                 "To use a fast tokenizer, the module `bert-score>=0.3.10` is required, and the current version of "
                 "`bert-score` doesn't match this condition.\n"
                 'You can install it with `pip install "bert-score>=0.3.10"`.'
             )
 
-        if model_type is None:
-            if lang is None:
+        if self.config.model_type is None:
+            if self.config.lang is None:
                 raise ValueError(
                     "Either 'lang' (e.g. 'en') or 'model_type' (e.g. 'microsoft/deberta-xlarge-mnli')"
                     " must be specified"
                 )
-            model_type = bert_score.utils.lang2model[lang.lower()]
+            model_type = bert_score.utils.lang2model[self.config.lang.lower()]
+        else:
+            model_type = self.config.model_type
 
-        if num_layers is None:
+        if self.config.num_layers is None:
             num_layers = bert_score.utils.model2layers[model_type]
 
         hashcode = get_hash(
             model=model_type,
             num_layers=num_layers,
-            idf=idf,
-            rescale_with_baseline=rescale_with_baseline,
-            use_custom_baseline=baseline_path is not None,
+            idf=self.config.idf,
+            rescale_with_baseline=self.config.rescale_with_baseline,
+            use_custom_baseline=self.config.baseline_path is not None,
         )
 
         with filter_logging_context():
@@ -189,22 +209,22 @@ class BERTScore(evaluate.Metric):
                 self.cached_bertscorer = scorer(
                     model_type=model_type,
                     num_layers=num_layers,
-                    batch_size=batch_size,
-                    nthreads=nthreads,
-                    all_layers=all_layers,
-                    idf=idf,
+                    batch_size=self.config.batch_size,
+                    nthreads=self.config.nthreads,
+                    all_layers=self.config.all_layers,
+                    idf=self.config.idf,
                     idf_sents=idf_sents,
-                    device=device,
-                    lang=lang,
-                    rescale_with_baseline=rescale_with_baseline,
-                    baseline_path=baseline_path,
+                    device=self.config.device,
+                    lang=self.config.lang,
+                    rescale_with_baseline=self.config.rescale_with_baseline,
+                    baseline_path=self.config.baseline_path,
                 )
 
         (P, R, F) = self.cached_bertscorer.score(
             cands=predictions,
             refs=references,
-            verbose=verbose,
-            batch_size=batch_size,
+            verbose=self.config.verbose,
+            batch_size=self.config.batch_size,
         )
         output_dict = {
             "precision": P.tolist(),

requirements.txt

@@ -1,2 +1,2 @@
-git+https://github.com/huggingface/evaluate@80448674f5447a9682afe051db243c4a13bfe4ff
+git+https://github.com/huggingface/evaluate@e4a2724377909fe2aeb4357e3971e5a569673b39
 bert_score