Upload folder using huggingface_hub

api.py

@@ -221,9 +221,7 @@ def _source_to_dataset(
         if streaming:
             return ds_builder.as_streaming_dataset(split=split)
 
-        return ds_builder.as_dataset(
-            split=split, run_post_process=False, verification_mode="no_checks"
-        )
+        return ds_builder.as_dataset(split=split)
 
     except DatasetGenerationError as e:
         raise e.__cause__

data.py

@@ -132,8 +132,6 @@ class Dataset(datasets.GeneratorBasedBuilder):
     def as_dataset(
         self,
         split: Optional[datasets.Split] = None,
-        run_post_process=True,
-        verification_mode: Optional[Union[datasets.VerificationMode, str]] = None,
         in_memory=False,
     ) -> Union[datasets.Dataset, datasets.DatasetDict]:
         """Return a Dataset for the specified split.
@@ -141,12 +139,6 @@ class Dataset(datasets.GeneratorBasedBuilder):
         Args:
             split (`datasets.Split`):
                 Which subset of the data to return.
-            run_post_process (`bool`, defaults to `True`):
-                Whether to run post-processing dataset transforms and/or add
-                indexes.
-            verification_mode ([`VerificationMode`] or `str`, defaults to `BASIC_CHECKS`):
-                Verification mode determining the checks to run on the
-                downloaded/processed dataset information (checksums/size/splits/...).
             in_memory (`bool`, defaults to `False`):
                 Whether to copy the data in-memory.
 
@@ -170,6 +162,6 @@ class Dataset(datasets.GeneratorBasedBuilder):
         """
         return (
             super()
-            .as_dataset(split, run_post_process, verification_mode, in_memory)
+            .as_dataset(split=split, in_memory=in_memory)
             .with_transform(loads_batch)
         )

inference.py

@@ -546,17 +546,37 @@ class HFInferenceEngineBase(
                 f"'{self.torch_dtype}' was given instead."
             )
 
-        try:
-            dtype = eval(self.torch_dtype)
-        except (AttributeError, TypeError) as e:
-            raise ValueError(
-                f"Incorrect value of 'torch_dtype' was given: '{self.torch_dtype}'."
-            ) from e
+        # Security fix: Use a lookup table instead of eval() to prevent code injection
+        # This addresses CWE-95 (Eval Injection) vulnerability
+        torch_dtypes = {
+            "torch.float16": torch.float16,
+            "torch.float32": torch.float32,
+            "torch.float64": torch.float64,
+            "torch.bfloat16": torch.bfloat16,
+            "torch.float": torch.float,
+            "torch.double": torch.double,
+            "torch.half": torch.half,
+            "torch.int8": torch.int8,
+            "torch.int16": torch.int16,
+            "torch.int32": torch.int32,
+            "torch.int64": torch.int64,
+            "torch.int": torch.int,
+            "torch.long": torch.long,
+            "torch.short": torch.short,
+            "torch.uint8": torch.uint8,
+            "torch.bool": torch.bool,
+            "torch.complex64": torch.complex64,
+            "torch.complex128": torch.complex128,
+            "torch.cfloat": torch.cfloat,
+            "torch.cdouble": torch.cdouble,
+        }
+
+        dtype = torch_dtypes.get(self.torch_dtype)
 
-        if not isinstance(dtype, torch.dtype):
+        if dtype is None:
             raise ValueError(
-                f"'torch_dtype' must be an instance of 'torch.dtype', however, "
-                f"'{dtype}' is an instance of '{type(dtype)}'."
+                f"Incorrect value of 'torch_dtype' was given: '{self.torch_dtype}'. "
+                f"Supported values are: {', '.join(sorted(torch_dtypes.keys()))}"
             )
 
         return dtype
@@ -728,9 +748,9 @@ class HFAutoModelInferenceEngine(HFInferenceEngineBase):
             args["quantization_config"] = quantization_config
         elif self.use_fp16:
             if self.device == torch.device("mps"):
-                args["torch_dtype"] = torch.float16
+                args["dtype"] = torch.float16
             else:
-                args["torch_dtype"] = torch.bfloat16
+                args["dtype"] = torch.bfloat16
 
         # We do this, because in some cases, using device:auto will offload some weights to the cpu
         # (even though the model might *just* fit to a single gpu), even if there is a gpu available, and this will
@@ -937,7 +957,7 @@ class HFLlavaInferenceEngine(HFInferenceEngineBase):
 
         self.model = LlavaForConditionalGeneration.from_pretrained(
             self.model_name,
-            torch_dtype=self._get_torch_dtype(),
+            dtype=self._get_torch_dtype(),
             low_cpu_mem_usage=self.low_cpu_mem_usage,
             device_map=self.device_map,
         )
@@ -1108,7 +1128,7 @@ class HFPeftInferenceEngine(HFAutoModelInferenceEngine):
             trust_remote_code=True,
             device_map=self.device_map,
             low_cpu_mem_usage=self.low_cpu_mem_usage,
-            torch_dtype=self._get_torch_dtype(),
+            dtype=self._get_torch_dtype(),
         )
         self.model = self.model.to(
             dtype=self._get_torch_dtype()
@@ -1197,9 +1217,9 @@ class HFPipelineBasedInferenceEngine(
             args["quantization_config"] = quantization_config
         elif self.use_fp16:
             if self.device == torch.device("mps"):
-                args["torch_dtype"] = torch.float16
+                args["dtype"] = torch.float16
             else:
-                args["torch_dtype"] = torch.bfloat16
+                args["dtype"] = torch.bfloat16
 
         # We do this, because in some cases, using device:auto will offload some weights to the cpu
         # (even though the model might *just* fit to a single gpu), even if there is a gpu available, and this will
@@ -2770,7 +2790,10 @@ class WMLInferenceEngineChat(WMLInferenceEngineBase, WMLChatParamsMixin):
             if tool_call:
                 if "tool_calls" in output:
                     func = output["tool_calls"][0]["function"]
-                    prediction = f'{{"name": "{func["name"]}", "arguments": {func["arguments"]}}}'
+                    arguments = func["arguments"]
+                    while isinstance(arguments, str):
+                        arguments = json.loads(arguments)
+                    prediction = f'{{"name": "{func["name"]}", "arguments": {json.dumps(arguments)}}}'
                 else:
                     prediction = output["content"]
             else:

metrics.py

@@ -1929,10 +1929,12 @@ class WeightedWinRateCorrelation(GlobalMetric):
             pred_df_win_rate, ref_df_win_rate, on="model", suffixes=("_pred", "_ref")
         )
         pearson_corr, _ = pearsonr(
-            merged_df["win_rate_pred"], merged_df["win_rate_ref"]
+            merged_df["win_rate_pred"].astype(float),
+            merged_df["win_rate_ref"].astype(float),
         )
         spearman_corr, _ = spearmanr(
-            merged_df["win_rate_pred"], merged_df["win_rate_ref"]
+            merged_df["win_rate_pred"].astype(float),
+            merged_df["win_rate_ref"].astype(float),
         )
 
         return {"pearson_corr": pearson_corr, "spearman_corr": spearman_corr}
@@ -3182,12 +3184,21 @@ class F1(GlobalMetric):
     prediction_type = str
     single_reference_per_prediction = True
 
-    _requirements_list: List[str] = ["scikit-learn<=1.5.2"]
+    _requirements_list: List[str] = ["scikit-learn"]
+
+    _sklearn_metric_fn = None
 
     def prepare(self):
         super().prepare()
 
-        self._metric = hf_evaluate_load(self.metric)
+        from sklearn.metrics import f1_score, precision_score, recall_score
+
+        metric_fn_map = {
+            "f1": f1_score,
+            "precision": precision_score,
+            "recall": recall_score,
+        }
+        self._sklearn_metric_fn = metric_fn_map[self.metric]
 
     def get_str_id(self, str):
         if str not in self.str_to_id:
@@ -3207,26 +3218,25 @@ class F1(GlobalMetric):
         formatted_references = [
             self.get_str_id(reference[0]) for reference in references
         ]
-        self.str_to_id.keys()
         formatted_predictions = [
             self.get_str_id(prediction) for prediction in predictions
         ]
         labels = list(set(formatted_references))
 
-        result = self._metric.compute(
-            predictions=formatted_predictions,
-            references=formatted_references,
+        score = self._sklearn_metric_fn(
+            y_true=formatted_references,
+            y_pred=formatted_predictions,
             labels=labels,
             average=self.average,
         )
-        if isinstance(result[self.metric], numpy.ndarray):
-            final_result = {self.main_score: nan_mean(result[self.metric])}
+        if isinstance(score, numpy.ndarray):
+            final_result = {self.main_score: nan_mean(score)}
             for i, label in enumerate(labels):
-                final_result[f"{self.metric}_" + self.id_to_str[label]] = result[
-                    self.metric
-                ][i]
+                final_result[f"{self.metric}_" + self.id_to_str[label]] = float(
+                    score[i]
+                )
         else:
-            final_result = {self.main_score: result[self.metric]}
+            final_result = {self.main_score: float(score)}
         return final_result
 
 
@@ -3475,10 +3485,19 @@ class F1MultiLabel(GlobalMetric, PackageRequirementsMixin):
     single_reference_per_prediction = True
     _requirements_list = ["scikit-learn"]
 
+    _sklearn_metric_fn = None
+
     def prepare(self):
         super().prepare()
 
-        self._metric = hf_evaluate_load(self.metric, "multilabel")
+        from sklearn.metrics import f1_score, precision_score, recall_score
+
+        metric_fn_map = {
+            "f1": f1_score,
+            "precision": precision_score,
+            "recall": recall_score,
+        }
+        self._sklearn_metric_fn = metric_fn_map[self.metric]
 
     def add_str_to_id(self, str):
         if str not in self.str_to_id:
@@ -3528,21 +3547,25 @@ class F1MultiLabel(GlobalMetric, PackageRequirementsMixin):
         else:
             labels_param = None
 
-        result = self._metric.compute(
-            predictions=formatted_predictions,
-            references=formatted_references,
-            average=self.average,
-            labels=labels_param,
-        )
-        if isinstance(result[self.metric], numpy.ndarray):
-            assert (
-                len(result[self.metric]) == len(labels)
-            ), f"F1 result ({result[self.metric]}) has more entries than labels ({labels})"
-            final_result = {self.main_score: nan_mean(result[self.metric])}
+        kwargs = {
+            "y_pred": formatted_predictions,
+            "y_true": formatted_references,
+            "average": self.average,
+        }
+        if labels_param is not None:
+            kwargs["labels"] = labels_param
+
+        score = self._sklearn_metric_fn(**kwargs)
+
+        if isinstance(score, numpy.ndarray):
+            assert len(score) == len(
+                labels
+            ), f"F1 result ({score}) has more entries than labels ({labels})"
+            final_result = {self.main_score: nan_mean(score)}
             for i, label in enumerate(labels):
-                final_result[self.metric + "_" + label] = result[self.metric][i]
+                final_result[self.metric + "_" + label] = float(score[i])
         else:
-            final_result = {self.main_score: result[self.metric]}
+            final_result = {self.main_score: float(score)}
         return final_result
 
 
@@ -4427,13 +4450,33 @@ class BertScore(MapReduceMetric[str, Dict[str, float]], TorchDeviceMixin):
         super().prepare()
         self.bertscore = None
 
+    def _get_scorer(self):
+        from bert_score import BERTScorer
+
+        if self.bertscore is None:
+            self.bertscore = BERTScorer(
+                model_type=self.model_name,
+                num_layers=self.model_layer,
+                batch_size=self.batch_size,
+                device=self.get_device(),
+            )
+            # Some models (e.g. DeBERTa) report an absurdly large
+            # model_max_length that overflows the tokenizers Rust backend.
+            # Cap it to the model's actual max_position_embeddings.
+            tokenizer = self.bertscore._tokenizer
+            if tokenizer.model_max_length > 1_000_000:
+                from transformers import AutoConfig
+
+                config = AutoConfig.from_pretrained(self.model_name)
+                tokenizer.model_max_length = getattr(
+                    config, "max_position_embeddings", 512
+                )
+        return self.bertscore
+
     def map_stream(
         self, evaluation_inputs_stream: Generator[EvaluationInput[str], None, None]
     ):
-        from evaluate import load
-
-        if self.bertscore is None:
-            self.bertscore = load("bertscore", experiment_id=str(uuid.uuid4()))
+        scorer = self._get_scorer()
 
         predictions = []
         references = []
@@ -4441,18 +4484,16 @@ class BertScore(MapReduceMetric[str, Dict[str, float]], TorchDeviceMixin):
             predictions.append(prediction)
             references.append(reference)
 
-        results = self.bertscore.compute(
-            predictions=predictions,
-            references=references,
+        (precisions, recalls, f1s) = scorer.score(
+            cands=predictions,
+            refs=references,
             batch_size=self.batch_size,
-            device=self.get_device(),
-            model_type=self.model_name,
-            num_layers=self.model_layer,
+            verbose=True,
         )
 
         intermediates = []
         for precision, recall, f1 in zip(
-            results["precision"], results["recall"], results["f1"]
+            precisions.tolist(), recalls.tolist(), f1s.tolist()
         ):
             intermediates.append(
                 {
@@ -5103,7 +5144,11 @@ class Perplexity(BulkInstanceMetric):
             model_path = self.model_name
             if settings.hf_offline_models_path is not None:
                 model_path = os.path.join(settings.hf_offline_models_path, model_path)
-            self.model = self.model_class().from_pretrained(model_path).to(self.device)
+            self.model = (
+                self.model_class()
+                .from_pretrained(model_path, dtype=torch.float32)
+                .to(self.device)
+            )
             self.tokenizer = AutoTokenizer.from_pretrained(model_path)
             if self.tokenizer.pad_token_id is None:
                 self.tokenizer.pad_token_id = self.tokenizer.eos_token_id

text2sql_utils.py

@@ -855,11 +855,9 @@ def compare_dfs_ignore_colnames_subset(
         return [row_to_multiset(row) for row in df.values]
 
     def sort_df(df):
-        sorted_df = df.copy()
+        sorted_df = df.astype(str).copy()
         for i in range(len(sorted_df.columns)):
-            sorted_df.iloc[:, i] = (
-                sorted_df.iloc[:, i].astype(str).sort_values(ignore_index=True)
-            )
+            sorted_df.iloc[:, i] = sorted_df.iloc[:, i].sort_values(ignore_index=True)
         return sorted_df
 
     if df1.empty or df2.empty or len(df1) != len(df2):

version.py

@@ -1 +1 @@
-version = "1.26.9"
+version = "1.26.10"