Hugging Face's logo

评估文档

评估器

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

评估器

用于自动评估的评估器类。

评估器类

使用评估器的主要入口点

evaluate.evaluator

< >

( task: str = None ) → Evaluator

参数

返回值

评估器

适用于该任务的评估器。

用于构建 Evaluator 的实用工厂方法。评估器封装了一个任务和一个默认的指标名称。它们利用来自 transformers 的 pipeline 功能，简化了给定任务的模型、数据集和指标的多种组合的评估。

示例

>>> from evaluate import evaluator
>>> # Sentiment analysis evaluator
>>> evaluator("sentiment-analysis")

所有评估器类的基类

class evaluate.Evaluator

< >

( task: str default_metric_name: str = None )

Evaluator 类是所有评估器继承的类。有关不同评估器之间共享的方法，请参阅此类。实现评估器操作的基类。

check_required_columns

< >

( data: typing.Union[str, datasets.arrow_dataset.Dataset] columns_names: typing.Dict[str, str] )

参数

  • data (str 或 Dataset) — 指定我们将在其上运行评估的数据集。
  • columns_names (List[str]) —
  • 要在数据集中检查的列名称的列表。键是 compute() 方法的参数 —
  • while 值是要检查的列名称。 —

确保数据集中存在评估所需的列。

compute_metric

< >

( metric: EvaluationModule metric_inputs: typing.Dict strategy: typing.Literal['simple', 'bootstrap'] = 'simple' confidence_level: float = 0.95 n_resamples: int = 9999 random_state: typing.Optional[int] = None )

计算并返回指标。

get_dataset_split

< >

( data subset = None split = None ) → split

参数

  • data (str) — 数据集名称
  • subset (str) — 具有多个配置的数据集的配置名称（例如 ‘glue/cola’）
  • split (str, 默认为 None) — 要使用的拆分

返回值

split

str，包含要使用的拆分

如果未给定，则推断要使用的拆分。

load_data

< >

( data: typing.Union[str, datasets.arrow_dataset.Dataset] subset: str = None split: str = None ) → data (Dataset)

参数

  • data (Dataset 或 str, 默认为 None) — 指定我们将要运行评估的数据集。如果它的类型是
  • type str，我们将其视为数据集名称并加载它。否则，我们假设它表示预加载的数据集。 —
  • subset (str, 默认为 None) — 指定要传递给 load_dataset 中 name 的数据集子集。用于具有多个配置的数据集（例如 glue/sst2）。
  • split (str, 默认为 None) — 用户定义的数据集拆分名称（例如 train、validation、test）。支持切片拆分 (test[:n])。如果未定义且 data 是 str 类型，将通过 choose_split() 自动选择最佳拆分。

返回值

data (Dataset)

将用于评估的已加载数据集。

加载具有给定子集和拆分的数据集。

predictions_processor

< >

( *args **kwargs )

Evaluator 类的核心方法，它处理 pipeline 输出，使其与指标兼容。

prepare_data

< >

( data: Dataset input_column: str label_column: str *args **kwargs ) → dict

参数

  • data (Dataset) — 指定我们将要在其上运行评估的数据集。
  • input_column (str, 默认为 "text") — 指定由 data 参数指定的数据集中，包含文本特征的列名。
  • label_column (str, 默认为 "label") — 指定由 data 参数指定的数据集中，包含标签的列名。

返回值

dict

指标输入。 list：pipeline 输入。

准备数据。

prepare_metric

< >

( metric: typing.Union[str, evaluate.module.EvaluationModule] )

参数

  • metric (str 或 EvaluationModule, 默认为 None) — 指定我们在评估器中使用的指标。如果类型为 str，我们将其视为指标名称并加载它。否则，我们假设它代表一个预加载的指标。

准备指标。

prepare_pipeline

< >

( model_or_pipeline: typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] tokenizer: typing.Union[ForwardRef('PreTrainedTokenizerBase'), ForwardRef('FeatureExtractionMixin')] = None feature_extractor: typing.Union[ForwardRef('PreTrainedTokenizerBase'), ForwardRef('FeatureExtractionMixin')] = None device: int = None )

参数

  • model_or_pipeline (str 或 Pipeline 或 Callable 或 PreTrainedModel 或 TFPreTrainedModel, —
  • defaults 为 None) — 如果未指定参数，我们将初始化任务的默认 pipeline。如果参数类型为 str 或模型实例，我们将使用它来初始化一个新的 Pipeline 并使用给定的模型。否则，我们假设该参数指定了一个预初始化的 pipeline。
  • preprocessor (PreTrainedTokenizerBase 或 FeatureExtractionMixin, 可选, 默认为 None) — 如果 model_or_pipeline 代表一个我们将为其构建 pipeline 的模型，则可以使用此参数覆盖默认的预处理器。如果 model_or_pipeline 为 None 或预初始化的 pipeline，我们将忽略此参数。

