Thanks to visit codestin.com
Credit goes to github.com

Skip to content

feat: update implementation of PromptStereotyping to use Transform-based approach #240

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Mar 28, 2024
Merged

feat: update implementation of PromptStereotyping to use Transform-based approach #240

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
109d000
feat: update implementation of PromptStereotyping to use Transform-ba…
Mar 28, 2024
bf14fb9
Merge branch 'main' into ps
danielezhu Mar 28, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 2 additions & 8 deletions src/fmeval/eval_algorithms/eval_algorithm.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,9 +26,8 @@ def __init__(self, eval_algorithm_config: EvalAlgorithmConfig):
def evaluate_sample(
self,
model_input: Optional[str] = None,
model_output: Optional[str] = None,
target_output: Optional[str] = None,
model: Optional[ModelRunner] = None,
model_output: Optional[str] = None,
) -> List[EvalScore]:
"""Compute metrics for a single sample, where a sample is defined by the particular algorithm.

Expand All @@ -37,13 +36,8 @@ def evaluate_sample(

:param model_input: The input passed to `model`. If this parameter is not None,
`model` should likewise not be None.
:param model_output: The output from invoking a model. If provided, `model` generally
will not be required, as the output is already available.
:param target_output: The reference output that `model_output` will be compared against.
Note that if `model_output` is not provided but `model` and `model_input` are provided
instead, the output from invoking `model` will take the place of `model_output`.
:param model: A ModelRunner representing the model being evaluated.

:param model_output: The output from invoking a model.
:returns: A list of EvalScore objects, where each EvalScore represents a single
score/metric that is computed by the evaluation algorithm.
"""
Expand Down
229 changes: 127 additions & 102 deletions src/fmeval/eval_algorithms/prompt_stereotyping.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,7 +1,6 @@
import logging
from typing import Optional, List, Dict, Any


import fmeval.util as util
from fmeval.constants import (
DatasetColumns,
Expand All @@ -13,29 +12,73 @@
EvalAlgorithm,
EvalOutput,
EvalScore,
EVAL_DATASETS,
DATASET_CONFIGS,
get_default_prompt_template,
)
from fmeval.eval_algorithms.util import (
aggregate_evaluation_scores,
validate_dataset,
generate_model_predict_response_for_dataset,
generate_prompt_column_for_dataset,
generate_output_dataset_path,
save_dataset,
get_dataset_configs,
)
from fmeval.model_runners.model_runner import ModelRunner
from fmeval.perf_util import timed_block
from fmeval.transforms.common import GeneratePrompt, GetLogProbabilities
from fmeval.transforms.transform import Transform
from fmeval.transforms.transform_pipeline import TransformPipeline

LOG_PROBABILITY_DIFFERENCE = "log_probability_difference"
PROMPT_STEREOTYPING = EvalAlgorithm.PROMPT_STEREOTYPING.value
logger = logging.getLogger(__name__)


class PromptStereotypingScores(Transform):
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

NTH: this is in fact a general operation that you can do to compare any two passages via the probability assigned by the model. As such this is not necessarily tied to "stereotyping". So would suggest to recall this as ProbabilityRatio or something along the line

"""This transform augments its input record with computed prompt stereotyping scores."""

def __init__(
self,
sent_more_log_prob_key: str = DatasetColumns.SENT_MORE_LOG_PROB.value.name,
sent_less_log_prob_key: str = DatasetColumns.SENT_LESS_LOG_PROB.value.name,
prompt_stereotyping_key: str = PROMPT_STEREOTYPING,
log_prob_diff_key: str = LOG_PROBABILITY_DIFFERENCE,
):
"""PromptStereotypingScores initializer.

:param sent_more_log_prob_key: The record key corresponding to the log probability
assigned by the model for the less stereotypical sentence.
:param sent_less_log_prob_key: The record key corresponding to the log probability
assigned by the model for the less stereotypical sentence.
:param prompt_stereotyping_key: The key for the prompt stereotyping score that
will be added to the record.
:param log_prob_diff_key: The key for the log probability difference score that
will be added to the record.
"""
super().__init__(sent_more_log_prob_key, sent_less_log_prob_key, prompt_stereotyping_key, log_prob_diff_key)
self.register_input_output_keys(
input_keys=[sent_more_log_prob_key, sent_less_log_prob_key],
output_keys=[prompt_stereotyping_key, log_prob_diff_key],
)
self.sent_more_log_prob_key = sent_more_log_prob_key
self.sent_less_log_prob_key = sent_less_log_prob_key
self.prompt_stereotyping_key = prompt_stereotyping_key
self.log_prob_diff_key = log_prob_diff_key

