Hugging Face 的 LOGO

Evaluate 文件

評估器

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 or Dataset) — 指定我們將進行評估的資料集。
  • columns_names (List[str]) — 資料集中要檢查的列名列表。鍵是 evaluate.EvaluationModule.compute() 方法的引數，而值是要檢查的列名。

確保評估所需的列存在於資料集中。

示例

>>> from datasets import load_dataset
>>> from evaluate import evaluator
>>> data = load_dataset("rotten_tomatoes', split="train")
>>> evaluator.check_required_columns(data, {"input_column": "text", "label_column": "label"})

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`

如果給定 `None`，則推斷使用哪個分割。

示例

>>> from evaluate import evaluator
>>> evaluator("text-classification").get_dataset_split(data="rotten_tomatoes")
WARNING:evaluate.evaluator.base:Dataset split not defined! Automatically evaluating with split: TEST
'test'

load_data

< >

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

引數

  • data (Dataset or str, 預設為 None) — 指定我們將進行評估的資料集。如果型別是 str，我們將其視為資料集名稱並載入它。否則我們假設它代表一個預載入的資料集。
  • subset (str, 預設為 None) — 指定要傳遞給 load_dataset 中 name 的資料集子集。用於具有多種配置的資料集（例如 glue/sst2）。
  • split (str, 預設為 None) — 使用者定義的資料集分割名稱（例如 train、validation、test）。支援切片分割 (test[:n])。如果未定義且資料是 str 型別，將透過 choose_split() 自動選擇最佳分割。

返回

data (Dataset)

將用於評估的已載入資料集。

載入具有給定子集和分割的資料集。

示例

>>> from evaluate import evaluator
>>> evaluator("text-classification").load_data(data="rotten_tomatoes", split="train")
Dataset({
    features: ['text', 'label'],
    num_rows: 8530
})

predictions_processor

< >

( *args **kwargs )

Evaluator 類的一個核心方法，它處理流水線輸出以相容指標。

prepare_data

< >

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

引數

  • data (Dataset) — 指定我們將進行評估的資料集。
  • input_column (str, 預設為 "text") — `data` 指定的資料集中包含文字特徵的列的名稱。
  • second_input_column(str, 可選) — 如果有第二個文字特徵，則為包含該特徵的列的名稱。否則，設定為 None。
  • label_column (str, 預設為 "label") — `data` 指定的資料集中包含標籤的列的名稱。

返回

字典

指標輸入。`list`：流水線輸入。

準備資料。

示例

>>> from evaluate import evaluator
>>> from datasets import load_dataset

>>> ds = load_dataset("rotten_tomatoes", split="train")
>>> evaluator("text-classification").prepare_data(ds, input_column="text", second_input_column=None, label_column="label")

prepare_metric

< >

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

引數

  • metric (str 或 EvaluationModule, 預設為 None) — 指定我們在評估器中使用的指標。如果型別是 str，我們將其視為指標名稱並載入它。否則我們假設它代表一個預載入的指標。

準備指標。

示例

>>> from evaluate import evaluator
>>> evaluator("text-classification").prepare_metric("accuracy")

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, 預設為 None) — 如果未指定此引數，我們將為任務初始化預設的流水線。如果引數型別為 str 或模型例項，我們用它來初始化一個新的 Pipeline。否則我們假設引數指定了一個預初始化的流水線。
  • preprocessor (PreTrainedTokenizerBase 或 FeatureExtractionMixin, 可選, 預設為 None) — 如果 model_or_pipeline 代表一個我們為其構建流水線的模型，此引數可用於覆蓋預設的預處理器。如果 model_or_pipeline 是 None 或一個預初始化的流水線，我們將忽略此引數。

準備流水線。

示例

>>> from evaluate import evaluator
>>> evaluator("text-classification").prepare_pipeline(model_or_pipeline="distilbert-base-uncased")

特定任務的評估器

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.Optional[typing.Dict[str, numbers.Number]] = 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 代表一個我們為其構建流水線的模型，此引數可用於覆蓋預設的 tokenizer。如果 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) — 用於管道（pipeline）的 CPU/GPU 支援的裝置序號。將其設定為 -1 將使用 CPU，設定為正整數將在相應的 CUDA 裝置 ID 上執行模型。如果提供 None，則會自動推斷，如果 CUDA:0 可用則使用它，否則使用 CPU。
  • random_state (int, 可選, 預設為 None) — 如果選擇 "bootstrap" 策略，則將 random_state 值傳遞給 bootstrap。這對於除錯非常有用。

計算給定管道和資料集組合的指標。

示例

>>> 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 )

問答評估器。該評估器處理抽取式問答，即從上下文中提取問題的答案。

目前，可以使用預設任務名稱 question-answering 從 evaluator() 載入此問答評估器。

此類中的方法假定資料格式與 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) — 如果未指定此引數，我們將初始化任務的預設管道（在此情況下為 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" 策略，則將 confidence_level 值傳遞給 bootstrap。
  • n_resamples (int, 預設為 9999) — 如果選擇 "bootstrap" 策略，則將 n_resamples 值傳遞給 bootstrap。
  • device (int, 預設為 None) — 用於管道（pipeline）的 CPU/GPU 支援的裝置序號。將其設定為 -1 將使用 CPU，設定為正整數將在相應的 CUDA 裝置 ID 上執行模型。如果提供 None，則會自動推斷，如果 CUDA:0 可用則使用它，否則使用 CPU。
  • random_state (int, 可選, 預設為 None) — 如果選擇 "bootstrap" 策略，則將 random_state 值傳遞給 bootstrap。這對於除錯非常有用。

計算給定管道和資料集組合的指標。

示例

>>> 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 資料集。在這種情況下，向 compute() 呼叫傳遞 squad_v2_format=True 更為安全。

>>> 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 )

文字分類評估器。目前，可以使用預設任務名稱 text-classification 或別名 "sentiment-analysis" 從 evaluator() 載入此文字分類評估器。此類中的方法假定資料格式與 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.Optional[typing.Dict[str, numbers.Number]] = 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" 策略，則將 confidence_level 值傳遞給 bootstrap。
  • n_resamples (int, 預設為 9999) — 如果選擇 "bootstrap" 策略，則將 n_resamples 值傳遞給 bootstrap。
  • device (int, 預設為 None) — 用於管道（pipeline）的 CPU/GPU 支援的裝置序號。將其設定為 -1 將使用 CPU，設定為正整數將在相應的 CUDA 裝置 ID 上執行模型。如果提供 None，則會自動推斷，如果 CUDA:0 可用則使用它，否則使用 CPU。
  • random_state (int, 可選, 預設為 None) — 如果選擇 "bootstrap" 策略，則將 random_state 值傳遞給 bootstrap。這對於除錯非常有用。

計算給定管道和資料集組合的指標。

示例

>>> 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() 載入此詞元分類評估器。

此類中的方法假定資料格式與 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) — 如果未指定此引數，我們將初始化任務的預設管道（在此情況下為 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" 策略，則將 confidence_level 值傳遞給 bootstrap。
  • n_resamples (int, 預設為 9999) — 如果選擇 "bootstrap" 策略，則將 n_resamples 值傳遞給 bootstrap。
  • device (int, 預設為 None) — 用於管道（pipeline）的 CPU/GPU 支援的裝置序號。將其設定為 -1 將使用 CPU，設定為正整數將在相應的 CUDA 裝置 ID 上執行模型。如果提供 None，則會自動推斷，如果 CUDA:0 可用則使用它，否則使用 CPU。
  • random_state (int, 可選, 預設為 None) — 如果選擇 "bootstrap" 策略，則將 random_state 值傳遞給 bootstrap。這對於除錯非常有用。

計算給定管道和資料集組合的指標。

資料集的輸入和標籤列應分別格式化為單詞列表和標籤列表，遵循 conll2003 資料集 的格式。不支援輸入為單個字串、標籤為偏移量列表的資料集。

示例

>>> 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",
>>> )

例如，評估器接受以下資料集格式

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"])),
        }),
)

例如，評估器不接受以下資料集格式

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() 載入此文字生成評估器。此類中的方法假定資料格式與 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.Optional[typing.Dict[str, numbers.Number]] = None )

文字到文字生成評估器 (Text2TextGenerationEvaluator)

class evaluate.Text2TextGenerationEvaluator

< >

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

文字到文字生成評估器。目前，可以使用預設任務名稱 text2text-generation 從 evaluator() 載入此文字到文字生成評估器。此類中的方法假定資料格式與 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) — 如果未指定此引數，我們將初始化該任務的預設管道（在這種情況下為 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) — generation_kwargs 傳遞給管道並設定文字生成策略。

計算給定管道和資料集組合的指標。

示例

>>> from evaluate import evaluator
>>> from datasets import load_dataset
>>> task_evaluator = evaluator("text2text-generation")
>>> data = load_dataset("cnn_dailymail", "3.0.0", split="validation[:40]")
>>> results = task_evaluator.compute(
>>>     model_or_pipeline="facebook/bart-large-cnn",
>>>     data=data,
>>>     input_column="article",
>>>     label_column="highlights",
>>>     metric="rouge",
>>> )

摘要評估器 (SummarizationEvaluator)

class evaluate.SummarizationEvaluator

< >

( task = 'summarization' default_metric_name = None )

文字摘要評估器。目前，可以使用預設任務名稱 summarization 從 evaluator() 載入此文字摘要評估器。此類中的方法假定資料格式與 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) — 如果未指定此引數，我們將初始化該任務的預設管道（在這種情況下為 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) — generation_kwargs 傳遞給管道並設定文字生成策略。

計算給定管道和資料集組合的指標。

示例

>>> from evaluate import evaluator
>>> from datasets import load_dataset
>>> task_evaluator = evaluator("summarization")
>>> data = load_dataset("cnn_dailymail", "3.0.0", split="validation[:40]")
>>> results = task_evaluator.compute(
>>>     model_or_pipeline="facebook/bart-large-cnn",
>>>     data=data,
>>>     input_column="article",
>>>     label_column="highlights",
>>> )

翻譯評估器 (TranslationEvaluator)

class evaluate.TranslationEvaluator

< >

( task = 'translation' default_metric_name = None )

翻譯評估器。目前，可以使用預設任務名稱 translation 從 evaluator() 載入此翻譯生成評估器。此類中的方法假定資料格式與 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) — generation kwargs 會傳遞給 pipeline 並設定文字生成策略。

計算給定管道和資料集組合的指標。

示例

>>> from evaluate import evaluator
>>> from datasets import load_dataset
>>> task_evaluator = evaluator("translation")
>>> data = load_dataset("wmt19", "fr-de", split="validation[:40]")
>>> data = data.map(lambda x: {"text": x["translation"]["de"], "label": x["translation"]["fr"]})
>>> results = task_evaluator.compute(
>>>     model_or_pipeline="Helsinki-NLP/opus-mt-de-fr",
>>>     data=data,
>>> )

AutomaticSpeechRecognitionEvaluator

class evaluate.AutomaticSpeechRecognitionEvaluator

< >

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

自動語音識別評估器。此自動語音識別評估器目前可從 evaluator() 使用預設任務名稱 automatic-speech-recognition 載入。此類中的方法假定資料格式與 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 值。對除錯很有用。

計算給定管道和資料集組合的指標。

示例

>>> 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",
>>> )

AudioClassificationEvaluator

class evaluate.AudioClassificationEvaluator

< >

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

音訊分類評估器。此音訊分類評估器目前可從 evaluator() 使用預設任務名稱 audio-classification 載入。此類中的方法假定資料格式與 transformers.AudioClassificationPipeline 相容。

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 = 'file' label_column: str = 'label' label_mapping: typing.Optional[typing.Dict[str, numbers.Number]] = 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 值。對除錯很有用。

計算給定管道和資料集組合的指標。

示例

請記住，為了處理音訊檔案，您需要安裝 ffmpeg（https://ffmpeg.org/download.html）

>>> from evaluate import evaluator
>>> from datasets import load_dataset

>>> task_evaluator = evaluator("audio-classification")
>>> data = load_dataset("superb", 'ks', split="test[:40]")
>>> results = task_evaluator.compute(
>>>     model_or_pipeline=""superb/wav2vec2-base-superb-ks"",
>>>     data=data,
>>>     label_column="label",
>>>     input_column="file",
>>>     metric="accuracy",
>>>     label_mapping={0: "yes", 1: "no", 2: "up", 3: "down"}
>>> )

評估器也支援原始音訊資料，形式為 numpy 陣列。但是，請注意，呼叫音訊列會自動解碼和重取樣音訊檔案，這對於大型資料集可能會很慢。

>>> from evaluate import evaluator
>>> from datasets import load_dataset

>>> task_evaluator = evaluator("audio-classification")
>>> data = load_dataset("superb", 'ks', split="test[:40]")
>>> data = data.map(lambda example: {"audio": example["audio"]["array"]})
>>> results = task_evaluator.compute(
>>>     model_or_pipeline=""superb/wav2vec2-base-superb-ks"",
>>>     data=data,
>>>     label_column="label",
>>>     input_column="audio",
>>>     metric="accuracy",
>>>     label_mapping={0: "yes", 1: "no", 2: "up", 3: "down"}
>>> )
< > 在 GitHub 上更新

←Hub 方法 視覺化方法→
© . This site is unofficial and not affiliated with Hugging Face, Inc.