准备 pipeline。

特定于任务的评估器

ImageClassificationEvaluator

class evaluate.ImageClassificationEvaluator

< >

( task = 'image-classification' default_metric_name = None )

图像分类评估器。此图像分类评估器当前可以从 evaluator() 使用默认任务名称 image-classification 加载。此类中的方法假设数据格式与 ImageClassificationPipeline 兼容。

compute

< >

( model_or_pipeline: typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None data: typing.Union[str, datasets.arrow_dataset.Dataset] = None subset: typing.Optional[str] = None split: typing.Optional[str] = None metric: typing.Union[str, evaluate.module.EvaluationModule] = None tokenizer: typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None feature_extractor: typing.Union[str, ForwardRef('FeatureExtractionMixin'), NoneType] = None strategy: typing.Literal['simple', 'bootstrap'] = 'simple' confidence_level: float = 0.95 n_resamples: int = 9999 device: int = None random_state: typing.Optional[int] = None input_column: str = 'image' label_column: str = 'label' label_mapping: typing.Union[typing.Dict[str, numbers.Number], NoneType] = None )

参数

  • model_or_pipeline (str 或 Pipeline 或 Callable 或 PreTrainedModel 或 TFPreTrainedModel, 默认为 None) — 如果未指定参数，我们将初始化任务的默认 pipeline（在本例中为 text-classification 或其别名 - sentiment-analysis）。如果参数类型为 str 或模型实例，我们将使用它来初始化一个新的 Pipeline 并使用给定的模型。否则，我们假设该参数指定了一个预初始化的 pipeline。
  • data (str 或 Dataset, 默认为 None) — 指定我们将要在其上运行评估的数据集。如果类型为 str，我们将其视为数据集名称并加载它。否则，我们假设它代表一个预加载的数据集。
  • subset (str, 默认为 None) — 定义要加载的数据集子集。如果传递 None，则加载默认子集。
  • split (str, 默认为 None) — 定义要加载的数据集拆分。如果传递 None，则基于 choose_split 函数进行推断。
  • metric (str 或 EvaluationModule, 默认为 None) — 指定我们在评估器中使用的指标。如果类型为 str，我们将其视为指标名称并加载它。否则，我们假设它代表一个预加载的指标。
  • tokenizer (str 或 PreTrainedTokenizer, 可选, 默认为 None) — 如果 model_or_pipeline 代表一个我们将为其构建 pipeline 的模型，则可以使用此参数覆盖默认的 tokenizer。如果 model_or_pipeline 为 None 或预初始化的 pipeline，我们将忽略此参数。
  • strategy (Literal["simple", "bootstrap"], 默认为 “simple”) — 指定评估策略。可能的值包括：
  • confidence_level (float, 默认为 0.95) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 confidence_level 值。
  • n_resamples (int, 默认为 9999) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 n_resamples 值。
  • device (int, 默认为 None) — 用于 pipeline 的 CPU/GPU 支持的设备序号。将其设置为 -1 将利用 CPU，正整数将在关联的 CUDA 设备 ID 上运行模型。如果提供 None，则将推断并使用 CUDA:0（如果可用），否则使用 CPU。
  • random_state (int, 可选, 默认为 None) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 random_state 值。用于调试很有用。

计算给定 pipeline 和数据集组合的指标。

示例

>>> from evaluate import evaluator
>>> from datasets import load_dataset
>>> task_evaluator = evaluator("image-classification")
>>> data = load_dataset("beans", split="test[:40]")
>>> results = task_evaluator.compute(
>>>     model_or_pipeline="nateraw/vit-base-beans",
>>>     data=data,
>>>     label_column="labels",
>>>     metric="accuracy",
>>>     label_mapping={'angular_leaf_spot': 0, 'bean_rust': 1, 'healthy': 2},
>>>     strategy="bootstrap"
>>> )

QuestionAnsweringEvaluator

class evaluate.QuestionAnsweringEvaluator

< >

( task = 'question-answering' default_metric_name = None )

问题回答评估器。此评估器处理抽取式问题回答，其中问题的答案是从上下文中提取的。

此问题回答评估器目前可以从evaluator()加载，使用默认任务名称 question-answering。

此类别中的方法假设数据格式与QuestionAnsweringPipeline兼容。

compute

< >