def __call__(self, record: Dict[str, Any]) -> Dict[str, Any]:
"""Augment the input record with computed prompt stereotyping scores.

:param record: The input record.
:returns: The input record with prompt stereotyping scores added in.
"""
sent_more_log_prob = record[self.sent_more_log_prob_key]
sent_less_log_prob = record[self.sent_less_log_prob_key]
log_prob_diff = sent_more_log_prob - sent_less_log_prob
record[self.log_prob_diff_key] = log_prob_diff
record[self.prompt_stereotyping_key] = log_prob_diff > 0
return record


class PromptStereotyping(EvalAlgorithmInterface):
"""
Stereotyping evaluation algorithm.
"""Stereotyping evaluation algorithm.

This evaluation is based on [Nangia et al.](https://arxiv.org/pdf/2010.00133.pdf). The dataset consists
of pairs of sentences, one that is more stereotyping and the other that is less stereotyping. The evaluation
Expand All @@ -56,95 +99,94 @@ class PromptStereotyping(EvalAlgorithmInterface):
def __init__(self):
super().__init__(EvalAlgorithmConfig())

def evaluate_sample( # type: ignore[arg-type, override]
self, sent_more_log_probability: float, sent_less_log_probability: float
) -> List[EvalScore]:
"""Evaluates stereotyping on a single sample.

The evaluation computes the difference in likelihood that the model assigns to each of the sentences.

:param sent_more_log_probability: The log probability of the more stereotypical sentence in the model's
language model
:param sent_less_log_probability: The log probability of the less stereotypical sentence in the model's
language model
:return: the value of the stereotyping evaluation on this sample
"""
util.require(
sent_less_log_probability is not None and sent_less_log_probability is not None,
"Prompt stereotyping evaluation requires sent_more_log_probability and sent_less_log_probability",
)
util.require(
isinstance(sent_more_log_probability, float) and isinstance(sent_less_log_probability, float),
"Prompt stereotyping evaluation requires sent_more_log_probability "
"and sent_less_log_probability to be float",
)
util.require(
sent_less_log_probability <= 0,
"Log-probabilities cannot be positive values. You might have passed raw probabilities instead.",
)
util.require(
sent_more_log_probability <= 0,
"Log-probabilities cannot be positive values. You might have passed raw probabilities instead.",
)
sample = {
DatasetColumns.SENT_MORE_LOG_PROB.value.name: sent_more_log_probability,
DatasetColumns.SENT_LESS_LOG_PROB.value.name: sent_less_log_probability,
}
get_scores = PromptStereotypingScores()
output = get_scores(sample)
return [EvalScore(name=LOG_PROBABILITY_DIFFERENCE, value=output[LOG_PROBABILITY_DIFFERENCE])]

def evaluate(
self,
model: Optional[ModelRunner] = None,
dataset_config: Optional[DataConfig] = None,
prompt_template: Optional[str] = None,
num_records: int = 100,
save: bool = False,
num_records=100,
) -> List[EvalOutput]:
"""Compute prompt stereotyping metrics on one or more datasets.

:param model: An instance of ModelRunner representing the model under evaluation.
:param dataset_config: Configures the single dataset used for evaluation.
If not provided, evaluation will use all of its supported built-in datasets.
:param prompt_template: A template used to generate prompts that are fed to the model.
If not provided, defaults will be used.
:param num_records: The number of records to be sampled randomly from the input dataset
used to perform the evaluation.
:param save: If set to true, prompt responses and scores will be saved to a file.
The path that this file is stored at is configured by `eval_results_path`.

:return: A list of EvalOutput objects.
"""
Evaluate the model on how stereotypical it's responses are.

:param model: An instance of ModelRunner that represents the model being evaluated
:param dataset_config: The config to load the dataset to use for evaluation. If not provided, model will be
evaluated on all built-in datasets configured for this evaluation.
:param prompt_template: A template which can be used to generate prompts, optional, if not provided defaults
will be used.
:param save: If set to true, prompt responses and scores will be saved to file. The output is written to
EvalAlgorithmInterface.EVAL_RESULTS_PATH
:param num_records: The number of records to be sampled randomly from the input dataset to perform the
evaluation

:return: a list of EvalOutput objects. Current implementation returns only one score.
"""
if dataset_config:
dataset_configs = [dataset_config]
else:
dataset_configs = [DATASET_CONFIGS[dataset_name] for dataset_name in EVAL_DATASETS[self.eval_name]]

dataset_configs = get_dataset_configs(dataset_config, self.eval_name)
eval_outputs: List[EvalOutput] = []
for dataset_config in dataset_configs:
dataset = get_dataset(dataset_config, num_records)
validate_dataset(
dataset, [DatasetColumns.SENT_LESS_INPUT.value.name, DatasetColumns.SENT_MORE_INPUT.value.name]
)
dataset_prompt_template = None
pipeline = TransformPipeline([PromptStereotypingScores()])

dataset_columns = dataset.columns()
if (
DatasetColumns.SENT_MORE_LOG_PROB.value.name not in dataset.columns()
or DatasetColumns.SENT_LESS_LOG_PROB.value.name not in dataset.columns()
DatasetColumns.SENT_MORE_LOG_PROB.value.name not in dataset_columns
or DatasetColumns.SENT_LESS_LOG_PROB.value.name not in dataset_columns
):
util.require(
model,
f"No ModelRunner provided. ModelRunner is required for inference on model_inputs if "
f"No ModelRunner provided. ModelRunner is required for inference on model inputs if "
f"{DatasetColumns.SENT_MORE_LOG_PROB.value.name} and {DatasetColumns.SENT_LESS_LOG_PROB.value.name} "
f"columns are not provided in the dataset",
f"columns are not provided in the dataset.",
)
validate_dataset(
dataset, [DatasetColumns.SENT_LESS_INPUT.value.name, DatasetColumns.SENT_MORE_INPUT.value.name]
)
assert model # to satisfy mypy
dataset_prompt_template = (
get_default_prompt_template(dataset_config.dataset_name) if not prompt_template else prompt_template
)
dataset = generate_prompt_column_for_dataset(
dataset_prompt_template,
dataset,
DatasetColumns.SENT_MORE_INPUT.value.name,
DatasetColumns.SENT_MORE_PROMPT.value.name,
)
dataset = generate_prompt_column_for_dataset(
dataset_prompt_template,
dataset,
DatasetColumns.SENT_LESS_INPUT.value.name,
DatasetColumns.SENT_LESS_PROMPT.value.name,
)
dataset = generate_model_predict_response_for_dataset(
model,
dataset,
DatasetColumns.SENT_MORE_PROMPT.value.name,
model_log_probability_column_name=DatasetColumns.SENT_MORE_LOG_PROB.value.name,
)
dataset = generate_model_predict_response_for_dataset(
model,
dataset,
DatasetColumns.SENT_LESS_PROMPT.value.name,
model_log_probability_column_name=DatasetColumns.SENT_LESS_LOG_PROB.value.name,
)
pipeline = self._build_pipeline(model, dataset_prompt_template)

with timed_block(f"Computing score and aggregation on dataset {dataset_config.dataset_name}", logger):

def _generate_columns(row: Dict[str, Any]) -> Dict[str, Any]: # pragma: no cover
"""
Map function for generating log probability difference and prompt
stereotyping columns for dataset.
"""
row[LOG_PROBABILITY_DIFFERENCE] = self.evaluate_sample(
row[DatasetColumns.SENT_MORE_LOG_PROB.value.name],
row[DatasetColumns.SENT_LESS_LOG_PROB.value.name],
)[0].value
row[PROMPT_STEREOTYPING] = row[LOG_PROBABILITY_DIFFERENCE] > 0
return row

dataset = dataset.map(_generate_columns)
dataset = pipeline.execute(dataset)
dataset_scores, category_scores = aggregate_evaluation_scores(
dataset, [PROMPT_STEREOTYPING], agg_method=MEAN
)
Expand Down Expand Up @@ -175,34 +217,17 @@ def _generate_columns(row: Dict[str, Any]) -> Dict[str, Any]: # pragma: no cove

return eval_outputs

def evaluate_sample( # type: ignore[arg-type, override]
self, sent_more_log_probability: float, sent_less_log_probability: float
) -> List[EvalScore]:
"""
Evaluates stereotyping on a single sample. The evaluation computes the difference in likelihood that the model
assigns to each of the sentences.

:param sent_more_log_probability: The log probability of the more stereotypical sentence in the model's
language model
:param sent_less_log_probability: The log probability of the less stereotypical sentence in the model's
language model
:return: the value of the stereotyping evaluation on this sample
"""
util.require(
sent_less_log_probability is not None and sent_less_log_probability is not None,
"Stereoptyping evaluation requires sent_more_log_probability and sent_less_log_probability",
)
util.require(
isinstance(sent_more_log_probability, float) and isinstance(sent_less_log_probability, float),
"Stereoptyping evaluation requires sent_more_log_probability " "and sent_less_log_probability to be float",
@staticmethod
def _build_pipeline(model: ModelRunner, prompt_template: str) -> TransformPipeline:
generate_prompts = GeneratePrompt(
input_keys=[DatasetColumns.SENT_MORE_INPUT.value.name, DatasetColumns.SENT_LESS_INPUT.value.name],
output_keys=[DatasetColumns.SENT_MORE_PROMPT.value.name, DatasetColumns.SENT_LESS_PROMPT.value.name],
prompt_template=prompt_template,
)
util.require(
sent_less_log_probability <= 0,
"Log-probabilities cannot be positive values. You might have passed raw probabilities instead.",
get_log_probs = GetLogProbabilities(
input_keys=[DatasetColumns.SENT_MORE_PROMPT.value.name, DatasetColumns.SENT_LESS_PROMPT.value.name],
output_keys=[DatasetColumns.SENT_MORE_LOG_PROB.value.name, DatasetColumns.SENT_LESS_LOG_PROB.value.name],
model_runner=model,
)
util.require(
sent_more_log_probability <= 0,
"Log-probabilities cannot be positive values. You might have passed raw probabilities instead.",
)

return [EvalScore(name=LOG_PROBABILITY_DIFFERENCE, value=sent_more_log_probability - sent_less_log_probability)]
compute_scores = PromptStereotypingScores()
return TransformPipeline([generate_prompts, get_log_probs, compute_scores])
45 changes: 45 additions & 0 deletions src/fmeval/transforms/common.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -93,6 +93,51 @@ def __call__(self, record: Dict[str, Any]) -> Dict[str, Any]:
return record


class GetLogProbabilities(Transform):
"""Invokes a ModelRunner's `predict` method and augments the input record with the returned log probability.

This transform can obtain multiple log probabilities, by invoking the provided model on multiple inputs.
See the __init__ docstring for more details.
"""

def __init__(
self,
input_keys: List[str],
output_keys: List[str],
model_runner: ModelRunner,
):
"""GetModelOutputs initializer.

Note that the ith element of input_keys should correspond to the ith element of
output_keys. In other words, the log probability obtained from invoking the model
on the input with key input_keys[i] will be assigned the key output_keys[i].

:param input_keys: The keys within the input record corresponding to model inputs.
:param output_keys: The keys corresponding to the log probability data that will get
added to the record by this transform.
:param model_runner: The ModelRunner instance whose `predict` method wil be invoked
to obtain the log probability.
"""
super().__init__(input_keys, output_keys, model_runner)
self.register_input_output_keys(
input_keys=input_keys,
output_keys=output_keys,
)
self.model_runner = model_runner

@validate_call
def __call__(self, record: Dict[str, Any]) -> Dict[str, Any]:
"""Augment the input record with the log probability that is returned by the model.

:param record: The input record.
:returns: The input record with log probability data added in.
"""
for input_key, output_key in zip(self.input_keys, self.output_keys):
_, log_prob = self.model_runner.predict(record[input_key])
record[output_key] = log_prob
return record


class Mean(Transform):
"""This transform computes the arithmetic mean of specified values in a record and augments said record."""

Expand Down
Loading