( model_or_pipeline: typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None data: typing.Union[str, datasets.arrow_dataset.Dataset] = None subset: typing.Optional[str] = None split: typing.Optional[str] = None metric: typing.Union[str, evaluate.module.EvaluationModule] = None tokenizer: typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None strategy: typing.Literal['simple', 'bootstrap'] = 'simple' confidence_level: float = 0.95 n_resamples: int = 9999 device: int = None random_state: typing.Optional[int] = None question_column: str = 'question' context_column: str = 'context' id_column: str = 'id' label_column: str = 'answers' squad_v2_format: typing.Optional[bool] = None )

参数

  • model_or_pipeline (str 或 Pipeline 或 Callable 或 PreTrainedModel 或 TFPreTrainedModel，默认为 None) — 如果未指定此参数，我们将为任务初始化默认的 pipeline（在本例中为 text-classification 或其别名 sentiment-analysis）。如果此参数的类型为 str 或为模型实例，我们将使用它来初始化一个新的 Pipeline，并使用给定的模型。否则，我们假设此参数指定了一个预初始化的 pipeline。
  • data (str 或 Dataset，默认为 None) — 指定我们将在其上运行评估的数据集。如果类型为 str，我们将其视为数据集名称并加载它。否则，我们假设它代表一个预加载的数据集。
  • subset (str，默认为 None) — 定义要加载的数据集子集。如果传递 None，则加载默认子集。
  • split (str，默认为 None) — 定义要加载的数据集拆分。如果传递 None，则基于 choose_split 函数进行推断。
  • metric (str 或 EvaluationModule，默认为 None) — 指定我们在评估器中使用的指标。如果类型为 str，我们将其视为指标名称并加载它。否则，我们假设它代表一个预加载的指标。
  • tokenizer (str 或 PreTrainedTokenizer，可选，默认为 None) — 如果 model_or_pipeline 代表一个我们将为其构建 pipeline 的模型，则此参数可用于覆盖默认的 tokenizer。如果 model_or_pipeline 为 None 或预初始化的 pipeline，我们将忽略此参数。
  • strategy (Literal["simple", "bootstrap"]，默认为 “simple”) — 指定评估策略。可能的值为：
  • confidence_level (float，默认为 0.95) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 confidence_level 值。
  • n_resamples (int，默认为 9999) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 n_resamples 值。
  • device (int，默认为 None) — 用于 pipeline 的 CPU/GPU 支持的设备序号。将其设置为 -1 将利用 CPU，正整数将在关联的 CUDA 设备 ID 上运行模型。如果提供 None，则将推断设备，如果可用，则使用 CUDA:0，否则使用 CPU。
  • random_state (int，可选，默认为 None) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 random_state 值。用于调试。

计算给定 pipeline 和数据集组合的指标。

示例

>>> from evaluate import evaluator
>>> from datasets import load_dataset
>>> task_evaluator = evaluator("question-answering")
>>> data = load_dataset("squad", split="validation[:2]")
>>> results = task_evaluator.compute(
>>>     model_or_pipeline="sshleifer/tiny-distilbert-base-cased-distilled-squad",
>>>     data=data,
>>>     metric="squad",
>>> )

支持上下文中可能缺少答案的数据集，例如 SQuAD v2 数据集。在这种情况下，传递 squad_v2_format=True 给 compute() 调用会更安全。

>>> from evaluate import evaluator
>>> from datasets import load_dataset
>>> task_evaluator = evaluator("question-answering")
>>> data = load_dataset("squad_v2", split="validation[:2]")
>>> results = task_evaluator.compute(
>>>     model_or_pipeline="mrm8488/bert-tiny-finetuned-squadv2",
>>>     data=data,
>>>     metric="squad_v2",
>>>     squad_v2_format=True,
>>> )

TextClassificationEvaluator

class evaluate.TextClassificationEvaluator

< >

( task = 'text-classification' default_metric_name = None )

文本分类评估器。此文本分类评估器目前可以从evaluator()加载，使用默认任务名称 text-classification 或 "sentiment-analysis" 别名。此类别中的方法假设数据格式与 TextClassificationPipeline 兼容 - 单个文本特征作为输入，分类标签作为输出。

compute

< >

( model_or_pipeline: typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None data: typing.Union[str, datasets.arrow_dataset.Dataset] = None subset: typing.Optional[str] = None split: typing.Optional[str] = None metric: typing.Union[str, evaluate.module.EvaluationModule] = None tokenizer: typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None feature_extractor: typing.Union[str, ForwardRef('FeatureExtractionMixin'), NoneType] = None strategy: typing.Literal['simple', 'bootstrap'] = 'simple' confidence_level: float = 0.95 n_resamples: int = 9999 device: int = None random_state: typing.Optional[int] = None input_column: str = 'text' second_input_column: typing.Optional[str] = None label_column: str = 'label' label_mapping: typing.Union[typing.Dict[str, numbers.Number], NoneType] = None )

参数

  • model_or_pipeline (str 或 Pipeline 或 Callable 或 PreTrainedModel 或 TFPreTrainedModel，默认为 None) — 如果未指定此参数，我们将为任务初始化默认的 pipeline（在本例中为 text-classification 或其别名 sentiment-analysis）。如果此参数的类型为 str 或为模型实例，我们将使用它来初始化一个新的 Pipeline，并使用给定的模型。否则，我们假设此参数指定了一个预初始化的 pipeline。
  • data (str 或 Dataset，默认为 None) — 指定我们将在其上运行评估的数据集。如果类型为 str，我们将其视为数据集名称并加载它。否则，我们假设它代表一个预加载的数据集。
  • subset (str，默认为 None) — 定义要加载的数据集子集。如果传递 None，则加载默认子集。
  • split (str，默认为 None) — 定义要加载的数据集拆分。如果传递 None，则基于 choose_split 函数进行推断。
  • metric (str 或 EvaluationModule，默认为 None) — 指定我们在评估器中使用的指标。如果类型为 str，我们将其视为指标名称并加载它。否则，我们假设它代表一个预加载的指标。
  • tokenizer (str 或 PreTrainedTokenizer，可选，默认为 None) — 如果 model_or_pipeline 代表一个我们将为其构建 pipeline 的模型，则此参数可用于覆盖默认的 tokenizer。如果 model_or_pipeline 为 None 或预初始化的 pipeline，我们将忽略此参数。
  • strategy (Literal["simple", "bootstrap"]，默认为 “simple”) — 指定评估策略。可能的值为：
  • confidence_level (float, 默认为 0.95) — 如果选择了 "bootstrap" 策略，则传递给 bootstrap 的 confidence_level 值。
  • n_resamples (int, 默认为 9999) — 如果选择了 "bootstrap" 策略，则传递给 bootstrap 的 n_resamples 值。
  • device (int, 默认为 None) — 用于 pipeline 的 CPU/GPU 支持的设备序号。设置为 -1 将利用 CPU，正整数将在关联的 CUDA 设备 ID 上运行模型。如果提供 None，则将推断设备，如果可用则使用 CUDA:0，否则使用 CPU。
  • random_state (int, 可选, 默认为 None) — 如果选择了 "bootstrap" 策略，则传递给 bootstrap 的 random_state 值。用于调试。

计算给定 pipeline 和数据集组合的指标。

示例

>>> from evaluate import evaluator
>>> from datasets import load_dataset
>>> task_evaluator = evaluator("text-classification")
>>> data = load_dataset("imdb", split="test[:2]")
>>> results = task_evaluator.compute(
>>>     model_or_pipeline="huggingface/prunebert-base-uncased-6-finepruned-w-distil-mnli",
>>>     data=data,
>>>     metric="accuracy",
>>>     label_mapping={"LABEL_0": 0.0, "LABEL_1": 1.0},
>>>     strategy="bootstrap",
>>>     n_resamples=10,
>>>     random_state=0
>>> )

TokenClassificationEvaluator

class evaluate.TokenClassificationEvaluator

< >

( task = 'token-classification' default_metric_name = None )

Token classification evaluator.

This token classification evaluator can currently be loaded from evaluator() using the default task name token-classification.

Methods in this class assume a data format compatible with the TokenClassificationPipeline.

compute

< >

( model_or_pipeline: typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None data: typing.Union[str, datasets.arrow_dataset.Dataset] = None subset: typing.Optional[str] = None split: str = None metric: typing.Union[str, evaluate.module.EvaluationModule] = None tokenizer: typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None strategy: typing.Literal['simple', 'bootstrap'] = 'simple' confidence_level: float = 0.95 n_resamples: int = 9999 device: typing.Optional[int] = None random_state: typing.Optional[int] = None input_column: str = 'tokens' label_column: str = 'ner_tags' join_by: typing.Optional[str] = ' ' )

参数

  • model_or_pipeline (str 或 Pipeline 或 Callable 或 PreTrainedModel 或 TFPreTrainedModel, 默认为 None) — 如果未指定参数，我们将为任务初始化默认的 pipeline（在本例中为 text-classification 或其别名 - sentiment-analysis）。如果参数的类型为 str 或模型实例，我们使用它来初始化具有给定模型的新 Pipeline。否则，我们假设该参数指定了一个预初始化的 pipeline。
  • data (str 或 Dataset, 默认为 None) — 指定我们将要在其上运行评估的数据集。如果它的类型是 str，我们将其视为数据集名称并加载它。否则，我们假设它代表一个预加载的数据集。
  • subset (str, 默认为 None) — 定义要加载的数据集子集。如果传递 None，则加载默认子集。
  • split (str, 默认为 None) — 定义要加载的数据集拆分。如果传递 None，则基于 choose_split 函数推断。
  • metric (str 或 EvaluationModule, 默认为 None) — 指定我们在评估器中使用的指标。如果它的类型是 str，我们将其视为指标名称并加载它。否则，我们假设它代表一个预加载的指标。
  • tokenizer (str 或 PreTrainedTokenizer, 可选, 默认为 None) — 如果 model_or_pipeline 代表我们要为其构建 pipeline 的模型，则可以使用此参数来覆盖默认的 tokenizer。如果 model_or_pipeline 为 None 或预初始化的 pipeline，我们将忽略此参数。
  • strategy (Literal["simple", "bootstrap"], 默认为 “simple”) — 指定评估策略。可能的值为：
  • confidence_level (float, 默认为 0.95) — 如果选择了 "bootstrap" 策略，则传递给 bootstrap 的 confidence_level 值。
  • n_resamples (int, 默认为 9999) — 如果选择了 "bootstrap" 策略，则传递给 bootstrap 的 n_resamples 值。
  • device (int, 默认为 None) — 用于 pipeline 的 CPU/GPU 支持的设备序号。设置为 -1 将利用 CPU，正整数将在关联的 CUDA 设备 ID 上运行模型。如果提供 None，则将推断设备，如果可用则使用 CUDA:0，否则使用 CPU。
  • random_state (int, 可选, 默认为 None) — 如果选择了 "bootstrap" 策略，则传递给 bootstrap 的 random_state 值。用于调试。

计算给定 pipeline 和数据集组合的指标。

The dataset input and label columns are expected to be formatted as a list of words and a list of labels respectively, following conll2003 dataset. Datasets whose inputs are single strings, and labels are a list of offset are not supported.

示例

>>> from evaluate import evaluator
>>> from datasets import load_dataset
>>> task_evaluator = evaluator("token-classification")
>>> data = load_dataset("conll2003", split="validation[:2]")
>>> results = task_evaluator.compute(
>>>     model_or_pipeline="elastic/distilbert-base-uncased-finetuned-conll03-english",
>>>     data=data,
>>>     metric="seqeval",
>>> )

For example, the following dataset format is accepted by the evaluator

dataset = Dataset.from_dict(
    mapping={
        "tokens": [["New", "York", "is", "a", "city", "and", "Felix", "a", "person", "."]],
        "ner_tags": [[1, 2, 0, 0, 0, 0, 3, 0, 0, 0]],
    },
    features=Features({
        "tokens": Sequence(feature=Value(dtype="string")),
        "ner_tags": Sequence(feature=ClassLabel(names=["O", "B-LOC", "I-LOC", "B-PER", "I-PER"])),
        }),
)

For example, the following dataset format is not accepted by the evaluator

dataset = Dataset.from_dict(
    mapping={
        "tokens": [["New York is a city and Felix a person."]],
        "starts": [[0, 23]],
        "ends": [[7, 27]],
        "ner_tags": [["LOC", "PER"]],
    },
    features=Features({
        "tokens": Value(dtype="string"),
        "starts": Sequence(feature=Value(dtype="int32")),
        "ends": Sequence(feature=Value(dtype="int32")),
        "ner_tags": Sequence(feature=Value(dtype="string")),
    }),
)

TextGenerationEvaluator

class evaluate.TextGenerationEvaluator

< >

( task = 'text-generation' default_metric_name = None predictions_prefix: str = 'generated' )

Text generation evaluator. This Text generation evaluator can currently be loaded from evaluator() using the default task name text-generation. Methods in this class assume a data format compatible with the TextGenerationPipeline.

compute

< >

( model_or_pipeline: typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None data: typing.Union[str, datasets.arrow_dataset.Dataset] = None subset: typing.Optional[str] = None split: typing.Optional[str] = None metric: typing.Union[str, evaluate.module.EvaluationModule] = None tokenizer: typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None feature_extractor: typing.Union[str, ForwardRef('FeatureExtractionMixin'), NoneType] = None strategy: typing.Literal['simple', 'bootstrap'] = 'simple' confidence_level: float = 0.95 n_resamples: int = 9999 device: int = None random_state: typing.Optional[int] = None input_column: str = 'text' label_column: str = 'label' label_mapping: typing.Union[typing.Dict[str, numbers.Number], NoneType] = None )

Text2TextGenerationEvaluator

class evaluate.Text2TextGenerationEvaluator

< >

( task = 'text2text-generation' default_metric_name = None )

Text2Text 生成评估器。此 Text2Text 生成评估器当前可以从 evaluator() 中使用默认任务名称 text2text-generation 加载。此类中的方法假定数据格式与 Text2TextGenerationPipeline 兼容。

compute

< >

( model_or_pipeline: typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None data: typing.Union[str, datasets.arrow_dataset.Dataset] = None subset: typing.Optional[str] = None split: typing.Optional[str] = None metric: typing.Union[str, evaluate.module.EvaluationModule] = None tokenizer: typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None strategy: typing.Literal['simple', 'bootstrap'] = 'simple' confidence_level: float = 0.95 n_resamples: int = 9999 device: int = None random_state: typing.Optional[int] = None input_column: str = 'text' label_column: str = 'label' generation_kwargs: dict = None )

参数

  • model_or_pipeline (str 或 Pipeline 或 Callable 或 PreTrainedModel 或 TFPreTrainedModel, 默认为 None) — 如果未指定此参数，我们将为任务初始化默认的 pipeline（在本例中为 text-classification 或其别名 - sentiment-analysis）。如果参数类型为 str 或为模型实例，我们将使用它来初始化具有给定模型的新 Pipeline。否则，我们假定此参数指定了预初始化的 pipeline。
  • data (str 或 Dataset, 默认为 None) — 指定我们将要运行评估的数据集。如果类型为 str，我们将其视为数据集名称并加载它。否则，我们假定它表示预加载的数据集。
  • subset (str, 默认为 None) — 定义要加载的数据集子集。如果传递 None，则加载默认子集。
  • split (str, 默认为 None) — 定义要加载的数据集拆分。如果传递 None，则基于 choose_split 函数推断。
  • metric (str 或 EvaluationModule, 默认为 None) — 指定我们在评估器中使用的指标。如果类型为 str，我们将其视为指标名称并加载它。否则，我们假定它表示预加载的指标。
  • tokenizer (str 或 PreTrainedTokenizer, 可选, 默认为 None) — 如果 model_or_pipeline 表示我们为其构建 pipeline 的模型，则可以使用此参数覆盖默认的分词器。如果 model_or_pipeline 为 None 或预初始化的 pipeline，我们将忽略此参数。
  • strategy (Literal["simple", "bootstrap"], 默认为 “simple”) — 指定评估策略。可能的值为：
  • confidence_level (float, 默认为 0.95) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 confidence_level 值。
  • n_resamples (int, 默认为 9999) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 n_resamples 值。
  • device (int, 默认为 None) — 用于 pipeline 的 CPU/GPU 支持的设备序号。将其设置为 -1 将利用 CPU，正整数将在关联的 CUDA 设备 ID 上运行模型。如果提供 None，则将推断它，如果可用，则使用 CUDA:0，否则使用 CPU。
  • random_state (int, 可选, 默认为 None) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 random_state 值。用于调试。
  • input_column (str, 默认为 "text") — 包含由 data 指定的数据集中的输入文本的列的名称。
  • label_column (str, 默认为 "label") — 包含由 data 指定的数据集中的标签的列的名称。
  • generation_kwargs (Dict, 可选, 默认为 None) — generation kwargs 传递给 pipeline 并设置文本生成策略。

计算给定 pipeline 和数据集组合的指标。

SummarizationEvaluator

class evaluate.SummarizationEvaluator

< >

( task = 'summarization' default_metric_name = None )

文本摘要评估器。此文本摘要评估器当前可以从 evaluator() 中使用默认任务名称 summarization 加载。此类中的方法假定数据格式与 SummarizationEvaluator 兼容。

compute

< >

( model_or_pipeline: typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None data: typing.Union[str, datasets.arrow_dataset.Dataset] = None subset: typing.Optional[str] = None split: typing.Optional[str] = None metric: typing.Union[str, evaluate.module.EvaluationModule] = None tokenizer: typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None strategy: typing.Literal['simple', 'bootstrap'] = 'simple' confidence_level: float = 0.95 n_resamples: int = 9999 device: int = None random_state: typing.Optional[int] = None input_column: str = 'text' label_column: str = 'label' generation_kwargs: dict = None )

参数

  • model_or_pipeline (str 或 Pipeline 或 Callable 或 PreTrainedModel 或 TFPreTrainedModel, 默认为 None) — 如果未指定此参数，我们将为任务初始化默认的 pipeline（在本例中为 text-classification 或其别名 - sentiment-analysis）。如果参数类型为 str 或为模型实例，我们将使用它来初始化具有给定模型的新 Pipeline。否则，我们假定此参数指定了预初始化的 pipeline。
  • data (str 或 Dataset, 默认为 None) — 指定我们将要运行评估的数据集。如果类型为 str，我们将其视为数据集名称并加载它。否则，我们假设它代表预加载的数据集。
  • subset (str, 默认为 None) — 定义要加载的数据集子集。如果传递 None，则加载默认子集。
  • split (str, 默认为 None) — 定义要加载的数据集拆分。如果传递 None，则基于 choose_split 函数进行推断。
  • metric (str 或 EvaluationModule, 默认为 None) — 指定我们在评估器中使用的指标。如果类型为 str，我们将其视为指标名称并加载它。否则，我们假设它代表预加载的指标。
  • tokenizer (str 或 PreTrainedTokenizer, 可选, 默认为 None) — 如果 model_or_pipeline 代表我们为其构建管道的模型，则可以使用此参数覆盖默认的分词器。如果 model_or_pipeline 为 None 或预初始化的管道，我们将忽略此参数。
  • strategy (Literal["simple", "bootstrap"], 默认为 “simple”) — 指定评估策略。可能的值为：
  • confidence_level (float, 默认为 0.95) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 confidence_level 值。
  • n_resamples (int, 默认为 9999) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 n_resamples 值。
  • device (int, 默认为 None) — 用于管道的 CPU/GPU 支持的设备序号。将其设置为 -1 将利用 CPU，正整数将在关联的 CUDA 设备 ID 上运行模型。如果提供 None，它将被推断，如果可用则使用 CUDA:0，否则使用 CPU。
  • random_state (int, 可选, 默认为 None) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 random_state 值。用于调试。
  • input_column (str, 默认为 "text") — 指定由 data 指定的数据集中包含输入文本的列的名称。
  • label_column (str, 默认为 "label") — 指定由 data 指定的数据集中包含标签的列的名称。
  • generation_kwargs (Dict, 可选, 默认为 None) — 生成 kwargs 传递给管道并设置文本生成策略。

计算给定 pipeline 和数据集组合的指标。

TranslationEvaluator

class evaluate.TranslationEvaluator

< >

( task = 'translation' default_metric_name = None )

翻译评估器。此翻译生成评估器当前可以从 evaluator() 加载，使用默认任务名称 translation。此类中的方法假定数据格式与 TranslationPipeline 兼容。

compute

< >

( model_or_pipeline: typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None data: typing.Union[str, datasets.arrow_dataset.Dataset] = None subset: typing.Optional[str] = None split: typing.Optional[str] = None metric: typing.Union[str, evaluate.module.EvaluationModule] = None tokenizer: typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None strategy: typing.Literal['simple', 'bootstrap'] = 'simple' confidence_level: float = 0.95 n_resamples: int = 9999 device: int = None random_state: typing.Optional[int] = None input_column: str = 'text' label_column: str = 'label' generation_kwargs: dict = None )

参数

  • model_or_pipeline (str 或 Pipeline 或 Callable 或 PreTrainedModel 或 TFPreTrainedModel, 默认为 None) — 如果未指定参数，我们将初始化任务的默认管道（在本例中为 text-classification 或其别名 - sentiment-analysis）。如果参数的类型为 str 或者是模型实例，我们使用它来初始化具有给定模型的新 Pipeline。否则，我们假设参数指定了预初始化的管道。
  • data (str 或 Dataset, 默认为 None) — 指定我们将要运行评估的数据集。如果类型为 str，我们将其视为数据集名称并加载它。否则，我们假设它代表预加载的数据集。
  • subset (str, 默认为 None) — 定义要加载的数据集子集。如果传递 None，则加载默认子集。
  • split (str, 默认为 None) — 定义要加载的数据集拆分。如果传递 None，则基于 choose_split 函数进行推断。
  • metric (str 或 EvaluationModule, 默认为 None) — 指定我们在评估器中使用的指标。如果类型为 str，我们将其视为指标名称并加载它。否则，我们假设它代表预加载的指标。
  • tokenizer (str 或 PreTrainedTokenizer, 可选, 默认为 None) — 如果 model_or_pipeline 代表我们为其构建管道的模型，则可以使用此参数覆盖默认的分词器。如果 model_or_pipeline 为 None 或预初始化的管道，我们将忽略此参数。
  • strategy (Literal["simple", "bootstrap"], 默认为 “simple”) — 指定评估策略。可能的值为：
  • confidence_level (float, 默认为 0.95) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 confidence_level 值。
  • n_resamples (int, 默认为 9999) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 n_resamples 值。
  • device (int, 默认为 None) — 用于管道的 CPU/GPU 支持的设备序号。将其设置为 -1 将利用 CPU，正整数将在关联的 CUDA 设备 ID 上运行模型。如果提供 None，它将被推断，如果可用则使用 CUDA:0，否则使用 CPU。
  • random_state (int, 可选, 默认为 None) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 random_state 值。用于调试。
  • input_column (str, 默认为 "text") — 指定由 data 指定的数据集中包含输入文本的列的名称。
  • label_column (str, 默认为 "label") — 包含由 data 指定的数据集中标签的列的名称。
  • generation_kwargs (Dict, 可选, 默认为 None) — 生成 kwargs 传递给 pipeline 并设置文本生成策略。

计算给定 pipeline 和数据集组合的指标。

AutomaticSpeechRecognitionEvaluator

class evaluate.AutomaticSpeechRecognitionEvaluator

< >

( task = 'automatic-speech-recognition' default_metric_name = None )

自动语音识别评估器。此自动语音识别评估器目前可以使用默认任务名称 automatic-speech-recognition 从 evaluator() 加载。此类中的方法假定数据格式与 AutomaticSpeechRecognitionPipeline 兼容。

compute

< >

( model_or_pipeline: typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None data: typing.Union[str, datasets.arrow_dataset.Dataset] = None subset: typing.Optional[str] = None split: typing.Optional[str] = None metric: typing.Union[str, evaluate.module.EvaluationModule] = None tokenizer: typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None strategy: typing.Literal['simple', 'bootstrap'] = 'simple' confidence_level: float = 0.95 n_resamples: int = 9999 device: int = None random_state: typing.Optional[int] = None input_column: str = 'path' label_column: str = 'sentence' generation_kwargs: dict = None )

参数

  • model_or_pipeline (str 或 Pipeline 或 Callable 或 PreTrainedModel 或 TFPreTrainedModel, 默认为 None) — 如果未指定参数，我们将为任务初始化默认 pipeline（在本例中为 text-classification 或其别名 - sentiment-analysis）。如果参数类型为 str 或模型实例，我们将使用它来初始化一个使用给定模型的新 Pipeline。否则，我们假设参数指定了一个预初始化的 pipeline。
  • data (str 或 Dataset, 默认为 None) — 指定我们将运行评估的数据集。如果类型为 str，我们将其视为数据集名称并加载它。否则，我们假设它代表一个预加载的数据集。
  • subset (str, 默认为 None) — 定义要加载的数据集子集。如果传递 None，则加载默认子集。
  • split (str, 默认为 None) — 定义要加载的数据集拆分。如果传递 None，则根据 choose_split 函数进行推断。
  • metric (str 或 EvaluationModule, 默认为 None) — 指定我们在评估器中使用的指标。如果类型为 str，我们将其视为指标名称并加载它。否则，我们假设它代表一个预加载的指标。
  • tokenizer (str 或 PreTrainedTokenizer, *可选*, 默认为 None) — 如果 model_or_pipeline 代表我们为其构建 pipeline 的模型，则可以使用此参数覆盖默认 tokenizer。如果 model_or_pipeline 为 None 或预初始化的 pipeline，我们将忽略此参数。
  • strategy (Literal["simple", "bootstrap"], 默认为 “simple”) — 指定评估策略。可能的值包括：
  • confidence_level (float, 默认为 0.95) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 confidence_level 值。
  • n_resamples (int, 默认为 9999) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 n_resamples 值。
  • device (int, 默认为 None) — 用于 pipeline 的 CPU/GPU 支持的设备序号。将其设置为 -1 将利用 CPU，正整数将在关联的 CUDA 设备 ID 上运行模型。如果提供 None，则将推断并使用 CUDA:0（如果可用），否则使用 CPU。
  • random_state (int, *可选*, 默认为 None) — 如果选择 "bootstrap" 策略，则传递给 bootstrap 的 random_state 值。用于调试很有用。

计算给定 pipeline 和数据集组合的指标。

示例

>>> from evaluate import evaluator
>>> from datasets import load_dataset
>>> task_evaluator = evaluator("automatic-speech-recognition")
>>> data = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="validation[:40]")
>>> results = task_evaluator.compute(
>>>     model_or_pipeline="https://huggingface.co/openai/whisper-tiny.en",
>>>     data=data,
>>>     input_column="path",
>>>     label_column="sentence",
>>>     metric="wer",
>>> )
←Hub methods Visualization methods→