From ef1991ce4ace6db229ea2a4f00f06d7fc9cb0c65 Mon Sep 17 00:00:00 2001 From: Laerdon Kim <96972420+laerdon@users.noreply.github.com> Date: Wed, 1 Apr 2026 12:23:32 -0400 Subject: [PATCH 01/21] Introduce pluggable decision policies for ForecasterModel (#1) * refactor forecaster model to use decision policies Co-authored-by: Laerdon Kim * update forecaster models for score and policy orchestration Co-authored-by: Laerdon Kim --------- Co-authored-by: Cursor Agent Co-authored-by: Laerdon Kim --- convokit/__init__.py | 1 + convokit/decisionpolicy/__init__.py | 3 + convokit/decisionpolicy/decisionPolicy.py | 41 ++++ .../decisionpolicy/deferralDecisionPolicy.py | 144 ++++++++++++++ .../decisionpolicy/thresholdDecisionPolicy.py | 57 ++++++ convokit/forecaster/CRAFTModel.py | 178 ++++++++++++++---- .../forecaster/TransformerDecoderModel.py | 81 +++++--- .../forecaster/TransformerEncoderModel.py | 96 +++++++--- convokit/forecaster/__init__.py | 1 + convokit/forecaster/cumulativeBoW.py | 35 ++++ convokit/forecaster/forecaster.py | 4 +- convokit/forecaster/forecasterModel.py | 61 +++++- docs/source/decisionpolicy.rst | 9 + docs/source/forecaster.rst | 1 + 14 files changed, 626 insertions(+), 86 deletions(-) create mode 100644 convokit/decisionpolicy/__init__.py create mode 100644 convokit/decisionpolicy/decisionPolicy.py create mode 100644 convokit/decisionpolicy/deferralDecisionPolicy.py create mode 100644 convokit/decisionpolicy/thresholdDecisionPolicy.py create mode 100644 docs/source/decisionpolicy.rst diff --git a/convokit/__init__.py b/convokit/__init__.py index 9bd3462b9..d2a8f4f9a 100644 --- a/convokit/__init__.py +++ b/convokit/__init__.py @@ -21,6 +21,7 @@ "classifier": ".classifier", "ranker": ".ranker", "forecaster": ".forecaster", + "decisionpolicy": ".decisionpolicy", "fighting_words": ".fighting_words", "paired_prediction": ".paired_prediction", "bag_of_words": ".bag_of_words", diff --git a/convokit/decisionpolicy/__init__.py b/convokit/decisionpolicy/__init__.py new file mode 100644 index 000000000..43e3ab9bc --- /dev/null +++ b/convokit/decisionpolicy/__init__.py @@ -0,0 +1,3 @@ +from .decisionPolicy import * +from .thresholdDecisionPolicy import * +from .deferralDecisionPolicy import * diff --git a/convokit/decisionpolicy/decisionPolicy.py b/convokit/decisionpolicy/decisionPolicy.py new file mode 100644 index 000000000..f0aca8546 --- /dev/null +++ b/convokit/decisionpolicy/decisionPolicy.py @@ -0,0 +1,41 @@ +from abc import ABC, abstractmethod +from typing import Callable + + +class DecisionPolicy(ABC): + """ + Abstract interface for converting a conversational context into an action. + """ + + def __init__(self): + self._labeler = None + + @property + def labeler(self): + return self._labeler + + @labeler.setter + def labeler(self, value: Callable): + self._labeler = value + + @abstractmethod + def decide(self, context, score_fn: Callable) -> int: + """ + Decide whether to intervene for a context. + + :param context: context tuple supplied by Forecaster + :param score_fn: callable that maps a context tuple to a scalar score + :return: integer action label (currently 0/1) + """ + pass + + @abstractmethod + def fit(self, contexts, val_contexts=None, score_fn: Callable = None): + """ + Fit policy-specific parameters if needed. + + :param contexts: training contexts for policy fitting + :param val_contexts: optional validation contexts + :param score_fn: optional scorer callable exposed by ForecasterModel + """ + pass diff --git a/convokit/decisionpolicy/deferralDecisionPolicy.py b/convokit/decisionpolicy/deferralDecisionPolicy.py new file mode 100644 index 000000000..ab8d2848e --- /dev/null +++ b/convokit/decisionpolicy/deferralDecisionPolicy.py @@ -0,0 +1,144 @@ +from itertools import tee +from typing import Callable, List, Optional + +import numpy as np +from sklearn.metrics import roc_curve + +from .decisionPolicy import DecisionPolicy + + +class _synthetic_speaker: + def __init__(self, speaker_id: str): + self.id = speaker_id + + +class _synthetic_utterance: + def __init__(self, text: str, utterance_id: str, speaker_id: str): + self.text = text + self.id = utterance_id + self.speaker_ = _synthetic_speaker(speaker_id) + self.meta = {} + + def get_conversation(self): + return None + + +class DeferralDecisionPolicy(DecisionPolicy): + """ + Decision policy that can defer intervention using simulated next utterances. + """ + + def __init__( + self, + simulator=None, + threshold: float = 0.5, + num_simulations: int = 3, + aggregation: str = "mean", + ): + super().__init__() + self.simulator = simulator + self.threshold = float(threshold) + self.num_simulations = int(num_simulations) + self.aggregation = aggregation + + def _aggregate_scores(self, scores: List[float]) -> float: + if len(scores) == 0: + return 0.0 + if self.aggregation == "max": + return float(np.max(scores)) + if self.aggregation == "min": + return float(np.min(scores)) + return float(np.mean(scores)) + + def get_simulations(self, context, simulator=None, k: Optional[int] = None) -> List[str]: + simulator = simulator if simulator is not None else self.simulator + if k is None: + k = self.num_simulations + if simulator is None: + return [] + if callable(simulator): + sims = simulator(context, k) + return list(sims)[:k] + if hasattr(simulator, "get_simulations"): + sims = simulator.get_simulations(context, k) + return list(sims)[:k] + if hasattr(simulator, "transform"): + sims = simulator.transform(iter([context])) + if context.current_utterance.id in sims.index: + col_name = sims.columns[0] + return list(sims.loc[context.current_utterance.id][col_name])[:k] + return [] + + def _build_simulated_context(self, context, simulation_text: str, simulation_idx: int): + current_utt = context.current_utterance + synthetic_utt = _synthetic_utterance( + text=simulation_text, + utterance_id=f"{current_utt.id}__sim_{simulation_idx}", + speaker_id="simulator", + ) + new_context_utts = list(context.context) + [synthetic_utt] + context_cls = context.__class__ + return context_cls( + context=new_context_utts, + current_utterance=synthetic_utt, + future_context=None, + conversation_id=context.conversation_id, + ) + + def _decision_score(self, context, score_fn: Callable) -> float: + current_score = float(score_fn(context)) + simulations = self.get_simulations(context) + if len(simulations) == 0: + return current_score + simulation_scores = [] + for idx, sim_text in enumerate(simulations): + sim_context = self._build_simulated_context(context, sim_text, idx) + simulation_scores.append(float(score_fn(sim_context))) + return self._aggregate_scores([current_score] + simulation_scores) + + def decide(self, context, score_fn: Callable) -> int: + decision_score = self._decision_score(context, score_fn) + return int(decision_score > self.threshold) + + def fit(self, contexts, val_contexts=None, score_fn: Callable = None): + if self.simulator is not None and hasattr(self.simulator, "fit"): + if val_contexts is None: + sim_contexts = contexts + sim_val_contexts = None + else: + sim_contexts, contexts = tee(contexts, 2) + sim_val_contexts, val_contexts = tee(val_contexts, 2) + self.simulator.fit(sim_contexts, sim_val_contexts) + + if val_contexts is None or score_fn is None or self.labeler is None: + return {"threshold": self.threshold} + val_contexts = list(val_contexts) + if len(val_contexts) == 0: + return {"threshold": self.threshold} + + highest_convo_scores = {} + convo_labels = {} + for context in val_contexts: + convo_id = context.conversation_id + score = self._decision_score(context, score_fn) + label = int(self.labeler(context.current_utterance.get_conversation())) + if convo_id not in highest_convo_scores: + highest_convo_scores[convo_id] = score + else: + highest_convo_scores[convo_id] = max(highest_convo_scores[convo_id], score) + convo_labels[convo_id] = label + + convo_ids = list(highest_convo_scores.keys()) + y_true = np.asarray([convo_labels[c] for c in convo_ids]) + y_score = np.asarray([highest_convo_scores[c] for c in convo_ids]) + try: + _, _, thresholds = roc_curve(y_true, y_score) + except ValueError: + return {"threshold": self.threshold} + if len(thresholds) == 0: + return {"threshold": self.threshold} + + accs = [((y_score > t).astype(int) == y_true).mean() for t in thresholds] + best_idx = int(np.argmax(accs)) + self.threshold = float(thresholds[best_idx]) + return {"threshold": self.threshold, "best_val_accuracy": float(accs[best_idx])} diff --git a/convokit/decisionpolicy/thresholdDecisionPolicy.py b/convokit/decisionpolicy/thresholdDecisionPolicy.py new file mode 100644 index 000000000..0f3814a44 --- /dev/null +++ b/convokit/decisionpolicy/thresholdDecisionPolicy.py @@ -0,0 +1,57 @@ +from typing import Callable + +import numpy as np +from sklearn.metrics import roc_curve + +from .decisionPolicy import DecisionPolicy + + +class ThresholdDecisionPolicy(DecisionPolicy): + """ + A simple decision policy that predicts 1 when score > threshold. + """ + + def __init__(self, threshold: float = 0.5): + super().__init__() + self.threshold = float(threshold) + + def decide(self, context, score_fn: Callable) -> int: + return int(score_fn(context) > self.threshold) + + def fit(self, contexts, val_contexts=None, score_fn: Callable = None): + if val_contexts is None or score_fn is None or self.labeler is None: + return {"best_threshold": self.threshold} + + val_contexts = list(val_contexts) + if len(val_contexts) == 0: + return {"best_threshold": self.threshold} + + highest_convo_scores = {} + convo_labels = {} + for context in val_contexts: + convo_id = context.conversation_id + score = score_fn(context) + label = int(self.labeler(context.current_utterance.get_conversation())) + if convo_id not in highest_convo_scores: + highest_convo_scores[convo_id] = score + else: + highest_convo_scores[convo_id] = max(highest_convo_scores[convo_id], score) + convo_labels[convo_id] = label + + convo_ids = list(highest_convo_scores.keys()) + y_true = np.asarray([convo_labels[c] for c in convo_ids]) + y_score = np.asarray([highest_convo_scores[c] for c in convo_ids]) + + # roc_curve can fail when only one class is present; keep current threshold in that case. + try: + _, _, thresholds = roc_curve(y_true, y_score) + except ValueError: + return {"best_threshold": self.threshold} + + if len(thresholds) == 0: + return {"best_threshold": self.threshold} + + accs = [((y_score > t).astype(int) == y_true).mean() for t in thresholds] + best_idx = int(np.argmax(accs)) + self.threshold = float(thresholds[best_idx]) + return {"best_threshold": self.threshold, "best_val_accuracy": float(accs[best_idx])} diff --git a/convokit/forecaster/CRAFTModel.py b/convokit/forecaster/CRAFTModel.py index b0937e7f4..e100e0a1e 100644 --- a/convokit/forecaster/CRAFTModel.py +++ b/convokit/forecaster/CRAFTModel.py @@ -10,13 +10,12 @@ from convokit import download, warn from convokit.convokitConfig import ConvoKitConfig from .CRAFT.model import EncoderRNN, ContextEncoderRNN, SingleTargetClf -from .CRAFT.runners import Predictor, trainIters, evaluateDataset +from .CRAFT.runners import Predictor, trainIters, evaluateBatch from .forecasterModel import ForecasterModel -import numpy as np -import torch.nn.functional as F from torch import optim, nn from typing import Dict, Union import os +from convokit.decisionpolicy import ThresholdDecisionPolicy # parameters baked into the model design (because the provided models were saved with these parameters); # these cannot be changed by the user @@ -89,8 +88,9 @@ def __init__( decision_threshold: Union[float, str] = "auto", torch_device: str = "cpu", config: dict = DEFAULT_CONFIG, + decision_policy=None, ): - super().__init__() + super().__init__(decision_policy=decision_policy) # load the initial weights and store this as the current model if initial_weights in MODEL_FILENAME_MAP: @@ -131,18 +131,36 @@ def __init__( raise TypeError("CRAFTModel: decision_threshold must be either a float or 'auto'") self._decision_threshold = DECISION_THRESHOLDS.get(initial_weights, 0.5) + if isinstance(self.decision_policy, ThresholdDecisionPolicy): + self.decision_policy.threshold = float(self._decision_threshold) + self._device = torch.device(torch_device) self._config = config + self._inference_components = None + + @property + def best_threshold(self): + if hasattr(self.decision_policy, "threshold"): + return self.decision_policy.threshold + return None - def _context_to_craft_data(self, contexts): + @best_threshold.setter + def best_threshold(self, value): + if hasattr(self.decision_policy, "threshold"): + self.decision_policy.threshold = float(value) + + def _context_to_craft_data(self, contexts, include_labels=True): """ Convert context utterances to a list of token-lists using the model's vocabulary object, maintaining the original temporal ordering """ pairs = [] for context in contexts: - convo = context.current_utterance.get_conversation() - label = self.labeler(convo) + if include_labels: + convo = context.current_utterance.get_conversation() + label = self.labeler(convo) + else: + label = 0 processed_context = processContext(self._voc, context, label) utt = processed_context[-1]["tokens"][: (MAX_LENGTH - 1)] context_utts = [u["tokens"][: (MAX_LENGTH - 1)] for u in processed_context] @@ -188,7 +206,17 @@ def _init_craft(self): return embedding, encoder, context_encoder, attack_clf - def fit(self, contexts, val_contexts=None): + def _get_inference_components(self): + if self._inference_components is None: + embedding, encoder, context_encoder, attack_clf = self._init_craft() + encoder.eval() + context_encoder.eval() + attack_clf.eval() + predictor = Predictor(encoder, context_encoder, attack_clf) + self._inference_components = (encoder, context_encoder, predictor) + return self._inference_components + + def fit_belief_estimator(self, contexts, val_contexts=None): """ Fine-tune the CRAFT model, and save the best model according to validation performance. @@ -196,12 +224,12 @@ def fit(self, contexts, val_contexts=None): :param val_contexts: an iterator over context tuples to be used only for validation. IMPORTANT: this is marked Optional only for compatibility with the generic Forecaster API; CRAFT actually REQUIRES a validation set so leaving this parameter at None will raise an error! """ # convert the input contexts into CRAFT's data format - train_pairs = self._context_to_craft_data(contexts) + train_pairs = self._context_to_craft_data(contexts, include_labels=True) print("Processed", len(train_pairs), "context tuples for model training") # val_contexts is made Optional to conform to the Forecaster spec, but in reality CRAFT requires a validation set if val_contexts is None: raise ValueError("CRAFTModel requires a validation set!") - val_pairs = self._context_to_craft_data(val_contexts) + val_pairs = self._context_to_craft_data(val_contexts, include_labels=True) print("Processed", len(val_pairs), "context tuples for model validation") # initialize the CRAFT model with whatever weights we currently have saved @@ -252,6 +280,50 @@ def fit(self, contexts, val_contexts=None): # save the resulting checkpoints so we can load them later during transform self._model = best_model + self._inference_components = None + + def fit_decision_policy(self, contexts, val_contexts=None): + return super().fit_decision_policy(contexts, val_contexts) + + def fit(self, contexts, val_contexts=None): + return super().fit(contexts, val_contexts) + + def score(self, context) -> float: + encoder, context_encoder, predictor = self._get_inference_components() + score_pairs = self._context_to_craft_data([context], include_labels=False) + batch, batch_dialogs, _, true_batch_size = next( + batchIterator(self._voc, score_pairs, batch_size=1, shuffle=False) + ) + ( + input_variable, + dialog_lengths, + utt_lengths, + batch_indices, + dialog_indices, + labels, + convo_ids, + target_variable, + mask, + max_target_len, + ) = batch + dialog_lengths_list = [len(x) for x in batch_dialogs] + _, scores = evaluateBatch( + encoder, + context_encoder, + predictor, + self._voc, + input_variable, + dialog_lengths, + dialog_lengths_list, + utt_lengths, + batch_indices, + dialog_indices, + true_batch_size, + self._device, + MAX_LENGTH, + threshold=self.best_threshold if self.best_threshold is not None else 0.5, + ) + return float(scores[0].item()) def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name): """ @@ -264,34 +336,72 @@ def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_n :return: a Pandas DataFrame, with one row for each context, indexed by the ID of that context's current utterance. Contains two columns, one with raw probabilities named according to forecast_prob_attribute_name, and one with discretized (binary) forecasts named according to forecast_attribute_name """ # convert the input contexts into CRAFT's data format - test_pairs = self._context_to_craft_data(contexts) + contexts = list(contexts) + context_by_utt_id = {context.current_utterance.id: context for context in contexts} + test_pairs = self._context_to_craft_data(contexts, include_labels=False) print("Processed", len(test_pairs), "context tuples for model evaluation") # initialize the CRAFT model with whatever weights we currently have saved - embedding, encoder, context_encoder, attack_clf = self._init_craft() - - # Set dropout layers to eval mode - encoder.eval() - context_encoder.eval() - attack_clf.eval() + encoder, context_encoder, predictor = self._get_inference_components() - # Initialize the pipeline - predictor = Predictor(encoder, context_encoder, attack_clf) - - # Run the pipeline! - forecasts_df = evaluateDataset( - test_pairs, - encoder, - context_encoder, - predictor, - self._voc, - self._config["batch_size"], - self._device, - MAX_LENGTH, - batchIterator, - self._decision_threshold, - forecast_attribute_name, - forecast_prob_attribute_name, + output_df = {"id": [], forecast_attribute_name: [], forecast_prob_attribute_name: []} + batch_iterator = batchIterator( + self._voc, test_pairs, self._config["batch_size"], shuffle=False + ) + n_iters = len(test_pairs) // self._config["batch_size"] + int( + len(test_pairs) % self._config["batch_size"] > 0 ) + for iteration in range(1, n_iters + 1): + batch, batch_dialogs, _, true_batch_size = next(batch_iterator) + ( + input_variable, + dialog_lengths, + utt_lengths, + batch_indices, + dialog_indices, + labels, + convo_ids, + target_variable, + mask, + max_target_len, + ) = batch + dialog_lengths_list = [len(x) for x in batch_dialogs] + _, scores = evaluateBatch( + encoder, + context_encoder, + predictor, + self._voc, + input_variable, + dialog_lengths, + dialog_lengths_list, + utt_lengths, + batch_indices, + dialog_indices, + true_batch_size, + self._device, + MAX_LENGTH, + threshold=self.best_threshold if self.best_threshold is not None else 0.5, + ) + for i in range(true_batch_size): + score = float(scores[i].item()) + utt_id = convo_ids[i] + context = context_by_utt_id[utt_id] + + def score_fn(scored_context): + scored_utt_id = scored_context.current_utterance.id + if scored_utt_id == utt_id: + return score + return self.score(scored_context) + + pred = self.decision_policy.decide(context, score_fn) + output_df["id"].append(utt_id) + output_df[forecast_attribute_name].append(int(pred)) + output_df[forecast_prob_attribute_name].append(score) + print( + "Iteration: {}; Percent complete: {:.1f}%".format( + iteration, iteration / n_iters * 100 + ) + ) + forecasts_df = pd.DataFrame(output_df).set_index("id") return forecasts_df diff --git a/convokit/forecaster/TransformerDecoderModel.py b/convokit/forecaster/TransformerDecoderModel.py index a8d1813ea..e2df302c2 100644 --- a/convokit/forecaster/TransformerDecoderModel.py +++ b/convokit/forecaster/TransformerDecoderModel.py @@ -14,6 +14,7 @@ from sklearn.metrics import roc_curve from .forecasterModel import ForecasterModel from .TransformerForecasterConfig import TransformerForecasterConfig +from convokit.decisionpolicy import ThresholdDecisionPolicy import shutil @@ -72,7 +73,9 @@ def __init__( config=DEFAULT_CONFIG, system_msg=None, question_msg=None, + decision_policy=None, ): + super().__init__(decision_policy=decision_policy) self.max_seq_length = 4_096 * 2 self.model, tokenizer = FastLanguageModel.from_pretrained( model_name=model_name_or_path, @@ -100,7 +103,6 @@ def __init__( "Will the above conversation derail into a personal attack now or at any point in the future? " "Strictly start your answer with Yes or No, otherwise the answer is invalid." ) - self.best_threshold = 0.5 if not os.path.exists(config.output_dir): os.makedirs(config.output_dir) @@ -108,6 +110,17 @@ def __init__( return + @property + def best_threshold(self): + if hasattr(self.decision_policy, "threshold"): + return self.decision_policy.threshold + return None + + @best_threshold.setter + def best_threshold(self, value): + if hasattr(self.decision_policy, "threshold"): + self.decision_policy.threshold = float(value) + def _context_mode(self, context): """ Select the utterances to include in the input context based on the configured context mode. @@ -218,7 +231,7 @@ def _context_to_llm_data(self, contexts): print(f"There are {len(dataset)} samples") return Dataset.from_list(dataset) - def fit(self, train_contexts, val_contexts): + def fit_belief_estimator(self, train_contexts, val_contexts=None): """ Fine-tune the TransformerDecoder model using LoRA and save the best model based on validation performance. @@ -282,7 +295,6 @@ def fit(self, train_contexts, val_contexts): ), ) trainer.train() - _ = self._tune_threshold(self, val_contexts) return def _tune_threshold(self, val_contexts): @@ -310,7 +322,8 @@ def _tune_threshold(self, val_contexts): checkpoints = [cp for cp in os.listdir(self.config.output_dir) if "checkpoint-" in cp] if checkpoints == []: checkpoints.append("zero-shot") - best_val_accuracy = 0 + best_val_accuracy = -1 + best_checkpoint = checkpoints[0] val_convo_ids = set() utt2convo = {} val_labels_dict = {} @@ -334,7 +347,7 @@ def _tune_threshold(self, val_contexts): FastLanguageModel.for_inference(self.model) utt2score = {} for context in tqdm(val_contexts): - utt_score, _ = self._predict(context) + utt_score = self.score(context) utt_id = context.current_utterance.id utt2score[utt_id] = utt_score # for each CONVERSATION, whether or not it triggers will be effectively determined by what the highest score it ever got was @@ -392,26 +405,7 @@ def acc_with_threshold(y_true, y_score, thresh): ) return best_config - def _predict(self, context, threshold=None): - """ - Run inference on a single context using the fine-tuned TransformerDecoder model. - - This method prepares the input from the given context, generates a single-token - prediction (either "Yes" or "No"), and computes the softmax probability for "Yes". - The output is a confidence score and a binary prediction based on the given or - default threshold. - - :param context: A context tuple containing the current utterance and conversation history. - :param threshold: (Optional) A float threshold for converting the predicted probability into a binary label. - If not provided, `self.best_threshold` is used. - - :return: A tuple (`utt_score`, `utt_pred`), where: - - `utt_score` is the softmax probability assigned to "Yes" - - `utt_pred` is the binary prediction (1 if `utt_score > threshold`, else 0) - """ - # Enabling inference with different checkpoints to _tune_best_val_accuracy - if not threshold: - threshold = self.best_threshold + def score(self, context) -> float: FastLanguageModel.for_inference(self.model) context_utts = self._context_mode(context) inputs = self._tokenize(context_utts).to(self.config.device) @@ -432,9 +426,44 @@ def _predict(self, context, threshold=None): utt_score = F.softmax(torch.tensor([yes_logit, no_logit], dtype=torch.float32), dim=0)[ 0 ].item() - utt_pred = int(utt_score > threshold) + return utt_score + + def _predict(self, context, threshold=None): + """ + Run inference on a single context using the fine-tuned TransformerDecoder model. + + This method prepares the input from the given context, generates a single-token + prediction (either "Yes" or "No"), and computes the softmax probability for "Yes". + The output is a confidence score and a binary prediction based on the given or + default threshold. + + :param context: A context tuple containing the current utterance and conversation history. + :param threshold: (Optional) A float threshold for converting the predicted probability into a binary label. + If not provided, `self.best_threshold` is used. + + :return: A tuple (`utt_score`, `utt_pred`), where: + - `utt_score` is the softmax probability assigned to "Yes" + - `utt_pred` is the binary prediction (1 if `utt_score > threshold`, else 0) + """ + utt_score = self.score(context) + # keep threshold override for backward compatibility. + if threshold is not None: + utt_pred = int(utt_score > threshold) + else: + utt_pred = self.decision_policy.decide(context, self.score) return utt_score, utt_pred + def fit_decision_policy(self, contexts, val_contexts=None): + if ( + val_contexts is not None + and isinstance(self.decision_policy, ThresholdDecisionPolicy) + ): + return self._tune_threshold(val_contexts) + return super().fit_decision_policy(contexts, val_contexts) + + def fit(self, contexts, val_contexts=None): + return super().fit(contexts, val_contexts) + def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name): """ Generate forecasts using the fine-tuned TransformerDecoder model on the provided contexts, and save the predictions to the output directory specified in the configuration. diff --git a/convokit/forecaster/TransformerEncoderModel.py b/convokit/forecaster/TransformerEncoderModel.py index 7203818b0..e86a9d133 100644 --- a/convokit/forecaster/TransformerEncoderModel.py +++ b/convokit/forecaster/TransformerEncoderModel.py @@ -17,6 +17,7 @@ from sklearn.metrics import roc_curve from .forecasterModel import ForecasterModel from .TransformerForecasterConfig import TransformerForecasterConfig +from convokit.decisionpolicy import ThresholdDecisionPolicy import shutil os.environ["TOKENIZERS_PARALLELISM"] = "false" @@ -43,15 +44,14 @@ class TransformerEncoderModel(ForecasterModel): :param config: (Optional) TransformerForecasterConfig object containing parameters for training and evaluation. """ - def __init__(self, model_name_or_path, config=DEFAULT_CONFIG): - super().__init__() + def __init__(self, model_name_or_path, config=DEFAULT_CONFIG, decision_policy=None): + super().__init__(decision_policy=decision_policy) self.tokenizer = AutoTokenizer.from_pretrained( model_name_or_path, model_max_length=512, truncation_side="left", padding_side="right", ) - self.best_threshold = 0.5 model_config = AutoConfig.from_pretrained( model_name_or_path, num_labels=2, problem_type="single_label_classification" ) @@ -63,6 +63,17 @@ def __init__(self, model_name_or_path, config=DEFAULT_CONFIG): self.config = config return + @property + def best_threshold(self): + if hasattr(self.decision_policy, "threshold"): + return self.decision_policy.threshold + return None + + @best_threshold.setter + def best_threshold(self, value): + if hasattr(self.decision_policy, "threshold"): + self.decision_policy.threshold = float(value) + def _context_mode(self, context): """ Select the utterances to include in the input context based on the configured context mode. @@ -153,11 +164,11 @@ def _context_to_bert_data(self, contexts): @torch.inference_mode @torch.no_grad - def _predict( + def _score_dataset( self, dataset, model=None, - threshold=0.5, + threshold=None, forecast_prob_attribute_name="forecast_prob", forecast_attribute_name="forecast", ): @@ -179,6 +190,8 @@ def _predict( """ if not model: model = self.model.to(self.config.device) + if threshold is None: + threshold = self.best_threshold if self.best_threshold is not None else 0.5 utt_ids = [] preds = [] scores = [] @@ -198,6 +211,26 @@ def _predict( {forecast_attribute_name: preds, forecast_prob_attribute_name: scores}, index=utt_ids ) + @torch.inference_mode + @torch.no_grad + def score(self, context) -> float: + self.model.eval() + context_utts = self._context_mode(context) + tokenized_context = self._tokenize(context_utts) + input_ids = ( + torch.tensor(tokenized_context["input_ids"], dtype=torch.long) + .to(self.config.device) + .reshape([1, -1]) + ) + attention_mask = ( + torch.tensor(tokenized_context["attention_mask"], dtype=torch.long) + .to(self.config.device) + .reshape([1, -1]) + ) + outputs = self.model(input_ids=input_ids, attention_mask=attention_mask) + probs = F.softmax(outputs.logits, dim=-1) + return probs[0, 1].item() + def _tune_threshold(self, val_dataset, val_contexts): """ Tune the decision threshold and select the best model checkpoint based on validation accuracy. @@ -221,7 +254,10 @@ def _tune_threshold(self, val_dataset, val_contexts): :return: A dictionary containing the best checkpoint path, best threshold, and best validation accuracy. """ checkpoints = [cp for cp in os.listdir(self.config.output_dir) if "checkpoint-" in cp] - best_val_accuracy = 0 + if len(checkpoints) == 0: + raise ValueError("no checkpoints found for threshold tuning") + best_val_accuracy = -1 + best_checkpoint = checkpoints[0] val_convo_ids = set() utt2convo = {} val_labels_dict = {} @@ -238,7 +274,7 @@ def _tune_threshold(self, val_dataset, val_contexts): finetuned_model = AutoModelForSequenceClassification.from_pretrained( full_model_path ).to(self.config.device) - val_scores = self._predict(val_dataset, model=finetuned_model) + val_scores = self._score_dataset(val_dataset, model=finetuned_model) # for each CONVERSATION, whether or not it triggers will be effectively determined by what the highest score it ever got was highest_convo_scores = {convo_id: -1 for convo_id in val_convo_ids} for utt_id in val_scores.index: @@ -266,7 +302,7 @@ def acc_with_threshold(y_true, y_score, thresh): self.best_threshold = thresholds[best_acc_idx] self.model = finetuned_model - eval_forecasts_df = self._predict(val_dataset, threshold=self.best_threshold) + eval_forecasts_df = self._score_dataset(val_dataset, threshold=self.best_threshold) eval_prediction_file = os.path.join(self.config.output_dir, "val_predictions.csv") eval_forecasts_df.to_csv(eval_prediction_file) @@ -291,7 +327,7 @@ def acc_with_threshold(y_true, y_score, thresh): ) return best_config - def fit(self, contexts, val_contexts): + def fit_belief_estimator(self, contexts, val_contexts=None): """ Fine-tune the TransformerEncoder model, and save the best model according to validation performance. @@ -301,12 +337,10 @@ def fit(self, contexts, val_contexts): held-out validation set. :param contexts: an iterator over context tuples, provided by the Forecaster framework - :param val_contexts: an iterator over context tuples to be used only for validation. + :param val_contexts: optional validation contexts (not used by this stage). """ - val_contexts = list(val_contexts) train_pairs = self._context_to_bert_data(contexts) - val_for_tuning_pairs = self._context_to_bert_data(val_contexts) - dataset = DatasetDict({"train": train_pairs, "val_for_tuning": val_for_tuning_pairs}) + dataset = DatasetDict({"train": train_pairs}) dataset.set_format("torch") training_args = TrainingArguments( @@ -324,9 +358,25 @@ def fit(self, contexts, val_contexts): ) trainer = Trainer(model=self.model, args=training_args, train_dataset=dataset["train"]) trainer.train() - _ = self._tune_threshold(dataset["val_for_tuning"], val_contexts) return + def fit_decision_policy(self, contexts, val_contexts=None): + if val_contexts is None: + return super().fit_decision_policy(contexts, val_contexts) + val_contexts = list(val_contexts) + val_for_tuning_pairs = self._context_to_bert_data(val_contexts) + val_for_tuning_pairs.set_format("torch") + return self._tune_threshold(val_for_tuning_pairs, val_contexts) + + def fit(self, contexts, val_contexts=None): + return super().fit(contexts, val_contexts) + + def _predict(self, context, threshold=None): + utt_score = self.score(context) + if threshold is not None: + return utt_score, int(utt_score > threshold) + return utt_score, self.decision_policy.decide(context, self.score) + def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name): """ Generate forecasts using the fine-tuned TransformerEncoder model on the provided contexts, and save the predictions to the output directory specified in the configuration. @@ -337,14 +387,16 @@ def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_n :return: a Pandas DataFrame, with one row for each context, indexed by the ID of that context's current utterance. Contains two columns, one with raw probabilities named according to forecast_prob_attribute_name, and one with discretized (binary) forecasts named according to forecast_attribute_name """ - test_pairs = self._context_to_bert_data(contexts) - dataset = DatasetDict({"test": test_pairs}) - dataset.set_format("torch") - forecasts_df = self._predict( - dataset["test"], - threshold=self.best_threshold, - forecast_attribute_name=forecast_attribute_name, - forecast_prob_attribute_name=forecast_prob_attribute_name, + utt_ids = [] + preds = [] + scores = [] + for context in tqdm(contexts): + utt_score, utt_pred = self._predict(context) + utt_ids.append(context.current_utterance.id) + preds.append(utt_pred) + scores.append(utt_score) + forecasts_df = pd.DataFrame( + {forecast_attribute_name: preds, forecast_prob_attribute_name: scores}, index=utt_ids ) prediction_file = os.path.join(self.config.output_dir, "test_predictions.csv") diff --git a/convokit/forecaster/__init__.py b/convokit/forecaster/__init__.py index 12a137604..71fac5534 100644 --- a/convokit/forecaster/__init__.py +++ b/convokit/forecaster/__init__.py @@ -1,6 +1,7 @@ from .forecaster import * from .forecasterModel import * from .cumulativeBoW import * +from convokit.decisionpolicy import * import sys # Import CRAFT models if torch is available diff --git a/convokit/forecaster/cumulativeBoW.py b/convokit/forecaster/cumulativeBoW.py index 50fe0373a..c14b9c61a 100644 --- a/convokit/forecaster/cumulativeBoW.py +++ b/convokit/forecaster/cumulativeBoW.py @@ -25,11 +25,15 @@ def __init__( use_tokens=False, forecast_attribute_name: str = "prediction", forecast_prob_attribute_name: str = "score", + decision_policy=None, ): super().__init__( + decision_policy=decision_policy, forecast_attribute_name=forecast_attribute_name, forecast_prob_attribute_name=forecast_prob_attribute_name, ) + self.forecast_attribute_name = forecast_attribute_name + self.forecast_prob_attribute_name = forecast_prob_attribute_name if vectorizer is None: print("Initializing default unigram CountVectorizer...") if use_tokens: @@ -66,6 +70,10 @@ def __init__( else: self.clf_model = clf_model + @staticmethod + def _context_to_text(context): + return " ".join([u.text for u in context.context]) + @staticmethod def _combine_contexts(id_to_context_others): """ @@ -114,3 +122,30 @@ def forecast(self, id_to_context_reply_label): data=list(zip(ids, preds, pred_probs)), columns=["id", self.forecast_attribute_name, self.forecast_prob_attribute_name], ).set_index("id") + + def fit_belief_estimator(self, contexts, val_contexts=None): + contexts = list(contexts) + X_raw = [self._context_to_text(context) for context in contexts] + y = [self.labeler(context.current_utterance.get_conversation()) for context in contexts] + X = self.vectorizer.fit_transform(X_raw) + self.clf_model.fit(X, y) + + def score(self, context) -> float: + X = self.vectorizer.transform([self._context_to_text(context)]) + return float(self.clf_model.predict_proba(X)[0, 1]) + + def fit(self, contexts, val_contexts=None): + return super().fit(contexts, val_contexts) + + def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name): + utt_ids = [] + preds = [] + scores = [] + for context in contexts: + utt_score, utt_pred = self._predict(context) + utt_ids.append(context.current_utterance.id) + preds.append(utt_pred) + scores.append(utt_score) + return pd.DataFrame( + {forecast_attribute_name: preds, forecast_prob_attribute_name: scores}, index=utt_ids + ) diff --git a/convokit/forecaster/forecaster.py b/convokit/forecaster/forecaster.py index c3c259ac5..1df481122 100644 --- a/convokit/forecaster/forecaster.py +++ b/convokit/forecaster/forecaster.py @@ -6,7 +6,9 @@ import numpy as np from matplotlib import pyplot as plt -# Define a namedtuple template to represent conversational context tuples +# define a namedtuple template to represent conversational context tuples. +# this alias is kept for backwards compatibility; decision policies should +# accept the same structure. ContextTuple = namedtuple( "ContextTuple", ["context", "current_utterance", "future_context", "conversation_id"] ) diff --git a/convokit/forecaster/forecasterModel.py b/convokit/forecaster/forecasterModel.py index 0051ff32e..474aa30e3 100644 --- a/convokit/forecaster/forecasterModel.py +++ b/convokit/forecaster/forecasterModel.py @@ -1,6 +1,9 @@ from abc import ABC, abstractmethod +from itertools import tee from typing import Callable +from convokit.decisionpolicy import ThresholdDecisionPolicy + class ForecasterModel(ABC): """ @@ -9,8 +12,9 @@ class ForecasterModel(ABC): in a consistent format, defined above. """ - def __init__(self): + def __init__(self, decision_policy=None, **kwargs): self._labeler = None + self._decision_policy = decision_policy or ThresholdDecisionPolicy() @property def labeler(self): @@ -19,17 +23,68 @@ def labeler(self): @labeler.setter def labeler(self, value: Callable): self._labeler = value + if self._decision_policy is not None: + self._decision_policy.labeler = value + + @property + def decision_policy(self): + return self._decision_policy + + @decision_policy.setter + def decision_policy(self, value): + self._decision_policy = value + if self._decision_policy is not None: + self._decision_policy.labeler = self._labeler - @abstractmethod def fit(self, contexts, val_contexts=None): """ - Train this conversational forecasting model on the given data + Train this conversational forecasting model on the given data by fitting + both the belief estimator and the decision policy. :param contexts: an iterator over context tuples :param val_contexts: an optional second iterator over context tuples to be used as a separate held-out validation set. Concrete ForecasterModel implementations may choose to ignore this, or conversely even enforce its presence. """ + belief_contexts, policy_contexts = tee(contexts, 2) + if val_contexts is None: + belief_val_contexts = None + policy_val_contexts = None + else: + belief_val_contexts, policy_val_contexts = tee(val_contexts, 2) + self.fit_belief_estimator(belief_contexts, belief_val_contexts) + self.fit_decision_policy(policy_contexts, policy_val_contexts) + + @abstractmethod + def fit_belief_estimator(self, contexts, val_contexts=None): + """ + Fit only the belief estimator component that produces continuous scores. + """ + pass + + def fit_decision_policy(self, contexts, val_contexts=None): + """ + Fit only the decision policy component. + """ + if self.decision_policy is not None: + return self.decision_policy.fit( + contexts=contexts, val_contexts=val_contexts, score_fn=self.score + ) + return None + + @abstractmethod + def score(self, context) -> float: + """ + Produce the belief estimator score for a context. + """ pass + def _predict(self, context): + """ + Return both belief score and policy action for a context. + """ + utt_score = self.score(context) + utt_pred = self.decision_policy.decide(context, self.score) + return utt_score, utt_pred + @abstractmethod def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name): """ diff --git a/docs/source/decisionpolicy.rst b/docs/source/decisionpolicy.rst new file mode 100644 index 000000000..48eebd1a7 --- /dev/null +++ b/docs/source/decisionpolicy.rst @@ -0,0 +1,9 @@ +Decision Policy +=============== + +The decision policy API separates belief estimation (continuous scores) from +intervention decisions (discrete actions). This keeps ``Forecaster`` unchanged +while allowing flexible action logic in ``ForecasterModel``. + +.. automodule:: convokit.decisionpolicy + :members: diff --git a/docs/source/forecaster.rst b/docs/source/forecaster.rst index e688aa7c7..cd0fe35b0 100644 --- a/docs/source/forecaster.rst +++ b/docs/source/forecaster.rst @@ -41,6 +41,7 @@ These are subclasses of ForecasterModel, each implementing forecasting models us .. toctree:: :maxdepth: 1 + Decision Policy CRAFT Model Transformer Encoder-based Model Transformer Decoder-based Model From ed76ff61f3c5659b6717e2a29bd22e37515fc164 Mon Sep 17 00:00:00 2001 From: laerdon Date: Sat, 11 Apr 2026 19:29:14 +0000 Subject: [PATCH 02/21] reformulated decisionpolicy threshold tuning --- .gitignore | 1 + convokit/decisionpolicy/decisionPolicy.py | 98 ++++++++- .../decisionpolicy/deferralDecisionPolicy.py | 164 ++++++++------- .../decisionpolicy/thresholdDecisionPolicy.py | 48 ++--- .../forecaster/TransformerDecoderModel.py | 180 +++++------------ .../forecaster/TransformerEncoderModel.py | 132 +++---------- convokit/forecaster/forecaster.py | 31 ++- convokit/forecaster/forecasterModel.py | 92 +++++++-- examples/forecaster/train_deferral.py | 186 ++++++++++++++++++ 9 files changed, 546 insertions(+), 386 deletions(-) create mode 100644 examples/forecaster/train_deferral.py diff --git a/.gitignore b/.gitignore index 68ebdbf40..07ed59bff 100644 --- a/.gitignore +++ b/.gitignore @@ -40,3 +40,4 @@ venv-triadmotif/ !/docs/source/img/* env/ website/docs/build +examples/forecaster/deferral_out diff --git a/convokit/decisionpolicy/decisionPolicy.py b/convokit/decisionpolicy/decisionPolicy.py index f0aca8546..40b87b857 100644 --- a/convokit/decisionpolicy/decisionPolicy.py +++ b/convokit/decisionpolicy/decisionPolicy.py @@ -1,5 +1,9 @@ from abc import ABC, abstractmethod -from typing import Callable +from typing import Callable, Tuple, Optional, Dict, Any + +import numpy as np +from sklearn.metrics import roc_curve +from tqdm import tqdm class DecisionPolicy(ABC): @@ -18,14 +22,100 @@ def labeler(self): def labeler(self, value: Callable): self._labeler = value + def _fit_with_model_checkpoint_selection(self, val_contexts, score_fn: Callable = None): + if score_fn is None: + return None + forecaster_model = getattr(score_fn, "__self__", None) + if forecaster_model is None: + return None + get_checkpoints = getattr(forecaster_model, "get_checkpoints", None) + load_checkpoint = getattr(forecaster_model, "load_checkpoint", None) + finalize_best_checkpoint_selection = getattr( + forecaster_model, "finalize_best_checkpoint_selection", None + ) + if not callable(get_checkpoints) or not callable(load_checkpoint): + return None + + checkpoints = list(get_checkpoints()) + if len(checkpoints) == 0: + return None + + best_config = None + best_checkpoint = None + best_val_accuracy = -1.0 + for checkpoint_name in checkpoints: + load_checkpoint(checkpoint_name) + fit_result = self._fit_threshold_for_loaded_model(val_contexts, score_fn=score_fn) + print(f"accuracy: {checkpoint_name} {fit_result['best_val_accuracy']}") + if fit_result["best_val_accuracy"] > best_val_accuracy: + best_checkpoint = checkpoint_name + best_val_accuracy = fit_result["best_val_accuracy"] + best_config = { + "best_checkpoint": checkpoint_name, + "best_threshold": float(fit_result["best_threshold"]), + "best_val_accuracy": float(fit_result["best_val_accuracy"]), + } + + if best_config is None: + return None + + if hasattr(self, "threshold"): + self.threshold = float(best_config["best_threshold"]) + load_checkpoint(best_checkpoint) + if callable(finalize_best_checkpoint_selection): + finalize_best_checkpoint_selection( + best_checkpoint, + best_config, + val_contexts=val_contexts, + score_fn=score_fn, + ) + return best_config + + def _fit_threshold_for_loaded_model(self, val_contexts, score_fn: Callable): + y_true, y_score = self._get_validation_arrays(val_contexts, score_fn) + default_threshold = float(getattr(self, "threshold", 0.5)) + if len(y_true) == 0: + return {"best_threshold": default_threshold, "best_val_accuracy": 0.0} + + try: + _, _, thresholds = roc_curve(y_true, y_score) + except ValueError: + thresholds = np.asarray([default_threshold], dtype=float) + + if len(thresholds) == 0: + thresholds = np.asarray([default_threshold], dtype=float) + + accs = [((y_score > t).astype(int) == y_true).mean() for t in thresholds] + best_idx = int(np.argmax(accs)) + best_threshold = float(thresholds[best_idx]) + return {"best_threshold": best_threshold, "best_val_accuracy": float(accs[best_idx])} + + def _get_validation_arrays(self, val_contexts, score_fn: Callable): + highest_convo_scores = {} + convo_labels = {} + for context in tqdm(val_contexts): + convo_id = context.conversation_id + score = float(score_fn(context)) + label = int(self.labeler(context.current_utterance.get_conversation())) + if convo_id not in highest_convo_scores: + highest_convo_scores[convo_id] = score + else: + highest_convo_scores[convo_id] = max(highest_convo_scores[convo_id], score) + convo_labels[convo_id] = label + + convo_ids = list(highest_convo_scores.keys()) + y_true = np.asarray([convo_labels[c] for c in convo_ids]) + y_score = np.asarray([highest_convo_scores[c] for c in convo_ids]) + return y_true, y_score + @abstractmethod - def decide(self, context, score_fn: Callable) -> int: + def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]: """ Decide whether to intervene for a context. :param context: context tuple supplied by Forecaster :param score_fn: callable that maps a context tuple to a scalar score - :return: integer action label (currently 0/1) + :return: tuple containing the score, the integer action label (currently 0/1), and any additional metadata """ pass @@ -38,4 +128,4 @@ def fit(self, contexts, val_contexts=None, score_fn: Callable = None): :param val_contexts: optional validation contexts :param score_fn: optional scorer callable exposed by ForecasterModel """ - pass + pass \ No newline at end of file diff --git a/convokit/decisionpolicy/deferralDecisionPolicy.py b/convokit/decisionpolicy/deferralDecisionPolicy.py index ab8d2848e..848e1154f 100644 --- a/convokit/decisionpolicy/deferralDecisionPolicy.py +++ b/convokit/decisionpolicy/deferralDecisionPolicy.py @@ -1,8 +1,4 @@ -from itertools import tee -from typing import Callable, List, Optional - -import numpy as np -from sklearn.metrics import roc_curve +from typing import Callable, List, Optional, Dict, Any, Tuple from .decisionPolicy import DecisionPolicy @@ -25,56 +21,63 @@ def get_conversation(self): class DeferralDecisionPolicy(DecisionPolicy): """ - Decision policy that can defer intervention using simulated next utterances. + Decision policy that defers intervention by looking ahead at simulated next utterances. + + :param simulator: utterance simulator model (must have a ``transform(contexts)`` method + returning a DataFrame indexed by utterance id). if the simulator exposes + ``get_num_simulations()``, ``num_simulations`` is capped to that value. + :param threshold: probability threshold above which a context is flagged. + :param tau: minimum number of simulated branches that must exceed the threshold + before an intervention is issued. + :param num_simulations: how many simulated branches to use per context (capped to + simulator's ``get_num_simulations()`` if available). + :param store_simulations: if True, simulated reply strings are cached during decide() + and written to corpus utterance metadata by post_transform(). + :param simulated_reply_attribute_name: metadata field name used when storing simulations + on corpus utterances (only relevant when store_simulations=True). """ def __init__( self, - simulator=None, - threshold: float = 0.5, - num_simulations: int = 3, - aggregation: str = "mean", + simulator, + threshold, + tau: int = 5, + num_simulations: int = 10, + store_simulations: bool = False, + simulated_reply_attribute_name: str = "sim_replies", + sim_replies_forecast_probs_attribute_name: str = "sim_replies_forecast_probs", ): super().__init__() self.simulator = simulator self.threshold = float(threshold) - self.num_simulations = int(num_simulations) - self.aggregation = aggregation - - def _aggregate_scores(self, scores: List[float]) -> float: - if len(scores) == 0: - return 0.0 - if self.aggregation == "max": - return float(np.max(scores)) - if self.aggregation == "min": - return float(np.min(scores)) - return float(np.mean(scores)) - - def get_simulations(self, context, simulator=None, k: Optional[int] = None) -> List[str]: - simulator = simulator if simulator is not None else self.simulator - if k is None: - k = self.num_simulations - if simulator is None: + self.tau = int(tau) + n = int(num_simulations) + if simulator is not None and hasattr(simulator, "get_num_simulations"): + n = min(n, int(simulator.get_num_simulations())) + self.num_simulations = n + self.store_simulations = store_simulations + self.simulated_reply_attribute_name = simulated_reply_attribute_name + self.sim_replies_forecast_probs_attribute_name = sim_replies_forecast_probs_attribute_name + self._sim_cache: dict = {} + self._sim_score_cache: dict = {} + + def get_simulations(self, context, simulator=None) -> List[str]: + sim = simulator if simulator is not None else self.simulator + if sim is None or not hasattr(sim, "transform"): + return [] + sims = sim.transform(iter([context])) + utt_id = context.current_utterance.id + if utt_id not in sims.index or sims.shape[1] == 0: return [] - if callable(simulator): - sims = simulator(context, k) - return list(sims)[:k] - if hasattr(simulator, "get_simulations"): - sims = simulator.get_simulations(context, k) - return list(sims)[:k] - if hasattr(simulator, "transform"): - sims = simulator.transform(iter([context])) - if context.current_utterance.id in sims.index: - col_name = sims.columns[0] - return list(sims.loc[context.current_utterance.id][col_name])[:k] - return [] + col_name = sims.columns[0] + return list(sims.loc[utt_id][col_name])[: self.num_simulations] def _build_simulated_context(self, context, simulation_text: str, simulation_idx: int): current_utt = context.current_utterance synthetic_utt = _synthetic_utterance( text=simulation_text, utterance_id=f"{current_utt.id}__sim_{simulation_idx}", - speaker_id="simulator", + speaker_id="", ) new_context_utts = list(context.context) + [synthetic_utt] context_cls = context.__class__ @@ -85,60 +88,49 @@ def _build_simulated_context(self, context, simulation_text: str, simulation_idx conversation_id=context.conversation_id, ) - def _decision_score(self, context, score_fn: Callable) -> float: + def _decision_score(self, context, score_fn: Callable): current_score = float(score_fn(context)) simulations = self.get_simulations(context) - if len(simulations) == 0: - return current_score simulation_scores = [] for idx, sim_text in enumerate(simulations): sim_context = self._build_simulated_context(context, sim_text, idx) simulation_scores.append(float(score_fn(sim_context))) - return self._aggregate_scores([current_score] + simulation_scores) - - def decide(self, context, score_fn: Callable) -> int: - decision_score = self._decision_score(context, score_fn) - return int(decision_score > self.threshold) + if self.store_simulations and simulations: + utt_id = context.current_utterance.id + self._sim_cache[utt_id] = simulations + self._sim_score_cache[utt_id] = simulation_scores + return current_score, simulations, simulation_scores + + def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]: + decision_score, simulations, simulation_scores = self._decision_score(context, score_fn) + num_simulations_above_threshold = sum(1 for score in simulation_scores if score > self.threshold) + + # we want to return an awry prediction if we have + return (decision_score, + 1 if decision_score > self.threshold and num_simulations_above_threshold > 5 else 0, + { + self.simulated_reply_attribute_name: simulations, + self.sim_replies_forecast_probs_attribute_name: simulation_scores, + } + ) def fit(self, contexts, val_contexts=None, score_fn: Callable = None): - if self.simulator is not None and hasattr(self.simulator, "fit"): - if val_contexts is None: - sim_contexts = contexts - sim_val_contexts = None - else: - sim_contexts, contexts = tee(contexts, 2) - sim_val_contexts, val_contexts = tee(val_contexts, 2) - self.simulator.fit(sim_contexts, sim_val_contexts) - if val_contexts is None or score_fn is None or self.labeler is None: - return {"threshold": self.threshold} + print("either no validation contexts/score function/labeler were provided, returning current threshold") + return {"best_threshold": self.threshold} + val_contexts = list(val_contexts) if len(val_contexts) == 0: - return {"threshold": self.threshold} - - highest_convo_scores = {} - convo_labels = {} - for context in val_contexts: - convo_id = context.conversation_id - score = self._decision_score(context, score_fn) - label = int(self.labeler(context.current_utterance.get_conversation())) - if convo_id not in highest_convo_scores: - highest_convo_scores[convo_id] = score - else: - highest_convo_scores[convo_id] = max(highest_convo_scores[convo_id], score) - convo_labels[convo_id] = label - - convo_ids = list(highest_convo_scores.keys()) - y_true = np.asarray([convo_labels[c] for c in convo_ids]) - y_score = np.asarray([highest_convo_scores[c] for c in convo_ids]) - try: - _, _, thresholds = roc_curve(y_true, y_score) - except ValueError: - return {"threshold": self.threshold} - if len(thresholds) == 0: - return {"threshold": self.threshold} - - accs = [((y_score > t).astype(int) == y_true).mean() for t in thresholds] - best_idx = int(np.argmax(accs)) - self.threshold = float(thresholds[best_idx]) - return {"threshold": self.threshold, "best_val_accuracy": float(accs[best_idx])} + print("no validation contexts were provided, returning current threshold") + return {"best_threshold": self.threshold} + + fit_result = self._fit_with_model_checkpoint_selection(val_contexts, score_fn=score_fn) + if isinstance(fit_result, dict): + if "best_threshold" in fit_result: + self.threshold = float(fit_result["best_threshold"]) + return fit_result + + fit_result = self._fit_threshold_for_loaded_model(val_contexts, score_fn=score_fn) + if "best_threshold" in fit_result: + self.threshold = float(fit_result["best_threshold"]) + return fit_result diff --git a/convokit/decisionpolicy/thresholdDecisionPolicy.py b/convokit/decisionpolicy/thresholdDecisionPolicy.py index 0f3814a44..44a8b0e3c 100644 --- a/convokit/decisionpolicy/thresholdDecisionPolicy.py +++ b/convokit/decisionpolicy/thresholdDecisionPolicy.py @@ -1,7 +1,4 @@ -from typing import Callable - -import numpy as np -from sklearn.metrics import roc_curve +from typing import Callable, Tuple from .decisionPolicy import DecisionPolicy @@ -15,43 +12,26 @@ def __init__(self, threshold: float = 0.5): super().__init__() self.threshold = float(threshold) - def decide(self, context, score_fn: Callable) -> int: - return int(score_fn(context) > self.threshold) + def decide(self, context, score_fn: Callable) -> Tuple[float, int]: + return score_fn(context), int(score_fn(context) > self.threshold) def fit(self, contexts, val_contexts=None, score_fn: Callable = None): if val_contexts is None or score_fn is None or self.labeler is None: + print("either no validation contexts/score function/labeler were provided, returning current threshold") return {"best_threshold": self.threshold} val_contexts = list(val_contexts) if len(val_contexts) == 0: + print("no validation contexts were provided, returning current threshold") return {"best_threshold": self.threshold} - highest_convo_scores = {} - convo_labels = {} - for context in val_contexts: - convo_id = context.conversation_id - score = score_fn(context) - label = int(self.labeler(context.current_utterance.get_conversation())) - if convo_id not in highest_convo_scores: - highest_convo_scores[convo_id] = score - else: - highest_convo_scores[convo_id] = max(highest_convo_scores[convo_id], score) - convo_labels[convo_id] = label - - convo_ids = list(highest_convo_scores.keys()) - y_true = np.asarray([convo_labels[c] for c in convo_ids]) - y_score = np.asarray([highest_convo_scores[c] for c in convo_ids]) - - # roc_curve can fail when only one class is present; keep current threshold in that case. - try: - _, _, thresholds = roc_curve(y_true, y_score) - except ValueError: - return {"best_threshold": self.threshold} - - if len(thresholds) == 0: - return {"best_threshold": self.threshold} + fit_result = self._fit_with_model_checkpoint_selection(val_contexts, score_fn=score_fn) + if isinstance(fit_result, dict): + if "best_threshold" in fit_result: + self.threshold = float(fit_result["best_threshold"]) + return fit_result - accs = [((y_score > t).astype(int) == y_true).mean() for t in thresholds] - best_idx = int(np.argmax(accs)) - self.threshold = float(thresholds[best_idx]) - return {"best_threshold": self.threshold, "best_val_accuracy": float(accs[best_idx])} + fit_result = self._fit_threshold_for_loaded_model(val_contexts, score_fn=score_fn) + if "best_threshold" in fit_result: + self.threshold = float(fit_result["best_threshold"]) + return fit_result diff --git a/convokit/forecaster/TransformerDecoderModel.py b/convokit/forecaster/TransformerDecoderModel.py index e2df302c2..449a1e4d9 100644 --- a/convokit/forecaster/TransformerDecoderModel.py +++ b/convokit/forecaster/TransformerDecoderModel.py @@ -1,3 +1,4 @@ +from itertools import tee import unsloth from unsloth import FastLanguageModel, is_bfloat16_supported from unsloth.chat_templates import get_chat_template @@ -5,18 +6,13 @@ import torch.nn.functional as F from trl import SFTTrainer, SFTConfig from datasets import Dataset +from collections import defaultdict -import json import os from tqdm import tqdm import pandas as pd -import numpy as np -from sklearn.metrics import roc_curve from .forecasterModel import ForecasterModel from .TransformerForecasterConfig import TransformerForecasterConfig -from convokit.decisionpolicy import ThresholdDecisionPolicy -import shutil - def _get_template_map(model_name_or_path): """ @@ -121,6 +117,22 @@ def best_threshold(self, value): if hasattr(self.decision_policy, "threshold"): self.decision_policy.threshold = float(value) + def get_checkpoints(self): + checkpoints = [cp for cp in os.listdir(self.config.output_dir) if "checkpoint-" in cp] + if len(checkpoints) == 0: + return ["zero-shot"] + return checkpoints + + def load_checkpoint(self, checkpoint_name): + if checkpoint_name == "zero-shot": + return + full_model_path = os.path.join(self.config.output_dir, checkpoint_name) + self.model, _ = FastLanguageModel.from_pretrained( + model_name=full_model_path, + max_seq_length=self.max_seq_length, + load_in_4bit=True, + ) + def _context_mode(self, context): """ Select the utterances to include in the input context based on the configured context mode. @@ -273,9 +285,9 @@ def fit_belief_estimator(self, train_contexts, val_contexts=None): model=self.model, tokenizer=self.tokenizer, train_dataset=train_dataset, + max_seq_length=self.max_seq_length, args=SFTConfig( dataset_text_field="text", - max_seq_length=self.max_seq_length, per_device_train_batch_size=self.config.per_device_batch_size, gradient_accumulation_steps=self.config.gradient_accumulation_steps, warmup_steps=10, @@ -297,114 +309,6 @@ def fit_belief_estimator(self, train_contexts, val_contexts=None): trainer.train() return - def _tune_threshold(self, val_contexts): - """ - Tune the decision threshold and select the best model checkpoint based on validation accuracy. - - This method evaluates all model checkpoints in the configured output directory using a - held-out validation set. - - The selected model, threshold, and associated metadata are stored in: - - `self.model`: the best-performing fine-tuned model - - `self.best_threshold`: the optimal decision threshold - - `dev_config.json`: file containing best checkpoint metadata - - `val_predictions.csv`: CSV file with forecast outputs on the validation set - - Additionally, all non-optimal model checkpoints are removed to save disk space, and the - tokenizer is saved to the directory of the best checkpoint. - - :param val_dataset: A HuggingFace-compatible dataset containing features for validation. - :param val_contexts: An iterable of context tuples corresponding to the validation set. - Used to map utterance IDs to conversation IDs and extract ground-truth labels. - - :return: A dictionary containing the best checkpoint path, best threshold, and best validation accuracy. - """ - checkpoints = [cp for cp in os.listdir(self.config.output_dir) if "checkpoint-" in cp] - if checkpoints == []: - checkpoints.append("zero-shot") - best_val_accuracy = -1 - best_checkpoint = checkpoints[0] - val_convo_ids = set() - utt2convo = {} - val_labels_dict = {} - val_contexts = list(val_contexts) - for context in val_contexts: - convo_id = context.conversation_id - utt_id = context.current_utterance.id - label = self.labeler(context.current_utterance.get_conversation()) - utt2convo[utt_id] = convo_id - val_labels_dict[convo_id] = label - val_convo_ids.add(convo_id) - val_convo_ids = list(val_convo_ids) - for cp in checkpoints: - if cp != "zero-shot": - full_model_path = os.path.join(self.config.output_dir, cp) - self.model, _ = FastLanguageModel.from_pretrained( - model_name=full_model_path, - max_seq_length=self.max_seq_length, - load_in_4bit=True, - ) - FastLanguageModel.for_inference(self.model) - utt2score = {} - for context in tqdm(val_contexts): - utt_score = self.score(context) - utt_id = context.current_utterance.id - utt2score[utt_id] = utt_score - # for each CONVERSATION, whether or not it triggers will be effectively determined by what the highest score it ever got was - highest_convo_scores = {convo_id: -1 for convo_id in val_convo_ids} - - for utt_id in utt2convo: - convo_id = utt2convo[utt_id] - utt_score = utt2score[utt_id] - if utt_score > highest_convo_scores[convo_id]: - highest_convo_scores[convo_id] = utt_score - - val_labels = np.asarray([int(val_labels_dict[c]) for c in val_convo_ids]) - val_scores = np.asarray([highest_convo_scores[c] for c in val_convo_ids]) - # use scikit learn to find candidate threshold cutoffs - _, _, thresholds = roc_curve(val_labels, val_scores) - - def acc_with_threshold(y_true, y_score, thresh): - y_pred = (y_score > thresh).astype(int) - return (y_pred == y_true).mean() - - accs = [acc_with_threshold(val_labels, val_scores, t) for t in thresholds] - best_acc_idx = np.argmax(accs) - - print("Accuracy:", cp, accs[best_acc_idx]) - if accs[best_acc_idx] > best_val_accuracy: - best_checkpoint = cp - best_val_accuracy = accs[best_acc_idx] - self.best_threshold = thresholds[best_acc_idx] - - # Save the best config - best_config = {} - best_config["best_checkpoint"] = best_checkpoint - best_config["best_threshold"] = self.best_threshold - best_config["best_val_accuracy"] = best_val_accuracy - config_file = os.path.join(self.config.output_dir, "dev_config.json") - with open(config_file, "w") as outfile: - json_object = json.dumps(best_config, indent=4) - outfile.write(json_object) - # Load best model - best_model_path = os.path.join(self.config.output_dir, best_checkpoint) - self.model, _ = FastLanguageModel.from_pretrained( - model_name=best_model_path, - max_seq_length=self.max_seq_length, - load_in_4bit=True, - ) - - # Clean other checkpoints to save disk space. - for root, _, _ in os.walk(self.config.output_dir): - if ("checkpoint" in root) and (best_checkpoint not in root): - print("Deleting:", root) - shutil.rmtree(root) - # Save the tokenizer. - self.tokenizer.save_pretrained( - os.path.join(self.config.output_dir, best_config["best_checkpoint"]) - ) - return best_config - def score(self, context) -> float: FastLanguageModel.for_inference(self.model) context_utts = self._context_mode(context) @@ -450,19 +354,14 @@ def _predict(self, context, threshold=None): if threshold is not None: utt_pred = int(utt_score > threshold) else: - utt_pred = self.decision_policy.decide(context, self.score) + utt_score, utt_pred, _ = self.decision_policy.decide(context, self.score) return utt_score, utt_pred - def fit_decision_policy(self, contexts, val_contexts=None): - if ( - val_contexts is not None - and isinstance(self.decision_policy, ThresholdDecisionPolicy) - ): - return self._tune_threshold(val_contexts) - return super().fit_decision_policy(contexts, val_contexts) - def fit(self, contexts, val_contexts=None): - return super().fit(contexts, val_contexts) + val_contexts_belief_estimator, val_contexts_decision_policy = tee(val_contexts, 2) + self.fit_belief_estimator(contexts, val_contexts_belief_estimator) + self.fit_decision_policy(contexts, val_contexts_decision_policy, score_fn=self.score) + return def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name): """ @@ -478,15 +377,36 @@ def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_n utt_ids = [] preds = [] scores = [] + metadatas = defaultdict(list) + # for safety/flexibility we can accept either only score and pred or also the metadata for context in tqdm(contexts): - utt_score, utt_pred = self._predict(context) - + result = self.decision_policy.decide(context, self.score) + + if len(result) == 2: + utt_score, utt_pred = result + utt_metadata = {} + # no metadata + elif len(result) == 3: + utt_score, utt_pred, utt_metadata = result + for key in utt_metadata.keys(): + metadatas[key].append(utt_metadata.get(key, None)) + else: + raise ValueError( + "decision_policy.decide() must return (utt_score, utt_pred) " + "or (utt_score, utt_pred, metadata_dict)" + ) utt_ids.append(context.current_utterance.id) preds.append(utt_pred) scores.append(utt_score) - forecasts_df = pd.DataFrame( - {forecast_attribute_name: preds, forecast_prob_attribute_name: scores}, index=utt_ids - ) + cols = { + forecast_attribute_name: preds, + forecast_prob_attribute_name: scores, + } + for key, series in metadatas.items(): + assert len(series) == len(preds), "Metadata series length must match number of predictions" + cols[key] = series # each series same length as preds + forecasts_df = pd.DataFrame(cols, index=utt_ids) + prediction_file = os.path.join(self.config.output_dir, "test_predictions.csv") forecasts_df.to_csv(prediction_file) return forecasts_df diff --git a/convokit/forecaster/TransformerEncoderModel.py b/convokit/forecaster/TransformerEncoderModel.py index e86a9d133..f2130ac4d 100644 --- a/convokit/forecaster/TransformerEncoderModel.py +++ b/convokit/forecaster/TransformerEncoderModel.py @@ -11,14 +11,9 @@ import os import pandas as pd -import numpy as np -import json from tqdm import tqdm -from sklearn.metrics import roc_curve from .forecasterModel import ForecasterModel from .TransformerForecasterConfig import TransformerForecasterConfig -from convokit.decisionpolicy import ThresholdDecisionPolicy -import shutil os.environ["TOKENIZERS_PARALLELISM"] = "false" @@ -74,6 +69,29 @@ def best_threshold(self, value): if hasattr(self.decision_policy, "threshold"): self.decision_policy.threshold = float(value) + def get_checkpoints(self): + return [cp for cp in os.listdir(self.config.output_dir) if "checkpoint-" in cp] + + def load_checkpoint(self, checkpoint_name): + full_model_path = os.path.join(self.config.output_dir, checkpoint_name) + self.model = AutoModelForSequenceClassification.from_pretrained(full_model_path).to( + self.config.device + ) + + def finalize_best_checkpoint_selection( + self, best_checkpoint, best_config, val_contexts=None, score_fn=None + ): + super().finalize_best_checkpoint_selection( + best_checkpoint, best_config, val_contexts=val_contexts, score_fn=score_fn + ) + if val_contexts is None or self.best_threshold is None: + return + val_dataset = self._context_to_bert_data(val_contexts) + val_dataset.set_format("torch") + eval_forecasts_df = self._score_dataset(val_dataset, threshold=self.best_threshold) + eval_prediction_file = os.path.join(self.config.output_dir, "val_predictions.csv") + eval_forecasts_df.to_csv(eval_prediction_file) + def _context_mode(self, context): """ Select the utterances to include in the input context based on the configured context mode. @@ -231,102 +249,6 @@ def score(self, context) -> float: probs = F.softmax(outputs.logits, dim=-1) return probs[0, 1].item() - def _tune_threshold(self, val_dataset, val_contexts): - """ - Tune the decision threshold and select the best model checkpoint based on validation accuracy. - - This method evaluates all model checkpoints in the configured output directory using a - held-out validation set. - - The selected model, threshold, and associated metadata are stored in: - - `self.model`: the best-performing fine-tuned model - - `self.best_threshold`: the optimal decision threshold - - `dev_config.json`: file containing best checkpoint metadata - - `val_predictions.csv`: CSV file with forecast outputs on the validation set - - Additionally, all non-optimal model checkpoints are removed to save disk space, and the - tokenizer is saved to the directory of the best checkpoint. - - :param val_dataset: A HuggingFace-compatible dataset containing features for validation. - :param val_contexts: An iterable of context tuples corresponding to the validation set. - Used to map utterance IDs to conversation IDs and extract ground-truth labels. - - :return: A dictionary containing the best checkpoint path, best threshold, and best validation accuracy. - """ - checkpoints = [cp for cp in os.listdir(self.config.output_dir) if "checkpoint-" in cp] - if len(checkpoints) == 0: - raise ValueError("no checkpoints found for threshold tuning") - best_val_accuracy = -1 - best_checkpoint = checkpoints[0] - val_convo_ids = set() - utt2convo = {} - val_labels_dict = {} - for context in val_contexts: - convo_id = context.conversation_id - utt_id = context.current_utterance.id - label = self.labeler(context.current_utterance.get_conversation()) - utt2convo[utt_id] = convo_id - val_labels_dict[convo_id] = label - val_convo_ids.add(convo_id) - val_convo_ids = list(val_convo_ids) - for cp in checkpoints: - full_model_path = os.path.join(self.config.output_dir, cp) - finetuned_model = AutoModelForSequenceClassification.from_pretrained( - full_model_path - ).to(self.config.device) - val_scores = self._score_dataset(val_dataset, model=finetuned_model) - # for each CONVERSATION, whether or not it triggers will be effectively determined by what the highest score it ever got was - highest_convo_scores = {convo_id: -1 for convo_id in val_convo_ids} - for utt_id in val_scores.index: - convo_id = utt2convo[utt_id] - utt_score = val_scores.loc[utt_id].forecast_prob - if utt_score > highest_convo_scores[convo_id]: - highest_convo_scores[convo_id] = utt_score - - val_labels = np.asarray([int(val_labels_dict[c]) for c in val_convo_ids]) - val_scores = np.asarray([highest_convo_scores[c] for c in val_convo_ids]) - # use scikit learn to find candidate threshold cutoffs - _, _, thresholds = roc_curve(val_labels, val_scores) - - def acc_with_threshold(y_true, y_score, thresh): - y_pred = (y_score > thresh).astype(int) - return (y_pred == y_true).mean() - - accs = [acc_with_threshold(val_labels, val_scores, t) for t in thresholds] - best_acc_idx = np.argmax(accs) - - print("Accuracy:", cp, accs[best_acc_idx]) - if accs[best_acc_idx] > best_val_accuracy: - best_checkpoint = cp - best_val_accuracy = accs[best_acc_idx] - self.best_threshold = thresholds[best_acc_idx] - self.model = finetuned_model - - eval_forecasts_df = self._score_dataset(val_dataset, threshold=self.best_threshold) - eval_prediction_file = os.path.join(self.config.output_dir, "val_predictions.csv") - eval_forecasts_df.to_csv(eval_prediction_file) - - # Save the best config - best_config = {} - best_config["best_checkpoint"] = best_checkpoint - best_config["best_threshold"] = self.best_threshold - best_config["best_val_accuracy"] = best_val_accuracy - config_file = os.path.join(self.config.output_dir, "dev_config.json") - with open(config_file, "w") as outfile: - json_object = json.dumps(best_config, indent=4) - outfile.write(json_object) - - # Clean other checkpoints to save disk space. - for root, _, _ in os.walk(self.config.output_dir): - if ("checkpoint" in root) and (best_checkpoint not in root): - print("Deleting:", root) - shutil.rmtree(root) - # Save the tokenizer. - self.tokenizer.save_pretrained( - os.path.join(self.config.output_dir, best_config["best_checkpoint"]) - ) - return best_config - def fit_belief_estimator(self, contexts, val_contexts=None): """ Fine-tune the TransformerEncoder model, and save the best model according to validation performance. @@ -360,14 +282,6 @@ def fit_belief_estimator(self, contexts, val_contexts=None): trainer.train() return - def fit_decision_policy(self, contexts, val_contexts=None): - if val_contexts is None: - return super().fit_decision_policy(contexts, val_contexts) - val_contexts = list(val_contexts) - val_for_tuning_pairs = self._context_to_bert_data(val_contexts) - val_for_tuning_pairs.set_format("torch") - return self._tune_threshold(val_for_tuning_pairs, val_contexts) - def fit(self, contexts, val_contexts=None): return super().fit(contexts, val_contexts) diff --git a/convokit/forecaster/forecaster.py b/convokit/forecaster/forecaster.py index 1df481122..c89dddaf9 100644 --- a/convokit/forecaster/forecaster.py +++ b/convokit/forecaster/forecaster.py @@ -121,6 +121,20 @@ def fit( self.forecaster_model.fit(contexts, val_contexts) return self + + def fit_decision_policy(self, corpus, context_selector, val_context_selector): + contexts = self._create_context_iterator(corpus, context_selector, include_future_context=True) + val_contexts = None + if val_context_selector is not None: + val_contexts = self._create_context_iterator(corpus, val_context_selector, include_future_context=True) + return self.forecaster_model.fit_decision_policy(contexts, val_contexts) + + def fit_belief_estimator(self, corpus, context_selector, val_context_selector): + contexts = self._create_context_iterator(corpus, context_selector, include_future_context=True) + val_contexts = None + if val_context_selector is not None: + val_contexts = self._create_context_iterator(corpus, val_context_selector, include_future_context=True) + return self.forecaster_model.fit_belief_estimator(contexts, val_contexts) def transform( self, @@ -142,19 +156,16 @@ def transform( contexts, self.forecast_attribute_name, self.forecast_prob_attribute_name ) + # generalize addition of metadata columns + meta_columns = list(forecast_df.columns) for utt in corpus.iter_utterances(): if utt.id in forecast_df.index: - utt.add_meta( - self.forecast_attribute_name, - forecast_df.loc[utt.id][self.forecast_attribute_name], - ) - utt.add_meta( - self.forecast_prob_attribute_name, - forecast_df.loc[utt.id][self.forecast_prob_attribute_name], - ) + row = forecast_df.loc[utt.id] + for col in meta_columns: + utt.add_meta(col, row[col]) else: - utt.add_meta(self.forecast_attribute_name, None) - utt.add_meta(self.forecast_prob_attribute_name, None) + for col in meta_columns: + utt.add_meta(col, None) return corpus diff --git a/convokit/forecaster/forecasterModel.py b/convokit/forecaster/forecasterModel.py index 474aa30e3..48d41ffa7 100644 --- a/convokit/forecaster/forecasterModel.py +++ b/convokit/forecaster/forecasterModel.py @@ -2,6 +2,10 @@ from itertools import tee from typing import Callable +import json +import os +import shutil + from convokit.decisionpolicy import ThresholdDecisionPolicy @@ -36,6 +40,7 @@ def decision_policy(self, value): if self._decision_policy is not None: self._decision_policy.labeler = self._labeler + @abstractmethod def fit(self, contexts, val_contexts=None): """ Train this conversational forecasting model on the given data by fitting @@ -44,14 +49,7 @@ def fit(self, contexts, val_contexts=None): :param contexts: an iterator over context tuples :param val_contexts: an optional second iterator over context tuples to be used as a separate held-out validation set. Concrete ForecasterModel implementations may choose to ignore this, or conversely even enforce its presence. """ - belief_contexts, policy_contexts = tee(contexts, 2) - if val_contexts is None: - belief_val_contexts = None - policy_val_contexts = None - else: - belief_val_contexts, policy_val_contexts = tee(val_contexts, 2) - self.fit_belief_estimator(belief_contexts, belief_val_contexts) - self.fit_decision_policy(policy_contexts, policy_val_contexts) + pass @abstractmethod def fit_belief_estimator(self, contexts, val_contexts=None): @@ -60,16 +58,83 @@ def fit_belief_estimator(self, contexts, val_contexts=None): """ pass - def fit_decision_policy(self, contexts, val_contexts=None): + def fit_decision_policy(self, contexts, val_contexts=None, score_fn: Callable = None): """ Fit only the decision policy component. """ if self.decision_policy is not None: - return self.decision_policy.fit( - contexts=contexts, val_contexts=val_contexts, score_fn=self.score + if score_fn is None: + score_fn = self.score + fit_result = self.decision_policy.fit( + contexts=contexts, val_contexts=val_contexts, score_fn=score_fn ) + self._json_dump_fit_result(fit_result) + return fit_result return None + def _json_dump_fit_result(self, fit_result): + if not isinstance(fit_result, dict): + return + + output_dir = getattr(getattr(self, "config", None), "output_dir", None) + if output_dir is None: + return + + config_file = os.path.join(output_dir, "dev_config.json") + existing_config = {} + if os.path.exists(config_file): + try: + with open(config_file, "r") as infile: + existing_config = json.load(infile) + except (json.JSONDecodeError, OSError): + existing_config = {} + + if "best_checkpoint" in fit_result: + existing_config["best_checkpoint"] = fit_result["best_checkpoint"] + if "best_threshold" in fit_result: + existing_config["best_threshold"] = float(fit_result["best_threshold"]) + if "best_val_accuracy" in fit_result: + existing_config["best_val_accuracy"] = float(fit_result["best_val_accuracy"]) + + with open(config_file, "w") as outfile: + json.dump(existing_config, outfile, indent=4) + + def get_checkpoints(self): + return [] + + def load_checkpoint(self, checkpoint_name): + raise NotImplementedError("checkpoint loading is not implemented for this model") + + def finalize_best_checkpoint_selection( + self, best_checkpoint, best_config, val_contexts=None, score_fn: Callable = None + ): + if best_checkpoint is None: + return + self._cleanup_checkpoints(best_checkpoint) + self._save_tokenizer_checkpoint(best_checkpoint) + + def _cleanup_checkpoints(self, best_checkpoint): + output_dir = getattr(getattr(self, "config", None), "output_dir", None) + if output_dir is None or best_checkpoint is None: + return + + for root, _, _ in os.walk(output_dir): + if ("checkpoint" in root) and (best_checkpoint not in root): + print(f"deleting: {root}") + shutil.rmtree(root) + + def _save_tokenizer_checkpoint(self, best_checkpoint): + tokenizer = getattr(self, "tokenizer", None) + output_dir = getattr(getattr(self, "config", None), "output_dir", None) + if ( + tokenizer is None + or output_dir is None + or best_checkpoint is None + or not hasattr(tokenizer, "save_pretrained") + ): + return + tokenizer.save_pretrained(os.path.join(output_dir, best_checkpoint)) + @abstractmethod def score(self, context) -> float: """ @@ -80,9 +145,10 @@ def score(self, context) -> float: def _predict(self, context): """ Return both belief score and policy action for a context. + + This method is deprecated in favor of using the self.decision_policy.decide method. """ - utt_score = self.score(context) - utt_pred = self.decision_policy.decide(context, self.score) + utt_score, utt_pred = self.decision_policy.decide(context, self.score) return utt_score, utt_pred @abstractmethod diff --git a/examples/forecaster/train_deferral.py b/examples/forecaster/train_deferral.py new file mode 100644 index 000000000..dec75fe49 --- /dev/null +++ b/examples/forecaster/train_deferral.py @@ -0,0 +1,186 @@ +""" +end-to-end training script for a TransformerDecoderModel forecaster with a DeferralDecisionPolicy. + +flow: + 1. load the CGA-CMV corpus + 2. build a DeferralDecisionPolicy backed by an UnslothUtteranceSimulatorModel + 3. build a TransformerDecoderModel (forecaster backbone) with that policy attached + 4. wrap both in a Forecaster + 5. fit: LoRA fine-tune the forecaster, then fit the decision policy on the val set + 6. evaluate on the test set and print metrics + +usage: + python train_deferral.py [--device cuda] [--gpu 0] +""" + +import argparse +import os +import sys + +# ensure the repo root is on the path when running directly +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) + + +def main(args): + import convokit + from convokit import Corpus, Forecaster, download + from convokit.forecaster.TransformerDecoderModel import TransformerDecoderModel + from convokit.forecaster.TransformerForecasterConfig import TransformerForecasterConfig + from convokit.decisionpolicy import DeferralDecisionPolicy, ThresholdDecisionPolicy + + # ------------------------------------------------------------------ # + # 1. corpus + # ------------------------------------------------------------------ # + print("[info] loading corpus...") + corpus = Corpus( + filename=download( + "conversations-gone-awry-cmv-corpus", + data_dir=args.data_dir, + ) + ) + + labeler = "has_removed_comment" + + # ------------------------------------------------------------------ # + # 2. context selectors + # ------------------------------------------------------------------ # + def train_selector(ctx): + """last context of every train conversation (matches original craft/llm training setup)""" + convo = ctx.current_utterance.get_conversation() + return ( + convo.meta.get("split") == "train" + and len(ctx.future_context) == 0 + ) + + def val_selector(ctx): + return ctx.current_utterance.get_conversation().meta.get("split") == "val" + + def test_selector(ctx): + convo = ctx.current_utterance.get_conversation() + convo_len = len(convo.get_chronological_utterance_list()) + return ( + convo.meta.get("split") == "test" + # exclude the very last context (the toxic turn itself) + and len(ctx.context) < convo_len + ) + + + # 3. simulator model + # # + # 4. decision policy + policy = ThresholdDecisionPolicy( + threshold=0.5926666259765625, + ) + + # 5. forecaster model + print("[info] loading forecaster model...") + config = TransformerForecasterConfig( + output_dir=args.output_dir, + per_device_batch_size=args.batch_size, + gradient_accumulation_steps=args.grad_accum, + num_train_epochs=args.epochs, + learning_rate=args.lr, + random_seed=args.seed, + context_mode="normal", + device=args.device, + ) + + forecaster_model = TransformerDecoderModel( + model_name_or_path=args.forecaster_model, + config=config, + decision_policy=policy, + ) + + # 6. forecaster wrapper + forecaster = Forecaster( + forecaster_model=forecaster_model, + labeler=labeler, + ) + + # 7. fit + # print("[info] fitting forecaster (belief estimator + decision policy)...") + # forecaster.fit( + # corpus=corpus, + # context_selector=train_selector, + # val_context_selector=val_selector, + # ) + + forecaster.fit_decision_policy( + corpus=corpus, + context_selector=train_selector, + val_context_selector=val_selector, + ) + + # print(forecaster.forecaster_model.decision_policy.threshold) + + # # 8. evaluate on test set + # print("[info] running transform on test set...") + # corpus = forecaster.transform( + # corpus=corpus, + # context_selector=test_selector, + # ) + + # print("[info] computing metrics...") + # forecaster.summarize( + # corpus=corpus, + # selector=lambda convo: convo.meta.get("split") == "test", + # ) + + # optional: inspect a few utterances with stored simulations + if args.store_simulations: + print("\n[info] sample utterances with stored simulations:") + shown = 0 + for utt in corpus.iter_utterances(): + # show only utterances that were forecasted and have sim_replies + if ( + utt.meta.get("forecast") is not None + and utt.meta.get("sim_replies") is not None + ): + print("---") + print("text :", utt.text[:120]) + print("forecast_prob :", utt.meta["forecast_prob"]) + print("forecast :", utt.meta["forecast"]) + print("sim_replies :", utt.meta["sim_replies"][:2]) + print("sim_probs :", utt.meta["sim_replies_forecast_probs"][:2]) + shown += 1 + if shown >= 3: + break + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="train forecaster with DeferralDecisionPolicy") + + # paths + parser.add_argument("--forecaster-model", required=True, + help="hf model name or local path for the decoder forecaster") + parser.add_argument("--simulator-model", required=True, + help="hf model name or local path for the utterance simulator") + parser.add_argument("--output-dir", default="./deferral_output", + help="directory to save checkpoints and predictions") + parser.add_argument("--data-dir", default="./", + help="directory to download/find the corpus") + + # training hyperparams + parser.add_argument("--epochs", type=int, default=1) + parser.add_argument("--batch-size", type=int, default=2) + parser.add_argument("--grad-accum", type=int, default=32) + parser.add_argument("--lr", type=float, default=1e-4) + parser.add_argument("--seed", type=int, default=1) + + # deferral policy hyperparams + parser.add_argument("--num-simulations", type=int, default=10, + help="number of simulated branches per context") + parser.add_argument("--tau", type=int, default=5, + help="minimum simulated branches above threshold to intervene") + + # misc + parser.add_argument("--device", default="cuda") + parser.add_argument("--gpu", type=int, default=3, + help="which gpu to use (sets CUDA_VISIBLE_DEVICES)") + parser.add_argument("--store-simulations", action="store_true", + help="write simulated replies and their forecast probs to corpus metadata") + + args = parser.parse_args() + os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu) + + main(args) From 21a314ff65dfbc8a8350f462d9686c6f5c6ede70 Mon Sep 17 00:00:00 2001 From: laerdon Date: Sun, 26 Apr 2026 21:13:48 +0000 Subject: [PATCH 03/21] final 1/x --- convokit/decisionpolicy/decisionPolicy.py | 31 +++- .../decisionpolicy/deferralDecisionPolicy.py | 98 ++++++++++-- .../decisionpolicy/thresholdDecisionPolicy.py | 15 +- convokit/forecaster/CRAFTModel.py | 15 +- .../forecaster/TransformerDecoderModel.py | 148 ++++++++++++++++-- .../forecaster/TransformerEncoderModel.py | 22 ++- convokit/forecaster/forecaster.py | 6 +- convokit/forecaster/forecasterModel.py | 35 ++++- 8 files changed, 332 insertions(+), 38 deletions(-) diff --git a/convokit/decisionpolicy/decisionPolicy.py b/convokit/decisionpolicy/decisionPolicy.py index 40b87b857..eff7ac755 100644 --- a/convokit/decisionpolicy/decisionPolicy.py +++ b/convokit/decisionpolicy/decisionPolicy.py @@ -11,8 +11,17 @@ class DecisionPolicy(ABC): Abstract interface for converting a conversational context into an action. """ - def __init__(self): + def __init__( + self, + forecast_prob_attribute_name: str = "forecast_prob", + reuse_cached_forecast_probs: bool = True, + ): self._labeler = None + # name of the utterance-meta field that may already hold a forecast prob + # from a prior Forecaster.transform() pass. kept in sync with the owning + # ForecasterModel / Forecaster when they are wired up. + self.forecast_prob_attribute_name = forecast_prob_attribute_name + self.reuse_cached_forecast_probs = bool(reuse_cached_forecast_probs) @property def labeler(self): @@ -22,6 +31,18 @@ def labeler(self): def labeler(self, value: Callable): self._labeler = value + def _score(self, context, score_fn: Callable) -> float: + # prefer a previously written forecast prob on the current utterance meta + # so policies don't re-invoke the belief estimator on utterances the + # forecaster has already transformed. synthetic / simulated utterances + # carry an empty meta and always fall through to score_fn. + if self.reuse_cached_forecast_probs: + meta = getattr(getattr(context, "current_utterance", None), "meta", None) or {} + cached = meta.get(self.forecast_prob_attribute_name) + if cached is not None: + return float(cached) + return float(score_fn(context)) + def _fit_with_model_checkpoint_selection(self, val_contexts, score_fn: Callable = None): if score_fn is None: return None @@ -43,6 +64,11 @@ def _fit_with_model_checkpoint_selection(self, val_contexts, score_fn: Callable best_config = None best_checkpoint = None best_val_accuracy = -1.0 + # while sweeping checkpoints, any cached forecast_prob on utterance meta + # reflects whichever checkpoint's transform() ran last, not the one we + # are currently evaluating. force a fresh score_fn call for each sweep. + prior_reuse_flag = self.reuse_cached_forecast_probs + self.reuse_cached_forecast_probs = False for checkpoint_name in checkpoints: load_checkpoint(checkpoint_name) fit_result = self._fit_threshold_for_loaded_model(val_contexts, score_fn=score_fn) @@ -55,6 +81,7 @@ def _fit_with_model_checkpoint_selection(self, val_contexts, score_fn: Callable "best_threshold": float(fit_result["best_threshold"]), "best_val_accuracy": float(fit_result["best_val_accuracy"]), } + self.reuse_cached_forecast_probs = prior_reuse_flag if best_config is None: return None @@ -95,7 +122,7 @@ def _get_validation_arrays(self, val_contexts, score_fn: Callable): convo_labels = {} for context in tqdm(val_contexts): convo_id = context.conversation_id - score = float(score_fn(context)) + score = self._score(context, score_fn) label = int(self.labeler(context.current_utterance.get_conversation())) if convo_id not in highest_convo_scores: highest_convo_scores[convo_id] = score diff --git a/convokit/decisionpolicy/deferralDecisionPolicy.py b/convokit/decisionpolicy/deferralDecisionPolicy.py index 848e1154f..335eb2ae4 100644 --- a/convokit/decisionpolicy/deferralDecisionPolicy.py +++ b/convokit/decisionpolicy/deferralDecisionPolicy.py @@ -35,6 +35,11 @@ class DeferralDecisionPolicy(DecisionPolicy): and written to corpus utterance metadata by post_transform(). :param simulated_reply_attribute_name: metadata field name used when storing simulations on corpus utterances (only relevant when store_simulations=True). + :param reuse_cached_simulations: if True (default), simulations already present on the + current utterance's metadata under ``simulated_reply_attribute_name`` are reused + instead of re-invoking the simulator. similarly, cached simulation scores under + ``sim_replies_forecast_probs_attribute_name`` are reused when they align with the + reused simulations, skipping re-scoring. set to False to force regeneration. """ def __init__( @@ -46,8 +51,14 @@ def __init__( store_simulations: bool = False, simulated_reply_attribute_name: str = "sim_replies", sim_replies_forecast_probs_attribute_name: str = "sim_replies_forecast_probs", + reuse_cached_simulations: bool = True, + forecast_prob_attribute_name: str = "forecast_prob", + reuse_cached_forecast_probs: bool = True, ): - super().__init__() + super().__init__( + forecast_prob_attribute_name=forecast_prob_attribute_name, + reuse_cached_forecast_probs=reuse_cached_forecast_probs, + ) self.simulator = simulator self.threshold = float(threshold) self.tau = int(tau) @@ -58,10 +69,49 @@ def __init__( self.store_simulations = store_simulations self.simulated_reply_attribute_name = simulated_reply_attribute_name self.sim_replies_forecast_probs_attribute_name = sim_replies_forecast_probs_attribute_name + self.reuse_cached_simulations = bool(reuse_cached_simulations) self._sim_cache: dict = {} self._sim_score_cache: dict = {} + def _get_utt_meta(self, context): + # unified accessor so both real Utterance and _synthetic_utterance work; returns {} if absent. + return getattr(context.current_utterance, "meta", {}) or {} + + def _get_cached_simulations(self, context) -> Optional[List[str]]: + # returns cached simulation strings for this utterance if available on its metadata, else None. + if not self.reuse_cached_simulations: + return None + meta = self._get_utt_meta(context) + cached = meta.get(self.simulated_reply_attribute_name) + if cached is None: + return None + cached_list = list(cached) + if len(cached_list) == 0: + return None + return cached_list[: self.num_simulations] + + def _get_cached_simulation_scores( + self, context, num_expected: int + ) -> Optional[List[float]]: + # returns cached per-simulation scores aligned with reused simulations, else None. + if not self.reuse_cached_simulations or num_expected == 0: + return None + meta = self._get_utt_meta(context) + cached = meta.get(self.sim_replies_forecast_probs_attribute_name) + if cached is None: + return None + cached_list = list(cached) + # if the cached scores are shorter than the reused simulations, fall back to re-scoring + # rather than silently mixing cached and fresh scores. + if len(cached_list) < num_expected: + return None + return [float(x) for x in cached_list[:num_expected]] + def get_simulations(self, context, simulator=None) -> List[str]: + # fast path: reuse pre-computed simulations from utterance metadata when present. + cached = self._get_cached_simulations(context) + if cached is not None: + return cached sim = simulator if simulator is not None else self.simulator if sim is None or not hasattr(sim, "transform"): return [] @@ -89,12 +139,21 @@ def _build_simulated_context(self, context, simulation_text: str, simulation_idx ) def _decision_score(self, context, score_fn: Callable): - current_score = float(score_fn(context)) + current_score = self._score(context, score_fn) simulations = self.get_simulations(context) - simulation_scores = [] - for idx, sim_text in enumerate(simulations): - sim_context = self._build_simulated_context(context, sim_text, idx) - simulation_scores.append(float(score_fn(sim_context))) + # the get_simulations method actively checks if cached simulations exist + + # fast path: if cached per-simulation scores align with the reused simulations, + # skip re-scoring the simulated contexts entirely. + cached_scores = self._get_cached_simulation_scores(context, len(simulations)) + if cached_scores is not None: + simulation_scores = cached_scores + else: + simulation_scores = [] + for idx, sim_text in enumerate(simulations): + sim_context = self._build_simulated_context(context, sim_text, idx) + # synthetic utterances have empty meta so _score falls through to score_fn. + simulation_scores.append(self._score(sim_context, score_fn)) if self.store_simulations and simulations: utt_id = context.current_utterance.id self._sim_cache[utt_id] = simulations @@ -102,16 +161,27 @@ def _decision_score(self, context, score_fn: Callable): return current_score, simulations, simulation_scores def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]: + max_defer_index = 4 decision_score, simulations, simulation_scores = self._decision_score(context, score_fn) num_simulations_above_threshold = sum(1 for score in simulation_scores if score > self.threshold) - - # we want to return an awry prediction if we have - return (decision_score, - 1 if decision_score > self.threshold and num_simulations_above_threshold > 5 else 0, - { - self.simulated_reply_attribute_name: simulations, - self.sim_replies_forecast_probs_attribute_name: simulation_scores, - } + num_simulations = len(simulations) + # context.context contains chronological_utts[: i+1] (includes current_utterance), + # so the current utterance's position in the conversation is len(context.context) - 1. + utt_index = max(0, len(getattr(context, "context", []) or []) - 1) + # past the deferral window we always commit when fp > threshold, mirroring the + # `i < 4` early-only deferral in performance_utils.no_tricks. + past_defer_window = max_defer_index is not None and utt_index >= max_defer_index + defer_eligible = not past_defer_window + num_calm = num_simulations - num_simulations_above_threshold + # defer = defer_eligible and (num_calm > self.tau) + defer = (num_calm > self.tau) + return ( + decision_score, + 1 if decision_score > self.threshold and not defer else 0, + { + self.simulated_reply_attribute_name: simulations, + self.sim_replies_forecast_probs_attribute_name: simulation_scores, + }, ) def fit(self, contexts, val_contexts=None, score_fn: Callable = None): diff --git a/convokit/decisionpolicy/thresholdDecisionPolicy.py b/convokit/decisionpolicy/thresholdDecisionPolicy.py index 44a8b0e3c..16df7ff2f 100644 --- a/convokit/decisionpolicy/thresholdDecisionPolicy.py +++ b/convokit/decisionpolicy/thresholdDecisionPolicy.py @@ -8,12 +8,21 @@ class ThresholdDecisionPolicy(DecisionPolicy): A simple decision policy that predicts 1 when score > threshold. """ - def __init__(self, threshold: float = 0.5): - super().__init__() + def __init__( + self, + threshold: float = 0.5, + forecast_prob_attribute_name: str = "forecast_prob", + reuse_cached_forecast_probs: bool = True, + ): + super().__init__( + forecast_prob_attribute_name=forecast_prob_attribute_name, + reuse_cached_forecast_probs=reuse_cached_forecast_probs, + ) self.threshold = float(threshold) def decide(self, context, score_fn: Callable) -> Tuple[float, int]: - return score_fn(context), int(score_fn(context) > self.threshold) + score = self._score(context, score_fn) + return score, int(score > self.threshold) def fit(self, contexts, val_contexts=None, score_fn: Callable = None): if val_contexts is None or score_fn is None or self.labeler is None: diff --git a/convokit/forecaster/CRAFTModel.py b/convokit/forecaster/CRAFTModel.py index e100e0a1e..80aa0b35d 100644 --- a/convokit/forecaster/CRAFTModel.py +++ b/convokit/forecaster/CRAFTModel.py @@ -344,6 +344,7 @@ def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_n # initialize the CRAFT model with whatever weights we currently have saved encoder, context_encoder, predictor = self._get_inference_components() + base_columns = {"id", forecast_attribute_name, forecast_prob_attribute_name} output_df = {"id": [], forecast_attribute_name: [], forecast_prob_attribute_name: []} batch_iterator = batchIterator( self._voc, test_pairs, self._config["batch_size"], shuffle=False @@ -393,10 +394,20 @@ def score_fn(scored_context): return score return self.score(scored_context) - pred = self.decision_policy.decide(context, score_fn) + utt_score, pred, utt_metadata = self._parse_decision_result( + self.decision_policy.decide(context, score_fn) + ) + current_idx = len(output_df["id"]) output_df["id"].append(utt_id) output_df[forecast_attribute_name].append(int(pred)) - output_df[forecast_prob_attribute_name].append(score) + output_df[forecast_prob_attribute_name].append(utt_score) + existing_metadata_keys = [key for key in output_df if key not in base_columns] + for key in existing_metadata_keys: + output_df[key].append(utt_metadata.get(key, None)) + for key, value in utt_metadata.items(): + if key not in output_df: + output_df[key] = [None] * current_idx + output_df[key].append(value) print( "Iteration: {}; Percent complete: {:.1f}%".format( iteration, iteration / n_iters * 100 diff --git a/convokit/forecaster/TransformerDecoderModel.py b/convokit/forecaster/TransformerDecoderModel.py index 449a1e4d9..a7d17782f 100644 --- a/convokit/forecaster/TransformerDecoderModel.py +++ b/convokit/forecaster/TransformerDecoderModel.py @@ -1,4 +1,4 @@ -from itertools import tee +from itertools import tee, islice import unsloth from unsloth import FastLanguageModel, is_bfloat16_supported from unsloth.chat_templates import get_chat_template @@ -249,8 +249,7 @@ def fit_belief_estimator(self, train_contexts, val_contexts=None): This method applies Low-Rank Adaptation (LoRA) to the decoder model, converts the training contexts into text-based input for LLM fine-tuning, and trains the model - using HuggingFace's `SFTTrainer`. After training, it tunes a decision threshold on - a held-out validation set to optimize binary forecast classification. + using HuggingFace's `SFTTrainer`. :param contexts: an iterator over context tuples, provided by the Forecaster framework :param val_contexts: an iterator over context tuples to be used only for validation. @@ -354,7 +353,16 @@ def _predict(self, context, threshold=None): if threshold is not None: utt_pred = int(utt_score > threshold) else: - utt_score, utt_pred, _ = self.decision_policy.decide(context, self.score) + result = self.decision_policy.decide(context, self.score) + if len(result) == 2: + utt_score, utt_pred = result + elif len(result) == 3: + utt_score, utt_pred, _ = result + else: + raise ValueError( + "decision_policy.decide() must return (utt_score, utt_pred) " + "or (utt_score, utt_pred, metadata_dict)" + ) return utt_score, utt_pred def fit(self, contexts, val_contexts=None): @@ -363,13 +371,14 @@ def fit(self, contexts, val_contexts=None): self.fit_decision_policy(contexts, val_contexts_decision_policy, score_fn=self.score) return - def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name): + def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name, verbose=False): """ Generate forecasts using the fine-tuned TransformerDecoder model on the provided contexts, and save the predictions to the output directory specified in the configuration. :param contexts: context tuples from the Forecaster framework :param forecast_attribute_name: Forecaster will use this to look up the table column containing your model's discretized predictions (see output specification below) :param forecast_prob_attribute_name: Forecaster will use this to look up the table column containing your model's raw forecast probabilities (see output specification below) + :param verbose: if True, print verbose transform logging during the transformation :return: a Pandas DataFrame, with one row for each context, indexed by the ID of that context's current utterance. Contains two columns, one with raw probabilities named according to forecast_prob_attribute_name, and one with discretized (binary) forecasts named according to forecast_attribute_name """ @@ -378,8 +387,45 @@ def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_n preds = [] scores = [] metadatas = defaultdict(list) + # TODO(metrics): temporary running metric logging during transform; remove before merge. + report_every_n = 250 + prediction_file = os.path.join(self.config.output_dir, "predictions.csv") + if os.path.exists(prediction_file): + os.remove(prediction_file) + next_flush_start = 0 + csv_header_written = False + convo_forecasts = {} + convo_labels = {} + + def _compute_conversation_metrics(): + common_convo_ids = [cid for cid in convo_forecasts if cid in convo_labels] + if len(common_convo_ids) == 0: + return None + tp = 0 + fp = 0 + tn = 0 + fn = 0 + for convo_id in common_convo_ids: + pred = int(convo_forecasts[convo_id] > 0) + label = int(convo_labels[convo_id]) + if label == 1 and pred == 1: + tp += 1 + elif label == 0 and pred == 1: + fp += 1 + elif label == 0 and pred == 0: + tn += 1 + elif label == 1 and pred == 0: + fn += 1 + n = len(common_convo_ids) + acc = (tp + tn) / n if n > 0 else 0.0 + p = tp / (tp + fp) if (tp + fp) > 0 else 0.0 + r = tp / (tp + fn) if (tp + fn) > 0 else 0.0 + fpr = fp / (fp + tn) if (fp + tn) > 0 else 0.0 + f1 = (2 * p * r / (p + r)) if (p + r) > 0 else 0.0 + return {"n": n, "acc": acc, "p": p, "r": r, "fpr": fpr, "f1": f1} # for safety/flexibility we can accept either only score and pred or also the metadata - for context in tqdm(contexts): + progress = tqdm(contexts) + for idx, context in enumerate(progress, start=1): result = self.decision_policy.decide(context, self.score) if len(result) == 2: @@ -388,8 +434,10 @@ def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_n # no metadata elif len(result) == 3: utt_score, utt_pred, utt_metadata = result - for key in utt_metadata.keys(): - metadatas[key].append(utt_metadata.get(key, None)) + # coerce None metadata to {} so policies that return (score, pred, None) + # don't crash downstream utt_metadata.items() / .get() calls. + if utt_metadata is None: + utt_metadata = {} else: raise ValueError( "decision_policy.decide() must return (utt_score, utt_pred) " @@ -398,15 +446,91 @@ def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_n utt_ids.append(context.current_utterance.id) preds.append(utt_pred) scores.append(utt_score) + current_idx = len(preds) - 1 + existing_metadata_keys = list(metadatas.keys()) + for key in existing_metadata_keys: + metadatas[key].append(utt_metadata.get(key, None)) + for key, value in utt_metadata.items(): + if key not in metadatas: + metadatas[key] = [None] * current_idx + metadatas[key].append(value) + + convo_id = getattr(context, "conversation_id", None) + try: + convo = context.current_utterance.get_conversation() + if convo_id is None and convo is not None: + convo_id = convo.id + if convo_id is not None: + if convo_id in convo_forecasts: + convo_forecasts[convo_id] = max(convo_forecasts[convo_id], int(utt_pred)) + else: + convo_forecasts[convo_id] = int(utt_pred) + if convo_id not in convo_labels: + convo_labels[convo_id] = int(self.labeler(convo)) + except Exception: + pass + + if idx % report_every_n == 0: + batch_cols = { + forecast_attribute_name: preds[next_flush_start:idx], + forecast_prob_attribute_name: scores[next_flush_start:idx], + } + for key, series in metadatas.items(): + batch_cols[key] = series[next_flush_start:idx] + batch_df = pd.DataFrame(batch_cols, index=utt_ids[next_flush_start:idx]) + batch_df.to_csv( + prediction_file, + mode="a" if csv_header_written else "w", + header=not csv_header_written, + ) + csv_header_written = True + next_flush_start = idx + + running_metrics = _compute_conversation_metrics() + if verbose: + if running_metrics is not None: + tqdm.write( + f"[info] transform metrics running: " + f"processed_contexts={idx}, conversations={running_metrics['n']}, " + f"acc={running_metrics['acc']:.4f}, p={running_metrics['p']:.4f}, " + f"r={running_metrics['r']:.4f}, fpr={running_metrics['fpr']:.4f}, " + f"f1={running_metrics['f1']:.4f}" + ) + else: + tqdm.write( + f"[info] transform metrics running: " + f"processed_contexts={idx}, conversations=0" + ) + total_processed = len(preds) + if total_processed > next_flush_start: + batch_cols = { + forecast_attribute_name: preds[next_flush_start:total_processed], + forecast_prob_attribute_name: scores[next_flush_start:total_processed], + } + for key, series in metadatas.items(): + batch_cols[key] = series[next_flush_start:total_processed] + batch_df = pd.DataFrame(batch_cols, index=utt_ids[next_flush_start:total_processed]) + batch_df.to_csv( + prediction_file, + mode="a" if csv_header_written else "w", + header=not csv_header_written, + ) + csv_header_written = True cols = { forecast_attribute_name: preds, forecast_prob_attribute_name: scores, } + final_metrics = _compute_conversation_metrics() + if final_metrics is not None: + tqdm.write( + f"[info] final transform metrics: " + f"processed_contexts={len(preds)}, conversations={final_metrics['n']}, " + f"acc={final_metrics['acc']:.4f}, p={final_metrics['p']:.4f}, " + f"r={final_metrics['r']:.4f}, fpr={final_metrics['fpr']:.4f}, " + f"f1={final_metrics['f1']:.4f}" + ) for key, series in metadatas.items(): assert len(series) == len(preds), "Metadata series length must match number of predictions" cols[key] = series # each series same length as preds forecasts_df = pd.DataFrame(cols, index=utt_ids) - - prediction_file = os.path.join(self.config.output_dir, "test_predictions.csv") - forecasts_df.to_csv(prediction_file) - return forecasts_df + return forecasts_df \ No newline at end of file diff --git a/convokit/forecaster/TransformerEncoderModel.py b/convokit/forecaster/TransformerEncoderModel.py index f2130ac4d..f7e8a07d6 100644 --- a/convokit/forecaster/TransformerEncoderModel.py +++ b/convokit/forecaster/TransformerEncoderModel.py @@ -14,6 +14,7 @@ from tqdm import tqdm from .forecasterModel import ForecasterModel from .TransformerForecasterConfig import TransformerForecasterConfig +from itertools import tee os.environ["TOKENIZERS_PARALLELISM"] = "false" @@ -283,13 +284,28 @@ def fit_belief_estimator(self, contexts, val_contexts=None): return def fit(self, contexts, val_contexts=None): - return super().fit(contexts, val_contexts) + val_contexts_belief_estimator, val_contexts_decision_policy = tee(val_contexts, 2) + self.fit_belief_estimator(contexts, val_contexts_belief_estimator) + self.fit_decision_policy(contexts, val_contexts_decision_policy, score_fn=self.score) + return def _predict(self, context, threshold=None): utt_score = self.score(context) + # keep threshold override for backward compatibility. if threshold is not None: - return utt_score, int(utt_score > threshold) - return utt_score, self.decision_policy.decide(context, self.score) + utt_pred = int(utt_score > threshold) + else: + result = self.decision_policy.decide(context, self.score) + if len(result) == 2: + utt_score, utt_pred = result + elif len(result) == 3: + utt_score, utt_pred, _ = result + else: + raise ValueError( + "decision_policy.decide() must return (utt_score, utt_pred) " + "or (utt_score, utt_pred, metadata_dict)" + ) + return utt_score, utt_pred def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name): """ diff --git a/convokit/forecaster/forecaster.py b/convokit/forecaster/forecaster.py index c89dddaf9..0e0b485cb 100644 --- a/convokit/forecaster/forecaster.py +++ b/convokit/forecaster/forecaster.py @@ -50,6 +50,9 @@ def __init__( # also give the underlying ForecasterModel access to the labeler function self.forecaster_model.labeler = self.labeler + # keep the decision policy's forecast_prob cache key aligned with the + # meta field that Forecaster.transform() writes to. + self.forecaster_model.forecast_prob_attribute_name = self.forecast_prob_attribute_name def _create_context_iterator( self, @@ -140,6 +143,7 @@ def transform( self, corpus: Corpus, context_selector: Callable[[ContextTuple], bool] = lambda context: True, + **kwargs, ) -> Corpus: """ Wrapper method for applying the underlying conversational forecasting model to make forecasts over the Conversations in a given Corpus. @@ -153,7 +157,7 @@ def transform( """ contexts = self._create_context_iterator(corpus, context_selector) forecast_df = self.forecaster_model.transform( - contexts, self.forecast_attribute_name, self.forecast_prob_attribute_name + contexts, self.forecast_attribute_name, self.forecast_prob_attribute_name, **kwargs, ) # generalize addition of metadata columns diff --git a/convokit/forecaster/forecasterModel.py b/convokit/forecaster/forecasterModel.py index 48d41ffa7..168d52786 100644 --- a/convokit/forecaster/forecasterModel.py +++ b/convokit/forecaster/forecasterModel.py @@ -18,6 +18,7 @@ class ForecasterModel(ABC): def __init__(self, decision_policy=None, **kwargs): self._labeler = None + self._forecast_prob_attribute_name = "forecast_prob" self._decision_policy = decision_policy or ThresholdDecisionPolicy() @property @@ -30,6 +31,18 @@ def labeler(self, value: Callable): if self._decision_policy is not None: self._decision_policy.labeler = value + @property + def forecast_prob_attribute_name(self) -> str: + return self._forecast_prob_attribute_name + + @forecast_prob_attribute_name.setter + def forecast_prob_attribute_name(self, value: str): + # keeps the decision policy's cache key aligned with the forecaster's + # meta field so policies can reuse previously written forecast probs. + self._forecast_prob_attribute_name = value + if self._decision_policy is not None: + self._decision_policy.forecast_prob_attribute_name = value + @property def decision_policy(self): return self._decision_policy @@ -39,6 +52,9 @@ def decision_policy(self, value): self._decision_policy = value if self._decision_policy is not None: self._decision_policy.labeler = self._labeler + self._decision_policy.forecast_prob_attribute_name = ( + self._forecast_prob_attribute_name + ) @abstractmethod def fit(self, contexts, val_contexts=None): @@ -148,9 +164,26 @@ def _predict(self, context): This method is deprecated in favor of using the self.decision_policy.decide method. """ - utt_score, utt_pred = self.decision_policy.decide(context, self.score) + utt_score, utt_pred, _ = self._parse_decision_result( + self.decision_policy.decide(context, self.score) + ) return utt_score, utt_pred + def _parse_decision_result(self, result): + if len(result) == 2: + utt_score, utt_pred = result + utt_metadata = {} + elif len(result) == 3: + utt_score, utt_pred, utt_metadata = result + if utt_metadata is None: + utt_metadata = {} + else: + raise ValueError( + "decision_policy.decide() must return (utt_score, utt_pred) " + "or (utt_score, utt_pred, metadata_dict)" + ) + return float(utt_score), int(utt_pred), utt_metadata + @abstractmethod def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name): """ From 924f909f3f0ca955698d7d76316474c03d499d91 Mon Sep 17 00:00:00 2001 From: laerdon Date: Tue, 28 Apr 2026 05:15:43 +0000 Subject: [PATCH 04/21] download config --- download_config.json | 6 +- .../decisionpolicy/decisionpolicy_demo.ipynb | 1217 +++++++++++++++++ 2 files changed, 1221 insertions(+), 2 deletions(-) create mode 100644 examples/decisionpolicy/decisionpolicy_demo.ipynb diff --git a/download_config.json b/download_config.json index 09bf149fb..3027a0d28 100644 --- a/download_config.json +++ b/download_config.json @@ -41,7 +41,8 @@ "ubuntu-chat-logs": 0, "contextual-abuse": 0, "news-interview": 0, - "emotional-support": 0 + "emotional-support": 0, + "decisionpolicy-demo": 0 }, "DatasetURLs": { "chromium-corpus": "http://zissou.infosci.cornell.edu/convokit/datasets/chromium-corpus/chromium-corpus.zip", @@ -115,7 +116,8 @@ "ubuntu-chat-logs": "https://zissou.infosci.cornell.edu/convokit/datasets/ubuntu-chat-logs/ubuntu-chat-logs.zip", "contextual-abuse": "https://zissou.infosci.cornell.edu/convokit/datasets/contextual-abuse/contextual-abuse.zip", "news-interview": "https://zissou.infosci.cornell.edu/convokit/datasets/news-interview/news-interview.zip", - "emotional-support": "https://zissou.infosci.cornell.edu/convokit/datasets/emotional-support/emotional-support.zip" + "emotional-support": "https://zissou.infosci.cornell.edu/convokit/datasets/emotional-support/emotional-support.zip", + "decisionpolicy-demo": "https://zissou.infosci.cornell.edu/convokit/datasets/decisionpolicy-demo/decisionpolicy-demo.zip" }, "ModelURLS": { "craft-wiki-pretrained": [ diff --git a/examples/decisionpolicy/decisionpolicy_demo.ipynb b/examples/decisionpolicy/decisionpolicy_demo.ipynb new file mode 100644 index 000000000..a3b44be6f --- /dev/null +++ b/examples/decisionpolicy/decisionpolicy_demo.ipynb @@ -0,0 +1,1217 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "90659cc6", + "metadata": {}, + "source": [ + "# Decision Policy Demo\n", + "\n", + "This notebook will provide code demonstrating how to use Decision Policies as introduced in Wait! There's a Way Out. This notebook will also provide code for running the experiments in the paper. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "703021a8", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ['CUDA_VISIBLE_DEVICES'] = '2'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd8b87be", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import argparse\n", + "import sys\n", + "import glob\n", + "\n", + "from functools import partial\n", + "import json\n", + "from convokit import Corpus, Forecaster, download\n", + "from convokit.forecaster.TransformerDecoderModel import TransformerDecoderModel\n", + "from convokit.forecaster.TransformerForecasterConfig import TransformerForecasterConfig\n", + "from convokit.decisionpolicy import DeferralDecisionPolicy, ThresholdDecisionPolicy\n", + "from convokit.utterance_simulator.unslothUtteranceSimulatorModel import UnslothUtteranceSimulatorModel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15f977d3", + "metadata": {}, + "outputs": [], + "source": [ + "# Set repo root\n", + "\n", + "from pathlib import Path\n", + "\n", + "repo_root = Path.cwd()\n", + "while repo_root.name != \"ConvoKit\":\n", + " repo_root = repo_root.parent\n", + "\n", + "repo_root = str(repo_root)" + ] + }, + { + "cell_type": "markdown", + "id": "dab74642", + "metadata": {}, + "source": [ + "Having imported our DeferralDecisionPolicy and ThresholdDecisionPolicy, we now will first define all of the other decision policies to benchmark. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5dabf0bd", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Callable, List, Optional, Dict, Any, Tuple\n", + "import numpy as np\n", + "from convokit.decisionpolicy import DecisionPolicy\n", + "\n", + "\n", + "class _synthetic_speaker:\n", + " def __init__(self, speaker_id: str):\n", + " self.id = speaker_id\n", + "\n", + "\n", + "class _synthetic_utterance:\n", + " def __init__(self, text: str, utterance_id: str, speaker_id: str):\n", + " self.text = text\n", + " self.id = utterance_id\n", + " self.speaker_ = _synthetic_speaker(speaker_id)\n", + " self.meta = {}\n", + "\n", + " def get_conversation(self):\n", + " return None\n", + "\n", + "\n", + "class RandomDeferralDecisionPolicy(DecisionPolicy):\n", + " \"\"\"\n", + " Decision policy that defers intervention by looking ahead at simulated next utterances.\n", + "\n", + " :param simulator: utterance simulator model (must have a ``transform(contexts)`` method\n", + " returning a DataFrame indexed by utterance id). if the simulator exposes\n", + " ``get_num_simulations()``, ``num_simulations`` is capped to that value.\n", + " :param threshold: probability threshold above which a context is flagged.\n", + " :param tau: minimum number of simulated branches that must exceed the threshold\n", + " before an intervention is issued.\n", + " :param num_simulations: how many simulated branches to use per context (capped to\n", + " simulator's ``get_num_simulations()`` if available).\n", + " :param store_simulations: if True, simulated reply strings are cached during decide()\n", + " and written to corpus utterance metadata by post_transform().\n", + " :param simulated_reply_attribute_name: metadata field name used when storing simulations\n", + " on corpus utterances (only relevant when store_simulations=True).\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " simulator,\n", + " threshold,\n", + " deferral_probability: float = 0.1515,\n", + " reuse_cached_forecast_probs: bool = True,\n", + " forecast_prob_attribute_name: str = \"forecast_prob\",\n", + " ):\n", + " # forward the cache flag to the base class so its _score helper honors it.\n", + " # without this, reuse_cached_probabilities on this subclass had no effect.\n", + " super().__init__(\n", + " forecast_prob_attribute_name=forecast_prob_attribute_name,\n", + " reuse_cached_forecast_probs=reuse_cached_forecast_probs,\n", + " )\n", + " self.simulator = simulator\n", + " self.threshold = float(threshold)\n", + " self.deferral_probability = float(deferral_probability)\n", + "\n", + " def _decision_score(self, context, score_fn: Callable):\n", + " # use base _score so a cached forecast_prob on the utterance meta is reused\n", + " # instead of re-invoking the belief estimator.\n", + " return self._score(context, score_fn)\n", + "\n", + " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", + " decision_score = self._score(context, score_fn)\n", + "\n", + " p = float(np.random.rand())\n", + " \n", + "\n", + " # return an empty metadata dict (not None) so downstream code that iterates\n", + " # utt_metadata.items() in TransformerDecoderModel.transform doesn't crash.\n", + " return (decision_score,\n", + " 1 if decision_score > self.threshold and p > self.deferral_probability else 0,\n", + " {}\n", + " )\n", + "\n", + " def fit(self, contexts, val_contexts=None, score_fn: Callable = None):\n", + " if val_contexts is None or score_fn is None or self.labeler is None:\n", + " print(\"either no validation contexts/score function/labeler were provided, returning current threshold\")\n", + " return {\"best_threshold\": self.threshold}\n", + "\n", + " val_contexts = list(val_contexts)\n", + " if len(val_contexts) == 0:\n", + " print(\"no validation contexts were provided, returning current threshold\")\n", + " return {\"best_threshold\": self.threshold}\n", + "\n", + " fit_result = self._fit_with_model_checkpoint_selection(val_contexts, score_fn=score_fn)\n", + " if isinstance(fit_result, dict):\n", + " if \"best_threshold\" in fit_result:\n", + " self.threshold = float(fit_result[\"best_threshold\"])\n", + " return fit_result\n", + "\n", + " fit_result = self._fit_threshold_for_loaded_model(val_contexts, score_fn=score_fn)\n", + " if \"best_threshold\" in fit_result:\n", + " self.threshold = float(fit_result[\"best_threshold\"])\n", + " return fit_result" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9d3db5bc", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Callable, Optional, Dict, Any, Tuple\n", + "\n", + "from convokit.decisionpolicy import DeferralDecisionPolicy\n", + "\n", + "\n", + "class SimulationAverageDecisionPolicy(DeferralDecisionPolicy):\n", + " \"\"\"\n", + " decision policy that intervenes if the mean of the simulated next-utterance\n", + " scores is at or above the threshold.\n", + "\n", + " this subclass inherits all simulation fetching, per-utterance metadata\n", + " caching, sim-score caching, and threshold fitting from\n", + " DeferralDecisionPolicy. the only differences are:\n", + " * no ``tau`` parameter (unused; forwarded as 0 to super)\n", + " * ``decide`` predicts based on mean(simulation_scores) >= threshold\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " simulator,\n", + " threshold,\n", + " num_simulations: int = 10,\n", + " store_simulations: bool = False,\n", + " simulated_reply_attribute_name: str = \"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name: str = \"sim_replies_forecast_probs\",\n", + " reuse_cached_simulations: bool = True,\n", + " ):\n", + " # tau is irrelevant for the mean-based decision rule, so we pin it to 0\n", + " # upstream rather than expose it to callers of this subclass.\n", + " super().__init__(\n", + " simulator=simulator,\n", + " threshold=threshold,\n", + " tau=0,\n", + " num_simulations=num_simulations,\n", + " store_simulations=store_simulations,\n", + " simulated_reply_attribute_name=simulated_reply_attribute_name,\n", + " sim_replies_forecast_probs_attribute_name=sim_replies_forecast_probs_attribute_name,\n", + " reuse_cached_simulations=reuse_cached_simulations,\n", + " )\n", + "\n", + " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", + " decision_score, simulations, simulation_scores = self._decision_score(context, score_fn)\n", + " # empty simulation_scores would zero-divide. this happens when the\n", + " # simulator returns no completions for a context (e.g. end-of-conversation\n", + " # contexts that slip through the selector). treat as no intervention so\n", + " # a single degenerate context doesn't abort the whole transform run.\n", + " if len(simulation_scores) == 0:\n", + " average_simulation_score = 0.0\n", + " pred = 0\n", + " else:\n", + " average_simulation_score = sum(simulation_scores) / len(simulation_scores)\n", + " pred = 1 if average_simulation_score >= self.threshold else 0\n", + " return (\n", + " decision_score,\n", + " pred,\n", + " {\n", + " self.simulated_reply_attribute_name: simulations,\n", + " self.sim_replies_forecast_probs_attribute_name: simulation_scores,\n", + " },\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d0d1ea7a", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Callable, Optional, Dict, Any, Tuple\n", + "\n", + "from convokit.decisionpolicy import DeferralDecisionPolicy\n", + "\n", + "\n", + "class SimulationMajorityDecisionPolicy(DeferralDecisionPolicy):\n", + " \"\"\"\n", + " decision policy that intervenes if at least ``tau`` of the simulated next\n", + " utterances score above the threshold, ignoring the current utterance score.\n", + "\n", + " this subclass inherits all simulation fetching, per-utterance metadata\n", + " caching, sim-score caching, and threshold fitting from\n", + " DeferralDecisionPolicy. the only difference is in ``decide``: the gate\n", + " ``decision_score > threshold`` is dropped so that only the simulated-branch\n", + " vote count drives the prediction.\n", + " \"\"\"\n", + "\n", + " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", + " decision_score, simulations, simulation_scores = self._decision_score(context, score_fn)\n", + " num_simulations_above_threshold = sum(\n", + " 1 for score in simulation_scores if score > self.threshold\n", + " )\n", + " return (\n", + " decision_score,\n", + " 1 if num_simulations_above_threshold >= self.tau else 0,\n", + " {\n", + " self.simulated_reply_attribute_name: simulations,\n", + " self.sim_replies_forecast_probs_attribute_name: simulation_scores,\n", + " },\n", + " )\n" + ] + }, + { + "cell_type": "markdown", + "id": "0498693e", + "metadata": {}, + "source": [ + "Since we use simulations in our baselines, we must define a simulation configuration as follows: " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "638fb31c", + "metadata": {}, + "outputs": [], + "source": [ + "SIMULATOR_TRAIN_CONFIG = {\n", + " \"per_device_train_batch_size\": 16,\n", + " \"per_device_eval_batch_size\": 16,\n", + " \"eval_strategy\": \"steps\",\n", + " \"save_strategy\": \"steps\",\n", + " \"save_steps\": 30,\n", + " \"gradient_accumulation_steps\": 4,\n", + " \"warmup_steps\": 5,\n", + " \"num_train_epochs\": 1,\n", + " \"eval_steps\": 30,\n", + " \"learning_rate\": 2e-4,\n", + " \"logging_steps\": 5,\n", + " \"optim\": \"adamw_8bit\",\n", + " \"weight_decay\": 0.01,\n", + " \"lr_scheduler_type\": \"linear\",\n", + " \"output_dir\": \"outputs/simulator_finetune\",\n", + " \"logging_dir\": \"logs\",\n", + " \"load_best_model_at_end\": True,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "bf55d140", + "metadata": {}, + "outputs": [], + "source": [ + "TAU = 7\n", + "DEFERRAL_PROBABILITY_THRESHOLD = 0.2518938553561718\n", + "NUM_SIMULATIONS = 10\n", + "OUTPUT_DIR = \"benchmark_preannotated\"\n", + "SEEDS = [1,2,3,4,5]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "aedd02fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==((====))== Unsloth 2025.7.11: Fast Llama patching. Transformers: 4.53.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Unsloth 2025.7.11 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n", + "Unsloth: Already have LoRA adapters! We shall skip this step.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unsloth: Training embed_tokens in mixed precision to save VRAM\n", + "Unsloth: Training lm_head in mixed precision to save VRAM\n" + ] + } + ], + "source": [ + "simulator_model = UnslothUtteranceSimulatorModel(\n", + " model_name=\"/reef/lyk25/dynamic_training/game_analysis/outputs/checkpoint-74\",\n", + " train_config=SIMULATOR_TRAIN_CONFIG,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "fe147ae8", + "metadata": {}, + "source": [ + "After loading the simulator model, we define context selectors." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a9502041", + "metadata": {}, + "outputs": [], + "source": [ + "def context_selector(context_tuple, split):\n", + " \"\"\"\n", + " We use this generic function for both training and validation data.\n", + " In both cases, its job is to select only those contexts for which the\n", + " FUTURE context is not empty, so we have a next utterance to predict.\n", + " \"\"\"\n", + " matches_split = (context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split)\n", + " is_end = (len(context_tuple.future_context) == 0)\n", + " return matches_split and not is_end\n", + "\n", + "def make_data_selector(split):\n", + " return lambda context_tuple: context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split\n", + "\n", + "train_context_selector = partial(context_selector, split=\"train\")\n", + "val_context_selector = partial(context_selector, split=\"val\")\n", + "test_context_selector = partial(context_selector, split=\"test\")" + ] + }, + { + "cell_type": "markdown", + "id": "f707a3a5", + "metadata": {}, + "source": [ + "Below is a script to fully reproduce, sans regenerating simulations (which takes substantially longer)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dde130ed", + "metadata": {}, + "outputs": [], + "source": [ + "for seed_idx in SEEDS:\n", + " train_corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", + " corpus = Corpus(filename=f'/reef/lyk25/theres-a-way-out-ACL26-internal/outputs/benchmark_preannotated/seed-{seed_idx}-ThresholdDecisionPolicy/ThresholdDecisionPolicy')\n", + " # corpus = Corpus(filename=f'/reef/lyk25/dynamic_training/game_analysis/corpi/test/test-son-seed-{seed_idx}')\n", + "\n", + " config = TransformerForecasterConfig(\n", + " output_dir=f\"outputs/{OUTPUT_DIR}/forecaster_{seed_idx}\",\n", + " per_device_batch_size=16,\n", + " gradient_accumulation_steps=1,\n", + " num_train_epochs=1,\n", + " learning_rate=1e-5,\n", + " random_seed=seed_idx,\n", + " context_mode=\"normal\",\n", + " device=\"cuda\",\n", + " )\n", + "\n", + " # TODO this will have to be edited\n", + " forecaster_model = TransformerDecoderModel(\n", + " model_name_or_path=\"google/gemma-2-9b-it\",\n", + " config=config,\n", + " )\n", + "\n", + " forecaster = Forecaster(\n", + " forecaster_model=forecaster_model,\n", + " labeler='has_removed_comment',\n", + " )\n", + "\n", + " forecaster.fit_belief_estimator(\n", + " corpus=train_corpus,\n", + " context_selector=train_context_selector,\n", + " val_context_selector=val_context_selector,\n", + " )\n", + "\n", + "\n", + "\n", + " # ---\n", + " cfg_path = os.path.join(repo_root, \"saves\", f\"seed-{seed_idx}\", \"dev_config.json\")\n", + " with open(cfg_path) as f:\n", + " cfg = json.load(f)\n", + " best_threshold = cfg['best_threshold']\n", + "\n", + " for policy_trial in [ThresholdDecisionPolicy, DeferralDecisionPolicy]:\n", + " print('---')\n", + " print(f\"Fitting policy {policy_trial.__name__} for seed {seed_idx}\")\n", + " if policy_trial == ThresholdDecisionPolicy:\n", + " policy = ThresholdDecisionPolicy(\n", + " threshold=best_threshold,\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == DeferralDecisionPolicy:\n", + " policy = DeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " tau=TAU,\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == RandomDeferralDecisionPolicy:\n", + " policy = RandomDeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " deferral_probability=DEFERRAL_PROBABILITY_THRESHOLD,\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == SimulationAverageDecisionPolicy:\n", + " policy = SimulationAverageDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " num_simulations=NUM_SIMULATIONS,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == SimulationMajorityDecisionPolicy:\n", + " policy = SimulationMajorityDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " tau=TAU,\n", + " num_simulations=NUM_SIMULATIONS,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " \n", + " # attach the decision policy to the underlying forecaster model;\n", + " # Forecaster itself does not accept decision_policy in its constructor.\n", + " forecaster_model.decision_policy = policy\n", + "\n", + " forecaster = Forecaster(\n", + " forecaster_model=forecaster_model,\n", + " labeler='has_removed_comment',\n", + " )\n", + "\n", + " print('starting transformation.')\n", + " # evaluate the forecaster on the test set\n", + " forecaster.transform(\n", + " corpus=corpus,\n", + " context_selector=make_data_selector('test'),\n", + " verbose=True,\n", + " )\n", + " print('transformation complete.')\n", + "\n", + " output_dir = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + " os.makedirs(output_dir, exist_ok=True)\n", + " corpus.dump(name=f\"{policy_trial.__name__}\", base_path=output_dir)\n", + " print('corpus dumped.')\n", + "\n", + " print('starting summarization.')\n", + " # forecaster.summarize expects a conversation-level selector (Callable[[Conversation], bool]),\n", + " # unlike the context-tuple selectors used in fit/transform.\n", + " def summarize_selector(convo):\n", + " return convo.meta.get(\"split\") == \"test\"\n", + " conversational_forecasts_df, metrics = forecaster.summarize(\n", + " corpus=corpus,\n", + " selector=summarize_selector,\n", + " )\n", + " print('summarization complete.')\n", + " \n", + " # path to the seed output directory\n", + " seed_folder = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + "\n", + " # ensure the directory exists\n", + " os.makedirs(seed_folder, exist_ok=True)\n", + "\n", + " # save conversational_forecasts_df as CSV\n", + " conversational_forecasts_df.to_csv(os.path.join(seed_folder, \"conversational_forecasts.csv\"), index=False)\n", + "\n", + " # save metrics as JSON\n", + " with open(os.path.join(seed_folder, \"metrics.json\"), \"w\") as f:\n", + " json.dump(metrics, f, indent=2)" + ] + }, + { + "cell_type": "markdown", + "id": "e3c6f428", + "metadata": {}, + "source": [ + "A faster reproduction is possible by skipping the training and transformation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f4a29c2", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO insert code here to download all" + ] + }, + { + "cell_type": "markdown", + "id": "29a0cdc1", + "metadata": {}, + "source": [ + "# Human Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d673d0d6", + "metadata": {}, + "outputs": [], + "source": [ + "# import human data SQL here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d55b3bab", + "metadata": {}, + "outputs": [], + "source": [ + "import sqlite3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "92766a80", + "metadata": {}, + "outputs": [], + "source": [ + "# connect to the game database\n", + "db_path = '/reef/sqt2/cga-eval/human/game_db.sqlite'\n", + "connection = sqlite3.connect(db_path)\n", + "cursor = connection.cursor()\n", + "\n", + "print(f\"[info] connected to database: {db_path}\")\n", + "cursor.execute(\"SELECT COUNT(*) FROM results\")\n", + "\n", + "# # names_list = []\n", + "# # answers_list = []\n", + "# # scores_list = []\n", + "# # comments_list = []\n", + "\n", + "# TIME_CUTOFF = 1714059814630 # timestamp to cut off previous results\n", + "# TIME_CUTOFF_END = 1730385762530\n", + "\n", + "# for row in connection.execute('SELECT * FROM results'):\n", + "# if row[0] != 'yc2727' and row[0] != 'sqt2':\n", + "# answers = json.loads(row[1])\n", + "# if answers[0]['start_time'] > TIME_CUTOFF and answers[0]['start_time'] < TIME_CUTOFF_END:\n", + "# names_list.append(row[0])\n", + "# answers_list.append(answers)\n", + "# scores_list.append(row[2])\n", + "# comments_list.append(row[3])\n", + "\n", + "if round_n == 1:\n", + " # for round_n 1\n", + " names_list_1 = []\n", + " answers_list_1 = []\n", + " scores_list_1 = []\n", + " comments_list_1 = []\n", + "\n", + " TIME_CUTOFF_1 = 1730395000000\n", + " TIME_CUTOFF_END_1 = 1730397199000\n", + "\n", + " for row in connection.execute('SELECT * FROM results'):\n", + " if row[0] != 'yc2727' and row[0] != 'sqt2':\n", + " answers = json.loads(row[1])\n", + " if answers[0]['start_time'] > TIME_CUTOFF_1 and answers[0]['start_time'] < TIME_CUTOFF_END_1:\n", + " names_list_1.append(row[0])\n", + " answers_list_1.append(answers)\n", + " scores_list_1.append(row[2])\n", + " comments_list_1.append(row[3])\n", + "elif round_n == 2:\n", + " # for round 2\n", + " names_list_2 = []\n", + " answers_list_2 = []\n", + " scores_list_2 = []\n", + " comments_list_2 = []\n", + "\n", + " TIME_CUTOFF_2_a = 1731002910000\n", + " TIME_CUTOFF_END_2_a = 1731016180000\n", + "\n", + " for row in connection.execute('SELECT * FROM results'):\n", + " if row[0] != 'yc2727' and row[0] != 'sqt2':\n", + " answers = json.loads(row[1])\n", + " if answers[0]['start_time'] > TIME_CUTOFF_2_a and answers[0]['start_time'] < TIME_CUTOFF_END_2_a:\n", + " names_list_2.append(row[0])\n", + " answers_list_2.append(answers)\n", + " scores_list_2.append(row[2])\n", + " comments_list_2.append(row[3])\n", + "\n", + " # The 2_b cutoff below is to specifically add data from 'ljl2' for a later second round window,\n", + " # likely because they submitted their data late or for a different time block.\n", + " TIME_CUTOFF_2_b = 1732212720000\n", + " TIME_CUTOFF_END_2_b = 1740000000000\n", + "\n", + " for row in connection.execute('SELECT * FROM results'):\n", + " if row[0].lower() == 'ljl2':\n", + " answers = json.loads(row[1])\n", + " if answers[0]['start_time'] > TIME_CUTOFF_2_b and answers[0]['start_time'] < TIME_CUTOFF_END_2_b:\n", + " names_list_2.append(row[0])\n", + " answers_list_2.append(answers)\n", + " scores_list_2.append(row[2])\n", + " comments_list_2.append(row[3])\n", + "\n", + " # print(f\"Round 1: {len(names_list_1)} entries\")\n", + " # print(f\"Round 2: {len(names_list_2)} entries\")\n", + " # names_list_1, names_list_2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "889d7ede", + "metadata": {}, + "outputs": [], + "source": [ + "human_map1 = {\n", + " \"vn72\": ['d3efg03', 'd3f07tv', 'f1353ra', 'f13u0n2', 'fegw71k', 'fegwvia', 'ikpw1ol', 'ikpxahv', 'isz5n6g', 'isz6a7m'],\n", + " \"nac86\": ['dyd7cfv', 'dydawov', 'ewtjxp2', 'ewtowqu', 'f00nxjs', 'f014doo', 'ii3cpve', 'ii4ivim', 'ikzb571', 'ikzcblg'],\n", + " # \"sj597\": ['dbnr5nd', 'dbnxbzn', 'g1sm9mt', 'g1spg0k', 'g297nn7', 'g2998qp', 'h2h7yl0', 'h2hauaj', 'ifknq44', 'ifkoazb'],\n", + " \"yc2727\": ['d08x3kl', 'd08x4q0', 'd3efg03', 'd3f07tv', 'ewtjxp2', 'ewtowqu', 'hnupywh', 'hnuu3ip', 'ih2fn94', 'ih3iwph'],\n", + " # \"ex36\": ['d0fyu9x', 'd0fzp40', 'dg7wmdb', 'dg7x3eu', 'ej6jusi', 'ej6ollb', 'ewtjxp2', 'ewtowqu', 'f0dryv4', 'f0dsbw4'],\n", + " \"kz88\": ['doi3vuz', 'doi44j8', 'e9mybxp', 'e9mynuy', 'g1q1973', 'g1q3upb', 'ggwdbsa', 'ggwei5y', 'gmxoyuu', 'gmxqrdz'],\n", + " \"LJL2\": ['ffpj88q', 'ffpk80c', 'flixm8f', 'fljdrtt', 'fmre7l9', 'fmspcex', 'fphcwq0', 'g3hmlew', 'givok1i', 'givp578'],\n", + " \"lyk25\": ['dpirnlc', 'dpkib9q', 'e1vstxd', 'e1vv6x1', 'ewr7ls3', 'ewr7msm', 'fixjxxs', 'fixlxvy', 'fmre7l9', 'fmspcex'],\n", + " \"sqt2\": ['d3efg03', 'd3f07tv', 'g0fwpzc', 'g0ggz8e', 'g8nyz4f', 'g8nzx3m', 'h4i75b9', 'h4i79lc', 'h6ikmzc', 'h6ime20'],\n", + " \"cd326\": ['djh1bt1', 'djh2v24', 'dmlny27', 'dmlqnzz', 'f83akyz', 'f83hb2k', 'h28lknz', 'h28ltfw', 'i4rgtqf', 'i4rh1id'],\n", + " \"tg352\": ['dm8exht', 'dm8qu78', 'dvisfl0', 'dvivs9p', 'dyx2jn4', 'dyx3au1', 'gvb1ekl', 'gvdnrrb', 'i4rgtqf', 'i4rh1id'],\n", + "}\n", + "\n", + "# all_convo_ids = []\n", + "# for k,v in human_map1.items():\n", + "# all_convo_ids.extend(v)\n", + "# all_convo_ids = list(set(all_convo_ids))\n", + "# len(all_convo_ids)\n", + "\n", + "all_convo_ids = []\n", + "# # collect from round 1\n", + "if round_n == 1:\n", + " for i in range(len(answers_list_1)):\n", + " for j in range(len(answers_list_1[i])):\n", + " all_convo_ids.append(answers_list_1[i][j]['id'])\n", + "# collect from round 2\n", + "elif round_n == 2:\n", + " for i in range(len(answers_list_2)):\n", + " for j in range(len(answers_list_2[i])):\n", + " all_convo_ids.append(answers_list_2[i][j]['id'])\n", + "all_convo_ids = list(set(all_convo_ids))\n", + "print(f\"[info] total unique conversation ids: {len(all_convo_ids)}\")\n", + "print(all_convo_ids)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "168fb025", + "metadata": {}, + "outputs": [], + "source": [ + "# we want all utterances to have a human_guesses meta field\n", + "for convo in corpus.iter_conversations():\n", + " for utt in convo.get_chronological_utterance_list():\n", + " utt.add_meta('human_guesses', [])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27fc646a", + "metadata": {}, + "outputs": [], + "source": [ + "# now we r gonna add the human guesses to the utterances, with their player ids\n", + "\n", + "# extract human first awry guess indices, now using answers_list_2\n", + "\n", + "# from collections import defaultdict\n", + "\n", + "# for i, participant_sessions in enumerate(answers_list):\n", + "# participant_id = names_list[i]\n", + "# print(participant_id)\n", + "# for session in participant_sessions:\n", + "# convo_id = session['id']\n", + "# convo = corpus.get_conversation(convo_id)\n", + "# utts = convo.get_chronological_utterance_list()\n", + "# actions = session.get('actions', [])\n", + "\n", + "# for action_idx, action in enumerate(actions):\n", + "# if action.get('guess') is True:\n", + "# utt = utts[action_idx]\n", + "# # get current guesses (returns deep copy if exists, or empty list if not)\n", + "# # create a new list to avoid mutating the copy\n", + "# current_guesses = list(utt.meta.get('human_guesses', []))\n", + "# # append new participant and set back\n", + "# current_guesses.append(participant_id)\n", + "# utt.add_meta('human_guesses', current_guesses)\n", + "if round_n == 1:\n", + " for i, participant_sessions in enumerate(answers_list_1):\n", + " participant_id = names_list_1[i]\n", + " print(participant_id)\n", + " for session in participant_sessions:\n", + " convo_id = session['id']\n", + " convo = corpus.get_conversation(convo_id)\n", + " utts = convo.get_chronological_utterance_list()\n", + " actions = session.get('actions', [])\n", + "\n", + " for action_idx, action in enumerate(actions):\n", + " if action.get('guess') is True:\n", + " utt = utts[action_idx]\n", + " # get current guesses (returns deep copy if exists, or empty list if not)\n", + " # create a new list to avoid mutating the copy\n", + " current_guesses = list(utt.meta.get('human_guesses', []))\n", + " # append new participant and set back\n", + " current_guesses.append(participant_id)\n", + " utt.add_meta('human_guesses', current_guesses)\n", + "elif round_n == 2:\n", + " for i, participant_sessions in enumerate(answers_list_2):\n", + " participant_id = names_list_2[i]\n", + " print(participant_id)\n", + " for session in participant_sessions:\n", + " convo_id = session['id']\n", + " convo = corpus.get_conversation(convo_id)\n", + " utts = convo.get_chronological_utterance_list()\n", + " actions = session.get('actions', [])\n", + "\n", + " for action_idx, action in enumerate(actions):\n", + " if action.get('guess') is True:\n", + " utt = utts[action_idx]\n", + " # get current guesses (returns deep copy if exists, or empty list if not)\n", + " # create a new list to avoid mutating the copy\n", + " current_guesses = list(utt.meta.get('human_guesses', []))\n", + " # append new participant and set back\n", + " current_guesses.append(participant_id)\n", + " utt.add_meta('human_guesses', current_guesses)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd613b4b", + "metadata": {}, + "outputs": [], + "source": [ + "# initialize model prediction metadata fields for each utterance\n", + "for convo in corpus.iter_conversations():\n", + " for utt in convo.get_chronological_utterance_list():\n", + " utt.add_meta('model_forecast_probs', {}) # will store {seed: prob}\n", + " utt.add_meta('model_forecasts', {}) # will store {seed: binary_forecast}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "873cb706", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO need to choose which decisionpolicy/forecaster run to use to get the forecast probabilities\n", + "\n", + "# load model predictions from all 5 seeds\n", + "test_corpi_path = '/reef/lyk25/dynamic_training/game_analysis/corpi/test'\n", + "\n", + "for seed_num in range(1, 6):\n", + " seed_corpus_path = f'{test_corpi_path}/test-son-seed-{seed_num}'\n", + " print(f\"[info] loading predictions from seed {seed_num}: {seed_corpus_path}\")\n", + " \n", + " # load the seed corpus\n", + " seed_corpus = Corpus(filename=seed_corpus_path)\n", + " \n", + " # iterate through conversations in our main corpus\n", + " for convo in corpus.iter_conversations():\n", + " convo_id = convo.id\n", + " \n", + " # check if this conversation exists in the seed corpus\n", + " if convo_id not in seed_corpus.conversations:\n", + " print(f\"[warning] convo {convo_id} not found in seed {seed_num}\")\n", + " continue\n", + " \n", + " # get the corresponding conversation from seed corpus\n", + " seed_convo = seed_corpus.get_conversation(convo_id)\n", + " \n", + " # get utterances from both corpora\n", + " main_utts = convo.get_chronological_utterance_list()\n", + " seed_utts = seed_convo.get_chronological_utterance_list()\n", + " \n", + " # match utterances and copy predictions\n", + " for main_utt, seed_utt in zip(main_utts, seed_utts):\n", + " # verify they're the same utterance\n", + " if main_utt.id != seed_utt.id:\n", + " print(f\"[warning] utterance mismatch: {main_utt.id} != {seed_utt.id}\")\n", + " continue\n", + " \n", + " # extract predictions from seed utterance\n", + " forecast_prob = seed_utt.meta.get('forecast_prob', None)\n", + " forecast = seed_utt.meta.get('forecast', None)\n", + " \n", + " # add to main utterance's metadata\n", + " if forecast_prob is not None:\n", + " current_probs = dict(main_utt.meta.get('model_forecast_probs', {}))\n", + " current_probs[f'seed_{seed_num}'] = forecast_prob\n", + " main_utt.add_meta('model_forecast_probs', current_probs)\n", + " \n", + " if forecast is not None:\n", + " current_forecasts = dict(main_utt.meta.get('model_forecasts', {}))\n", + " current_forecasts[f'seed_{seed_num}'] = forecast\n", + " main_utt.add_meta('model_forecasts', current_forecasts)\n", + "\n", + "print(\"\\n[pass] model predictions from all seeds added to corpus\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b0f0e44", + "metadata": {}, + "outputs": [], + "source": [ + "# horizon comparison between gemma and humans, using the same convention as\n", + "# performance_utils_wiki.calculate_current_performance:\n", + "# - only count true positives (ground truth awry AND trigger fired)\n", + "# - horizon = (len(utts) - first_trigger_index) - 1\n", + "# - first trigger only (break after first positive)\n", + "#\n", + "# reports per-round results for humans (round 1 and round 2), pulling data\n", + "# directly from the game sqlite so it works regardless of which round_n the\n", + "# rest of the notebook was run under. ljl2 is excluded.\n", + "\n", + "import sqlite3\n", + "import json as _json\n", + "from collections import defaultdict\n", + "import numpy as np\n", + "\n", + "def _horizon_mean(horizons):\n", + " # matches performance_utils_wiki: h = mean(horizons) - 1\n", + " if len(horizons) == 0:\n", + " return float('nan'), 0\n", + " return float(np.mean(horizons)) - 1, len(horizons)\n", + "\n", + "# always excluded (staff/test accounts). ljl2 is a legitimate late submitter\n", + "# in the round 2_b window, not an exclusion.\n", + "base_excluded = {'yc2727', 'sqt2'}\n", + "round1_excluded = set(base_excluded)\n", + "round2_excluded = set(base_excluded)\n", + "\n", + "# gemma: per-seed first-trigger horizons on TP convos only (ground truth awry)\n", + "gemma_horizons_by_seed = defaultdict(list)\n", + "for convo in corpus.iter_conversations():\n", + " if not convo.meta.get('has_removed_comment', False):\n", + " continue # skip non-awry convos; horizon is only meaningful on TPs\n", + " utts = convo.get_chronological_utterance_list()\n", + " for seed_num in range(1, 6):\n", + " for i, utt in enumerate(utts):\n", + " if utt.meta.get('model_forecasts', {}).get(f'seed_{seed_num}') == 1:\n", + " gemma_horizons_by_seed[seed_num].append(len(utts) - i)\n", + " break\n", + "\n", + "print('gemma horizon (TPs only, mean - 1):')\n", + "gemma_per_seed_h = []\n", + "for seed_num in sorted(gemma_horizons_by_seed.keys()):\n", + " h, n = _horizon_mean(gemma_horizons_by_seed[seed_num])\n", + " gemma_per_seed_h.append(h)\n", + " print(f' seed {seed_num}: n={n}, h={h:.4f}')\n", + "gemma_h_mean_of_seeds = float(np.mean(gemma_per_seed_h)) if gemma_per_seed_h else float('nan')\n", + "all_gemma_vals = [v for vs in gemma_horizons_by_seed.values() for v in vs]\n", + "gemma_h_pooled, gemma_n_pooled = _horizon_mean(all_gemma_vals)\n", + "print(f' mean over seeds: h={gemma_h_mean_of_seeds:.4f}')\n", + "print(f' pooled: n={gemma_n_pooled}, h={gemma_h_pooled:.4f}')\n", + "\n", + "# pull round-specific human guesses directly from the sqlite db\n", + "db_path = '/reef/sqt2/cga-eval/human/game_db.sqlite'\n", + "_conn = sqlite3.connect(db_path)\n", + "\n", + "def _load_round_answers(round_n):\n", + " # returns list of (participant_id, sessions) for the given round\n", + " entries = []\n", + " if round_n == 1:\n", + " excluded = round1_excluded\n", + " t_start, t_end = 1730395000000, 1730397199000\n", + " for row in _conn.execute('SELECT * FROM results'):\n", + " if row[0] in excluded:\n", + " continue\n", + " answers = _json.loads(row[1])\n", + " if answers and answers[0]['start_time'] > t_start and answers[0]['start_time'] < t_end:\n", + " entries.append((row[0], answers))\n", + " elif round_n == 2:\n", + " excluded = round2_excluded\n", + " t_start_a, t_end_a = 1731002910000, 1731016180000\n", + " t_start_b, t_end_b = 1732212720000, 1740000000000\n", + " for row in _conn.execute('SELECT * FROM results'):\n", + " name = row[0]\n", + " if name in excluded:\n", + " continue\n", + " answers = _json.loads(row[1])\n", + " if not answers:\n", + " continue\n", + " st = answers[0]['start_time']\n", + " in_a = t_start_a < st < t_end_a\n", + " # the 2_b late window is only valid for ljl2 (matches cell 7)\n", + " in_b = (name.lower() == 'ljl2') and (t_start_b < st < t_end_b)\n", + " if in_a or in_b:\n", + " entries.append((name, answers))\n", + " return entries\n", + "\n", + "def _unique_convo_ids(entries):\n", + " # unique convo ids seen across all included players' sessions\n", + " ids = set()\n", + " for _, sessions in entries:\n", + " for session in sessions:\n", + " cid = session.get('id')\n", + " if cid is not None:\n", + " ids.add(cid)\n", + " return ids\n", + "\n", + "def _compute_human_horizons(entries):\n", + " # returns dict: player_id -> list of horizons (non-awry convos only, first guess per convo)\n", + " by_player = defaultdict(list)\n", + " for participant_id, sessions in entries:\n", + " for session in sessions:\n", + " convo_id = session.get('id')\n", + " if convo_id is None:\n", + " continue\n", + " try:\n", + " convo = corpus.get_conversation(convo_id)\n", + " except KeyError:\n", + " # convo not in the loaded corpus (e.g., different round loaded)\n", + " continue\n", + " if not convo.meta.get('has_removed_comment', False):\n", + " continue # skip non-awry convos; horizon only counted on TPs\n", + " utts = convo.get_chronological_utterance_list()\n", + " for action_idx, action in enumerate(session.get('actions', [])):\n", + " if action.get('guess') is True:\n", + " if action_idx < len(utts):\n", + " by_player[participant_id].append(len(utts) - action_idx)\n", + " break # only first guess per (player, convo)\n", + " return by_player\n", + "\n", + "def _print_human_horizons(label, by_player):\n", + " print(f'human horizon ({label}, TPs only, mean - 1):')\n", + " player_h = []\n", + " for player, horizons in by_player.items():\n", + " h, n = _horizon_mean(horizons)\n", + " player_h.append(h)\n", + " print(f' player {player}: n={n}, h={h:.4f}')\n", + " mean_of_players = float(np.mean(player_h)) if player_h else float('nan')\n", + " all_vals = [v for vs in by_player.values() for v in vs]\n", + " h_pooled, n_pooled = _horizon_mean(all_vals)\n", + " print(f' mean over players: h={mean_of_players:.4f}')\n", + " print(f' pooled: n={n_pooled}, h={h_pooled:.4f}')\n", + " return mean_of_players, h_pooled\n", + "\n", + "print()\n", + "EXPECTED_N_CONVOS = 84\n", + "round1_entries = _load_round_answers(1)\n", + "round1_convo_ids = _unique_convo_ids(round1_entries)\n", + "print(f'round 1: {len(round1_entries)} included players, {len(round1_convo_ids)} unique convos')\n", + "assert len(round1_convo_ids) == EXPECTED_N_CONVOS, (\n", + " f'round 1 expected {EXPECTED_N_CONVOS} unique convos but got {len(round1_convo_ids)}'\n", + ")\n", + "round1_by_player = _compute_human_horizons(round1_entries)\n", + "r1_mean, r1_pooled = _print_human_horizons('round 1', round1_by_player)\n", + "\n", + "print()\n", + "round2_entries = _load_round_answers(2)\n", + "round2_convo_ids = _unique_convo_ids(round2_entries)\n", + "print(f'round 2: {len(round2_entries)} included players, {len(round2_convo_ids)} unique convos')\n", + "assert len(round2_convo_ids) == EXPECTED_N_CONVOS, (\n", + " f'round 2 expected {EXPECTED_N_CONVOS} unique convos but got {len(round2_convo_ids)}'\n", + ")\n", + "round2_by_player = _compute_human_horizons(round2_entries)\n", + "r2_mean, r2_pooled = _print_human_horizons('round 2', round2_by_player)\n", + "\n", + "_conn.close()\n", + "\n", + "print()\n", + "print('summary (comparable to h in performance_utils_wiki):')\n", + "print(f' gemma h (mean over seeds): {gemma_h_mean_of_seeds:.4f}')\n", + "print(f' gemma h (pooled): {gemma_h_pooled:.4f}')\n", + "print(f' round1 h (mean over players): {r1_mean:.4f}')\n", + "print(f' round1 h (pooled): {r1_pooled:.4f}')\n", + "print(f' round2 h (mean over players): {r2_mean:.4f}')\n", + "print(f' round2 h (pooled): {r2_pooled:.4f}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44ed25ac", + "metadata": {}, + "outputs": [], + "source": [ + "# benchmark humans, mirroring the gemma benchmark (cell 40).\n", + "# computes accuracy, precision, recall, f1, fpr, specificity, fnr for:\n", + "# - gemma (aggregated over seeds 1-5)\n", + "# - round 1 humans (aggregate \"any\" rule, plus per-player)\n", + "# - round 2 humans (aggregate \"any\" rule, plus per-player)\n", + "# uses the included entries loaded in the previous cell:\n", + "# round1_entries, round2_entries\n", + "# and the corpus in memory for ground truth.\n", + "from collections import defaultdict\n", + "import numpy as np\n", + "def _compute_metrics(tp, fp, tn, fn):\n", + " total = tp + fp + tn + fn\n", + " accuracy = (tp + tn) / total if total > 0 else 0.0\n", + " precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0\n", + " recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0\n", + " f1 = (2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0.0\n", + " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0.0\n", + " specificity = tn / (tn + fp) if (tn + fp) > 0 else 0.0\n", + " fnr = fn / (fn + tp) if (fn + tp) > 0 else 0.0\n", + " return {\n", + " 'tp': tp, 'fp': fp, 'tn': tn, 'fn': fn,\n", + " 'accuracy': accuracy, 'precision': precision, 'recall': recall,\n", + " 'f1': f1, 'fpr': fpr, 'specificity': specificity, 'fnr': fnr,\n", + " }\n", + "def _gt(convo):\n", + " return bool(convo.meta.get('has_removed_comment', False))\n", + "# gemma benchmark, per seed, then mean and std\n", + "gemma_per_seed = []\n", + "for seed_num in range(1, 6):\n", + " tp = fp = tn = fn = 0\n", + " for convo in corpus.iter_conversations():\n", + " utts = convo.get_chronological_utterance_list()\n", + " pred = any(\n", + " utt.meta.get('model_forecasts', {}).get(f'seed_{seed_num}') == 1\n", + " for utt in utts\n", + " )\n", + " truth = _gt(convo)\n", + " if pred and truth: tp += 1\n", + " elif pred and not truth: fp += 1\n", + " elif not pred and not truth: tn += 1\n", + " elif not pred and truth: fn += 1\n", + " gemma_per_seed.append(_compute_metrics(tp, fp, tn, fn))\n", + "gemma_mean = {k: float(np.mean([m[k] for m in gemma_per_seed])) for k in gemma_per_seed[0]}\n", + "gemma_std = {k: float(np.std([m[k] for m in gemma_per_seed], ddof=1)) for k in gemma_per_seed[0]}\n", + "def _build_per_player_preds(entries):\n", + " # returns dict[player_id] -> dict[convo_id] -> 0/1\n", + " preds = defaultdict(dict)\n", + " for player, sessions in entries:\n", + " for s in sessions:\n", + " cid = s.get('id')\n", + " if cid is None:\n", + " continue\n", + " try:\n", + " corpus.get_conversation(cid)\n", + " except KeyError:\n", + " continue\n", + " actions = s.get('actions', [])\n", + " preds[player][cid] = 1 if any(a.get('guess') is True for a in actions) else 0\n", + " return preds\n", + "def _aggregate_any(preds):\n", + " # per-convo prediction = 1 if any player who saw it guessed\n", + " by_convo = defaultdict(list)\n", + " for player, convo_preds in preds.items():\n", + " for cid, p in convo_preds.items():\n", + " by_convo[cid].append(p)\n", + " tp = fp = tn = fn = 0\n", + " for cid, plist in by_convo.items():\n", + " try:\n", + " convo = corpus.get_conversation(cid)\n", + " except KeyError:\n", + " continue\n", + " pred = 1 if any(plist) else 0\n", + " truth = 1 if _gt(convo) else 0\n", + " if pred and truth: tp += 1\n", + " elif pred and not truth: fp += 1\n", + " elif not pred and not truth: tn += 1\n", + " elif not pred and truth: fn += 1\n", + " return _compute_metrics(tp, fp, tn, fn), len(by_convo)\n", + "def _per_player_metrics(preds):\n", + " rows = {}\n", + " for player, convo_preds in preds.items():\n", + " tp = fp = tn = fn = 0\n", + " for cid, p in convo_preds.items():\n", + " try:\n", + " convo = corpus.get_conversation(cid)\n", + " except KeyError:\n", + " continue\n", + " truth = 1 if _gt(convo) else 0\n", + " if p and truth: tp += 1\n", + " elif p and not truth: fp += 1\n", + " elif not p and not truth: tn += 1\n", + " elif not p and truth: fn += 1\n", + " rows[player] = _compute_metrics(tp, fp, tn, fn)\n", + " return rows\n", + "# round 1 and round 2 humans\n", + "round1_preds = _build_per_player_preds(round1_entries)\n", + "round1_agg, round1_n_convos = _aggregate_any(round1_preds)\n", + "round1_per_player = _per_player_metrics(round1_preds)\n", + "round2_preds = _build_per_player_preds(round2_entries)\n", + "round2_agg, round2_n_convos = _aggregate_any(round2_preds)\n", + "round2_per_player = _per_player_metrics(round2_preds)\n", + "# metric mean over players (a different aggregation view)\n", + "def _mean_over_players(per_player):\n", + " keys = ['accuracy', 'precision', 'recall', 'f1', 'fpr', 'specificity', 'fnr']\n", + " return {k: float(np.mean([m[k] for m in per_player.values()])) for k in keys}\n", + "round1_mean_over_players = _mean_over_players(round1_per_player)\n", + "round2_mean_over_players = _mean_over_players(round2_per_player)\n", + "# printing\n", + "metric_order = ['accuracy', 'precision', 'recall', 'f1', 'fpr', 'specificity', 'fnr']\n", + "def _print_per_player(label, per_player):\n", + " print(f'{label} - per-player metrics:')\n", + " header = f\" {'player':<10}\" + \"\".join(f\"{m:>12}\" for m in metric_order) + f\"{'n_convos':>10}\"\n", + " print(header)\n", + " print(' ' + '-' * (len(header) - 2))\n", + " for player in sorted(per_player):\n", + " m = per_player[player]\n", + " n = m['tp'] + m['fp'] + m['tn'] + m['fn']\n", + " row = f\" {player:<10}\" + \"\".join(f\"{m[k]:>12.4f}\" for k in metric_order) + f\"{n:>10d}\"\n", + " print(row)\n", + "_print_per_player('round 1', round1_per_player)\n", + "print()\n", + "_print_per_player('round 2', round2_per_player)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "lyk25-env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From e448225da65af060f2bc9fe4235005a74cb09341 Mon Sep 17 00:00:00 2001 From: laerdon Date: Tue, 28 Apr 2026 07:35:48 +0000 Subject: [PATCH 05/21] update notebook --- .../decisionpolicy/decisionpolicy_demo.ipynb | 3738 +++++++++++------ 1 file changed, 2530 insertions(+), 1208 deletions(-) diff --git a/examples/decisionpolicy/decisionpolicy_demo.ipynb b/examples/decisionpolicy/decisionpolicy_demo.ipynb index a3b44be6f..79caffd36 100644 --- a/examples/decisionpolicy/decisionpolicy_demo.ipynb +++ b/examples/decisionpolicy/decisionpolicy_demo.ipynb @@ -1,1217 +1,2539 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "90659cc6", - "metadata": {}, - "source": [ - "# Decision Policy Demo\n", - "\n", - "This notebook will provide code demonstrating how to use Decision Policies as introduced in Wait! There's a Way Out. This notebook will also provide code for running the experiments in the paper. " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "703021a8", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "os.environ['CUDA_VISIBLE_DEVICES'] = '2'" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fd8b87be", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import argparse\n", - "import sys\n", - "import glob\n", - "\n", - "from functools import partial\n", - "import json\n", - "from convokit import Corpus, Forecaster, download\n", - "from convokit.forecaster.TransformerDecoderModel import TransformerDecoderModel\n", - "from convokit.forecaster.TransformerForecasterConfig import TransformerForecasterConfig\n", - "from convokit.decisionpolicy import DeferralDecisionPolicy, ThresholdDecisionPolicy\n", - "from convokit.utterance_simulator.unslothUtteranceSimulatorModel import UnslothUtteranceSimulatorModel" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "15f977d3", - "metadata": {}, - "outputs": [], - "source": [ - "# Set repo root\n", - "\n", - "from pathlib import Path\n", - "\n", - "repo_root = Path.cwd()\n", - "while repo_root.name != \"ConvoKit\":\n", - " repo_root = repo_root.parent\n", - "\n", - "repo_root = str(repo_root)" - ] - }, - { - "cell_type": "markdown", - "id": "dab74642", - "metadata": {}, - "source": [ - "Having imported our DeferralDecisionPolicy and ThresholdDecisionPolicy, we now will first define all of the other decision policies to benchmark. " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "5dabf0bd", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Callable, List, Optional, Dict, Any, Tuple\n", - "import numpy as np\n", - "from convokit.decisionpolicy import DecisionPolicy\n", - "\n", - "\n", - "class _synthetic_speaker:\n", - " def __init__(self, speaker_id: str):\n", - " self.id = speaker_id\n", - "\n", - "\n", - "class _synthetic_utterance:\n", - " def __init__(self, text: str, utterance_id: str, speaker_id: str):\n", - " self.text = text\n", - " self.id = utterance_id\n", - " self.speaker_ = _synthetic_speaker(speaker_id)\n", - " self.meta = {}\n", - "\n", - " def get_conversation(self):\n", - " return None\n", - "\n", - "\n", - "class RandomDeferralDecisionPolicy(DecisionPolicy):\n", - " \"\"\"\n", - " Decision policy that defers intervention by looking ahead at simulated next utterances.\n", - "\n", - " :param simulator: utterance simulator model (must have a ``transform(contexts)`` method\n", - " returning a DataFrame indexed by utterance id). if the simulator exposes\n", - " ``get_num_simulations()``, ``num_simulations`` is capped to that value.\n", - " :param threshold: probability threshold above which a context is flagged.\n", - " :param tau: minimum number of simulated branches that must exceed the threshold\n", - " before an intervention is issued.\n", - " :param num_simulations: how many simulated branches to use per context (capped to\n", - " simulator's ``get_num_simulations()`` if available).\n", - " :param store_simulations: if True, simulated reply strings are cached during decide()\n", - " and written to corpus utterance metadata by post_transform().\n", - " :param simulated_reply_attribute_name: metadata field name used when storing simulations\n", - " on corpus utterances (only relevant when store_simulations=True).\n", - " \"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " simulator,\n", - " threshold,\n", - " deferral_probability: float = 0.1515,\n", - " reuse_cached_forecast_probs: bool = True,\n", - " forecast_prob_attribute_name: str = \"forecast_prob\",\n", - " ):\n", - " # forward the cache flag to the base class so its _score helper honors it.\n", - " # without this, reuse_cached_probabilities on this subclass had no effect.\n", - " super().__init__(\n", - " forecast_prob_attribute_name=forecast_prob_attribute_name,\n", - " reuse_cached_forecast_probs=reuse_cached_forecast_probs,\n", - " )\n", - " self.simulator = simulator\n", - " self.threshold = float(threshold)\n", - " self.deferral_probability = float(deferral_probability)\n", - "\n", - " def _decision_score(self, context, score_fn: Callable):\n", - " # use base _score so a cached forecast_prob on the utterance meta is reused\n", - " # instead of re-invoking the belief estimator.\n", - " return self._score(context, score_fn)\n", - "\n", - " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", - " decision_score = self._score(context, score_fn)\n", - "\n", - " p = float(np.random.rand())\n", - " \n", - "\n", - " # return an empty metadata dict (not None) so downstream code that iterates\n", - " # utt_metadata.items() in TransformerDecoderModel.transform doesn't crash.\n", - " return (decision_score,\n", - " 1 if decision_score > self.threshold and p > self.deferral_probability else 0,\n", - " {}\n", - " )\n", - "\n", - " def fit(self, contexts, val_contexts=None, score_fn: Callable = None):\n", - " if val_contexts is None or score_fn is None or self.labeler is None:\n", - " print(\"either no validation contexts/score function/labeler were provided, returning current threshold\")\n", - " return {\"best_threshold\": self.threshold}\n", - "\n", - " val_contexts = list(val_contexts)\n", - " if len(val_contexts) == 0:\n", - " print(\"no validation contexts were provided, returning current threshold\")\n", - " return {\"best_threshold\": self.threshold}\n", - "\n", - " fit_result = self._fit_with_model_checkpoint_selection(val_contexts, score_fn=score_fn)\n", - " if isinstance(fit_result, dict):\n", - " if \"best_threshold\" in fit_result:\n", - " self.threshold = float(fit_result[\"best_threshold\"])\n", - " return fit_result\n", - "\n", - " fit_result = self._fit_threshold_for_loaded_model(val_contexts, score_fn=score_fn)\n", - " if \"best_threshold\" in fit_result:\n", - " self.threshold = float(fit_result[\"best_threshold\"])\n", - " return fit_result" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "9d3db5bc", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Callable, Optional, Dict, Any, Tuple\n", - "\n", - "from convokit.decisionpolicy import DeferralDecisionPolicy\n", - "\n", - "\n", - "class SimulationAverageDecisionPolicy(DeferralDecisionPolicy):\n", - " \"\"\"\n", - " decision policy that intervenes if the mean of the simulated next-utterance\n", - " scores is at or above the threshold.\n", - "\n", - " this subclass inherits all simulation fetching, per-utterance metadata\n", - " caching, sim-score caching, and threshold fitting from\n", - " DeferralDecisionPolicy. the only differences are:\n", - " * no ``tau`` parameter (unused; forwarded as 0 to super)\n", - " * ``decide`` predicts based on mean(simulation_scores) >= threshold\n", - " \"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " simulator,\n", - " threshold,\n", - " num_simulations: int = 10,\n", - " store_simulations: bool = False,\n", - " simulated_reply_attribute_name: str = \"sim_replies\",\n", - " sim_replies_forecast_probs_attribute_name: str = \"sim_replies_forecast_probs\",\n", - " reuse_cached_simulations: bool = True,\n", - " ):\n", - " # tau is irrelevant for the mean-based decision rule, so we pin it to 0\n", - " # upstream rather than expose it to callers of this subclass.\n", - " super().__init__(\n", - " simulator=simulator,\n", - " threshold=threshold,\n", - " tau=0,\n", - " num_simulations=num_simulations,\n", - " store_simulations=store_simulations,\n", - " simulated_reply_attribute_name=simulated_reply_attribute_name,\n", - " sim_replies_forecast_probs_attribute_name=sim_replies_forecast_probs_attribute_name,\n", - " reuse_cached_simulations=reuse_cached_simulations,\n", - " )\n", - "\n", - " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", - " decision_score, simulations, simulation_scores = self._decision_score(context, score_fn)\n", - " # empty simulation_scores would zero-divide. this happens when the\n", - " # simulator returns no completions for a context (e.g. end-of-conversation\n", - " # contexts that slip through the selector). treat as no intervention so\n", - " # a single degenerate context doesn't abort the whole transform run.\n", - " if len(simulation_scores) == 0:\n", - " average_simulation_score = 0.0\n", - " pred = 0\n", - " else:\n", - " average_simulation_score = sum(simulation_scores) / len(simulation_scores)\n", - " pred = 1 if average_simulation_score >= self.threshold else 0\n", - " return (\n", - " decision_score,\n", - " pred,\n", - " {\n", - " self.simulated_reply_attribute_name: simulations,\n", - " self.sim_replies_forecast_probs_attribute_name: simulation_scores,\n", - " },\n", - " )\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "d0d1ea7a", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Callable, Optional, Dict, Any, Tuple\n", - "\n", - "from convokit.decisionpolicy import DeferralDecisionPolicy\n", - "\n", - "\n", - "class SimulationMajorityDecisionPolicy(DeferralDecisionPolicy):\n", - " \"\"\"\n", - " decision policy that intervenes if at least ``tau`` of the simulated next\n", - " utterances score above the threshold, ignoring the current utterance score.\n", - "\n", - " this subclass inherits all simulation fetching, per-utterance metadata\n", - " caching, sim-score caching, and threshold fitting from\n", - " DeferralDecisionPolicy. the only difference is in ``decide``: the gate\n", - " ``decision_score > threshold`` is dropped so that only the simulated-branch\n", - " vote count drives the prediction.\n", - " \"\"\"\n", - "\n", - " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", - " decision_score, simulations, simulation_scores = self._decision_score(context, score_fn)\n", - " num_simulations_above_threshold = sum(\n", - " 1 for score in simulation_scores if score > self.threshold\n", - " )\n", - " return (\n", - " decision_score,\n", - " 1 if num_simulations_above_threshold >= self.tau else 0,\n", - " {\n", - " self.simulated_reply_attribute_name: simulations,\n", - " self.sim_replies_forecast_probs_attribute_name: simulation_scores,\n", - " },\n", - " )\n" - ] - }, - { - "cell_type": "markdown", - "id": "0498693e", - "metadata": {}, - "source": [ - "Since we use simulations in our baselines, we must define a simulation configuration as follows: " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "638fb31c", - "metadata": {}, - "outputs": [], - "source": [ - "SIMULATOR_TRAIN_CONFIG = {\n", - " \"per_device_train_batch_size\": 16,\n", - " \"per_device_eval_batch_size\": 16,\n", - " \"eval_strategy\": \"steps\",\n", - " \"save_strategy\": \"steps\",\n", - " \"save_steps\": 30,\n", - " \"gradient_accumulation_steps\": 4,\n", - " \"warmup_steps\": 5,\n", - " \"num_train_epochs\": 1,\n", - " \"eval_steps\": 30,\n", - " \"learning_rate\": 2e-4,\n", - " \"logging_steps\": 5,\n", - " \"optim\": \"adamw_8bit\",\n", - " \"weight_decay\": 0.01,\n", - " \"lr_scheduler_type\": \"linear\",\n", - " \"output_dir\": \"outputs/simulator_finetune\",\n", - " \"logging_dir\": \"logs\",\n", - " \"load_best_model_at_end\": True,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "bf55d140", - "metadata": {}, - "outputs": [], - "source": [ - "TAU = 7\n", - "DEFERRAL_PROBABILITY_THRESHOLD = 0.2518938553561718\n", - "NUM_SIMULATIONS = 10\n", - "OUTPUT_DIR = \"benchmark_preannotated\"\n", - "SEEDS = [1,2,3,4,5]" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "aedd02fe", - "metadata": {}, - "outputs": [ + "cells": [ + { + "cell_type": "markdown", + "id": "90659cc6", + "metadata": {}, + "source": [ + "# Decision Policy Demo\n", + "\n", + "This notebook will provide code demonstrating how to use Decision Policies as introduced in Wait! There's a Way Out. This notebook will also provide code for running the experiments in the paper. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "703021a8", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO\n", + "\n", + "import os\n", + "os.environ['CUDA_VISIBLE_DEVICES'] = '2'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fd8b87be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-04-28 07:19:59.106329: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2026-04-28 07:19:59.126464: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1777360799.150730 1126746 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1777360799.158776 1126746 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1777360799.179235 1126746 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1777360799.179259 1126746 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1777360799.179261 1126746 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1777360799.179264 1126746 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "2026-04-28 07:19:59.185112: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🦥 Unsloth Zoo will now patch everything to make training faster!\n" + ] + } + ], + "source": [ + "import os\n", + "import argparse\n", + "import sys\n", + "import glob\n", + "\n", + "from functools import partial\n", + "import json\n", + "from convokit import Corpus, Forecaster, download\n", + "from convokit.forecaster.TransformerDecoderModel import TransformerDecoderModel\n", + "from convokit.forecaster.TransformerForecasterConfig import TransformerForecasterConfig\n", + "from convokit.decisionpolicy import DeferralDecisionPolicy, ThresholdDecisionPolicy\n", + "from convokit.utterance_simulator.unslothUtteranceSimulatorModel import UnslothUtteranceSimulatorModel" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "15f977d3", + "metadata": {}, + "outputs": [], + "source": [ + "# Set repo root\n", + "\n", + "from pathlib import Path\n", + "\n", + "repo_root = Path.cwd()\n", + "while repo_root.name != \"ConvoKit\":\n", + " repo_root = repo_root.parent\n", + "\n", + "repo_root = str(repo_root)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "18f2375b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] using cached decisionpolicy-demo at /home/lyk25/.convokit/saved-corpora/decisionpolicy-demo\n", + "[info] loaded 26 corpora from /home/lyk25/.convokit/saved-corpora/decisionpolicy-demo\n" + ] + } + ], + "source": [ + "# TODO temporary pre-merge downloader for decisionpolicy-demo\n", + "from pathlib import Path\n", + "import json\n", + "import urllib.request\n", + "import zipfile\n", + "\n", + "from convokit import Corpus\n", + "\n", + "DOWNLOAD_CONFIG_URL = (\n", + " \"https://raw.githubusercontent.com/laerdon/ConvoKit/\"\n", + " \"master/download_config.json\"\n", + ")\n", + "\n", + "\n", + "def get_decisionpolicy_demo_url(config_url=DOWNLOAD_CONFIG_URL):\n", + " print(f\"[info] reading download config from {config_url}\")\n", + " with urllib.request.urlopen(config_url) as response:\n", + " dataset_config = json.load(response)\n", + " try:\n", + " return dataset_config[\"DatasetURLs\"][\"decisionpolicy-demo\"]\n", + " except KeyError as exc:\n", + " raise KeyError(\n", + " \"decisionpolicy-demo is missing from laerdon/ConvoKit master download_config.json\"\n", + " ) from exc\n", + "\n", + "\n", + "def download_decisionpolicy_demo(data_dir=None):\n", + " data_root = Path(data_dir or \"~/.convokit/saved-corpora\").expanduser()\n", + " dataset_name = \"decisionpolicy-demo\"\n", + " dataset_dir = data_root / dataset_name\n", + " zip_path = data_root / f\"{dataset_name}.zip\"\n", + "\n", + " if any(path.is_dir() and (path / \"index.json\").exists() for path in dataset_dir.rglob(\"*\")):\n", + " print(f\"[info] using cached {dataset_name} at {dataset_dir}\")\n", + " return dataset_dir\n", + "\n", + " url = get_decisionpolicy_demo_url()\n", + " data_root.mkdir(parents=True, exist_ok=True)\n", + " print(f\"[info] downloading {dataset_name} from {url}\")\n", + " urllib.request.urlretrieve(url, zip_path)\n", + "\n", + " print(f\"[info] extracting {zip_path} to {data_root}\")\n", + " with zipfile.ZipFile(zip_path, \"r\") as zipf:\n", + " zipf.extractall(data_root)\n", + "\n", + " if not dataset_dir.exists():\n", + " raise FileNotFoundError(f\"expected extracted folder missing: {dataset_dir}\")\n", + " return dataset_dir\n", + "\n", + "base = download_decisionpolicy_demo()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "858a8431", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] using cached decisionpolicy-demo at /home/lyk25/.convokit/saved-corpora/decisionpolicy-demo\n", + "[info] test-seed corpora: 5 (test-seed-1, test-seed-2, test-seed-3, test-seed-4, test-seed-5); seed-* policy corpora in corpora_all: 25\n" + ] + } + ], + "source": [ + "import re\n", + "corpus_dirs = sorted(\n", + " corpus_dir\n", + " for corpus_dir in base.rglob(\"*\")\n", + " if corpus_dir.is_dir() and (corpus_dir / \"index.json\").exists()\n", + ")\n", + "if not corpus_dirs:\n", + " raise FileNotFoundError(f\"no convokit corpora found under {base}\")\n", + "_seed_policy_re = re.compile(r\"^seed-(\\d+)-(.+)$\")\n", + "_test_seed_re = re.compile(r\"^test-seed-(\\d+)$\")\n", + "corpora_all = {}\n", + "corpora = {}\n", + "for corpus_dir in corpus_dirs:\n", + " if _test_seed_re.match(corpus_dir.name):\n", + " corpora[corpus_dir.name] = Corpus(filename=str(corpus_dir))\n", + " continue\n", + " m_test = _test_seed_re.match(corpus_dir.parent.name)\n", + " if m_test:\n", + " corpora[f\"test-seed-{m_test.group(1)}\"] = Corpus(filename=str(corpus_dir))\n", + " continue\n", + " m = _seed_policy_re.match(corpus_dir.parent.name)\n", + " if m and corpus_dir.name == m.group(2):\n", + " corpora_all[f\"seed-{m.group(1)}-{m.group(2)}\"] = Corpus(filename=str(corpus_dir))\n", + "CORPUS_POLICY_PER_SEED = \"DeferralDecisionPolicy\"\n", + "if not corpora:\n", + " for key in sorted(corpora_all):\n", + " m = _seed_policy_re.match(key)\n", + " if m and m.group(2) == CORPUS_POLICY_PER_SEED:\n", + " corpora[f\"test-seed-{m.group(1)}\"] = corpora_all[key]\n", + "if not corpora:\n", + " raise FileNotFoundError(\n", + " f\"no test-seed- corpora under {base} and none derived from {CORPUS_POLICY_PER_SEED!r}\"\n", + " )\n", + "print(\n", + " f\"[info] test-seed corpora: {len(corpora)} ({', '.join(sorted(corpora))}); \"\n", + " f\"seed-* policy corpora in corpora_all: {len(corpora_all)}\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a0bbbd7f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'seed-1-DeferralDecisionPolicy': ,\n", + " 'seed-1-RandomDeferralDecisionPolicy': ,\n", + " 'seed-1-SimulationAverageDecisionPolicy': ,\n", + " 'seed-1-SimulationMajorityDecisionPolicy': ,\n", + " 'seed-1-ThresholdDecisionPolicy': ,\n", + " 'seed-2-DeferralDecisionPolicy': ,\n", + " 'seed-2-RandomDeferralDecisionPolicy': ,\n", + " 'seed-2-SimulationAverageDecisionPolicy': ,\n", + " 'seed-2-SimulationMajorityDecisionPolicy': ,\n", + " 'seed-2-ThresholdDecisionPolicy': ,\n", + " 'seed-3-DeferralDecisionPolicy': ,\n", + " 'seed-3-RandomDeferralDecisionPolicy': ,\n", + " 'seed-3-SimulationAverageDecisionPolicy': ,\n", + " 'seed-3-SimulationMajorityDecisionPolicy': ,\n", + " 'seed-3-ThresholdDecisionPolicy': ,\n", + " 'seed-4-DeferralDecisionPolicy': ,\n", + " 'seed-4-RandomDeferralDecisionPolicy': ,\n", + " 'seed-4-SimulationAverageDecisionPolicy': ,\n", + " 'seed-4-SimulationMajorityDecisionPolicy': ,\n", + " 'seed-4-ThresholdDecisionPolicy': ,\n", + " 'seed-5-DeferralDecisionPolicy': ,\n", + " 'seed-5-RandomDeferralDecisionPolicy': ,\n", + " 'seed-5-SimulationAverageDecisionPolicy': ,\n", + " 'seed-5-SimulationMajorityDecisionPolicy': ,\n", + " 'seed-5-ThresholdDecisionPolicy': }" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "corpora_all" + ] + }, + { + "cell_type": "markdown", + "id": "dab74642", + "metadata": {}, + "source": [ + "Having imported our DeferralDecisionPolicy and ThresholdDecisionPolicy, we now will first define all of the other decision policies to benchmark. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5dabf0bd", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Callable, List, Optional, Dict, Any, Tuple\n", + "import numpy as np\n", + "from convokit.decisionpolicy import DecisionPolicy\n", + "\n", + "\n", + "class _synthetic_speaker:\n", + " def __init__(self, speaker_id: str):\n", + " self.id = speaker_id\n", + "\n", + "\n", + "class _synthetic_utterance:\n", + " def __init__(self, text: str, utterance_id: str, speaker_id: str):\n", + " self.text = text\n", + " self.id = utterance_id\n", + " self.speaker_ = _synthetic_speaker(speaker_id)\n", + " self.meta = {}\n", + "\n", + " def get_conversation(self):\n", + " return None\n", + "\n", + "\n", + "class RandomDeferralDecisionPolicy(DecisionPolicy):\n", + " \"\"\"\n", + " Decision policy that defers intervention by looking ahead at simulated next utterances.\n", + "\n", + " :param simulator: utterance simulator model (must have a ``transform(contexts)`` method\n", + " returning a DataFrame indexed by utterance id). if the simulator exposes\n", + " ``get_num_simulations()``, ``num_simulations`` is capped to that value.\n", + " :param threshold: probability threshold above which a context is flagged.\n", + " :param tau: minimum number of simulated branches that must exceed the threshold\n", + " before an intervention is issued.\n", + " :param num_simulations: how many simulated branches to use per context (capped to\n", + " simulator's ``get_num_simulations()`` if available).\n", + " :param store_simulations: if True, simulated reply strings are cached during decide()\n", + " and written to corpus utterance metadata by post_transform().\n", + " :param simulated_reply_attribute_name: metadata field name used when storing simulations\n", + " on corpus utterances (only relevant when store_simulations=True).\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " simulator,\n", + " threshold,\n", + " deferral_probability: float = 0.1515,\n", + " reuse_cached_forecast_probs: bool = True,\n", + " forecast_prob_attribute_name: str = \"forecast_prob\",\n", + " ):\n", + " # forward the cache flag to the base class so its _score helper honors it.\n", + " # without this, reuse_cached_probabilities on this subclass had no effect.\n", + " super().__init__(\n", + " forecast_prob_attribute_name=forecast_prob_attribute_name,\n", + " reuse_cached_forecast_probs=reuse_cached_forecast_probs,\n", + " )\n", + " self.simulator = simulator\n", + " self.threshold = float(threshold)\n", + " self.deferral_probability = float(deferral_probability)\n", + "\n", + " def _decision_score(self, context, score_fn: Callable):\n", + " # use base _score so a cached forecast_prob on the utterance meta is reused\n", + " # instead of re-invoking the belief estimator.\n", + " return self._score(context, score_fn)\n", + "\n", + " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", + " decision_score = self._score(context, score_fn)\n", + "\n", + " p = float(np.random.rand())\n", + " \n", + "\n", + " # return an empty metadata dict (not None) so downstream code that iterates\n", + " # utt_metadata.items() in TransformerDecoderModel.transform doesn't crash.\n", + " return (decision_score,\n", + " 1 if decision_score > self.threshold and p > self.deferral_probability else 0,\n", + " {}\n", + " )\n", + "\n", + " def fit(self, contexts, val_contexts=None, score_fn: Callable = None):\n", + " if val_contexts is None or score_fn is None or self.labeler is None:\n", + " print(\"either no validation contexts/score function/labeler were provided, returning current threshold\")\n", + " return {\"best_threshold\": self.threshold}\n", + "\n", + " val_contexts = list(val_contexts)\n", + " if len(val_contexts) == 0:\n", + " print(\"no validation contexts were provided, returning current threshold\")\n", + " return {\"best_threshold\": self.threshold}\n", + "\n", + " fit_result = self._fit_with_model_checkpoint_selection(val_contexts, score_fn=score_fn)\n", + " if isinstance(fit_result, dict):\n", + " if \"best_threshold\" in fit_result:\n", + " self.threshold = float(fit_result[\"best_threshold\"])\n", + " return fit_result\n", + "\n", + " fit_result = self._fit_threshold_for_loaded_model(val_contexts, score_fn=score_fn)\n", + " if \"best_threshold\" in fit_result:\n", + " self.threshold = float(fit_result[\"best_threshold\"])\n", + " return fit_result" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d3db5bc", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Callable, Optional, Dict, Any, Tuple\n", + "\n", + "from convokit.decisionpolicy import DeferralDecisionPolicy\n", + "\n", + "\n", + "class SimulationAverageDecisionPolicy(DeferralDecisionPolicy):\n", + " \"\"\"\n", + " decision policy that intervenes if the mean of the simulated next-utterance\n", + " scores is at or above the threshold.\n", + "\n", + " this subclass inherits all simulation fetching, per-utterance metadata\n", + " caching, sim-score caching, and threshold fitting from\n", + " DeferralDecisionPolicy. the only differences are:\n", + " * no ``tau`` parameter (unused; forwarded as 0 to super)\n", + " * ``decide`` predicts based on mean(simulation_scores) >= threshold\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " simulator,\n", + " threshold,\n", + " num_simulations: int = 10,\n", + " store_simulations: bool = False,\n", + " simulated_reply_attribute_name: str = \"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name: str = \"sim_replies_forecast_probs\",\n", + " reuse_cached_simulations: bool = True,\n", + " ):\n", + " # tau is irrelevant for the mean-based decision rule, so we pin it to 0\n", + " # upstream rather than expose it to callers of this subclass.\n", + " super().__init__(\n", + " simulator=simulator,\n", + " threshold=threshold,\n", + " tau=0,\n", + " num_simulations=num_simulations,\n", + " store_simulations=store_simulations,\n", + " simulated_reply_attribute_name=simulated_reply_attribute_name,\n", + " sim_replies_forecast_probs_attribute_name=sim_replies_forecast_probs_attribute_name,\n", + " reuse_cached_simulations=reuse_cached_simulations,\n", + " )\n", + "\n", + " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", + " decision_score, simulations, simulation_scores = self._decision_score(context, score_fn)\n", + " # empty simulation_scores would zero-divide. this happens when the\n", + " # simulator returns no completions for a context (e.g. end-of-conversation\n", + " # contexts that slip through the selector). treat as no intervention so\n", + " # a single degenerate context doesn't abort the whole transform run.\n", + " if len(simulation_scores) == 0:\n", + " average_simulation_score = 0.0\n", + " pred = 0\n", + " else:\n", + " average_simulation_score = sum(simulation_scores) / len(simulation_scores)\n", + " pred = 1 if average_simulation_score >= self.threshold else 0\n", + " return (\n", + " decision_score,\n", + " pred,\n", + " {\n", + " self.simulated_reply_attribute_name: simulations,\n", + " self.sim_replies_forecast_probs_attribute_name: simulation_scores,\n", + " },\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0d1ea7a", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Callable, Optional, Dict, Any, Tuple\n", + "\n", + "from convokit.decisionpolicy import DeferralDecisionPolicy\n", + "\n", + "\n", + "class SimulationMajorityDecisionPolicy(DeferralDecisionPolicy):\n", + " \"\"\"\n", + " decision policy that intervenes if at least ``tau`` of the simulated next\n", + " utterances score above the threshold, ignoring the current utterance score.\n", + "\n", + " this subclass inherits all simulation fetching, per-utterance metadata\n", + " caching, sim-score caching, and threshold fitting from\n", + " DeferralDecisionPolicy. the only difference is in ``decide``: the gate\n", + " ``decision_score > threshold`` is dropped so that only the simulated-branch\n", + " vote count drives the prediction.\n", + " \"\"\"\n", + "\n", + " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", + " decision_score, simulations, simulation_scores = self._decision_score(context, score_fn)\n", + " num_simulations_above_threshold = sum(\n", + " 1 for score in simulation_scores if score > self.threshold\n", + " )\n", + " return (\n", + " decision_score,\n", + " 1 if num_simulations_above_threshold >= self.tau else 0,\n", + " {\n", + " self.simulated_reply_attribute_name: simulations,\n", + " self.sim_replies_forecast_probs_attribute_name: simulation_scores,\n", + " },\n", + " )\n" + ] + }, + { + "cell_type": "markdown", + "id": "0498693e", + "metadata": {}, + "source": [ + "Since we use simulations in our baselines, we must define a simulation configuration as follows: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "638fb31c", + "metadata": {}, + "outputs": [], + "source": [ + "SIMULATOR_TRAIN_CONFIG = {\n", + " \"per_device_train_batch_size\": 16,\n", + " \"per_device_eval_batch_size\": 16,\n", + " \"eval_strategy\": \"steps\",\n", + " \"save_strategy\": \"steps\",\n", + " \"save_steps\": 30,\n", + " \"gradient_accumulation_steps\": 4,\n", + " \"warmup_steps\": 5,\n", + " \"num_train_epochs\": 1,\n", + " \"eval_steps\": 30,\n", + " \"learning_rate\": 2e-4,\n", + " \"logging_steps\": 5,\n", + " \"optim\": \"adamw_8bit\",\n", + " \"weight_decay\": 0.01,\n", + " \"lr_scheduler_type\": \"linear\",\n", + " \"output_dir\": \"outputs/simulator_finetune\",\n", + " \"logging_dir\": \"logs\",\n", + " \"load_best_model_at_end\": True,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf55d140", + "metadata": {}, + "outputs": [], + "source": [ + "TAU = 7\n", + "DEFERRAL_PROBABILITY_THRESHOLD = 0.2518938553561718\n", + "NUM_SIMULATIONS = 10\n", + "OUTPUT_DIR = \"benchmark_preannotated\"\n", + "SEEDS = [1,2,3,4,5]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aedd02fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==((====))== Unsloth 2025.7.11: Fast Llama patching. Transformers: 4.53.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unsloth 2025.7.11 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n", + "Unsloth: Already have LoRA adapters! We shall skip this step.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unsloth: Training embed_tokens in mixed precision to save VRAM\n", + "Unsloth: Training lm_head in mixed precision to save VRAM\n" + ] + } + ], + "source": [ + "simulator_model = UnslothUtteranceSimulatorModel(\n", + " model_name=\"/reef/lyk25/dynamic_training/game_analysis/outputs/checkpoint-74\",\n", + " train_config=SIMULATOR_TRAIN_CONFIG,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "fe147ae8", + "metadata": {}, + "source": [ + "After loading the simulator model, we define context selectors." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a9502041", + "metadata": {}, + "outputs": [], + "source": [ + "def context_selector(context_tuple, split):\n", + " \"\"\"\n", + " We use this generic function for both training and validation data.\n", + " In both cases, its job is to select only those contexts for which the\n", + " FUTURE context is not empty, so we have a next utterance to predict.\n", + " \"\"\"\n", + " matches_split = (context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split)\n", + " is_end = (len(context_tuple.future_context) == 0)\n", + " return matches_split and not is_end\n", + "\n", + "def make_data_selector(split):\n", + " return lambda context_tuple: context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split\n", + "\n", + "train_context_selector = partial(context_selector, split=\"train\")\n", + "val_context_selector = partial(context_selector, split=\"val\")\n", + "test_context_selector = partial(context_selector, split=\"test\")" + ] + }, + { + "cell_type": "markdown", + "id": "f707a3a5", + "metadata": {}, + "source": [ + "Below is a script to fully reproduce, sans regenerating simulations (simulations requires substantially more compute)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dde130ed", + "metadata": {}, + "outputs": [], + "source": [ + "for seed_idx in SEEDS:\n", + " train_corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", + " # corpus = Corpus(filename=f'/reef/lyk25/theres-a-way-out-ACL26-internal/outputs/benchmark_preannotated/seed-{seed_idx}-ThresholdDecisionPolicy/ThresholdDecisionPolicy')\n", + " # corpus = Corpus(filename=f'/reef/lyk25/dynamic_training/game_analysis/corpi/test/test-son-seed-{seed_idx}')\n", + " corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", + " corpus.filter_conversations_by(lambda convo: convo.meta['split'] == 'test')\n", + "\n", + " config = TransformerForecasterConfig(\n", + " output_dir=f\"outputs/{OUTPUT_DIR}/forecaster_{seed_idx}\",\n", + " per_device_batch_size=16,\n", + " gradient_accumulation_steps=1,\n", + " num_train_epochs=1,\n", + " learning_rate=1e-5,\n", + " random_seed=seed_idx,\n", + " context_mode=\"normal\",\n", + " device=\"cuda\",\n", + " )\n", + "\n", + " # TODO this will have to be edited\n", + " forecaster_model = TransformerDecoderModel(\n", + " model_name_or_path=\"google/gemma-2-9b-it\",\n", + " config=config,\n", + " )\n", + "\n", + " forecaster = Forecaster(\n", + " forecaster_model=forecaster_model,\n", + " labeler='has_removed_comment',\n", + " )\n", + "\n", + " forecaster.fit_belief_estimator(\n", + " corpus=train_corpus,\n", + " context_selector=train_context_selector,\n", + " val_context_selector=val_context_selector,\n", + " )\n", + "\n", + " # ---\n", + " cfg_path = os.path.join(repo_root, \"saves\", f\"seed-{seed_idx}\", \"dev_config.json\")\n", + " with open(cfg_path) as f:\n", + " cfg = json.load(f)\n", + " best_threshold = cfg['best_threshold']\n", + "\n", + " for policy_trial in [ThresholdDecisionPolicy, DeferralDecisionPolicy, RandomDeferralDecisionPolicy, SimulationAverageDecisionPolicy, SimulationMajorityDecisionPolicy]:\n", + " print('---')\n", + " print(f\"Fitting policy {policy_trial.__name__} for seed {seed_idx}\")\n", + " if policy_trial == ThresholdDecisionPolicy:\n", + " policy = ThresholdDecisionPolicy(\n", + " threshold=best_threshold,\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == DeferralDecisionPolicy:\n", + " policy = DeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " tau=TAU,\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == RandomDeferralDecisionPolicy:\n", + " policy = RandomDeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " deferral_probability=DEFERRAL_PROBABILITY_THRESHOLD,\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == SimulationAverageDecisionPolicy:\n", + " policy = SimulationAverageDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " num_simulations=NUM_SIMULATIONS,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == SimulationMajorityDecisionPolicy:\n", + " policy = SimulationMajorityDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " tau=TAU,\n", + " num_simulations=NUM_SIMULATIONS,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " \n", + " # attach the decision policy to the underlying forecaster model;\n", + " # Forecaster itself does not accept decision_policy in its constructor.\n", + " forecaster_model.decision_policy = policy\n", + "\n", + " forecaster = Forecaster(\n", + " forecaster_model=forecaster_model,\n", + " labeler='has_removed_comment',\n", + " )\n", + "\n", + " print('starting transformation.')\n", + " # evaluate the forecaster on the test set\n", + " forecaster.transform(\n", + " corpus=corpus,\n", + " context_selector=make_data_selector('test'),\n", + " verbose=True,\n", + " )\n", + " print('transformation complete.')\n", + "\n", + " output_dir = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + " os.makedirs(output_dir, exist_ok=True)\n", + " corpus.dump(name=f\"{policy_trial.__name__}\", base_path=output_dir)\n", + " print('corpus dumped.')\n", + "\n", + " print('starting summarization.')\n", + " # forecaster.summarize expects a conversation-level selector (Callable[[Conversation], bool]),\n", + " # unlike the context-tuple selectors used in fit/transform.\n", + " def summarize_selector(convo):\n", + " return convo.meta.get(\"split\") == \"test\"\n", + " conversational_forecasts_df, metrics = forecaster.summarize(\n", + " corpus=corpus,\n", + " selector=summarize_selector,\n", + " )\n", + " print('summarization complete.')\n", + " \n", + " # path to the seed output directory\n", + " seed_folder = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + "\n", + " # ensure the directory exists\n", + " os.makedirs(seed_folder, exist_ok=True)\n", + "\n", + " # save conversational_forecasts_df as CSV\n", + " conversational_forecasts_df.to_csv(os.path.join(seed_folder, \"conversational_forecasts.csv\"), index=False)\n", + "\n", + " # save metrics as JSON\n", + " with open(os.path.join(seed_folder, \"metrics.json\"), \"w\") as f:\n", + " json.dump(metrics, f, indent=2)" + ] + }, + { + "cell_type": "markdown", + "id": "e3c6f428", + "metadata": {}, + "source": [ + "A faster reproduction is possible by skipping the training and transformation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f4a29c2", + "metadata": {}, + "outputs": [], + "source": [ + "for seed_idx in SEEDS:\n", + " config = TransformerForecasterConfig(\n", + " output_dir=f\"outputs/{OUTPUT_DIR}/forecaster_{seed_idx}\",\n", + " per_device_batch_size=16,\n", + " gradient_accumulation_steps=1,\n", + " num_train_epochs=1,\n", + " learning_rate=1e-5,\n", + " random_seed=seed_idx,\n", + " context_mode=\"normal\",\n", + " device=\"cuda\",\n", + " )\n", + "\n", + " # TODO this will have to be edited\n", + " forecaster_model = TransformerDecoderModel(\n", + " model_name_or_path=\"google/gemma-2-9b-it\",\n", + " config=config,\n", + " )\n", + "\n", + " forecaster = Forecaster(\n", + " forecaster_model=forecaster_model,\n", + " labeler='has_removed_comment',\n", + " )\n", + "\n", + " # remove training---we can instead use the cached forecast probabilities.\n", + "\n", + " # ---\n", + " cfg_path = os.path.join(repo_root, \"saves\", f\"seed-{seed_idx}\", \"dev_config.json\")\n", + " with open(cfg_path) as f:\n", + " cfg = json.load(f)\n", + " best_threshold = cfg['best_threshold']\n", + "\n", + " for policy_trial in [ThresholdDecisionPolicy, DeferralDecisionPolicy, RandomDeferralDecisionPolicy, SimulationAverageDecisionPolicy, SimulationMajorityDecisionPolicy]:\n", + " corpus_name = f\"seed-{seed_idx}-{policy_trial.__name__}\"\n", + " if corpus_name in corpora:\n", + " corpus = corpora_all[corpus_name]\n", + " else:\n", + " raise KeyError(f\"missing corpus {corpus_name}\")\n", + "\n", + " print('---')\n", + " print(f\"fitting policy {policy_trial.__name__} for seed {seed_idx}\")\n", + " if policy_trial == ThresholdDecisionPolicy:\n", + " policy = ThresholdDecisionPolicy(\n", + " threshold=best_threshold,\n", + " )\n", + " elif policy_trial == DeferralDecisionPolicy:\n", + " policy = DeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " tau=TAU,\n", + " )\n", + " elif policy_trial == RandomDeferralDecisionPolicy:\n", + " policy = RandomDeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " deferral_probability=DEFERRAL_PROBABILITY_THRESHOLD,\n", + " )\n", + " elif policy_trial == SimulationAverageDecisionPolicy:\n", + " policy = SimulationAverageDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " num_simulations=NUM_SIMULATIONS,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " )\n", + " elif policy_trial == SimulationMajorityDecisionPolicy:\n", + " policy = SimulationMajorityDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " tau=TAU,\n", + " num_simulations=NUM_SIMULATIONS,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " )\n", + " \n", + " # attach the decision policy to the underlying forecaster model;\n", + " # Forecaster itself does not accept decision_policy in its constructor.\n", + " forecaster_model.decision_policy = policy\n", + "\n", + " forecaster = Forecaster(\n", + " forecaster_model=forecaster_model,\n", + " labeler='has_removed_comment',\n", + " )\n", + "\n", + " print('starting transformation.')\n", + " # evaluate the forecaster on the test set\n", + " forecaster.transform(\n", + " corpus=corpus,\n", + " context_selector=make_data_selector('test'),\n", + " verbose=True,\n", + " )\n", + " print('transformation complete.')\n", + "\n", + " output_dir = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + " os.makedirs(output_dir, exist_ok=True)\n", + " corpus.dump(name=f\"{policy_trial.__name__}\", base_path=output_dir)\n", + " print('corpus dumped.')\n", + "\n", + " print('starting summarization.')\n", + " # forecaster.summarize expects a conversation-level selector (Callable[[Conversation], bool]),\n", + " # unlike the context-tuple selectors used in fit/transform.\n", + " def summarize_selector(convo):\n", + " return convo.meta.get(\"split\") == \"test\"\n", + " conversational_forecasts_df, metrics = forecaster.summarize(\n", + " corpus=corpus,\n", + " selector=summarize_selector,\n", + " )\n", + " print('summarization complete.')\n", + " \n", + " # path to the seed output directory\n", + " seed_folder = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + "\n", + " # ensure the directory exists\n", + " os.makedirs(seed_folder, exist_ok=True)\n", + "\n", + " # save conversational_forecasts_df as CSV\n", + " conversational_forecasts_df.to_csv(os.path.join(seed_folder, \"conversational_forecasts.csv\"), index=False)\n", + "\n", + " # save metrics as JSON\n", + " with open(os.path.join(seed_folder, \"metrics.json\"), \"w\") as f:\n", + " json.dump(metrics, f, indent=2)" + ] + }, + { + "cell_type": "markdown", + "id": "29a0cdc1", + "metadata": {}, + "source": [ + "## Human benchmark analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d673d0d6", + "metadata": {}, + "outputs": [], + "source": [ + "# import human data SQL here" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "==((====))== Unsloth 2025.7.11: Fast Llama patching. Transformers: 4.53.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] + "cell_type": "code", + "execution_count": 13, + "id": "d55b3bab", + "metadata": {}, + "outputs": [], + "source": [ + "import sqlite3" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Unsloth 2025.7.11 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n", - "Unsloth: Already have LoRA adapters! We shall skip this step.\n" - ] + "cell_type": "code", + "execution_count": 16, + "id": "6047d55a", + "metadata": {}, + "outputs": [], + "source": [ + "round_n = 1" + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Unsloth: Training embed_tokens in mixed precision to save VRAM\n", - "Unsloth: Training lm_head in mixed precision to save VRAM\n" - ] + "cell_type": "code", + "execution_count": 17, + "id": "92766a80", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] connected to database: /reef/sqt2/cga-eval/human/game_db.sqlite\n" + ] + } + ], + "source": [ + "# connect to the game database\n", + "db_path = '/reef/sqt2/cga-eval/human/game_db.sqlite'\n", + "connection = sqlite3.connect(db_path)\n", + "cursor = connection.cursor()\n", + "\n", + "print(f\"[info] connected to database: {db_path}\")\n", + "cursor.execute(\"SELECT COUNT(*) FROM results\")\n", + "\n", + "# # names_list = []\n", + "# # answers_list = []\n", + "# # scores_list = []\n", + "# # comments_list = []\n", + "\n", + "# TIME_CUTOFF = 1714059814630 # timestamp to cut off previous results\n", + "# TIME_CUTOFF_END = 1730385762530\n", + "\n", + "# for row in connection.execute('SELECT * FROM results'):\n", + "# if row[0] != 'yc2727' and row[0] != 'sqt2':\n", + "# answers = json.loads(row[1])\n", + "# if answers[0]['start_time'] > TIME_CUTOFF and answers[0]['start_time'] < TIME_CUTOFF_END:\n", + "# names_list.append(row[0])\n", + "# answers_list.append(answers)\n", + "# scores_list.append(row[2])\n", + "# comments_list.append(row[3])\n", + "\n", + "if round_n == 1:\n", + " # for round_n 1\n", + " names_list_1 = []\n", + " answers_list_1 = []\n", + " scores_list_1 = []\n", + " comments_list_1 = []\n", + "\n", + " TIME_CUTOFF_1 = 1730395000000\n", + " TIME_CUTOFF_END_1 = 1730397199000\n", + "\n", + " for row in connection.execute('SELECT * FROM results'):\n", + " if row[0] != 'yc2727' and row[0] != 'sqt2':\n", + " answers = json.loads(row[1])\n", + " if answers[0]['start_time'] > TIME_CUTOFF_1 and answers[0]['start_time'] < TIME_CUTOFF_END_1:\n", + " names_list_1.append(row[0])\n", + " answers_list_1.append(answers)\n", + " scores_list_1.append(row[2])\n", + " comments_list_1.append(row[3])\n", + "elif round_n == 2:\n", + " # for round 2\n", + " names_list_2 = []\n", + " answers_list_2 = []\n", + " scores_list_2 = []\n", + " comments_list_2 = []\n", + "\n", + " TIME_CUTOFF_2_a = 1731002910000\n", + " TIME_CUTOFF_END_2_a = 1731016180000\n", + "\n", + " for row in connection.execute('SELECT * FROM results'):\n", + " if row[0] != 'yc2727' and row[0] != 'sqt2':\n", + " answers = json.loads(row[1])\n", + " if answers[0]['start_time'] > TIME_CUTOFF_2_a and answers[0]['start_time'] < TIME_CUTOFF_END_2_a:\n", + " names_list_2.append(row[0])\n", + " answers_list_2.append(answers)\n", + " scores_list_2.append(row[2])\n", + " comments_list_2.append(row[3])\n", + "\n", + " # The 2_b cutoff below is to specifically add data from 'ljl2' for a later second round window,\n", + " # likely because they submitted their data late or for a different time block.\n", + " TIME_CUTOFF_2_b = 1732212720000\n", + " TIME_CUTOFF_END_2_b = 1740000000000\n", + "\n", + " for row in connection.execute('SELECT * FROM results'):\n", + " if row[0].lower() == 'ljl2':\n", + " answers = json.loads(row[1])\n", + " if answers[0]['start_time'] > TIME_CUTOFF_2_b and answers[0]['start_time'] < TIME_CUTOFF_END_2_b:\n", + " names_list_2.append(row[0])\n", + " answers_list_2.append(answers)\n", + " scores_list_2.append(row[2])\n", + " comments_list_2.append(row[3])\n", + "\n", + " # print(f\"Round 1: {len(names_list_1)} entries\")\n", + " # print(f\"Round 2: {len(names_list_2)} entries\")\n", + " # names_list_1, names_list_2" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "889d7ede", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] total unique conversation ids: 84\n", + "['givp578', 'e1vstxd', 'f1353ra', 'ewr7ls3', 'dmlny27', 'dg7wmdb', 'flixm8f', 'f13u0n2', 'ggwdbsa', 'd3f07tv', 'isz5n6g', 'givok1i', 'dyx3au1', 'g1sm9mt', 'f0dryv4', 'doi44j8', 'g2998qp', 'dpirnlc', 'h2h7yl0', 'dg7x3eu', 'ej6jusi', 'ikzb571', 'e1vv6x1', 'ifkoazb', 'dpkib9q', 'g1q3upb', 'dydawov', 'g1q1973', 'dm8exht', 'fphcwq0', 'gmxqrdz', 'dmlqnzz', 'dyd7cfv', 'i4rgtqf', 'doi3vuz', 'd0fyu9x', 'f014doo', 'dm8qu78', 'gmxoyuu', 'fmre7l9', 'ii3cpve', 'ii4ivim', 'e9mynuy', 'djh1bt1', 'f83hb2k', 'ewtowqu', 'dbnxbzn', 'fixjxxs', 'dvivs9p', 'ej6ollb', 'g1spg0k', 'ggwei5y', 'd0fzp40', 'gvb1ekl', 'djh2v24', 'dvisfl0', 'ewtjxp2', 'dyx2jn4', 'ewr7msm', 'd3efg03', 'fixlxvy', 'fegw71k', 'ikzcblg', 'ffpk80c', 'fmspcex', 'f00nxjs', 'gvdnrrb', 'h28ltfw', 'f0dsbw4', 'dbnr5nd', 'ikpw1ol', 'ffpj88q', 'i4rh1id', 'e9mybxp', 'isz6a7m', 'ifknq44', 'g297nn7', 'fegwvia', 'ikpxahv', 'f83akyz', 'h2hauaj', 'h28lknz', 'g3hmlew', 'fljdrtt']\n" + ] + } + ], + "source": [ + "human_map1 = {\n", + " \"vn72\": ['d3efg03', 'd3f07tv', 'f1353ra', 'f13u0n2', 'fegw71k', 'fegwvia', 'ikpw1ol', 'ikpxahv', 'isz5n6g', 'isz6a7m'],\n", + " \"nac86\": ['dyd7cfv', 'dydawov', 'ewtjxp2', 'ewtowqu', 'f00nxjs', 'f014doo', 'ii3cpve', 'ii4ivim', 'ikzb571', 'ikzcblg'],\n", + " # \"sj597\": ['dbnr5nd', 'dbnxbzn', 'g1sm9mt', 'g1spg0k', 'g297nn7', 'g2998qp', 'h2h7yl0', 'h2hauaj', 'ifknq44', 'ifkoazb'],\n", + " \"yc2727\": ['d08x3kl', 'd08x4q0', 'd3efg03', 'd3f07tv', 'ewtjxp2', 'ewtowqu', 'hnupywh', 'hnuu3ip', 'ih2fn94', 'ih3iwph'],\n", + " # \"ex36\": ['d0fyu9x', 'd0fzp40', 'dg7wmdb', 'dg7x3eu', 'ej6jusi', 'ej6ollb', 'ewtjxp2', 'ewtowqu', 'f0dryv4', 'f0dsbw4'],\n", + " \"kz88\": ['doi3vuz', 'doi44j8', 'e9mybxp', 'e9mynuy', 'g1q1973', 'g1q3upb', 'ggwdbsa', 'ggwei5y', 'gmxoyuu', 'gmxqrdz'],\n", + " \"LJL2\": ['ffpj88q', 'ffpk80c', 'flixm8f', 'fljdrtt', 'fmre7l9', 'fmspcex', 'fphcwq0', 'g3hmlew', 'givok1i', 'givp578'],\n", + " \"lyk25\": ['dpirnlc', 'dpkib9q', 'e1vstxd', 'e1vv6x1', 'ewr7ls3', 'ewr7msm', 'fixjxxs', 'fixlxvy', 'fmre7l9', 'fmspcex'],\n", + " \"sqt2\": ['d3efg03', 'd3f07tv', 'g0fwpzc', 'g0ggz8e', 'g8nyz4f', 'g8nzx3m', 'h4i75b9', 'h4i79lc', 'h6ikmzc', 'h6ime20'],\n", + " \"cd326\": ['djh1bt1', 'djh2v24', 'dmlny27', 'dmlqnzz', 'f83akyz', 'f83hb2k', 'h28lknz', 'h28ltfw', 'i4rgtqf', 'i4rh1id'],\n", + " \"tg352\": ['dm8exht', 'dm8qu78', 'dvisfl0', 'dvivs9p', 'dyx2jn4', 'dyx3au1', 'gvb1ekl', 'gvdnrrb', 'i4rgtqf', 'i4rh1id'],\n", + "}\n", + "\n", + "# all_convo_ids = []\n", + "# for k,v in human_map1.items():\n", + "# all_convo_ids.extend(v)\n", + "# all_convo_ids = list(set(all_convo_ids))\n", + "# len(all_convo_ids)\n", + "\n", + "all_convo_ids = []\n", + "# # collect from round 1\n", + "if round_n == 1:\n", + " for i in range(len(answers_list_1)):\n", + " for j in range(len(answers_list_1[i])):\n", + " all_convo_ids.append(answers_list_1[i][j]['id'])\n", + "# collect from round 2\n", + "elif round_n == 2:\n", + " for i in range(len(answers_list_2)):\n", + " for j in range(len(answers_list_2[i])):\n", + " all_convo_ids.append(answers_list_2[i][j]['id'])\n", + "all_convo_ids = list(set(all_convo_ids))\n", + "print(f\"[info] total unique conversation ids: {len(all_convo_ids)}\")\n", + "print(all_convo_ids)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "e55a3803", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset already exists at /reef/lyk25/ConvoKit/examples/forecaster/conversations-gone-awry-cmv-corpus-large\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", + "corpus.filter_conversations_by(lambda convo: convo.id in all_convo_ids)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "168fb025", + "metadata": {}, + "outputs": [], + "source": [ + "# we want all utterances to have a human_guesses meta field\n", + "for convo in corpus.iter_conversations():\n", + " for utt in convo.get_chronological_utterance_list():\n", + " utt.add_meta('human_guesses', [])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27fc646a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vn72\n", + "nac86\n", + "sj597\n", + "ex36\n", + "kz88\n", + "LJL2\n", + "lyk25\n", + "cd326\n", + "tg352\n" + ] + } + ], + "source": [ + "if round_n == 1:\n", + " for i, participant_sessions in enumerate(answers_list_1):\n", + " participant_id = names_list_1[i]\n", + " print(participant_id)\n", + " for session in participant_sessions:\n", + " convo_id = session['id']\n", + " convo = corpus.get_conversation(convo_id)\n", + " utts = convo.get_chronological_utterance_list()\n", + " actions = session.get('actions', [])\n", + "\n", + " for action_idx, action in enumerate(actions):\n", + " if action.get('guess') is True:\n", + " utt = utts[action_idx]\n", + " # get current guesses (returns deep copy if exists, or empty list if not)\n", + " # create a new list to avoid mutating the copy\n", + " current_guesses = list(utt.meta.get('human_guesses', []))\n", + " # append new participant and set back\n", + " current_guesses.append(participant_id)\n", + " utt.add_meta('human_guesses', current_guesses)\n", + "elif round_n == 2:\n", + " for i, participant_sessions in enumerate(answers_list_2):\n", + " participant_id = names_list_2[i]\n", + " print(participant_id)\n", + " for session in participant_sessions:\n", + " convo_id = session['id']\n", + " convo = corpus.get_conversation(convo_id)\n", + " utts = convo.get_chronological_utterance_list()\n", + " actions = session.get('actions', [])\n", + "\n", + " for action_idx, action in enumerate(actions):\n", + " if action.get('guess') is True:\n", + " utt = utts[action_idx]\n", + " # get current guesses (returns deep copy if exists, or empty list if not)\n", + " # create a new list to avoid mutating the copy\n", + " current_guesses = list(utt.meta.get('human_guesses', []))\n", + " # append new participant and set back\n", + " current_guesses.append(participant_id)\n", + " utt.add_meta('human_guesses', current_guesses)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "fd613b4b", + "metadata": {}, + "outputs": [], + "source": [ + "# initialize model prediction metadata fields for each utterance\n", + "for convo in corpus.iter_conversations():\n", + " for utt in convo.get_chronological_utterance_list():\n", + " utt.add_meta('model_forecast_probs', {}) # will store {seed: prob}\n", + " utt.add_meta('model_forecasts', {}) # will store {seed: binary_forecast}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "873cb706", + "metadata": {}, + "outputs": [], + "source": [ + "# copy model predictions from the corpora loaded above\n", + "loaded_seed_nums = sorted(\n", + " int(corpus_name.rsplit(\"-\", 1)[-1])\n", + " for corpus_name in corpora\n", + " if corpus_name.startswith(\"test-seed-\")\n", + ")\n", + "\n", + "if not loaded_seed_nums:\n", + " available = \", \".join(sorted(corpora))\n", + " raise KeyError(f\"no test seed corpora found; available corpora: {available}\")\n", + "\n", + "for seed_num in loaded_seed_nums:\n", + " seed_key = f\"test-seed-{seed_num}\"\n", + " print(f\"[info] loading predictions from seed {seed_num}: {seed_key}\")\n", + " seed_corpus = corpora[seed_key]\n", + "\n", + " for convo in corpus.iter_conversations():\n", + " seed_convo = seed_corpus.get_conversation(convo.id)\n", + " main_utts = convo.get_chronological_utterance_list()\n", + " seed_utts = seed_convo.get_chronological_utterance_list()\n", + "\n", + " for main_utt, seed_utt in zip(main_utts, seed_utts):\n", + " forecast_prob = seed_utt.meta.get(\"forecast_prob\")\n", + " forecast = seed_utt.meta.get(\"forecast\")\n", + "\n", + " if forecast_prob is not None:\n", + " current_probs = dict(main_utt.meta.get(\"model_forecast_probs\", {}))\n", + " current_probs[f\"seed_{seed_num}\"] = forecast_prob\n", + " main_utt.add_meta(\"model_forecast_probs\", current_probs)\n", + "\n", + " if forecast is not None:\n", + " current_forecasts = dict(main_utt.meta.get(\"model_forecasts\", {}))\n", + " current_forecasts[f\"seed_{seed_num}\"] = forecast\n", + " main_utt.add_meta(\"model_forecasts\", current_forecasts)\n", + "\n", + "print(\"\\n[pass] model predictions from all seeds added to corpus\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5b0f0e44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "gemma horizon (TPs only, mean - 1):\n", + " mean over seeds: h=nan\n", + " pooled: n=0, h=nan\n", + "human horizon (round 1, TPs only, mean - 1):\n", + " player vn72: n=1, h=6.0000\n", + " player nac86: n=2, h=0.5000\n", + " player sj597: n=4, h=2.2500\n", + " player ex36: n=1, h=2.0000\n", + " player kz88: n=2, h=2.5000\n", + " player LJL2: n=4, h=1.5000\n", + " player lyk25: n=4, h=2.5000\n", + " player cd326: n=2, h=1.5000\n", + " player tg352: n=2, h=5.0000\n", + " mean over players: h=2.6389\n", + " pooled: n=22, h=2.3636\n", + "human horizon (round 2, TPs only, mean - 1):\n", + " player sj597: n=4, h=1.2500\n", + " player nac86: n=2, h=4.0000\n", + " player ex36: n=2, h=0.5000\n", + " player vn72: n=3, h=1.6667\n", + " player lyk25: n=4, h=3.0000\n", + " player kz88: n=1, h=3.0000\n", + " player cd326: n=4, h=3.2500\n", + " player tg352: n=3, h=2.0000\n", + " player LJL2: n=2, h=0.5000\n", + " mean over players: h=2.1296\n", + " pooled: n=25, h=2.1600\n", + "\n", + "summary (comparable to h in performance_utils_wiki):\n", + " gemma h (mean over seeds): nan\n", + " round1 h (mean over players): 2.6389\n", + " round2 h (mean over players): 2.1296\n" + ] + } + ], + "source": [ + "# horizon comparison between gemma and humans, using the same convention as\n", + "# performance_utils_wiki.calculate_current_performance:\n", + "# - only count true positives (ground truth awry AND trigger fired)\n", + "# - horizon = (len(utts) - first_trigger_index) - 1\n", + "# - first trigger only (break after first positive)\n", + "#\n", + "# reports per-round results for humans (round 1 and round 2), pulling data\n", + "# directly from the game sqlite so it works regardless of which round_n the\n", + "# rest of the notebook was run under. ljl2 is excluded.\n", + "\n", + "import sqlite3\n", + "import json as _json\n", + "from collections import defaultdict\n", + "import numpy as np\n", + "\n", + "def _horizon_mean(horizons):\n", + " # matches performance_utils_wiki: h = mean(horizons) - 1\n", + " if len(horizons) == 0:\n", + " return float('nan'), 0\n", + " return float(np.mean(horizons)) - 1, len(horizons)\n", + "\n", + "# always excluded (staff/test accounts). ljl2 is a legitimate late submitter\n", + "# in the round 2_b window, not an exclusion.\n", + "base_excluded = {'yc2727', 'sqt2'}\n", + "round1_excluded = set(base_excluded)\n", + "round2_excluded = set(base_excluded)\n", + "\n", + "# gemma: per-seed first-trigger horizons on TP convos only (ground truth awry)\n", + "gemma_horizons_by_seed = defaultdict(list)\n", + "for convo in corpus.iter_conversations():\n", + " if not convo.meta.get('has_removed_comment', False):\n", + " continue # skip non-awry convos; horizon is only meaningful on TPs\n", + " utts = convo.get_chronological_utterance_list()\n", + " for seed_num in range(1, 6):\n", + " for i, utt in enumerate(utts):\n", + " if utt.meta.get('model_forecasts', {}).get(f'seed_{seed_num}') == 1:\n", + " gemma_horizons_by_seed[seed_num].append(len(utts) - i)\n", + " break\n", + "\n", + "print('gemma horizon (TPs only, mean - 1):')\n", + "gemma_per_seed_h = []\n", + "for seed_num in sorted(gemma_horizons_by_seed.keys()):\n", + " h, n = _horizon_mean(gemma_horizons_by_seed[seed_num])\n", + " gemma_per_seed_h.append(h)\n", + " print(f' seed {seed_num}: n={n}, h={h:.4f}')\n", + "gemma_h_mean_of_seeds = float(np.mean(gemma_per_seed_h)) if gemma_per_seed_h else float('nan')\n", + "all_gemma_vals = [v for vs in gemma_horizons_by_seed.values() for v in vs]\n", + "gemma_h_pooled, gemma_n_pooled = _horizon_mean(all_gemma_vals)\n", + "print(f' mean over seeds: h={gemma_h_mean_of_seeds:.4f}')\n", + "print(f' pooled: n={gemma_n_pooled}, h={gemma_h_pooled:.4f}')\n", + "\n", + "# pull round-specific human guesses directly from the sqlite db\n", + "db_path = '/reef/sqt2/cga-eval/human/game_db.sqlite'\n", + "_conn = sqlite3.connect(db_path)\n", + "\n", + "def _load_round_answers(round_n):\n", + " # returns list of (participant_id, sessions) for the given round\n", + " entries = []\n", + " if round_n == 1:\n", + " excluded = round1_excluded\n", + " t_start, t_end = 1730395000000, 1730397199000\n", + " for row in _conn.execute('SELECT * FROM results'):\n", + " if row[0] in excluded:\n", + " continue\n", + " answers = _json.loads(row[1])\n", + " if answers and answers[0]['start_time'] > t_start and answers[0]['start_time'] < t_end:\n", + " entries.append((row[0], answers))\n", + " elif round_n == 2:\n", + " excluded = round2_excluded\n", + " t_start_a, t_end_a = 1731002910000, 1731016180000\n", + " t_start_b, t_end_b = 1732212720000, 1740000000000\n", + " for row in _conn.execute('SELECT * FROM results'):\n", + " name = row[0]\n", + " if name in excluded:\n", + " continue\n", + " answers = _json.loads(row[1])\n", + " if not answers:\n", + " continue\n", + " st = answers[0]['start_time']\n", + " in_a = t_start_a < st < t_end_a\n", + " # the 2_b late window is only valid for ljl2 (matches cell 7)\n", + " in_b = (name.lower() == 'ljl2') and (t_start_b < st < t_end_b)\n", + " if in_a or in_b:\n", + " entries.append((name, answers))\n", + " return entries\n", + "\n", + "def _unique_convo_ids(entries):\n", + " # unique convo ids seen across all included players' sessions\n", + " ids = set()\n", + " for _, sessions in entries:\n", + " for session in sessions:\n", + " cid = session.get('id')\n", + " if cid is not None:\n", + " ids.add(cid)\n", + " return ids\n", + "\n", + "def _compute_human_horizons(entries):\n", + " # returns dict: player_id -> list of horizons (non-awry convos only, first guess per convo)\n", + " by_player = defaultdict(list)\n", + " for participant_id, sessions in entries:\n", + " for session in sessions:\n", + " convo_id = session.get('id')\n", + " if convo_id is None:\n", + " continue\n", + " try:\n", + " convo = corpus.get_conversation(convo_id)\n", + " except KeyError:\n", + " # convo not in the loaded corpus (e.g., different round loaded)\n", + " continue\n", + " if not convo.meta.get('has_removed_comment', False):\n", + " continue # skip non-awry convos; horizon only counted on TPs\n", + " utts = convo.get_chronological_utterance_list()\n", + " for action_idx, action in enumerate(session.get('actions', [])):\n", + " if action.get('guess') is True:\n", + " if action_idx < len(utts):\n", + " by_player[participant_id].append(len(utts) - action_idx)\n", + " break # only first guess per (player, convo)\n", + " return by_player\n", + "\n", + "def _print_human_horizons(label, by_player):\n", + " print(f'human horizon ({label}, TPs only, mean - 1):')\n", + " player_h = []\n", + " for player, horizons in by_player.items():\n", + " h, n = _horizon_mean(horizons)\n", + " player_h.append(h)\n", + " print(f' player {player}: n={n}, h={h:.4f}')\n", + " mean_of_players = float(np.mean(player_h)) if player_h else float('nan')\n", + " all_vals = [v for vs in by_player.values() for v in vs]\n", + " h_pooled, n_pooled = _horizon_mean(all_vals)\n", + " print(f' mean over players: h={mean_of_players:.4f}')\n", + " print(f' pooled: n={n_pooled}, h={h_pooled:.4f}')\n", + " return mean_of_players, h_pooled\n", + "\n", + "EXPECTED_N_CONVOS = 84\n", + "round1_entries = _load_round_answers(1)\n", + "round1_convo_ids = _unique_convo_ids(round1_entries)\n", + "round1_by_player = _compute_human_horizons(round1_entries)\n", + "r1_mean, r1_pooled = _print_human_horizons('round 1', round1_by_player)\n", + "\n", + "round2_entries = _load_round_answers(2)\n", + "round2_convo_ids = _unique_convo_ids(round2_entries)\n", + "round2_by_player = _compute_human_horizons(round2_entries)\n", + "r2_mean, r2_pooled = _print_human_horizons('round 2', round2_by_player)\n", + "\n", + "_conn.close()\n", + "\n", + "print()\n", + "print('summary (comparable to h in performance_utils_wiki):')\n", + "print(f' gemma h (mean over seeds): {gemma_h_mean_of_seeds:.4f}')\n", + "print(f' round1 h (mean over players): {r1_mean:.4f}')\n", + "print(f' round2 h (mean over players): {r2_mean:.4f}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "44ed25ac", + "metadata": {}, + "outputs": [], + "source": [ + "from collections import defaultdict\n", + "import numpy as np\n", + "def _compute_metrics(tp, fp, tn, fn):\n", + " total = tp + fp + tn + fn\n", + " accuracy = (tp + tn) / total if total > 0 else 0.0\n", + " precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0\n", + " recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0\n", + " f1 = (2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0.0\n", + " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0.0\n", + " specificity = tn / (tn + fp) if (tn + fp) > 0 else 0.0\n", + " fnr = fn / (fn + tp) if (fn + tp) > 0 else 0.0\n", + " return {\n", + " 'tp': tp, 'fp': fp, 'tn': tn, 'fn': fn,\n", + " 'accuracy': accuracy, 'precision': precision, 'recall': recall,\n", + " 'f1': f1, 'fpr': fpr, 'specificity': specificity, 'fnr': fnr,\n", + " }\n", + "def _gt(convo):\n", + " return bool(convo.meta.get('has_removed_comment', False))\n", + "# gemma benchmark, per seed, then mean and std\n", + "gemma_per_seed = []\n", + "for seed_num in range(1, 6):\n", + " tp = fp = tn = fn = 0\n", + " for convo in corpus.iter_conversations():\n", + " utts = convo.get_chronological_utterance_list()\n", + " pred = any(\n", + " utt.meta.get('model_forecasts', {}).get(f'seed_{seed_num}') == 1\n", + " for utt in utts\n", + " )\n", + " truth = _gt(convo)\n", + " if pred and truth: tp += 1\n", + " elif pred and not truth: fp += 1\n", + " elif not pred and not truth: tn += 1\n", + " elif not pred and truth: fn += 1\n", + " gemma_per_seed.append(_compute_metrics(tp, fp, tn, fn))\n", + "gemma_mean = {k: float(np.mean([m[k] for m in gemma_per_seed])) for k in gemma_per_seed[0]}\n", + "gemma_std = {k: float(np.std([m[k] for m in gemma_per_seed], ddof=1)) for k in gemma_per_seed[0]}\n", + "def _build_per_player_preds(entries):\n", + " # returns dict[player_id] -> dict[convo_id] -> 0/1\n", + " preds = defaultdict(dict)\n", + " for player, sessions in entries:\n", + " for s in sessions:\n", + " cid = s.get('id')\n", + " if cid is None:\n", + " continue\n", + " try:\n", + " corpus.get_conversation(cid)\n", + " except KeyError:\n", + " continue\n", + " actions = s.get('actions', [])\n", + " preds[player][cid] = 1 if any(a.get('guess') is True for a in actions) else 0\n", + " return preds\n", + "def _aggregate_any(preds):\n", + " # per-convo prediction = 1 if any player who saw it guessed\n", + " by_convo = defaultdict(list)\n", + " for player, convo_preds in preds.items():\n", + " for cid, p in convo_preds.items():\n", + " by_convo[cid].append(p)\n", + " tp = fp = tn = fn = 0\n", + " for cid, plist in by_convo.items():\n", + " try:\n", + " convo = corpus.get_conversation(cid)\n", + " except KeyError:\n", + " continue\n", + " pred = 1 if any(plist) else 0\n", + " truth = 1 if _gt(convo) else 0\n", + " if pred and truth: tp += 1\n", + " elif pred and not truth: fp += 1\n", + " elif not pred and not truth: tn += 1\n", + " elif not pred and truth: fn += 1\n", + " return _compute_metrics(tp, fp, tn, fn), len(by_convo)\n", + "def _per_player_metrics(preds):\n", + " rows = {}\n", + " for player, convo_preds in preds.items():\n", + " tp = fp = tn = fn = 0\n", + " for cid, p in convo_preds.items():\n", + " try:\n", + " convo = corpus.get_conversation(cid)\n", + " except KeyError:\n", + " continue\n", + " truth = 1 if _gt(convo) else 0\n", + " if p and truth: tp += 1\n", + " elif p and not truth: fp += 1\n", + " elif not p and not truth: tn += 1\n", + " elif not p and truth: fn += 1\n", + " rows[player] = _compute_metrics(tp, fp, tn, fn)\n", + " return rows\n", + "# round 1 and round 2 humans\n", + "round1_preds = _build_per_player_preds(round1_entries)\n", + "round1_agg, round1_n_convos = _aggregate_any(round1_preds)\n", + "round1_per_player = _per_player_metrics(round1_preds)\n", + "round2_preds = _build_per_player_preds(round2_entries)\n", + "round2_agg, round2_n_convos = _aggregate_any(round2_preds)\n", + "round2_per_player = _per_player_metrics(round2_preds)\n", + "# metric mean over players (a different aggregation view)\n", + "def _mean_over_players(per_player):\n", + " keys = ['accuracy', 'precision', 'recall', 'f1', 'fpr', 'specificity', 'fnr']\n", + " return {k: float(np.mean([m[k] for m in per_player.values()])) for k in keys}\n", + "round1_mean_over_players = _mean_over_players(round1_per_player)\n", + "round2_mean_over_players = _mean_over_players(round2_per_player)\n", + "# printing\n", + "metric_order = ['accuracy', 'precision', 'recall', 'f1', 'fpr', 'specificity', 'fnr']\n", + "def _print_per_player(label, per_player):\n", + " print(f'{label} - per-player metrics:')\n", + " header = f\" {'player':<10}\" + \"\".join(f\"{m:>12}\" for m in metric_order) + f\"{'n_convos':>10}\"\n", + " print(header)\n", + " print(' ' + '-' * (len(header) - 2))\n", + " for player in sorted(per_player):\n", + " m = per_player[player]\n", + " n = m['tp'] + m['fp'] + m['tn'] + m['fn']\n", + " row = f\" {player:<10}\" + \"\".join(f\"{m[k]:>12.4f}\" for k in metric_order) + f\"{n:>10d}\"\n", + " print(row)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "68c5005a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "round 1 - per-player metrics:\n", + " player accuracy precision recall f1 fpr specificity fnr n_convos\n", + " --------------------------------------------------------------------------------------------------------\n", + " LJL2 0.8000 0.8000 0.8000 0.8000 0.2000 0.8000 0.2000 10\n", + " cd326 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", + " ex36 0.4000 0.3333 0.2000 0.2500 0.4000 0.6000 0.8000 10\n", + " kz88 0.7000 1.0000 0.4000 0.5714 0.0000 1.0000 0.6000 10\n", + " lyk25 0.7000 0.6667 0.8000 0.7273 0.4000 0.6000 0.2000 10\n", + " nac86 0.7000 1.0000 0.4000 0.5714 0.0000 1.0000 0.6000 10\n", + " sj597 0.8000 0.8000 0.8000 0.8000 0.2000 0.8000 0.2000 10\n", + " tg352 0.5000 0.5000 0.4000 0.4444 0.4000 0.6000 0.6000 10\n", + " vn72 0.4000 0.3333 0.2000 0.2500 0.4000 0.6000 0.8000 10\n", + "\n", + "round 2 - per-player metrics:\n", + " player accuracy precision recall f1 fpr specificity fnr n_convos\n", + " --------------------------------------------------------------------------------------------------------\n", + " LJL2 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", + " cd326 0.9000 1.0000 0.8000 0.8889 0.0000 1.0000 0.2000 10\n", + " ex36 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", + " kz88 0.4000 0.3333 0.2000 0.2500 0.4000 0.6000 0.8000 10\n", + " lyk25 0.9000 1.0000 0.8000 0.8889 0.0000 1.0000 0.2000 10\n", + " nac86 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", + " sj597 0.9000 1.0000 0.8000 0.8889 0.0000 1.0000 0.2000 10\n", + " tg352 0.7000 0.7500 0.6000 0.6667 0.2000 0.8000 0.4000 10\n", + " vn72 0.7000 0.7500 0.6000 0.6667 0.2000 0.8000 0.4000 10\n", + "\n", + "aggregate benchmark (gemma: mean±std over 5 seeds; humans: any-player rule + mean over players)\n", + "group accuracy precision recall f1 fpr specificity fnr\n", + "--------------------------------------------------------------------------------------------------------------------------------------\n", + "gemma (mean±std over seeds) 0.700±0.018 0.679±0.026 0.762±0.029 0.718±0.012 0.362±0.052 0.638±0.052 0.238±0.029\n", + "round1 humans (mean over players) 0.6222 0.6778 0.4889 0.5461 0.2444 0.7556 0.5111\n", + "round2 humans (mean over players) 0.7000 0.7593 0.5556 0.6389 0.1556 0.8444 0.4444\n", + "\n", + "round 1 unique convos: 84\n", + "round 2 unique convos: 84\n" + ] + } + ], + "source": [ + "pm = '\\u00b1'\n", + "metric_order = ['accuracy', 'precision', 'recall', 'f1', 'fpr', 'specificity', 'fnr']\n", + "\n", + "def _print_per_player(label, per_player):\n", + " print(f'{label} - per-player metrics:')\n", + " header = f\" {'player':<10}\" + \"\".join(f\"{m:>12}\" for m in metric_order) + f\"{'n_convos':>10}\"\n", + " print(header)\n", + " print(' ' + '-' * (len(header) - 2))\n", + " for player in sorted(per_player):\n", + " m = per_player[player]\n", + " n = m['tp'] + m['fp'] + m['tn'] + m['fn']\n", + " row = f\" {player:<10}\" + \"\".join(f\"{m[k]:>12.4f}\" for k in metric_order) + f\"{n:>10d}\"\n", + " print(row)\n", + "\n", + "_print_per_player('round 1', round1_per_player)\n", + "print()\n", + "_print_per_player('round 2', round2_per_player)\n", + "\n", + "print()\n", + "print(f'aggregate benchmark (gemma: mean{pm}std over 5 seeds; humans: any-player rule + mean over players)')\n", + "\n", + "header = f\"{'group':<36}\" + \"\".join(f\"{m:>14}\" for m in metric_order)\n", + "print(header)\n", + "print('-' * len(header))\n", + "\n", + "def _fmt_mean_std(mean_dict, std_dict):\n", + " return \"\".join(f\" {mean_dict[k]:.3f}{pm}{std_dict[k]:.3f}\" for k in metric_order)\n", + "\n", + "def _fmt_mean(mean_dict):\n", + " return \"\".join(f\"{mean_dict[k]:>14.4f}\" for k in metric_order)\n", + "\n", + "gemma_label = f'gemma (mean{pm}std over seeds)'\n", + "print(f\"{gemma_label:<36}\" + _fmt_mean_std(gemma_mean, gemma_std))\n", + "print(f\"{'round1 humans (mean over players)':<36}\" + _fmt_mean(round1_mean_over_players))\n", + "print(f\"{'round2 humans (mean over players)':<36}\" + _fmt_mean(round2_mean_over_players))\n", + "\n", + "print()\n", + "print(f'round 1 unique convos: {round1_n_convos}')\n", + "print(f'round 2 unique convos: {round2_n_convos}')" + ] + }, + { + "cell_type": "markdown", + "id": "9c68d1bd", + "metadata": {}, + "source": [ + "## Validation of forecast probability decrease" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5e527737", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pooled trigger_all current perf, best threshold per seed: 0.5532229185317815 (12359/22340)\n", + "pooled delayed_all best threshold per seed, k=7: 0.8353165159447882 (3510/4202)\n" + ] + } + ], + "source": [ + "import json\n", + "from pathlib import Path\n", + "from convokit import Corpus\n", + "\n", + "corpus_base = Path(\"/reef/lyk25/dynamic_training/game_analysis/corpi/test\")\n", + "config_base = Path(\"/reef/sqt2/FinalAAO/cga-cmv-large/google/gemma-2-9b-it\")\n", + "\n", + "corpus_dirs = sorted(\n", + " corpus_dir\n", + " for corpus_dir in corpus_base.rglob(\"*\")\n", + " if corpus_dir.is_dir() and (corpus_dir / \"index.json\").exists()\n", + ")\n", + "\n", + "if not corpus_dirs:\n", + " raise FileNotFoundError(f\"no convokit corpora found under {corpus_base}\")\n", + "\n", + "\n", + "def _test_seed_key(corpus_dir):\n", + " parent_name = corpus_dir.parent.name\n", + " if parent_name.startswith(\"test-seed-\"):\n", + " return parent_name\n", + " seed_idx = corpus_dir.name.rsplit(\"-\", 1)[-1]\n", + " return f\"test-seed-{seed_idx}\"\n", + "\n", + "\n", + "corpus_path_by_key = {}\n", + "for corpus_dir in corpus_dirs:\n", + " key = _test_seed_key(corpus_dir)\n", + " corpus_path_by_key[key] = corpus_dir\n", + "\n", + "\n", + "def is_calm_sim_forecast(forecast):\n", + " if isinstance(forecast, str):\n", + " forecast = forecast.strip().lower()\n", + " if forecast in {\"0\", \"false\", \"calm\"}:\n", + " return True\n", + " if forecast in {\"1\", \"true\", \"awry\"}:\n", + " return False\n", + " return int(forecast) == 0\n", + "\n", + "\n", + "def count_decreases_at_indices(corpus, get_indices):\n", + " total = 0\n", + " reduction = 0\n", + "\n", + " for convo in corpus.iter_conversations():\n", + " utts = convo.get_chronological_utterance_list()\n", + "\n", + " for i in get_indices(utts):\n", + " if i + 1 >= len(utts):\n", + " continue\n", + "\n", + " f1 = utts[i].meta[\"forecast_prob\"]\n", + " f2 = utts[i + 1].meta[\"forecast_prob\"]\n", + " total += 1\n", + "\n", + " if f1 > f2:\n", + " reduction += 1\n", + "\n", + " return reduction, total\n", + "\n", + "\n", + "def current_trigger_indices(utts, pred_threshold):\n", + " return [\n", + " i\n", + " for i, utt in enumerate(utts)\n", + " if utt.meta[\"forecast_prob\"] > pred_threshold\n", + " ]\n", + "\n", + "\n", + "def delayed_indices_from_sim_forecasts(utts, pred_threshold, k):\n", + " delayed = []\n", + "\n", + " for i, utt in enumerate(utts):\n", + " if utt.meta[\"forecast_prob\"] <= pred_threshold:\n", + " continue\n", + "\n", + " sim_forecasts = utt.meta[\"sim_replies_forecasts\"]\n", + " calm_sim_replies = sum(\n", + " 1 for forecast in sim_forecasts if is_calm_sim_forecast(forecast)\n", + " )\n", + "\n", + " if calm_sim_replies > k:\n", + " delayed.append(i)\n", + "\n", + " return delayed\n", + "\n", + "\n", + "current_reduction = 0\n", + "current_total = 0\n", + "delayed_reduction = 0\n", + "delayed_total = 0\n", + "\n", + "for seed in range(1, 6):\n", + " seed_key = f\"test-seed-{seed}\"\n", + " corpus = Corpus(filename=str(corpus_path_by_key[seed_key]))\n", + "\n", + " with open(config_base / f\"seed-{seed}\" / \"dev_config.json\") as f:\n", + " best_threshold = json.load(f)[\"best_threshold\"]\n", + "\n", + " r, t = count_decreases_at_indices(\n", + " corpus,\n", + " lambda utts: current_trigger_indices(utts, best_threshold),\n", + " )\n", + " current_reduction += r\n", + " current_total += t\n", + "\n", + " r, t = count_decreases_at_indices(\n", + " corpus,\n", + " lambda utts: delayed_indices_from_sim_forecasts(utts, best_threshold, k=7),\n", + " )\n", + " delayed_reduction += r\n", + " delayed_total += t\n", + "\n", + "pooled_trigger_all = current_reduction / current_total\n", + "pooled_delayed_all = delayed_reduction / delayed_total\n", + "\n", + "print(f\"pooled trigger_all current perf, best threshold per seed: {pooled_trigger_all} ({current_reduction}/{current_total})\")\n", + "print(f\"pooled delayed_all best threshold per seed, k=7: {pooled_delayed_all} ({delayed_reduction}/{delayed_total})\")" + ] + }, + { + "cell_type": "markdown", + "id": "cb154714", + "metadata": {}, + "source": [ + "## Calculating oracle threshold" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cba93b72", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] using 5 test-seed corpora: test-seed-1, test-seed-2, test-seed-3, test-seed-4, test-seed-5\n" + ] + } + ], + "source": [ + "# corpora comes from the decisionpolicy-demo download cell; use only test-seed- entries.\n", + "import re\n", + "\n", + "if \"corpora\" not in globals() or not corpora:\n", + " raise RuntimeError(\n", + " \"corpora is empty: run the download cell above first.\"\n", + " )\n", + "\n", + "_prev_keys = tuple(sorted(corpora))\n", + "_test_seed_re = re.compile(r\"^test-seed-(\\d+)$\")\n", + "\n", + "corpora = {\n", + " k: corpora[k]\n", + " for k in sorted(\n", + " (k for k in _prev_keys if _test_seed_re.match(k)),\n", + " key=lambda k: int(_test_seed_re.match(k).group(1)),\n", + " )\n", + "}\n", + "\n", + "if not corpora:\n", + " raise RuntimeError(\n", + " \"no test-seed- corpora after filter; had keys: \"\n", + " + \", \".join(_prev_keys)\n", + " )\n", + "\n", + "print(\n", + " f\"[info] using {len(corpora)} test-seed corpora: \"\n", + " + \", \".join(corpora)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3be18b5d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] per-seed best thresholds: {'test-seed-1': 0.5926666259765625, 'test-seed-2': 0.622459352016449, 'test-seed-3': 0.6513549089431763, 'test-seed-4': 0.6513549089431763, 'test-seed-5': 0.6513549089431763}\n", + "[info] mean best threshold: 0.633838\n", + "[info] generating baseline roc curve with 400 thresholds in [0.483838, 0.783838]\n", + "[info] testing k values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import json\n", + "\n", + "seed_best_thresholds = {\n", + " \"test-seed-1\": 0.5926666259765625,\n", + " \"test-seed-2\": 0.622459352016449,\n", + " \"test-seed-3\": 0.6513549089431763,\n", + " \"test-seed-4\": 0.6513549089431763,\n", + " \"test-seed-5\": 0.6513549089431763,\n", + "}\n", + "\n", + "mean_best_threshold = float(np.mean(list(seed_best_thresholds.values())))\n", + "search_radius = 0.15\n", + "num_thresholds = 400\n", + "baseline_thresholds = np.linspace(\n", + " mean_best_threshold - search_radius,\n", + " mean_best_threshold + search_radius,\n", + " num_thresholds,\n", + ")\n", + "\n", + "print(f\"[info] per-seed best thresholds: {seed_best_thresholds}\")\n", + "print(f\"[info] mean best threshold: {mean_best_threshold:.6f}\")\n", + "print(f\"[info] generating baseline roc curve with {len(baseline_thresholds)} thresholds in [{baseline_thresholds[0]:.6f}, {baseline_thresholds[-1]:.6f}]\")\n", + "\n", + "# k values to test for our method\n", + "k_values = list(range(1, 11)) # 1 to 10\n", + "print(f\"[info] testing k values: {k_values}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f6128fef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] computing baseline roc curves for all seeds...\n", + "\n", + "[info] processing test-son-seed-1...\n", + "[info] test-son-seed-1 baseline progress: 1/400\n", + "[info] test-son-seed-1 baseline progress: 21/400\n", + "[info] test-son-seed-1 baseline progress: 41/400\n", + "[info] test-son-seed-1 baseline progress: 61/400\n", + "[info] test-son-seed-1 baseline progress: 81/400\n", + "[info] test-son-seed-1 baseline progress: 101/400\n", + "[info] test-son-seed-1 baseline progress: 121/400\n", + "[info] test-son-seed-1 baseline progress: 141/400\n", + "[info] test-son-seed-1 baseline progress: 161/400\n", + "[info] test-son-seed-1 baseline progress: 181/400\n", + "[info] test-son-seed-1 baseline progress: 201/400\n", + "[info] test-son-seed-1 baseline progress: 221/400\n", + "[info] test-son-seed-1 baseline progress: 241/400\n", + "[info] test-son-seed-1 baseline progress: 261/400\n", + "[info] test-son-seed-1 baseline progress: 281/400\n", + "[info] test-son-seed-1 baseline progress: 301/400\n", + "[info] test-son-seed-1 baseline progress: 321/400\n", + "[info] test-son-seed-1 baseline progress: 341/400\n", + "[info] test-son-seed-1 baseline progress: 361/400\n", + "[info] test-son-seed-1 baseline progress: 381/400\n", + "[pass] test-son-seed-1 baseline complete - 400 points\n", + "\n", + "[info] processing test-son-seed-2...\n", + "[info] test-son-seed-2 baseline progress: 1/400\n", + "[info] test-son-seed-2 baseline progress: 21/400\n", + "[info] test-son-seed-2 baseline progress: 41/400\n", + "[info] test-son-seed-2 baseline progress: 61/400\n", + "[info] test-son-seed-2 baseline progress: 81/400\n", + "[info] test-son-seed-2 baseline progress: 101/400\n", + "[info] test-son-seed-2 baseline progress: 121/400\n", + "[info] test-son-seed-2 baseline progress: 141/400\n", + "[info] test-son-seed-2 baseline progress: 161/400\n", + "[info] test-son-seed-2 baseline progress: 181/400\n", + "[info] test-son-seed-2 baseline progress: 201/400\n", + "[info] test-son-seed-2 baseline progress: 221/400\n", + "[info] test-son-seed-2 baseline progress: 241/400\n", + "[info] test-son-seed-2 baseline progress: 261/400\n", + "[info] test-son-seed-2 baseline progress: 281/400\n", + "[info] test-son-seed-2 baseline progress: 301/400\n", + "[info] test-son-seed-2 baseline progress: 321/400\n", + "[info] test-son-seed-2 baseline progress: 341/400\n", + "[info] test-son-seed-2 baseline progress: 361/400\n", + "[info] test-son-seed-2 baseline progress: 381/400\n", + "[pass] test-son-seed-2 baseline complete - 400 points\n", + "\n", + "[info] processing test-son-seed-3...\n", + "[info] test-son-seed-3 baseline progress: 1/400\n", + "[info] test-son-seed-3 baseline progress: 21/400\n", + "[info] test-son-seed-3 baseline progress: 41/400\n", + "[info] test-son-seed-3 baseline progress: 61/400\n", + "[info] test-son-seed-3 baseline progress: 81/400\n", + "[info] test-son-seed-3 baseline progress: 101/400\n", + "[info] test-son-seed-3 baseline progress: 121/400\n", + "[info] test-son-seed-3 baseline progress: 141/400\n", + "[info] test-son-seed-3 baseline progress: 161/400\n", + "[info] test-son-seed-3 baseline progress: 181/400\n", + "[info] test-son-seed-3 baseline progress: 201/400\n", + "[info] test-son-seed-3 baseline progress: 221/400\n", + "[info] test-son-seed-3 baseline progress: 241/400\n", + "[info] test-son-seed-3 baseline progress: 261/400\n", + "[info] test-son-seed-3 baseline progress: 281/400\n", + "[info] test-son-seed-3 baseline progress: 301/400\n", + "[info] test-son-seed-3 baseline progress: 321/400\n", + "[info] test-son-seed-3 baseline progress: 341/400\n", + "[info] test-son-seed-3 baseline progress: 361/400\n", + "[info] test-son-seed-3 baseline progress: 381/400\n", + "[pass] test-son-seed-3 baseline complete - 400 points\n", + "\n", + "[info] processing test-son-seed-4...\n", + "[info] test-son-seed-4 baseline progress: 1/400\n", + "[info] test-son-seed-4 baseline progress: 21/400\n", + "[info] test-son-seed-4 baseline progress: 41/400\n", + "[info] test-son-seed-4 baseline progress: 61/400\n", + "[info] test-son-seed-4 baseline progress: 81/400\n", + "[info] test-son-seed-4 baseline progress: 101/400\n", + "[info] test-son-seed-4 baseline progress: 121/400\n", + "[info] test-son-seed-4 baseline progress: 141/400\n", + "[info] test-son-seed-4 baseline progress: 161/400\n", + "[info] test-son-seed-4 baseline progress: 181/400\n", + "[info] test-son-seed-4 baseline progress: 201/400\n", + "[info] test-son-seed-4 baseline progress: 221/400\n", + "[info] test-son-seed-4 baseline progress: 241/400\n", + "[info] test-son-seed-4 baseline progress: 261/400\n", + "[info] test-son-seed-4 baseline progress: 281/400\n", + "[info] test-son-seed-4 baseline progress: 301/400\n", + "[info] test-son-seed-4 baseline progress: 321/400\n", + "[info] test-son-seed-4 baseline progress: 341/400\n", + "[info] test-son-seed-4 baseline progress: 361/400\n", + "[info] test-son-seed-4 baseline progress: 381/400\n", + "[pass] test-son-seed-4 baseline complete - 400 points\n", + "\n", + "[info] processing test-son-seed-5...\n", + "[info] test-son-seed-5 baseline progress: 1/400\n", + "[info] test-son-seed-5 baseline progress: 21/400\n", + "[info] test-son-seed-5 baseline progress: 41/400\n", + "[info] test-son-seed-5 baseline progress: 61/400\n", + "[info] test-son-seed-5 baseline progress: 81/400\n", + "[info] test-son-seed-5 baseline progress: 101/400\n", + "[info] test-son-seed-5 baseline progress: 121/400\n", + "[info] test-son-seed-5 baseline progress: 141/400\n", + "[info] test-son-seed-5 baseline progress: 161/400\n", + "[info] test-son-seed-5 baseline progress: 181/400\n", + "[info] test-son-seed-5 baseline progress: 201/400\n", + "[info] test-son-seed-5 baseline progress: 221/400\n", + "[info] test-son-seed-5 baseline progress: 241/400\n", + "[info] test-son-seed-5 baseline progress: 261/400\n", + "[info] test-son-seed-5 baseline progress: 281/400\n", + "[info] test-son-seed-5 baseline progress: 301/400\n", + "[info] test-son-seed-5 baseline progress: 321/400\n", + "[info] test-son-seed-5 baseline progress: 341/400\n", + "[info] test-son-seed-5 baseline progress: 361/400\n", + "[info] test-son-seed-5 baseline progress: 381/400\n", + "[pass] test-son-seed-5 baseline complete - 400 points\n", + "\n", + "[pass] all baseline roc curves computed for 5 seeds\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from convokit.decisionpolicy import ThresholdDecisionPolicy\n", + "from convokit.forecaster.forecaster import ContextTuple\n", + "\n", + "\n", + "def _cached_forecast_score(context):\n", + " meta = getattr(context.current_utterance, \"meta\", {}) or {}\n", + " if \"forecast_prob\" not in meta:\n", + " raise KeyError(f\"missing forecast_prob for utterance {context.current_utterance.id}\")\n", + " return meta[\"forecast_prob\"]\n", + "\n", + "\n", + "def _threshold_policy_performance(corpus, policy):\n", + " tp = fp = tn = fn = 0\n", + " horizons = []\n", + "\n", + " for convo in corpus.iter_conversations():\n", + " utts = convo.get_chronological_utterance_list()\n", + " pred = 0\n", + " first_trigger_idx = None\n", + "\n", + " for utt_idx, utt in enumerate(utts):\n", + " context = ContextTuple(\n", + " context=utts[: utt_idx + 1],\n", + " current_utterance=utt,\n", + " future_context=utts[utt_idx + 1 :],\n", + " conversation_id=convo.id,\n", + " )\n", + " _, utt_pred = policy.decide(context, _cached_forecast_score)\n", + " if int(utt_pred) == 1:\n", + " pred = 1\n", + " first_trigger_idx = utt_idx\n", + " break\n", + "\n", + " truth = bool(convo.meta.get(\"has_removed_comment\", False))\n", + " if pred and truth:\n", + " tp += 1\n", + " horizons.append(len(utts) - first_trigger_idx)\n", + " elif pred and not truth:\n", + " fp += 1\n", + " elif not pred and not truth:\n", + " tn += 1\n", + " else:\n", + " fn += 1\n", + "\n", + " h = float(np.mean(horizons)) - 1 if horizons else float(\"nan\")\n", + " return {\n", + " \"confusion_matrix\": {\"TP\": tp, \"FP\": fp, \"TN\": tn, \"FN\": fn},\n", + " \"h\": h,\n", + " }\n", + "\n", + "\n", + "# step 1: compute baseline roc curve with ThresholdDecisionPolicy\n", + "print(\"[info] computing baseline roc curves for all seeds...\")\n", + "all_baseline_results = {}\n", + "\n", + "for seed_name, corpus in corpora.items():\n", + " print(f\"\\n[info] processing {seed_name}...\")\n", + " baseline_results = []\n", + "\n", + " for i, threshold in enumerate(baseline_thresholds):\n", + " if i % 20 == 0:\n", + " print(f\"[info] {seed_name} baseline progress: {i+1}/{len(baseline_thresholds)}\")\n", + "\n", + " policy = ThresholdDecisionPolicy(threshold=threshold)\n", + " results = _threshold_policy_performance(corpus, policy)\n", + " tp = results[\"confusion_matrix\"][\"TP\"]\n", + " fp = results[\"confusion_matrix\"][\"FP\"]\n", + " tn = results[\"confusion_matrix\"][\"TN\"]\n", + " fn = results[\"confusion_matrix\"][\"FN\"]\n", + "\n", + " # calculate tpr, fpr, accuracy, precision, recall, f1\n", + " # recall == tpr; kept as a separate field for downstream readability\n", + " tpr = tp / (tp + fn) if (tp + fn) > 0 else 0\n", + " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0\n", + " total = tp + fp + tn + fn\n", + " accuracy = (tp + tn) / total if total > 0 else 0\n", + " precision = tp / (tp + fp) if (tp + fp) > 0 else 0\n", + " recall = tpr\n", + " f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n", + "\n", + " baseline_results.append({\n", + " \"seed\": seed_name,\n", + " \"threshold\": threshold,\n", + " \"tpr\": tpr,\n", + " \"fpr\": fpr,\n", + " \"accuracy\": accuracy,\n", + " \"precision\": precision,\n", + " \"recall\": recall,\n", + " \"f1\": f1,\n", + " \"h\": results.get(\"h\", float(\"nan\")),\n", + " \"tp\": tp,\n", + " \"fp\": fp,\n", + " \"tn\": tn,\n", + " \"fn\": fn,\n", + " })\n", + "\n", + " all_baseline_results[seed_name] = pd.DataFrame(baseline_results)\n", + " print(f\"[pass] {seed_name} baseline complete - {len(all_baseline_results[seed_name])} points\")\n", + "\n", + "print(f\"\\n[pass] all baseline roc curves computed for {len(all_baseline_results)} seeds\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "022d240f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] all_baseline_results has been pickled to all_baseline_results.pkl\n" + ] + } + ], + "source": [ + "import pickle\n", + "\n", + "with open('all_baseline_results.pkl', 'wb') as f:\n", + " pickle.dump(all_baseline_results, f)\n", + "print(\"[info] all_baseline_results has been pickled to all_baseline_results.pkl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "aa6450a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[info] processing test-son-seed-1...\n", + "[info] config seed: seed-1\n", + "[info] k method threshold 0.5926666259765625\n", + "[info] test-son-seed-1 computing k=1...\n", + "[info] test-son-seed-1 computing k=2...\n", + "[info] test-son-seed-1 computing k=3...\n", + "[info] test-son-seed-1 computing k=4...\n", + "[info] test-son-seed-1 computing k=5...\n", + "[info] test-son-seed-1 computing k=6...\n", + "[info] test-son-seed-1 computing k=7...\n", + "[info] test-son-seed-1 computing k=8...\n", + "[info] test-son-seed-1 computing k=9...\n", + "[info] test-son-seed-1 computing k=10...\n", + "[pass] test-son-seed-1 k-method complete - 10 points\n", + "\n", + "[info] processing test-son-seed-2...\n", + "[info] config seed: seed-2\n", + "[info] k method threshold 0.622459352016449\n", + "[info] test-son-seed-2 computing k=1...\n", + "[info] test-son-seed-2 computing k=2...\n", + "[info] test-son-seed-2 computing k=3...\n", + "[info] test-son-seed-2 computing k=4...\n", + "[info] test-son-seed-2 computing k=5...\n", + "[info] test-son-seed-2 computing k=6...\n", + "[info] test-son-seed-2 computing k=7...\n", + "[info] test-son-seed-2 computing k=8...\n", + "[info] test-son-seed-2 computing k=9...\n", + "[info] test-son-seed-2 computing k=10...\n", + "[pass] test-son-seed-2 k-method complete - 10 points\n", + "\n", + "[info] processing test-son-seed-3...\n", + "[info] config seed: seed-3\n", + "[info] k method threshold 0.6513549089431763\n", + "[info] test-son-seed-3 computing k=1...\n", + "[info] test-son-seed-3 computing k=2...\n", + "[info] test-son-seed-3 computing k=3...\n", + "[info] test-son-seed-3 computing k=4...\n", + "[info] test-son-seed-3 computing k=5...\n", + "[info] test-son-seed-3 computing k=6...\n", + "[info] test-son-seed-3 computing k=7...\n", + "[info] test-son-seed-3 computing k=8...\n", + "[info] test-son-seed-3 computing k=9...\n", + "[info] test-son-seed-3 computing k=10...\n", + "[pass] test-son-seed-3 k-method complete - 10 points\n", + "\n", + "[info] processing test-son-seed-4...\n", + "[info] config seed: seed-4\n", + "[info] k method threshold 0.6513549089431763\n", + "[info] test-son-seed-4 computing k=1...\n", + "[info] test-son-seed-4 computing k=2...\n", + "[info] test-son-seed-4 computing k=3...\n", + "[info] test-son-seed-4 computing k=4...\n", + "[info] test-son-seed-4 computing k=5...\n", + "[info] test-son-seed-4 computing k=6...\n", + "[info] test-son-seed-4 computing k=7...\n", + "[info] test-son-seed-4 computing k=8...\n", + "[info] test-son-seed-4 computing k=9...\n", + "[info] test-son-seed-4 computing k=10...\n", + "[pass] test-son-seed-4 k-method complete - 10 points\n", + "\n", + "[info] processing test-son-seed-5...\n", + "[info] config seed: seed-5\n", + "[info] k method threshold 0.6513549089431763\n", + "[info] test-son-seed-5 computing k=1...\n", + "[info] test-son-seed-5 computing k=2...\n", + "[info] test-son-seed-5 computing k=3...\n", + "[info] test-son-seed-5 computing k=4...\n", + "[info] test-son-seed-5 computing k=5...\n", + "[info] test-son-seed-5 computing k=6...\n", + "[info] test-son-seed-5 computing k=7...\n", + "[info] test-son-seed-5 computing k=8...\n", + "[info] test-son-seed-5 computing k=9...\n", + "[info] test-son-seed-5 computing k=10...\n", + "[pass] test-son-seed-5 k-method complete - 10 points\n", + "\n", + "[pass] all k-method results computed for 5 seeds\n" + ] + } + ], + "source": [ + "import json\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from convokit.decisionpolicy import DeferralDecisionPolicy\n", + "from convokit.forecaster.forecaster import ContextTuple\n", + "\n", + "\n", + "def _cached_forecast_score(context):\n", + " meta = getattr(context.current_utterance, \"meta\", {}) or {}\n", + " if \"forecast_prob\" not in meta:\n", + " raise KeyError(f\"missing forecast_prob for utterance {context.current_utterance.id}\")\n", + " return meta[\"forecast_prob\"]\n", + "\n", + "\n", + "def _deferral_policy_performance(corpus, policy):\n", + " tp = fp = tn = fn = 0\n", + " horizons = []\n", + "\n", + " for convo in corpus.iter_conversations():\n", + " utts = convo.get_chronological_utterance_list()\n", + " pred = 0\n", + " first_trigger_idx = None\n", + "\n", + " for utt_idx, utt in enumerate(utts):\n", + " context = ContextTuple(\n", + " context=utts[: utt_idx + 1],\n", + " current_utterance=utt,\n", + " future_context=utts[utt_idx + 1 :],\n", + " conversation_id=convo.id,\n", + " )\n", + " result = policy.decide(context, _cached_forecast_score)\n", + " utt_pred = int(result[1])\n", + " if utt_pred == 1:\n", + " pred = 1\n", + " first_trigger_idx = utt_idx\n", + " break\n", + "\n", + " truth = bool(convo.meta.get(\"has_removed_comment\", False))\n", + " if pred and truth:\n", + " tp += 1\n", + " horizons.append(len(utts) - first_trigger_idx)\n", + " elif pred and not truth:\n", + " fp += 1\n", + " elif not pred and not truth:\n", + " tn += 1\n", + " else:\n", + " fn += 1\n", + "\n", + " h = float(np.mean(horizons)) - 1 if horizons else float(\"nan\")\n", + " return {\n", + " \"confusion_matrix\": {\"TP\": tp, \"FP\": fp, \"TN\": tn, \"FN\": fn},\n", + " \"h\": h,\n", + " }\n", + "\n", + "\n", + "all_k_results = {}\n", + "\n", + "for seed_name, corpus in corpora.items():\n", + " print(f\"\\n[info] processing {seed_name}...\")\n", + " k_results = []\n", + "\n", + " pruned_seed_name = seed_name[len(seed_name) - 6 :]\n", + " print(f\"[info] config seed: {pruned_seed_name}\")\n", + "\n", + " with open(f\"/reef/sqt2/FinalAAO/cga-cmv-large/google/gemma-2-9b-it/{pruned_seed_name}/dev_config.json\", \"r\") as f:\n", + " dev_config = json.load(f)\n", + "\n", + " k_method_threshold = dev_config[\"best_threshold\"]\n", + " print(\"[info] k method threshold\", k_method_threshold)\n", + "\n", + " for k in k_values:\n", + " print(f\"[info] {seed_name} computing k={k}...\")\n", + " policy = DeferralDecisionPolicy(\n", + " simulator=None,\n", + " threshold=k_method_threshold,\n", + " tau=k,\n", + " num_simulations=10,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " reuse_cached_simulations=True,\n", + " )\n", + " results = _deferral_policy_performance(corpus, policy)\n", + " tp = results[\"confusion_matrix\"][\"TP\"]\n", + " fp = results[\"confusion_matrix\"][\"FP\"]\n", + " tn = results[\"confusion_matrix\"][\"TN\"]\n", + " fn = results[\"confusion_matrix\"][\"FN\"]\n", + "\n", + " # calculate tpr, fpr, accuracy, precision, recall, f1\n", + " # recall == tpr; kept as a separate field for downstream readability\n", + " tpr = tp / (tp + fn) if (tp + fn) > 0 else 0\n", + " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0\n", + " total = tp + fp + tn + fn\n", + " accuracy = (tp + tn) / total if total > 0 else 0\n", + " precision = tp / (tp + fp) if (tp + fp) > 0 else 0\n", + " recall = tpr\n", + " f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n", + "\n", + " k_results.append({\n", + " \"seed\": seed_name,\n", + " \"k\": k,\n", + " \"threshold\": k_method_threshold,\n", + " \"tpr\": tpr,\n", + " \"fpr\": fpr,\n", + " \"accuracy\": accuracy,\n", + " \"precision\": precision,\n", + " \"recall\": recall,\n", + " \"f1\": f1,\n", + " \"h\": results.get(\"h\", float(\"nan\")),\n", + " \"tp\": tp,\n", + " \"fp\": fp,\n", + " \"tn\": tn,\n", + " \"fn\": fn,\n", + " })\n", + "\n", + " all_k_results[seed_name] = pd.DataFrame(k_results)\n", + " print(f\"[pass] {seed_name} k-method complete - {len(all_k_results[seed_name])} points\")\n", + "\n", + "print(f\"\\n[pass] all k-method results computed for {len(all_k_results)} seeds\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "bba8d667", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] matching fprs for all seeds...\n", + "\n", + "[info] matching fprs for test-son-seed-1...\n", + "[PASS] test-son-seed-1 matched 10 fpr points\n", + "\n", + "[info] matching fprs for test-son-seed-2...\n", + "[PASS] test-son-seed-2 matched 10 fpr points\n", + "\n", + "[info] matching fprs for test-son-seed-3...\n", + "[PASS] test-son-seed-3 matched 10 fpr points\n", + "\n", + "[info] matching fprs for test-son-seed-4...\n", + "[PASS] test-son-seed-4 matched 10 fpr points\n", + "\n", + "[info] matching fprs for test-son-seed-5...\n", + "[PASS] test-son-seed-5 matched 10 fpr points\n", + "\n", + "[PASS] all matching complete for 5 seeds\n" + ] + } + ], + "source": [ + "# step 3: for each k's FPR, find the closest baseline FPR (per seed)\n", + "print(\"[info] matching fprs for all seeds...\")\n", + "all_matched_results = {}\n", + "\n", + "for seed_name in corpora.keys():\n", + " print(f\"\\n[info] matching fprs for {seed_name}...\")\n", + " matched_results = []\n", + " \n", + " k_df = all_k_results[seed_name]\n", + " baseline_df = all_baseline_results[seed_name]\n", + " \n", + " for _, k_row in k_df.iterrows():\n", + " k_fpr = k_row['fpr']\n", + " k_tpr = k_row['tpr']\n", + " k_val = k_row['k']\n", + " \n", + " # find closest baseline fpr\n", + " fpr_diffs = np.abs(baseline_df['fpr'] - k_fpr)\n", + " closest_idx = fpr_diffs.idxmin()\n", + " baseline_match = baseline_df.iloc[closest_idx]\n", + " \n", + " matched_results.append({\n", + " 'seed': seed_name,\n", + " 'k': k_val,\n", + " 'k_fpr': k_fpr,\n", + " 'k_tpr': k_tpr,\n", + " 'baseline_fpr': baseline_match['fpr'],\n", + " 'baseline_tpr': baseline_match['tpr'],\n", + " 'baseline_accuracy': baseline_match['accuracy'],\n", + " 'baseline_precision': baseline_match['precision'],\n", + " 'baseline_recall': baseline_match['recall'],\n", + " 'baseline_f1': baseline_match['f1'],\n", + " 'baseline_h': baseline_match['h'],\n", + " 'baseline_threshold': baseline_match['threshold'],\n", + " 'fpr_diff': abs(k_fpr - baseline_match['fpr']),\n", + " 'tpr_improvement': k_tpr - baseline_match['tpr']\n", + " })\n", + " \n", + " all_matched_results[seed_name] = pd.DataFrame(matched_results)\n", + " print(f\"[PASS] {seed_name} matched {len(all_matched_results[seed_name])} fpr points\")\n", + "\n", + "print(f\"\\n[PASS] all matching complete for {len(all_matched_results)} seeds\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "95588d73", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] matched fpr-oracle metrics for tau=7 (mean ± std over seeds, n=5):\n", + " tau baseline_accuracy_mean baseline_accuracy_std baseline_precision_mean baseline_precision_std baseline_recall_mean baseline_recall_std baseline_f1_mean baseline_f1_std baseline_h_mean baseline_h_std fpr_diff_mean fpr_diff_std tpr_improvement_mean tpr_improvement_std baseline_threshold_mean baseline_threshold_std baseline_fpr_mean baseline_fpr_std baseline_tpr_mean baseline_tpr_std\n", + " 7 0.7002 0.0088 0.7152 0.0100 0.6677 0.0494 0.6896 0.0218 2.6965 0.1029 0.0036 0.0028 0.0155 0.0055 0.6900 0.0245 0.2674 0.0331 0.6677 0.0494\n" + ] + } + ], + "source": [ + "# average matched-baseline (oracle) metrics for tau=7, across all seeds\n", + "target_tau = 7\n", + "matched_long = pd.concat(\n", + " [df.assign(seed=seed_name) for seed_name, df in all_matched_results.items()],\n", + " ignore_index=True,\n", + ")\n", + "matched_long = matched_long[matched_long[\"k\"] == target_tau].copy()\n", + "\n", + "if matched_long.empty:\n", + " raise ValueError(f\"no matched results found for tau={target_tau}\")\n", + "\n", + "oracle_cols = [\n", + " \"baseline_accuracy\",\n", + " \"baseline_precision\",\n", + " \"baseline_recall\",\n", + " \"baseline_f1\",\n", + " \"baseline_h\",\n", + " \"fpr_diff\",\n", + " \"tpr_improvement\",\n", + " \"baseline_threshold\",\n", + " \"baseline_fpr\",\n", + " \"baseline_tpr\",\n", + "]\n", + "\n", + "oracle_stats_per_tau = (\n", + " matched_long.groupby(\"k\")[oracle_cols]\n", + " .agg([\"mean\", \"std\"])\n", + " .reset_index()\n", + " .rename(columns={\"k\": \"tau\"})\n", + ")\n", + "\n", + "# reformat columns to single-level, e.g. baseline_fpr_mean\n", + "oracle_stats_per_tau.columns = [\"tau\"] + [\n", + " f\"{col}_{stat}\" for col in oracle_cols for stat in [\"mean\", \"std\"]\n", + "]\n", + "\n", + "with pd.option_context(\n", + " \"display.float_format\",\n", + " \"{:.4f}\".format,\n", + " \"display.max_columns\",\n", + " None,\n", + " \"display.width\",\n", + " 200,\n", + "):\n", + " print(\"[info] matched fpr-oracle metrics for tau=7 \"\n", + " f\"(mean ± std over seeds, n={matched_long['seed'].nunique()}):\")\n", + " print(oracle_stats_per_tau.to_string(index=False))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "lyk25-env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" } - ], - "source": [ - "simulator_model = UnslothUtteranceSimulatorModel(\n", - " model_name=\"/reef/lyk25/dynamic_training/game_analysis/outputs/checkpoint-74\",\n", - " train_config=SIMULATOR_TRAIN_CONFIG,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "fe147ae8", - "metadata": {}, - "source": [ - "After loading the simulator model, we define context selectors." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "a9502041", - "metadata": {}, - "outputs": [], - "source": [ - "def context_selector(context_tuple, split):\n", - " \"\"\"\n", - " We use this generic function for both training and validation data.\n", - " In both cases, its job is to select only those contexts for which the\n", - " FUTURE context is not empty, so we have a next utterance to predict.\n", - " \"\"\"\n", - " matches_split = (context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split)\n", - " is_end = (len(context_tuple.future_context) == 0)\n", - " return matches_split and not is_end\n", - "\n", - "def make_data_selector(split):\n", - " return lambda context_tuple: context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split\n", - "\n", - "train_context_selector = partial(context_selector, split=\"train\")\n", - "val_context_selector = partial(context_selector, split=\"val\")\n", - "test_context_selector = partial(context_selector, split=\"test\")" - ] - }, - { - "cell_type": "markdown", - "id": "f707a3a5", - "metadata": {}, - "source": [ - "Below is a script to fully reproduce, sans regenerating simulations (which takes substantially longer)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "dde130ed", - "metadata": {}, - "outputs": [], - "source": [ - "for seed_idx in SEEDS:\n", - " train_corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", - " corpus = Corpus(filename=f'/reef/lyk25/theres-a-way-out-ACL26-internal/outputs/benchmark_preannotated/seed-{seed_idx}-ThresholdDecisionPolicy/ThresholdDecisionPolicy')\n", - " # corpus = Corpus(filename=f'/reef/lyk25/dynamic_training/game_analysis/corpi/test/test-son-seed-{seed_idx}')\n", - "\n", - " config = TransformerForecasterConfig(\n", - " output_dir=f\"outputs/{OUTPUT_DIR}/forecaster_{seed_idx}\",\n", - " per_device_batch_size=16,\n", - " gradient_accumulation_steps=1,\n", - " num_train_epochs=1,\n", - " learning_rate=1e-5,\n", - " random_seed=seed_idx,\n", - " context_mode=\"normal\",\n", - " device=\"cuda\",\n", - " )\n", - "\n", - " # TODO this will have to be edited\n", - " forecaster_model = TransformerDecoderModel(\n", - " model_name_or_path=\"google/gemma-2-9b-it\",\n", - " config=config,\n", - " )\n", - "\n", - " forecaster = Forecaster(\n", - " forecaster_model=forecaster_model,\n", - " labeler='has_removed_comment',\n", - " )\n", - "\n", - " forecaster.fit_belief_estimator(\n", - " corpus=train_corpus,\n", - " context_selector=train_context_selector,\n", - " val_context_selector=val_context_selector,\n", - " )\n", - "\n", - "\n", - "\n", - " # ---\n", - " cfg_path = os.path.join(repo_root, \"saves\", f\"seed-{seed_idx}\", \"dev_config.json\")\n", - " with open(cfg_path) as f:\n", - " cfg = json.load(f)\n", - " best_threshold = cfg['best_threshold']\n", - "\n", - " for policy_trial in [ThresholdDecisionPolicy, DeferralDecisionPolicy]:\n", - " print('---')\n", - " print(f\"Fitting policy {policy_trial.__name__} for seed {seed_idx}\")\n", - " if policy_trial == ThresholdDecisionPolicy:\n", - " policy = ThresholdDecisionPolicy(\n", - " threshold=best_threshold,\n", - " reuse_cached_forecast_probs=False,\n", - " )\n", - " elif policy_trial == DeferralDecisionPolicy:\n", - " policy = DeferralDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " tau=TAU,\n", - " reuse_cached_forecast_probs=False,\n", - " )\n", - " elif policy_trial == RandomDeferralDecisionPolicy:\n", - " policy = RandomDeferralDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " deferral_probability=DEFERRAL_PROBABILITY_THRESHOLD,\n", - " reuse_cached_forecast_probs=False,\n", - " )\n", - " elif policy_trial == SimulationAverageDecisionPolicy:\n", - " policy = SimulationAverageDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " num_simulations=NUM_SIMULATIONS,\n", - " store_simulations=False,\n", - " simulated_reply_attribute_name=\"sim_replies\",\n", - " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", - " reuse_cached_forecast_probs=False,\n", - " )\n", - " elif policy_trial == SimulationMajorityDecisionPolicy:\n", - " policy = SimulationMajorityDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " tau=TAU,\n", - " num_simulations=NUM_SIMULATIONS,\n", - " store_simulations=False,\n", - " simulated_reply_attribute_name=\"sim_replies\",\n", - " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", - " reuse_cached_forecast_probs=False,\n", - " )\n", - " \n", - " # attach the decision policy to the underlying forecaster model;\n", - " # Forecaster itself does not accept decision_policy in its constructor.\n", - " forecaster_model.decision_policy = policy\n", - "\n", - " forecaster = Forecaster(\n", - " forecaster_model=forecaster_model,\n", - " labeler='has_removed_comment',\n", - " )\n", - "\n", - " print('starting transformation.')\n", - " # evaluate the forecaster on the test set\n", - " forecaster.transform(\n", - " corpus=corpus,\n", - " context_selector=make_data_selector('test'),\n", - " verbose=True,\n", - " )\n", - " print('transformation complete.')\n", - "\n", - " output_dir = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", - " os.makedirs(output_dir, exist_ok=True)\n", - " corpus.dump(name=f\"{policy_trial.__name__}\", base_path=output_dir)\n", - " print('corpus dumped.')\n", - "\n", - " print('starting summarization.')\n", - " # forecaster.summarize expects a conversation-level selector (Callable[[Conversation], bool]),\n", - " # unlike the context-tuple selectors used in fit/transform.\n", - " def summarize_selector(convo):\n", - " return convo.meta.get(\"split\") == \"test\"\n", - " conversational_forecasts_df, metrics = forecaster.summarize(\n", - " corpus=corpus,\n", - " selector=summarize_selector,\n", - " )\n", - " print('summarization complete.')\n", - " \n", - " # path to the seed output directory\n", - " seed_folder = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", - "\n", - " # ensure the directory exists\n", - " os.makedirs(seed_folder, exist_ok=True)\n", - "\n", - " # save conversational_forecasts_df as CSV\n", - " conversational_forecasts_df.to_csv(os.path.join(seed_folder, \"conversational_forecasts.csv\"), index=False)\n", - "\n", - " # save metrics as JSON\n", - " with open(os.path.join(seed_folder, \"metrics.json\"), \"w\") as f:\n", - " json.dump(metrics, f, indent=2)" - ] - }, - { - "cell_type": "markdown", - "id": "e3c6f428", - "metadata": {}, - "source": [ - "A faster reproduction is possible by skipping the training and transformation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2f4a29c2", - "metadata": {}, - "outputs": [], - "source": [ - "# TODO insert code here to download all" - ] - }, - { - "cell_type": "markdown", - "id": "29a0cdc1", - "metadata": {}, - "source": [ - "# Human Data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d673d0d6", - "metadata": {}, - "outputs": [], - "source": [ - "# import human data SQL here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d55b3bab", - "metadata": {}, - "outputs": [], - "source": [ - "import sqlite3" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "92766a80", - "metadata": {}, - "outputs": [], - "source": [ - "# connect to the game database\n", - "db_path = '/reef/sqt2/cga-eval/human/game_db.sqlite'\n", - "connection = sqlite3.connect(db_path)\n", - "cursor = connection.cursor()\n", - "\n", - "print(f\"[info] connected to database: {db_path}\")\n", - "cursor.execute(\"SELECT COUNT(*) FROM results\")\n", - "\n", - "# # names_list = []\n", - "# # answers_list = []\n", - "# # scores_list = []\n", - "# # comments_list = []\n", - "\n", - "# TIME_CUTOFF = 1714059814630 # timestamp to cut off previous results\n", - "# TIME_CUTOFF_END = 1730385762530\n", - "\n", - "# for row in connection.execute('SELECT * FROM results'):\n", - "# if row[0] != 'yc2727' and row[0] != 'sqt2':\n", - "# answers = json.loads(row[1])\n", - "# if answers[0]['start_time'] > TIME_CUTOFF and answers[0]['start_time'] < TIME_CUTOFF_END:\n", - "# names_list.append(row[0])\n", - "# answers_list.append(answers)\n", - "# scores_list.append(row[2])\n", - "# comments_list.append(row[3])\n", - "\n", - "if round_n == 1:\n", - " # for round_n 1\n", - " names_list_1 = []\n", - " answers_list_1 = []\n", - " scores_list_1 = []\n", - " comments_list_1 = []\n", - "\n", - " TIME_CUTOFF_1 = 1730395000000\n", - " TIME_CUTOFF_END_1 = 1730397199000\n", - "\n", - " for row in connection.execute('SELECT * FROM results'):\n", - " if row[0] != 'yc2727' and row[0] != 'sqt2':\n", - " answers = json.loads(row[1])\n", - " if answers[0]['start_time'] > TIME_CUTOFF_1 and answers[0]['start_time'] < TIME_CUTOFF_END_1:\n", - " names_list_1.append(row[0])\n", - " answers_list_1.append(answers)\n", - " scores_list_1.append(row[2])\n", - " comments_list_1.append(row[3])\n", - "elif round_n == 2:\n", - " # for round 2\n", - " names_list_2 = []\n", - " answers_list_2 = []\n", - " scores_list_2 = []\n", - " comments_list_2 = []\n", - "\n", - " TIME_CUTOFF_2_a = 1731002910000\n", - " TIME_CUTOFF_END_2_a = 1731016180000\n", - "\n", - " for row in connection.execute('SELECT * FROM results'):\n", - " if row[0] != 'yc2727' and row[0] != 'sqt2':\n", - " answers = json.loads(row[1])\n", - " if answers[0]['start_time'] > TIME_CUTOFF_2_a and answers[0]['start_time'] < TIME_CUTOFF_END_2_a:\n", - " names_list_2.append(row[0])\n", - " answers_list_2.append(answers)\n", - " scores_list_2.append(row[2])\n", - " comments_list_2.append(row[3])\n", - "\n", - " # The 2_b cutoff below is to specifically add data from 'ljl2' for a later second round window,\n", - " # likely because they submitted their data late or for a different time block.\n", - " TIME_CUTOFF_2_b = 1732212720000\n", - " TIME_CUTOFF_END_2_b = 1740000000000\n", - "\n", - " for row in connection.execute('SELECT * FROM results'):\n", - " if row[0].lower() == 'ljl2':\n", - " answers = json.loads(row[1])\n", - " if answers[0]['start_time'] > TIME_CUTOFF_2_b and answers[0]['start_time'] < TIME_CUTOFF_END_2_b:\n", - " names_list_2.append(row[0])\n", - " answers_list_2.append(answers)\n", - " scores_list_2.append(row[2])\n", - " comments_list_2.append(row[3])\n", - "\n", - " # print(f\"Round 1: {len(names_list_1)} entries\")\n", - " # print(f\"Round 2: {len(names_list_2)} entries\")\n", - " # names_list_1, names_list_2" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "889d7ede", - "metadata": {}, - "outputs": [], - "source": [ - "human_map1 = {\n", - " \"vn72\": ['d3efg03', 'd3f07tv', 'f1353ra', 'f13u0n2', 'fegw71k', 'fegwvia', 'ikpw1ol', 'ikpxahv', 'isz5n6g', 'isz6a7m'],\n", - " \"nac86\": ['dyd7cfv', 'dydawov', 'ewtjxp2', 'ewtowqu', 'f00nxjs', 'f014doo', 'ii3cpve', 'ii4ivim', 'ikzb571', 'ikzcblg'],\n", - " # \"sj597\": ['dbnr5nd', 'dbnxbzn', 'g1sm9mt', 'g1spg0k', 'g297nn7', 'g2998qp', 'h2h7yl0', 'h2hauaj', 'ifknq44', 'ifkoazb'],\n", - " \"yc2727\": ['d08x3kl', 'd08x4q0', 'd3efg03', 'd3f07tv', 'ewtjxp2', 'ewtowqu', 'hnupywh', 'hnuu3ip', 'ih2fn94', 'ih3iwph'],\n", - " # \"ex36\": ['d0fyu9x', 'd0fzp40', 'dg7wmdb', 'dg7x3eu', 'ej6jusi', 'ej6ollb', 'ewtjxp2', 'ewtowqu', 'f0dryv4', 'f0dsbw4'],\n", - " \"kz88\": ['doi3vuz', 'doi44j8', 'e9mybxp', 'e9mynuy', 'g1q1973', 'g1q3upb', 'ggwdbsa', 'ggwei5y', 'gmxoyuu', 'gmxqrdz'],\n", - " \"LJL2\": ['ffpj88q', 'ffpk80c', 'flixm8f', 'fljdrtt', 'fmre7l9', 'fmspcex', 'fphcwq0', 'g3hmlew', 'givok1i', 'givp578'],\n", - " \"lyk25\": ['dpirnlc', 'dpkib9q', 'e1vstxd', 'e1vv6x1', 'ewr7ls3', 'ewr7msm', 'fixjxxs', 'fixlxvy', 'fmre7l9', 'fmspcex'],\n", - " \"sqt2\": ['d3efg03', 'd3f07tv', 'g0fwpzc', 'g0ggz8e', 'g8nyz4f', 'g8nzx3m', 'h4i75b9', 'h4i79lc', 'h6ikmzc', 'h6ime20'],\n", - " \"cd326\": ['djh1bt1', 'djh2v24', 'dmlny27', 'dmlqnzz', 'f83akyz', 'f83hb2k', 'h28lknz', 'h28ltfw', 'i4rgtqf', 'i4rh1id'],\n", - " \"tg352\": ['dm8exht', 'dm8qu78', 'dvisfl0', 'dvivs9p', 'dyx2jn4', 'dyx3au1', 'gvb1ekl', 'gvdnrrb', 'i4rgtqf', 'i4rh1id'],\n", - "}\n", - "\n", - "# all_convo_ids = []\n", - "# for k,v in human_map1.items():\n", - "# all_convo_ids.extend(v)\n", - "# all_convo_ids = list(set(all_convo_ids))\n", - "# len(all_convo_ids)\n", - "\n", - "all_convo_ids = []\n", - "# # collect from round 1\n", - "if round_n == 1:\n", - " for i in range(len(answers_list_1)):\n", - " for j in range(len(answers_list_1[i])):\n", - " all_convo_ids.append(answers_list_1[i][j]['id'])\n", - "# collect from round 2\n", - "elif round_n == 2:\n", - " for i in range(len(answers_list_2)):\n", - " for j in range(len(answers_list_2[i])):\n", - " all_convo_ids.append(answers_list_2[i][j]['id'])\n", - "all_convo_ids = list(set(all_convo_ids))\n", - "print(f\"[info] total unique conversation ids: {len(all_convo_ids)}\")\n", - "print(all_convo_ids)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "168fb025", - "metadata": {}, - "outputs": [], - "source": [ - "# we want all utterances to have a human_guesses meta field\n", - "for convo in corpus.iter_conversations():\n", - " for utt in convo.get_chronological_utterance_list():\n", - " utt.add_meta('human_guesses', [])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "27fc646a", - "metadata": {}, - "outputs": [], - "source": [ - "# now we r gonna add the human guesses to the utterances, with their player ids\n", - "\n", - "# extract human first awry guess indices, now using answers_list_2\n", - "\n", - "# from collections import defaultdict\n", - "\n", - "# for i, participant_sessions in enumerate(answers_list):\n", - "# participant_id = names_list[i]\n", - "# print(participant_id)\n", - "# for session in participant_sessions:\n", - "# convo_id = session['id']\n", - "# convo = corpus.get_conversation(convo_id)\n", - "# utts = convo.get_chronological_utterance_list()\n", - "# actions = session.get('actions', [])\n", - "\n", - "# for action_idx, action in enumerate(actions):\n", - "# if action.get('guess') is True:\n", - "# utt = utts[action_idx]\n", - "# # get current guesses (returns deep copy if exists, or empty list if not)\n", - "# # create a new list to avoid mutating the copy\n", - "# current_guesses = list(utt.meta.get('human_guesses', []))\n", - "# # append new participant and set back\n", - "# current_guesses.append(participant_id)\n", - "# utt.add_meta('human_guesses', current_guesses)\n", - "if round_n == 1:\n", - " for i, participant_sessions in enumerate(answers_list_1):\n", - " participant_id = names_list_1[i]\n", - " print(participant_id)\n", - " for session in participant_sessions:\n", - " convo_id = session['id']\n", - " convo = corpus.get_conversation(convo_id)\n", - " utts = convo.get_chronological_utterance_list()\n", - " actions = session.get('actions', [])\n", - "\n", - " for action_idx, action in enumerate(actions):\n", - " if action.get('guess') is True:\n", - " utt = utts[action_idx]\n", - " # get current guesses (returns deep copy if exists, or empty list if not)\n", - " # create a new list to avoid mutating the copy\n", - " current_guesses = list(utt.meta.get('human_guesses', []))\n", - " # append new participant and set back\n", - " current_guesses.append(participant_id)\n", - " utt.add_meta('human_guesses', current_guesses)\n", - "elif round_n == 2:\n", - " for i, participant_sessions in enumerate(answers_list_2):\n", - " participant_id = names_list_2[i]\n", - " print(participant_id)\n", - " for session in participant_sessions:\n", - " convo_id = session['id']\n", - " convo = corpus.get_conversation(convo_id)\n", - " utts = convo.get_chronological_utterance_list()\n", - " actions = session.get('actions', [])\n", - "\n", - " for action_idx, action in enumerate(actions):\n", - " if action.get('guess') is True:\n", - " utt = utts[action_idx]\n", - " # get current guesses (returns deep copy if exists, or empty list if not)\n", - " # create a new list to avoid mutating the copy\n", - " current_guesses = list(utt.meta.get('human_guesses', []))\n", - " # append new participant and set back\n", - " current_guesses.append(participant_id)\n", - " utt.add_meta('human_guesses', current_guesses)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fd613b4b", - "metadata": {}, - "outputs": [], - "source": [ - "# initialize model prediction metadata fields for each utterance\n", - "for convo in corpus.iter_conversations():\n", - " for utt in convo.get_chronological_utterance_list():\n", - " utt.add_meta('model_forecast_probs', {}) # will store {seed: prob}\n", - " utt.add_meta('model_forecasts', {}) # will store {seed: binary_forecast}" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "873cb706", - "metadata": {}, - "outputs": [], - "source": [ - "# TODO need to choose which decisionpolicy/forecaster run to use to get the forecast probabilities\n", - "\n", - "# load model predictions from all 5 seeds\n", - "test_corpi_path = '/reef/lyk25/dynamic_training/game_analysis/corpi/test'\n", - "\n", - "for seed_num in range(1, 6):\n", - " seed_corpus_path = f'{test_corpi_path}/test-son-seed-{seed_num}'\n", - " print(f\"[info] loading predictions from seed {seed_num}: {seed_corpus_path}\")\n", - " \n", - " # load the seed corpus\n", - " seed_corpus = Corpus(filename=seed_corpus_path)\n", - " \n", - " # iterate through conversations in our main corpus\n", - " for convo in corpus.iter_conversations():\n", - " convo_id = convo.id\n", - " \n", - " # check if this conversation exists in the seed corpus\n", - " if convo_id not in seed_corpus.conversations:\n", - " print(f\"[warning] convo {convo_id} not found in seed {seed_num}\")\n", - " continue\n", - " \n", - " # get the corresponding conversation from seed corpus\n", - " seed_convo = seed_corpus.get_conversation(convo_id)\n", - " \n", - " # get utterances from both corpora\n", - " main_utts = convo.get_chronological_utterance_list()\n", - " seed_utts = seed_convo.get_chronological_utterance_list()\n", - " \n", - " # match utterances and copy predictions\n", - " for main_utt, seed_utt in zip(main_utts, seed_utts):\n", - " # verify they're the same utterance\n", - " if main_utt.id != seed_utt.id:\n", - " print(f\"[warning] utterance mismatch: {main_utt.id} != {seed_utt.id}\")\n", - " continue\n", - " \n", - " # extract predictions from seed utterance\n", - " forecast_prob = seed_utt.meta.get('forecast_prob', None)\n", - " forecast = seed_utt.meta.get('forecast', None)\n", - " \n", - " # add to main utterance's metadata\n", - " if forecast_prob is not None:\n", - " current_probs = dict(main_utt.meta.get('model_forecast_probs', {}))\n", - " current_probs[f'seed_{seed_num}'] = forecast_prob\n", - " main_utt.add_meta('model_forecast_probs', current_probs)\n", - " \n", - " if forecast is not None:\n", - " current_forecasts = dict(main_utt.meta.get('model_forecasts', {}))\n", - " current_forecasts[f'seed_{seed_num}'] = forecast\n", - " main_utt.add_meta('model_forecasts', current_forecasts)\n", - "\n", - "print(\"\\n[pass] model predictions from all seeds added to corpus\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5b0f0e44", - "metadata": {}, - "outputs": [], - "source": [ - "# horizon comparison between gemma and humans, using the same convention as\n", - "# performance_utils_wiki.calculate_current_performance:\n", - "# - only count true positives (ground truth awry AND trigger fired)\n", - "# - horizon = (len(utts) - first_trigger_index) - 1\n", - "# - first trigger only (break after first positive)\n", - "#\n", - "# reports per-round results for humans (round 1 and round 2), pulling data\n", - "# directly from the game sqlite so it works regardless of which round_n the\n", - "# rest of the notebook was run under. ljl2 is excluded.\n", - "\n", - "import sqlite3\n", - "import json as _json\n", - "from collections import defaultdict\n", - "import numpy as np\n", - "\n", - "def _horizon_mean(horizons):\n", - " # matches performance_utils_wiki: h = mean(horizons) - 1\n", - " if len(horizons) == 0:\n", - " return float('nan'), 0\n", - " return float(np.mean(horizons)) - 1, len(horizons)\n", - "\n", - "# always excluded (staff/test accounts). ljl2 is a legitimate late submitter\n", - "# in the round 2_b window, not an exclusion.\n", - "base_excluded = {'yc2727', 'sqt2'}\n", - "round1_excluded = set(base_excluded)\n", - "round2_excluded = set(base_excluded)\n", - "\n", - "# gemma: per-seed first-trigger horizons on TP convos only (ground truth awry)\n", - "gemma_horizons_by_seed = defaultdict(list)\n", - "for convo in corpus.iter_conversations():\n", - " if not convo.meta.get('has_removed_comment', False):\n", - " continue # skip non-awry convos; horizon is only meaningful on TPs\n", - " utts = convo.get_chronological_utterance_list()\n", - " for seed_num in range(1, 6):\n", - " for i, utt in enumerate(utts):\n", - " if utt.meta.get('model_forecasts', {}).get(f'seed_{seed_num}') == 1:\n", - " gemma_horizons_by_seed[seed_num].append(len(utts) - i)\n", - " break\n", - "\n", - "print('gemma horizon (TPs only, mean - 1):')\n", - "gemma_per_seed_h = []\n", - "for seed_num in sorted(gemma_horizons_by_seed.keys()):\n", - " h, n = _horizon_mean(gemma_horizons_by_seed[seed_num])\n", - " gemma_per_seed_h.append(h)\n", - " print(f' seed {seed_num}: n={n}, h={h:.4f}')\n", - "gemma_h_mean_of_seeds = float(np.mean(gemma_per_seed_h)) if gemma_per_seed_h else float('nan')\n", - "all_gemma_vals = [v for vs in gemma_horizons_by_seed.values() for v in vs]\n", - "gemma_h_pooled, gemma_n_pooled = _horizon_mean(all_gemma_vals)\n", - "print(f' mean over seeds: h={gemma_h_mean_of_seeds:.4f}')\n", - "print(f' pooled: n={gemma_n_pooled}, h={gemma_h_pooled:.4f}')\n", - "\n", - "# pull round-specific human guesses directly from the sqlite db\n", - "db_path = '/reef/sqt2/cga-eval/human/game_db.sqlite'\n", - "_conn = sqlite3.connect(db_path)\n", - "\n", - "def _load_round_answers(round_n):\n", - " # returns list of (participant_id, sessions) for the given round\n", - " entries = []\n", - " if round_n == 1:\n", - " excluded = round1_excluded\n", - " t_start, t_end = 1730395000000, 1730397199000\n", - " for row in _conn.execute('SELECT * FROM results'):\n", - " if row[0] in excluded:\n", - " continue\n", - " answers = _json.loads(row[1])\n", - " if answers and answers[0]['start_time'] > t_start and answers[0]['start_time'] < t_end:\n", - " entries.append((row[0], answers))\n", - " elif round_n == 2:\n", - " excluded = round2_excluded\n", - " t_start_a, t_end_a = 1731002910000, 1731016180000\n", - " t_start_b, t_end_b = 1732212720000, 1740000000000\n", - " for row in _conn.execute('SELECT * FROM results'):\n", - " name = row[0]\n", - " if name in excluded:\n", - " continue\n", - " answers = _json.loads(row[1])\n", - " if not answers:\n", - " continue\n", - " st = answers[0]['start_time']\n", - " in_a = t_start_a < st < t_end_a\n", - " # the 2_b late window is only valid for ljl2 (matches cell 7)\n", - " in_b = (name.lower() == 'ljl2') and (t_start_b < st < t_end_b)\n", - " if in_a or in_b:\n", - " entries.append((name, answers))\n", - " return entries\n", - "\n", - "def _unique_convo_ids(entries):\n", - " # unique convo ids seen across all included players' sessions\n", - " ids = set()\n", - " for _, sessions in entries:\n", - " for session in sessions:\n", - " cid = session.get('id')\n", - " if cid is not None:\n", - " ids.add(cid)\n", - " return ids\n", - "\n", - "def _compute_human_horizons(entries):\n", - " # returns dict: player_id -> list of horizons (non-awry convos only, first guess per convo)\n", - " by_player = defaultdict(list)\n", - " for participant_id, sessions in entries:\n", - " for session in sessions:\n", - " convo_id = session.get('id')\n", - " if convo_id is None:\n", - " continue\n", - " try:\n", - " convo = corpus.get_conversation(convo_id)\n", - " except KeyError:\n", - " # convo not in the loaded corpus (e.g., different round loaded)\n", - " continue\n", - " if not convo.meta.get('has_removed_comment', False):\n", - " continue # skip non-awry convos; horizon only counted on TPs\n", - " utts = convo.get_chronological_utterance_list()\n", - " for action_idx, action in enumerate(session.get('actions', [])):\n", - " if action.get('guess') is True:\n", - " if action_idx < len(utts):\n", - " by_player[participant_id].append(len(utts) - action_idx)\n", - " break # only first guess per (player, convo)\n", - " return by_player\n", - "\n", - "def _print_human_horizons(label, by_player):\n", - " print(f'human horizon ({label}, TPs only, mean - 1):')\n", - " player_h = []\n", - " for player, horizons in by_player.items():\n", - " h, n = _horizon_mean(horizons)\n", - " player_h.append(h)\n", - " print(f' player {player}: n={n}, h={h:.4f}')\n", - " mean_of_players = float(np.mean(player_h)) if player_h else float('nan')\n", - " all_vals = [v for vs in by_player.values() for v in vs]\n", - " h_pooled, n_pooled = _horizon_mean(all_vals)\n", - " print(f' mean over players: h={mean_of_players:.4f}')\n", - " print(f' pooled: n={n_pooled}, h={h_pooled:.4f}')\n", - " return mean_of_players, h_pooled\n", - "\n", - "print()\n", - "EXPECTED_N_CONVOS = 84\n", - "round1_entries = _load_round_answers(1)\n", - "round1_convo_ids = _unique_convo_ids(round1_entries)\n", - "print(f'round 1: {len(round1_entries)} included players, {len(round1_convo_ids)} unique convos')\n", - "assert len(round1_convo_ids) == EXPECTED_N_CONVOS, (\n", - " f'round 1 expected {EXPECTED_N_CONVOS} unique convos but got {len(round1_convo_ids)}'\n", - ")\n", - "round1_by_player = _compute_human_horizons(round1_entries)\n", - "r1_mean, r1_pooled = _print_human_horizons('round 1', round1_by_player)\n", - "\n", - "print()\n", - "round2_entries = _load_round_answers(2)\n", - "round2_convo_ids = _unique_convo_ids(round2_entries)\n", - "print(f'round 2: {len(round2_entries)} included players, {len(round2_convo_ids)} unique convos')\n", - "assert len(round2_convo_ids) == EXPECTED_N_CONVOS, (\n", - " f'round 2 expected {EXPECTED_N_CONVOS} unique convos but got {len(round2_convo_ids)}'\n", - ")\n", - "round2_by_player = _compute_human_horizons(round2_entries)\n", - "r2_mean, r2_pooled = _print_human_horizons('round 2', round2_by_player)\n", - "\n", - "_conn.close()\n", - "\n", - "print()\n", - "print('summary (comparable to h in performance_utils_wiki):')\n", - "print(f' gemma h (mean over seeds): {gemma_h_mean_of_seeds:.4f}')\n", - "print(f' gemma h (pooled): {gemma_h_pooled:.4f}')\n", - "print(f' round1 h (mean over players): {r1_mean:.4f}')\n", - "print(f' round1 h (pooled): {r1_pooled:.4f}')\n", - "print(f' round2 h (mean over players): {r2_mean:.4f}')\n", - "print(f' round2 h (pooled): {r2_pooled:.4f}')\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "44ed25ac", - "metadata": {}, - "outputs": [], - "source": [ - "# benchmark humans, mirroring the gemma benchmark (cell 40).\n", - "# computes accuracy, precision, recall, f1, fpr, specificity, fnr for:\n", - "# - gemma (aggregated over seeds 1-5)\n", - "# - round 1 humans (aggregate \"any\" rule, plus per-player)\n", - "# - round 2 humans (aggregate \"any\" rule, plus per-player)\n", - "# uses the included entries loaded in the previous cell:\n", - "# round1_entries, round2_entries\n", - "# and the corpus in memory for ground truth.\n", - "from collections import defaultdict\n", - "import numpy as np\n", - "def _compute_metrics(tp, fp, tn, fn):\n", - " total = tp + fp + tn + fn\n", - " accuracy = (tp + tn) / total if total > 0 else 0.0\n", - " precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0\n", - " recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0\n", - " f1 = (2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0.0\n", - " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0.0\n", - " specificity = tn / (tn + fp) if (tn + fp) > 0 else 0.0\n", - " fnr = fn / (fn + tp) if (fn + tp) > 0 else 0.0\n", - " return {\n", - " 'tp': tp, 'fp': fp, 'tn': tn, 'fn': fn,\n", - " 'accuracy': accuracy, 'precision': precision, 'recall': recall,\n", - " 'f1': f1, 'fpr': fpr, 'specificity': specificity, 'fnr': fnr,\n", - " }\n", - "def _gt(convo):\n", - " return bool(convo.meta.get('has_removed_comment', False))\n", - "# gemma benchmark, per seed, then mean and std\n", - "gemma_per_seed = []\n", - "for seed_num in range(1, 6):\n", - " tp = fp = tn = fn = 0\n", - " for convo in corpus.iter_conversations():\n", - " utts = convo.get_chronological_utterance_list()\n", - " pred = any(\n", - " utt.meta.get('model_forecasts', {}).get(f'seed_{seed_num}') == 1\n", - " for utt in utts\n", - " )\n", - " truth = _gt(convo)\n", - " if pred and truth: tp += 1\n", - " elif pred and not truth: fp += 1\n", - " elif not pred and not truth: tn += 1\n", - " elif not pred and truth: fn += 1\n", - " gemma_per_seed.append(_compute_metrics(tp, fp, tn, fn))\n", - "gemma_mean = {k: float(np.mean([m[k] for m in gemma_per_seed])) for k in gemma_per_seed[0]}\n", - "gemma_std = {k: float(np.std([m[k] for m in gemma_per_seed], ddof=1)) for k in gemma_per_seed[0]}\n", - "def _build_per_player_preds(entries):\n", - " # returns dict[player_id] -> dict[convo_id] -> 0/1\n", - " preds = defaultdict(dict)\n", - " for player, sessions in entries:\n", - " for s in sessions:\n", - " cid = s.get('id')\n", - " if cid is None:\n", - " continue\n", - " try:\n", - " corpus.get_conversation(cid)\n", - " except KeyError:\n", - " continue\n", - " actions = s.get('actions', [])\n", - " preds[player][cid] = 1 if any(a.get('guess') is True for a in actions) else 0\n", - " return preds\n", - "def _aggregate_any(preds):\n", - " # per-convo prediction = 1 if any player who saw it guessed\n", - " by_convo = defaultdict(list)\n", - " for player, convo_preds in preds.items():\n", - " for cid, p in convo_preds.items():\n", - " by_convo[cid].append(p)\n", - " tp = fp = tn = fn = 0\n", - " for cid, plist in by_convo.items():\n", - " try:\n", - " convo = corpus.get_conversation(cid)\n", - " except KeyError:\n", - " continue\n", - " pred = 1 if any(plist) else 0\n", - " truth = 1 if _gt(convo) else 0\n", - " if pred and truth: tp += 1\n", - " elif pred and not truth: fp += 1\n", - " elif not pred and not truth: tn += 1\n", - " elif not pred and truth: fn += 1\n", - " return _compute_metrics(tp, fp, tn, fn), len(by_convo)\n", - "def _per_player_metrics(preds):\n", - " rows = {}\n", - " for player, convo_preds in preds.items():\n", - " tp = fp = tn = fn = 0\n", - " for cid, p in convo_preds.items():\n", - " try:\n", - " convo = corpus.get_conversation(cid)\n", - " except KeyError:\n", - " continue\n", - " truth = 1 if _gt(convo) else 0\n", - " if p and truth: tp += 1\n", - " elif p and not truth: fp += 1\n", - " elif not p and not truth: tn += 1\n", - " elif not p and truth: fn += 1\n", - " rows[player] = _compute_metrics(tp, fp, tn, fn)\n", - " return rows\n", - "# round 1 and round 2 humans\n", - "round1_preds = _build_per_player_preds(round1_entries)\n", - "round1_agg, round1_n_convos = _aggregate_any(round1_preds)\n", - "round1_per_player = _per_player_metrics(round1_preds)\n", - "round2_preds = _build_per_player_preds(round2_entries)\n", - "round2_agg, round2_n_convos = _aggregate_any(round2_preds)\n", - "round2_per_player = _per_player_metrics(round2_preds)\n", - "# metric mean over players (a different aggregation view)\n", - "def _mean_over_players(per_player):\n", - " keys = ['accuracy', 'precision', 'recall', 'f1', 'fpr', 'specificity', 'fnr']\n", - " return {k: float(np.mean([m[k] for m in per_player.values()])) for k in keys}\n", - "round1_mean_over_players = _mean_over_players(round1_per_player)\n", - "round2_mean_over_players = _mean_over_players(round2_per_player)\n", - "# printing\n", - "metric_order = ['accuracy', 'precision', 'recall', 'f1', 'fpr', 'specificity', 'fnr']\n", - "def _print_per_player(label, per_player):\n", - " print(f'{label} - per-player metrics:')\n", - " header = f\" {'player':<10}\" + \"\".join(f\"{m:>12}\" for m in metric_order) + f\"{'n_convos':>10}\"\n", - " print(header)\n", - " print(' ' + '-' * (len(header) - 2))\n", - " for player in sorted(per_player):\n", - " m = per_player[player]\n", - " n = m['tp'] + m['fp'] + m['tn'] + m['fn']\n", - " row = f\" {player:<10}\" + \"\".join(f\"{m[k]:>12.4f}\" for k in metric_order) + f\"{n:>10d}\"\n", - " print(row)\n", - "_print_per_player('round 1', round1_per_player)\n", - "print()\n", - "_print_per_player('round 2', round2_per_player)\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "lyk25-env", - "language": "python", - "name": "python3" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 + "nbformat": 4, + "nbformat_minor": 5 } From 44f77189cd992bd8976451c6b7e9ea0aadf83b01 Mon Sep 17 00:00:00 2001 From: Laerdon Kim <96972420+laerdon@users.noreply.github.com> Date: Thu, 30 Apr 2026 23:19:07 -0400 Subject: [PATCH 06/21] Delete examples/forecaster/train_deferral.py --- examples/forecaster/train_deferral.py | 186 -------------------------- 1 file changed, 186 deletions(-) delete mode 100644 examples/forecaster/train_deferral.py diff --git a/examples/forecaster/train_deferral.py b/examples/forecaster/train_deferral.py deleted file mode 100644 index dec75fe49..000000000 --- a/examples/forecaster/train_deferral.py +++ /dev/null @@ -1,186 +0,0 @@ -""" -end-to-end training script for a TransformerDecoderModel forecaster with a DeferralDecisionPolicy. - -flow: - 1. load the CGA-CMV corpus - 2. build a DeferralDecisionPolicy backed by an UnslothUtteranceSimulatorModel - 3. build a TransformerDecoderModel (forecaster backbone) with that policy attached - 4. wrap both in a Forecaster - 5. fit: LoRA fine-tune the forecaster, then fit the decision policy on the val set - 6. evaluate on the test set and print metrics - -usage: - python train_deferral.py [--device cuda] [--gpu 0] -""" - -import argparse -import os -import sys - -# ensure the repo root is on the path when running directly -sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..")) - - -def main(args): - import convokit - from convokit import Corpus, Forecaster, download - from convokit.forecaster.TransformerDecoderModel import TransformerDecoderModel - from convokit.forecaster.TransformerForecasterConfig import TransformerForecasterConfig - from convokit.decisionpolicy import DeferralDecisionPolicy, ThresholdDecisionPolicy - - # ------------------------------------------------------------------ # - # 1. corpus - # ------------------------------------------------------------------ # - print("[info] loading corpus...") - corpus = Corpus( - filename=download( - "conversations-gone-awry-cmv-corpus", - data_dir=args.data_dir, - ) - ) - - labeler = "has_removed_comment" - - # ------------------------------------------------------------------ # - # 2. context selectors - # ------------------------------------------------------------------ # - def train_selector(ctx): - """last context of every train conversation (matches original craft/llm training setup)""" - convo = ctx.current_utterance.get_conversation() - return ( - convo.meta.get("split") == "train" - and len(ctx.future_context) == 0 - ) - - def val_selector(ctx): - return ctx.current_utterance.get_conversation().meta.get("split") == "val" - - def test_selector(ctx): - convo = ctx.current_utterance.get_conversation() - convo_len = len(convo.get_chronological_utterance_list()) - return ( - convo.meta.get("split") == "test" - # exclude the very last context (the toxic turn itself) - and len(ctx.context) < convo_len - ) - - - # 3. simulator model - # # - # 4. decision policy - policy = ThresholdDecisionPolicy( - threshold=0.5926666259765625, - ) - - # 5. forecaster model - print("[info] loading forecaster model...") - config = TransformerForecasterConfig( - output_dir=args.output_dir, - per_device_batch_size=args.batch_size, - gradient_accumulation_steps=args.grad_accum, - num_train_epochs=args.epochs, - learning_rate=args.lr, - random_seed=args.seed, - context_mode="normal", - device=args.device, - ) - - forecaster_model = TransformerDecoderModel( - model_name_or_path=args.forecaster_model, - config=config, - decision_policy=policy, - ) - - # 6. forecaster wrapper - forecaster = Forecaster( - forecaster_model=forecaster_model, - labeler=labeler, - ) - - # 7. fit - # print("[info] fitting forecaster (belief estimator + decision policy)...") - # forecaster.fit( - # corpus=corpus, - # context_selector=train_selector, - # val_context_selector=val_selector, - # ) - - forecaster.fit_decision_policy( - corpus=corpus, - context_selector=train_selector, - val_context_selector=val_selector, - ) - - # print(forecaster.forecaster_model.decision_policy.threshold) - - # # 8. evaluate on test set - # print("[info] running transform on test set...") - # corpus = forecaster.transform( - # corpus=corpus, - # context_selector=test_selector, - # ) - - # print("[info] computing metrics...") - # forecaster.summarize( - # corpus=corpus, - # selector=lambda convo: convo.meta.get("split") == "test", - # ) - - # optional: inspect a few utterances with stored simulations - if args.store_simulations: - print("\n[info] sample utterances with stored simulations:") - shown = 0 - for utt in corpus.iter_utterances(): - # show only utterances that were forecasted and have sim_replies - if ( - utt.meta.get("forecast") is not None - and utt.meta.get("sim_replies") is not None - ): - print("---") - print("text :", utt.text[:120]) - print("forecast_prob :", utt.meta["forecast_prob"]) - print("forecast :", utt.meta["forecast"]) - print("sim_replies :", utt.meta["sim_replies"][:2]) - print("sim_probs :", utt.meta["sim_replies_forecast_probs"][:2]) - shown += 1 - if shown >= 3: - break - - -if __name__ == "__main__": - parser = argparse.ArgumentParser(description="train forecaster with DeferralDecisionPolicy") - - # paths - parser.add_argument("--forecaster-model", required=True, - help="hf model name or local path for the decoder forecaster") - parser.add_argument("--simulator-model", required=True, - help="hf model name or local path for the utterance simulator") - parser.add_argument("--output-dir", default="./deferral_output", - help="directory to save checkpoints and predictions") - parser.add_argument("--data-dir", default="./", - help="directory to download/find the corpus") - - # training hyperparams - parser.add_argument("--epochs", type=int, default=1) - parser.add_argument("--batch-size", type=int, default=2) - parser.add_argument("--grad-accum", type=int, default=32) - parser.add_argument("--lr", type=float, default=1e-4) - parser.add_argument("--seed", type=int, default=1) - - # deferral policy hyperparams - parser.add_argument("--num-simulations", type=int, default=10, - help="number of simulated branches per context") - parser.add_argument("--tau", type=int, default=5, - help="minimum simulated branches above threshold to intervene") - - # misc - parser.add_argument("--device", default="cuda") - parser.add_argument("--gpu", type=int, default=3, - help="which gpu to use (sets CUDA_VISIBLE_DEVICES)") - parser.add_argument("--store-simulations", action="store_true", - help="write simulated replies and their forecast probs to corpus metadata") - - args = parser.parse_args() - os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu) - - main(args) From 736f324d8eb7b9ddfad91d3d53f52b7eeaf96344 Mon Sep 17 00:00:00 2001 From: laerdon Date: Mon, 25 May 2026 00:13:46 +0000 Subject: [PATCH 07/21] added more decision policies --- .../decisionpolicy/deferralDecisionPolicy.py | 10 +-- .../randomDeferralDecisionPolicy.py | 78 +++++++++++++++++++ .../simulationAverageDecisionPolicy.py | 60 ++++++++++++++ .../simulationMajorityDecisionPolicy.py | 30 +++++++ 4 files changed, 169 insertions(+), 9 deletions(-) create mode 100644 convokit/decisionpolicy/randomDeferralDecisionPolicy.py create mode 100644 convokit/decisionpolicy/simulationAverageDecisionPolicy.py create mode 100644 convokit/decisionpolicy/simulationMajorityDecisionPolicy.py diff --git a/convokit/decisionpolicy/deferralDecisionPolicy.py b/convokit/decisionpolicy/deferralDecisionPolicy.py index 335eb2ae4..cfa91587e 100644 --- a/convokit/decisionpolicy/deferralDecisionPolicy.py +++ b/convokit/decisionpolicy/deferralDecisionPolicy.py @@ -161,19 +161,11 @@ def _decision_score(self, context, score_fn: Callable): return current_score, simulations, simulation_scores def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]: - max_defer_index = 4 decision_score, simulations, simulation_scores = self._decision_score(context, score_fn) num_simulations_above_threshold = sum(1 for score in simulation_scores if score > self.threshold) num_simulations = len(simulations) - # context.context contains chronological_utts[: i+1] (includes current_utterance), - # so the current utterance's position in the conversation is len(context.context) - 1. - utt_index = max(0, len(getattr(context, "context", []) or []) - 1) - # past the deferral window we always commit when fp > threshold, mirroring the - # `i < 4` early-only deferral in performance_utils.no_tricks. - past_defer_window = max_defer_index is not None and utt_index >= max_defer_index - defer_eligible = not past_defer_window + num_calm = num_simulations - num_simulations_above_threshold - # defer = defer_eligible and (num_calm > self.tau) defer = (num_calm > self.tau) return ( decision_score, diff --git a/convokit/decisionpolicy/randomDeferralDecisionPolicy.py b/convokit/decisionpolicy/randomDeferralDecisionPolicy.py new file mode 100644 index 000000000..adf1607d3 --- /dev/null +++ b/convokit/decisionpolicy/randomDeferralDecisionPolicy.py @@ -0,0 +1,78 @@ +import numpy as np +from typing import Callable, List, Optional, Dict, Any, Tuple +from .decisionPolicy import DecisionPolicy + +class RandomDeferralDecisionPolicy(DecisionPolicy): + """ + Decision policy that defers intervention by looking ahead at simulated next utterances. + + :param simulator: utterance simulator model (must have a ``transform(contexts)`` method + returning a DataFrame indexed by utterance id). if the simulator exposes + ``get_num_simulations()``, ``num_simulations`` is capped to that value. + :param threshold: probability threshold above which a context is flagged. + :param tau: minimum number of simulated branches that must exceed the threshold + before an intervention is issued. + :param num_simulations: how many simulated branches to use per context (capped to + simulator's ``get_num_simulations()`` if available). + :param store_simulations: if True, simulated reply strings are cached during decide() + and written to corpus utterance metadata by post_transform(). + :param simulated_reply_attribute_name: metadata field name used when storing simulations + on corpus utterances (only relevant when store_simulations=True). + """ + + def __init__( + self, + simulator, + threshold, + deferral_probability: float = 0.1515, + reuse_cached_forecast_probs: bool = True, + forecast_prob_attribute_name: str = "forecast_prob", + ): + # forward the cache flag to the base class so its _score helper honors it. + # without this, reuse_cached_probabilities on this subclass had no effect. + super().__init__( + forecast_prob_attribute_name=forecast_prob_attribute_name, + reuse_cached_forecast_probs=reuse_cached_forecast_probs, + ) + self.simulator = simulator + self.threshold = float(threshold) + self.deferral_probability = float(deferral_probability) + + def _decision_score(self, context, score_fn: Callable): + # use base _score so a cached forecast_prob on the utterance meta is reused + # instead of re-invoking the belief estimator. + return self._score(context, score_fn) + + def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]: + decision_score = self._score(context, score_fn) + + p = float(np.random.rand()) + + + # return an empty metadata dict (not None) so downstream code that iterates + # utt_metadata.items() in TransformerDecoderModel.transform doesn't crash. + return (decision_score, + 1 if decision_score > self.threshold and p > self.deferral_probability else 0, + {} + ) + + def fit(self, contexts, val_contexts=None, score_fn: Callable = None): + if val_contexts is None or score_fn is None or self.labeler is None: + print("either no validation contexts/score function/labeler were provided, returning current threshold") + return {"best_threshold": self.threshold} + + val_contexts = list(val_contexts) + if len(val_contexts) == 0: + print("no validation contexts were provided, returning current threshold") + return {"best_threshold": self.threshold} + + fit_result = self._fit_with_model_checkpoint_selection(val_contexts, score_fn=score_fn) + if isinstance(fit_result, dict): + if "best_threshold" in fit_result: + self.threshold = float(fit_result["best_threshold"]) + return fit_result + + fit_result = self._fit_threshold_for_loaded_model(val_contexts, score_fn=score_fn) + if "best_threshold" in fit_result: + self.threshold = float(fit_result["best_threshold"]) + return fit_result \ No newline at end of file diff --git a/convokit/decisionpolicy/simulationAverageDecisionPolicy.py b/convokit/decisionpolicy/simulationAverageDecisionPolicy.py new file mode 100644 index 000000000..07a052000 --- /dev/null +++ b/convokit/decisionpolicy/simulationAverageDecisionPolicy.py @@ -0,0 +1,60 @@ +from typing import Callable, Optional, Dict, Any, Tuple + +from convokit.decisionpolicy import DeferralDecisionPolicy + + +class SimulationAverageDecisionPolicy(DeferralDecisionPolicy): + """ + decision policy that intervenes if the mean of the simulated next-utterance + scores is at or above the threshold. + + this subclass inherits all simulation fetching, per-utterance metadata + caching, sim-score caching, and threshold fitting from + DeferralDecisionPolicy. the only differences are: + * no ``tau`` parameter (unused; forwarded as 0 to super) + * ``decide`` predicts based on mean(simulation_scores) >= threshold + """ + + def __init__( + self, + simulator, + threshold, + num_simulations: int = 10, + store_simulations: bool = False, + simulated_reply_attribute_name: str = "sim_replies", + sim_replies_forecast_probs_attribute_name: str = "sim_replies_forecast_probs", + reuse_cached_simulations: bool = True, + ): + # tau is irrelevant for the mean-based decision rule, so we pin it to 0 + # upstream rather than expose it to callers of this subclass. + super().__init__( + simulator=simulator, + threshold=threshold, + tau=0, + num_simulations=num_simulations, + store_simulations=store_simulations, + simulated_reply_attribute_name=simulated_reply_attribute_name, + sim_replies_forecast_probs_attribute_name=sim_replies_forecast_probs_attribute_name, + reuse_cached_simulations=reuse_cached_simulations, + ) + + def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]: + decision_score, simulations, simulation_scores = self._decision_score(context, score_fn) + # empty simulation_scores would zero-divide. this happens when the + # simulator returns no completions for a context (e.g. end-of-conversation + # contexts that slip through the selector). treat as no intervention so + # a single degenerate context doesn't abort the whole transform run. + if len(simulation_scores) == 0: + average_simulation_score = 0.0 + pred = 0 + else: + average_simulation_score = sum(simulation_scores) / len(simulation_scores) + pred = 1 if average_simulation_score >= self.threshold else 0 + return ( + decision_score, + pred, + { + self.simulated_reply_attribute_name: simulations, + self.sim_replies_forecast_probs_attribute_name: simulation_scores, + }, + ) diff --git a/convokit/decisionpolicy/simulationMajorityDecisionPolicy.py b/convokit/decisionpolicy/simulationMajorityDecisionPolicy.py new file mode 100644 index 000000000..b1f89276d --- /dev/null +++ b/convokit/decisionpolicy/simulationMajorityDecisionPolicy.py @@ -0,0 +1,30 @@ +from typing import Callable, Optional, Dict, Any, Tuple + +from convokit.decisionpolicy import DeferralDecisionPolicy + + +class SimulationMajorityDecisionPolicy(DeferralDecisionPolicy): + """ + decision policy that intervenes if at least ``tau`` of the simulated next + utterances score above the threshold, ignoring the current utterance score. + + this subclass inherits all simulation fetching, per-utterance metadata + caching, sim-score caching, and threshold fitting from + DeferralDecisionPolicy. the only difference is in ``decide``: the gate + ``decision_score > threshold`` is dropped so that only the simulated-branch + vote count drives the prediction. + """ + + def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]: + decision_score, simulations, simulation_scores = self._decision_score(context, score_fn) + num_simulations_above_threshold = sum( + 1 for score in simulation_scores if score > self.threshold + ) + return ( + decision_score, + 1 if num_simulations_above_threshold >= self.tau else 0, + { + self.simulated_reply_attribute_name: simulations, + self.sim_replies_forecast_probs_attribute_name: simulation_scores, + }, + ) From e23ad52ef6ba792194807fbaa3e264354b1aa6a1 Mon Sep 17 00:00:00 2001 From: laerdon Date: Mon, 25 May 2026 00:30:08 +0000 Subject: [PATCH 08/21] black formatting --- convokit/decisionpolicy/decisionPolicy.py | 2 +- .../decisionpolicy/deferralDecisionPolicy.py | 14 +- .../randomDeferralDecisionPolicy.py | 15 +- .../decisionpolicy/thresholdDecisionPolicy.py | 4 +- .../forecaster/TransformerDecoderModel.py | 14 +- convokit/forecaster/forecaster.py | 25 +- convokit/forecaster/forecasterModel.py | 4 +- .../decisionpolicy/decisionpolicy_demo.ipynb | 5618 ++++++++++------- 8 files changed, 3248 insertions(+), 2448 deletions(-) diff --git a/convokit/decisionpolicy/decisionPolicy.py b/convokit/decisionpolicy/decisionPolicy.py index eff7ac755..57e6a3a51 100644 --- a/convokit/decisionpolicy/decisionPolicy.py +++ b/convokit/decisionpolicy/decisionPolicy.py @@ -155,4 +155,4 @@ def fit(self, contexts, val_contexts=None, score_fn: Callable = None): :param val_contexts: optional validation contexts :param score_fn: optional scorer callable exposed by ForecasterModel """ - pass \ No newline at end of file + pass diff --git a/convokit/decisionpolicy/deferralDecisionPolicy.py b/convokit/decisionpolicy/deferralDecisionPolicy.py index cfa91587e..b14645482 100644 --- a/convokit/decisionpolicy/deferralDecisionPolicy.py +++ b/convokit/decisionpolicy/deferralDecisionPolicy.py @@ -90,9 +90,7 @@ def _get_cached_simulations(self, context) -> Optional[List[str]]: return None return cached_list[: self.num_simulations] - def _get_cached_simulation_scores( - self, context, num_expected: int - ) -> Optional[List[float]]: + def _get_cached_simulation_scores(self, context, num_expected: int) -> Optional[List[float]]: # returns cached per-simulation scores aligned with reused simulations, else None. if not self.reuse_cached_simulations or num_expected == 0: return None @@ -162,11 +160,13 @@ def _decision_score(self, context, score_fn: Callable): def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]: decision_score, simulations, simulation_scores = self._decision_score(context, score_fn) - num_simulations_above_threshold = sum(1 for score in simulation_scores if score > self.threshold) + num_simulations_above_threshold = sum( + 1 for score in simulation_scores if score > self.threshold + ) num_simulations = len(simulations) num_calm = num_simulations - num_simulations_above_threshold - defer = (num_calm > self.tau) + defer = num_calm > self.tau return ( decision_score, 1 if decision_score > self.threshold and not defer else 0, @@ -178,7 +178,9 @@ def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict def fit(self, contexts, val_contexts=None, score_fn: Callable = None): if val_contexts is None or score_fn is None or self.labeler is None: - print("either no validation contexts/score function/labeler were provided, returning current threshold") + print( + "either no validation contexts/score function/labeler were provided, returning current threshold" + ) return {"best_threshold": self.threshold} val_contexts = list(val_contexts) diff --git a/convokit/decisionpolicy/randomDeferralDecisionPolicy.py b/convokit/decisionpolicy/randomDeferralDecisionPolicy.py index adf1607d3..5d4dea49f 100644 --- a/convokit/decisionpolicy/randomDeferralDecisionPolicy.py +++ b/convokit/decisionpolicy/randomDeferralDecisionPolicy.py @@ -2,6 +2,7 @@ from typing import Callable, List, Optional, Dict, Any, Tuple from .decisionPolicy import DecisionPolicy + class RandomDeferralDecisionPolicy(DecisionPolicy): """ Decision policy that defers intervention by looking ahead at simulated next utterances. @@ -47,18 +48,20 @@ def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict decision_score = self._score(context, score_fn) p = float(np.random.rand()) - # return an empty metadata dict (not None) so downstream code that iterates # utt_metadata.items() in TransformerDecoderModel.transform doesn't crash. - return (decision_score, - 1 if decision_score > self.threshold and p > self.deferral_probability else 0, - {} + return ( + decision_score, + 1 if decision_score > self.threshold and p > self.deferral_probability else 0, + {}, ) def fit(self, contexts, val_contexts=None, score_fn: Callable = None): if val_contexts is None or score_fn is None or self.labeler is None: - print("either no validation contexts/score function/labeler were provided, returning current threshold") + print( + "either no validation contexts/score function/labeler were provided, returning current threshold" + ) return {"best_threshold": self.threshold} val_contexts = list(val_contexts) @@ -75,4 +78,4 @@ def fit(self, contexts, val_contexts=None, score_fn: Callable = None): fit_result = self._fit_threshold_for_loaded_model(val_contexts, score_fn=score_fn) if "best_threshold" in fit_result: self.threshold = float(fit_result["best_threshold"]) - return fit_result \ No newline at end of file + return fit_result diff --git a/convokit/decisionpolicy/thresholdDecisionPolicy.py b/convokit/decisionpolicy/thresholdDecisionPolicy.py index 16df7ff2f..1ff75a4f6 100644 --- a/convokit/decisionpolicy/thresholdDecisionPolicy.py +++ b/convokit/decisionpolicy/thresholdDecisionPolicy.py @@ -26,7 +26,9 @@ def decide(self, context, score_fn: Callable) -> Tuple[float, int]: def fit(self, contexts, val_contexts=None, score_fn: Callable = None): if val_contexts is None or score_fn is None or self.labeler is None: - print("either no validation contexts/score function/labeler were provided, returning current threshold") + print( + "either no validation contexts/score function/labeler were provided, returning current threshold" + ) return {"best_threshold": self.threshold} val_contexts = list(val_contexts) diff --git a/convokit/forecaster/TransformerDecoderModel.py b/convokit/forecaster/TransformerDecoderModel.py index a7d17782f..9dd14a1d5 100644 --- a/convokit/forecaster/TransformerDecoderModel.py +++ b/convokit/forecaster/TransformerDecoderModel.py @@ -14,6 +14,7 @@ from .forecasterModel import ForecasterModel from .TransformerForecasterConfig import TransformerForecasterConfig + def _get_template_map(model_name_or_path): """ Map a model name or path to its corresponding prompt template family. @@ -371,7 +372,9 @@ def fit(self, contexts, val_contexts=None): self.fit_decision_policy(contexts, val_contexts_decision_policy, score_fn=self.score) return - def transform(self, contexts, forecast_attribute_name, forecast_prob_attribute_name, verbose=False): + def transform( + self, contexts, forecast_attribute_name, forecast_prob_attribute_name, verbose=False + ): """ Generate forecasts using the fine-tuned TransformerDecoder model on the provided contexts, and save the predictions to the output directory specified in the configuration. @@ -423,6 +426,7 @@ def _compute_conversation_metrics(): fpr = fp / (fp + tn) if (fp + tn) > 0 else 0.0 f1 = (2 * p * r / (p + r)) if (p + r) > 0 else 0.0 return {"n": n, "acc": acc, "p": p, "r": r, "fpr": fpr, "f1": f1} + # for safety/flexibility we can accept either only score and pred or also the metadata progress = tqdm(contexts) for idx, context in enumerate(progress, start=1): @@ -530,7 +534,9 @@ def _compute_conversation_metrics(): f"f1={final_metrics['f1']:.4f}" ) for key, series in metadatas.items(): - assert len(series) == len(preds), "Metadata series length must match number of predictions" - cols[key] = series # each series same length as preds + assert len(series) == len( + preds + ), "Metadata series length must match number of predictions" + cols[key] = series # each series same length as preds forecasts_df = pd.DataFrame(cols, index=utt_ids) - return forecasts_df \ No newline at end of file + return forecasts_df diff --git a/convokit/forecaster/forecaster.py b/convokit/forecaster/forecaster.py index 0e0b485cb..dc2a037e8 100644 --- a/convokit/forecaster/forecaster.py +++ b/convokit/forecaster/forecaster.py @@ -124,19 +124,27 @@ def fit( self.forecaster_model.fit(contexts, val_contexts) return self - + def fit_decision_policy(self, corpus, context_selector, val_context_selector): - contexts = self._create_context_iterator(corpus, context_selector, include_future_context=True) + contexts = self._create_context_iterator( + corpus, context_selector, include_future_context=True + ) val_contexts = None if val_context_selector is not None: - val_contexts = self._create_context_iterator(corpus, val_context_selector, include_future_context=True) + val_contexts = self._create_context_iterator( + corpus, val_context_selector, include_future_context=True + ) return self.forecaster_model.fit_decision_policy(contexts, val_contexts) - + def fit_belief_estimator(self, corpus, context_selector, val_context_selector): - contexts = self._create_context_iterator(corpus, context_selector, include_future_context=True) + contexts = self._create_context_iterator( + corpus, context_selector, include_future_context=True + ) val_contexts = None if val_context_selector is not None: - val_contexts = self._create_context_iterator(corpus, val_context_selector, include_future_context=True) + val_contexts = self._create_context_iterator( + corpus, val_context_selector, include_future_context=True + ) return self.forecaster_model.fit_belief_estimator(contexts, val_contexts) def transform( @@ -157,7 +165,10 @@ def transform( """ contexts = self._create_context_iterator(corpus, context_selector) forecast_df = self.forecaster_model.transform( - contexts, self.forecast_attribute_name, self.forecast_prob_attribute_name, **kwargs, + contexts, + self.forecast_attribute_name, + self.forecast_prob_attribute_name, + **kwargs, ) # generalize addition of metadata columns diff --git a/convokit/forecaster/forecasterModel.py b/convokit/forecaster/forecasterModel.py index 168d52786..49e0dd278 100644 --- a/convokit/forecaster/forecasterModel.py +++ b/convokit/forecaster/forecasterModel.py @@ -52,9 +52,7 @@ def decision_policy(self, value): self._decision_policy = value if self._decision_policy is not None: self._decision_policy.labeler = self._labeler - self._decision_policy.forecast_prob_attribute_name = ( - self._forecast_prob_attribute_name - ) + self._decision_policy.forecast_prob_attribute_name = self._forecast_prob_attribute_name @abstractmethod def fit(self, contexts, val_contexts=None): diff --git a/examples/decisionpolicy/decisionpolicy_demo.ipynb b/examples/decisionpolicy/decisionpolicy_demo.ipynb index 79caffd36..50a4ffca7 100644 --- a/examples/decisionpolicy/decisionpolicy_demo.ipynb +++ b/examples/decisionpolicy/decisionpolicy_demo.ipynb @@ -1,2539 +1,3317 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "90659cc6", - "metadata": {}, - "source": [ - "# Decision Policy Demo\n", - "\n", - "This notebook will provide code demonstrating how to use Decision Policies as introduced in Wait! There's a Way Out. This notebook will also provide code for running the experiments in the paper. " - ] + "cells": [ + { + "cell_type": "markdown", + "id": "90659cc6", + "metadata": {}, + "source": [ + "# Decision Policy Demo\n", + "\n", + "This notebook will provide code demonstrating how to use Decision Policies as introduced in Wait! There's a Way Out. This notebook will also provide code for running the experiments in the paper. " + ] + }, + { + "cell_type": "markdown", + "id": "7e8e6367", + "metadata": {}, + "source": [ + "## 1. Imports and downloads" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "703021a8", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO\n", + "\n", + "import os\n", + "os.environ['CUDA_VISIBLE_DEVICES'] = '2'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd8b87be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n" + ] }, { - "cell_type": "code", - "execution_count": 1, - "id": "703021a8", - "metadata": {}, - "outputs": [], - "source": [ - "# TODO\n", - "\n", - "import os\n", - "os.environ['CUDA_VISIBLE_DEVICES'] = '2'" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-05-09 06:39:57.997129: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2026-05-09 06:39:58.017604: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1778308798.042093 1608381 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1778308798.050215 1608381 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1778308798.070817 1608381 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1778308798.070837 1608381 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1778308798.070840 1608381 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1778308798.070842 1608381 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "2026-05-09 06:39:58.076717: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] }, { - "cell_type": "code", - "execution_count": 2, - "id": "fd8b87be", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2026-04-28 07:19:59.106329: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", - "2026-04-28 07:19:59.126464: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "E0000 00:00:1777360799.150730 1126746 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "E0000 00:00:1777360799.158776 1126746 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "W0000 00:00:1777360799.179235 1126746 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1777360799.179259 1126746 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1777360799.179261 1126746 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1777360799.179264 1126746 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "2026-04-28 07:19:59.185112: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "🦥 Unsloth Zoo will now patch everything to make training faster!\n" - ] - } - ], - "source": [ - "import os\n", - "import argparse\n", - "import sys\n", - "import glob\n", - "\n", - "from functools import partial\n", - "import json\n", - "from convokit import Corpus, Forecaster, download\n", - "from convokit.forecaster.TransformerDecoderModel import TransformerDecoderModel\n", - "from convokit.forecaster.TransformerForecasterConfig import TransformerForecasterConfig\n", - "from convokit.decisionpolicy import DeferralDecisionPolicy, ThresholdDecisionPolicy\n", - "from convokit.utterance_simulator.unslothUtteranceSimulatorModel import UnslothUtteranceSimulatorModel" + "name": "stdout", + "output_type": "stream", + "text": [ + "🦥 Unsloth Zoo will now patch everything to make training faster!\n" + ] + } + ], + "source": [ + "import os\n", + "import argparse\n", + "import sys\n", + "import glob\n", + "\n", + "from functools import partial\n", + "import json\n", + "from convokit import Corpus, Forecaster, download\n", + "from convokit.forecaster.TransformerDecoderModel import TransformerDecoderModel\n", + "from convokit.forecaster.TransformerForecasterConfig import TransformerForecasterConfig\n", + "from convokit.decisionpolicy import DeferralDecisionPolicy, ThresholdDecisionPolicy, SimulationAverageDecisionPolicy, SimulationMajorityDecisionPolicy, RandomDeferralDecisionPolicy\n", + "from convokit.utterance_simulator.unslothUtteranceSimulatorModel import UnslothUtteranceSimulatorModel" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "15f977d3", + "metadata": {}, + "outputs": [], + "source": [ + "# Set repo root\n", + "\n", + "from pathlib import Path\n", + "\n", + "repo_root = Path.cwd()\n", + "while repo_root.name != \"ConvoKit\":\n", + " repo_root = repo_root.parent\n", + "\n", + "repo_root = str(repo_root)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "18f2375b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] using cached decisionpolicy-demo at /home/lyk25/.convokit/saved-corpora/decisionpolicy-demo\n" + ] + } + ], + "source": [ + "# TODO temporary pre-merge downloader for decisionpolicy-demo\n", + "from pathlib import Path\n", + "import json\n", + "import urllib.request\n", + "import zipfile\n", + "\n", + "from convokit import Corpus\n", + "\n", + "DOWNLOAD_CONFIG_PATH = Path(\"/reef/lyk25/ConvoKit/download_config.json\")\n", + "\n", + "\n", + "def get_dataset_url(config_path=DOWNLOAD_CONFIG_PATH, dataset=\"decisionpolicy-demo\"):\n", + " print(f\"[info] reading download config from {config_path}\")\n", + " with open(config_path) as infile:\n", + " dataset_config = json.load(infile)\n", + " try:\n", + " return dataset_config[\"DatasetURLs\"][dataset]\n", + " except KeyError as exc:\n", + " raise KeyError(f\"{dataset} is missing from local download_config.json\") from exc\n", + "\n", + "def download_dataset(data_dir=None, dataset_name=\"decisionpolicy-demo\"):\n", + " data_root = Path(data_dir or \"~/.convokit/saved-corpora\").expanduser()\n", + " dataset_dir = data_root / dataset_name\n", + " zip_path = data_root / f\"{dataset_name}.zip\"\n", + "\n", + " if any(path.is_dir() and (path / \"index.json\").exists() for path in dataset_dir.rglob(\"*\")):\n", + " print(f\"[info] using cached {dataset_name} at {dataset_dir}\")\n", + " return dataset_dir\n", + "\n", + " url = get_dataset_url(dataset=dataset_name)\n", + " data_root.mkdir(parents=True, exist_ok=True)\n", + " print(f\"[info] downloading {dataset_name} from {url}\")\n", + " urllib.request.urlretrieve(url, zip_path)\n", + "\n", + " print(f\"[info] extracting {zip_path} to {data_root}\")\n", + " with zipfile.ZipFile(zip_path, \"r\") as zipf:\n", + " zipf.extractall(data_root)\n", + "\n", + " if not dataset_dir.exists():\n", + " raise FileNotFoundError(f\"expected extracted folder missing: {dataset_dir}\")\n", + " return dataset_dir\n", + "\n", + "base = download_dataset()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "858a8431", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] test-seed corpora: 5 (test-seed-1, test-seed-2, test-seed-3, test-seed-4, test-seed-5); seed-* policy corpora in corpora_all: 25\n" + ] + } + ], + "source": [ + "import re\n", + "corpus_dirs = sorted(\n", + " corpus_dir\n", + " for corpus_dir in base.rglob(\"*\")\n", + " if corpus_dir.is_dir() and (corpus_dir / \"index.json\").exists()\n", + ")\n", + "if not corpus_dirs:\n", + " raise FileNotFoundError(f\"no convokit corpora found under {base}\")\n", + "_seed_policy_re = re.compile(r\"^seed-(\\d+)-(.+)$\")\n", + "_test_seed_re = re.compile(r\"^test-seed-(\\d+)$\")\n", + "corpora_all = {}\n", + "corpora = {}\n", + "for corpus_dir in corpus_dirs:\n", + " if _test_seed_re.match(corpus_dir.name):\n", + " corpora[corpus_dir.name] = Corpus(filename=str(corpus_dir))\n", + " continue\n", + " m_test = _test_seed_re.match(corpus_dir.parent.name)\n", + " if m_test:\n", + " corpora[f\"test-seed-{m_test.group(1)}\"] = Corpus(filename=str(corpus_dir))\n", + " continue\n", + " m = _seed_policy_re.match(corpus_dir.parent.name)\n", + " if m and corpus_dir.name == m.group(2):\n", + " corpora_all[f\"seed-{m.group(1)}-{m.group(2)}\"] = Corpus(filename=str(corpus_dir))\n", + "CORPUS_POLICY_PER_SEED = \"DeferralDecisionPolicy\"\n", + "if not corpora:\n", + " for key in sorted(corpora_all):\n", + " m = _seed_policy_re.match(key)\n", + " if m and m.group(2) == CORPUS_POLICY_PER_SEED:\n", + " corpora[f\"test-seed-{m.group(1)}\"] = corpora_all[key]\n", + "if not corpora:\n", + " raise FileNotFoundError(\n", + " f\"no test-seed- corpora under {base} and none derived from {CORPUS_POLICY_PER_SEED!r}\"\n", + " )\n", + "print(\n", + " f\"[info] test-seed corpora: {len(corpora)} ({', '.join(sorted(corpora))}); \"\n", + " f\"seed-* policy corpora in corpora_all: {len(corpora_all)}\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a0bbbd7f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'seed-1-DeferralDecisionPolicy': ,\n", + " 'seed-1-RandomDeferralDecisionPolicy': ,\n", + " 'seed-1-SimulationAverageDecisionPolicy': ,\n", + " 'seed-1-SimulationMajorityDecisionPolicy': ,\n", + " 'seed-1-ThresholdDecisionPolicy': ,\n", + " 'seed-2-DeferralDecisionPolicy': ,\n", + " 'seed-2-RandomDeferralDecisionPolicy': ,\n", + " 'seed-2-SimulationAverageDecisionPolicy': ,\n", + " 'seed-2-SimulationMajorityDecisionPolicy': ,\n", + " 'seed-2-ThresholdDecisionPolicy': ,\n", + " 'seed-3-DeferralDecisionPolicy': ,\n", + " 'seed-3-RandomDeferralDecisionPolicy': ,\n", + " 'seed-3-SimulationAverageDecisionPolicy': ,\n", + " 'seed-3-SimulationMajorityDecisionPolicy': ,\n", + " 'seed-3-ThresholdDecisionPolicy': ,\n", + " 'seed-4-DeferralDecisionPolicy': ,\n", + " 'seed-4-RandomDeferralDecisionPolicy': ,\n", + " 'seed-4-SimulationAverageDecisionPolicy': ,\n", + " 'seed-4-SimulationMajorityDecisionPolicy': ,\n", + " 'seed-4-ThresholdDecisionPolicy': ,\n", + " 'seed-5-DeferralDecisionPolicy': ,\n", + " 'seed-5-RandomDeferralDecisionPolicy': ,\n", + " 'seed-5-SimulationAverageDecisionPolicy': ,\n", + " 'seed-5-SimulationMajorityDecisionPolicy': ,\n", + " 'seed-5-ThresholdDecisionPolicy': }" ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "corpora_all" + ] + }, + { + "cell_type": "markdown", + "id": "dab74642", + "metadata": {}, + "source": [ + "Having imported our DeferralDecisionPolicy and ThresholdDecisionPolicy, we now will first define all of the other decision policies to benchmark. " + ] + }, + { + "cell_type": "markdown", + "id": "65c78756", + "metadata": {}, + "source": [ + "## 2. Loading simulators" + ] + }, + { + "cell_type": "markdown", + "id": "0498693e", + "metadata": {}, + "source": [ + "Since we use simulations in our baselines, we must define a simulation configuration as follows: " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "638fb31c", + "metadata": {}, + "outputs": [], + "source": [ + "SIMULATOR_TRAIN_CONFIG = {\n", + " \"per_device_train_batch_size\": 16,\n", + " \"per_device_eval_batch_size\": 16,\n", + " \"eval_strategy\": \"steps\",\n", + " \"save_strategy\": \"steps\",\n", + " \"save_steps\": 30,\n", + " \"gradient_accumulation_steps\": 4,\n", + " \"warmup_steps\": 5,\n", + " \"num_train_epochs\": 1,\n", + " \"eval_steps\": 30,\n", + " \"learning_rate\": 2e-4,\n", + " \"logging_steps\": 5,\n", + " \"optim\": \"adamw_8bit\",\n", + " \"weight_decay\": 0.01,\n", + " \"lr_scheduler_type\": \"linear\",\n", + " \"output_dir\": \"outputs/simulator_finetune\",\n", + " \"logging_dir\": \"logs\",\n", + " \"load_best_model_at_end\": True,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "bf55d140", + "metadata": {}, + "outputs": [], + "source": [ + "TAU = 7\n", + "DEFERRAL_PROBABILITY_THRESHOLD = 0.2518938553561718\n", + "NUM_SIMULATIONS = 10\n", + "OUTPUT_DIR = \"benchmark_preannotated\"\n", + "SEEDS = [1,2,3,4,5]" + ] + }, + { + "cell_type": "markdown", + "id": "fe147ae8", + "metadata": {}, + "source": [ + "After loading the simulator model, we define context selectors." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a9502041", + "metadata": {}, + "outputs": [], + "source": [ + "def context_selector(context_tuple, split):\n", + " \"\"\"\n", + " We use this generic function for both training and validation data.\n", + " In both cases, its job is to select only those contexts for which the\n", + " FUTURE context is not empty, so we have a next utterance to predict.\n", + " \"\"\"\n", + " matches_split = (context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split)\n", + " is_end = (len(context_tuple.future_context) == 0)\n", + " return matches_split and not is_end\n", + "\n", + "def make_data_selector(split):\n", + " return lambda context_tuple: context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split\n", + "\n", + "train_context_selector = partial(context_selector, split=\"train\")\n", + "val_context_selector = partial(context_selector, split=\"val\")\n", + "test_context_selector = partial(context_selector, split=\"test\")" + ] + }, + { + "cell_type": "markdown", + "id": "e3c6f428", + "metadata": {}, + "source": [ + "A faster reproduction is possible by skipping retraining, instead transforming the corpus using the existing simulations and forecast probabilities." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "aedd02fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==((====))== Unsloth 2025.7.11: Fast Llama patching. Transformers: 4.53.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" + ] }, { - "cell_type": "code", - "execution_count": 3, - "id": "15f977d3", - "metadata": {}, - "outputs": [], - "source": [ - "# Set repo root\n", - "\n", - "from pathlib import Path\n", - "\n", - "repo_root = Path.cwd()\n", - "while repo_root.name != \"ConvoKit\":\n", - " repo_root = repo_root.parent\n", - "\n", - "repo_root = str(repo_root)" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "Unsloth 2025.7.11 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n", + "Unsloth: Already have LoRA adapters! We shall skip this step.\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "id": "18f2375b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] using cached decisionpolicy-demo at /home/lyk25/.convokit/saved-corpora/decisionpolicy-demo\n", - "[info] loaded 26 corpora from /home/lyk25/.convokit/saved-corpora/decisionpolicy-demo\n" - ] - } - ], - "source": [ - "# TODO temporary pre-merge downloader for decisionpolicy-demo\n", - "from pathlib import Path\n", - "import json\n", - "import urllib.request\n", - "import zipfile\n", - "\n", - "from convokit import Corpus\n", - "\n", - "DOWNLOAD_CONFIG_URL = (\n", - " \"https://raw.githubusercontent.com/laerdon/ConvoKit/\"\n", - " \"master/download_config.json\"\n", - ")\n", - "\n", - "\n", - "def get_decisionpolicy_demo_url(config_url=DOWNLOAD_CONFIG_URL):\n", - " print(f\"[info] reading download config from {config_url}\")\n", - " with urllib.request.urlopen(config_url) as response:\n", - " dataset_config = json.load(response)\n", - " try:\n", - " return dataset_config[\"DatasetURLs\"][\"decisionpolicy-demo\"]\n", - " except KeyError as exc:\n", - " raise KeyError(\n", - " \"decisionpolicy-demo is missing from laerdon/ConvoKit master download_config.json\"\n", - " ) from exc\n", - "\n", - "\n", - "def download_decisionpolicy_demo(data_dir=None):\n", - " data_root = Path(data_dir or \"~/.convokit/saved-corpora\").expanduser()\n", - " dataset_name = \"decisionpolicy-demo\"\n", - " dataset_dir = data_root / dataset_name\n", - " zip_path = data_root / f\"{dataset_name}.zip\"\n", - "\n", - " if any(path.is_dir() and (path / \"index.json\").exists() for path in dataset_dir.rglob(\"*\")):\n", - " print(f\"[info] using cached {dataset_name} at {dataset_dir}\")\n", - " return dataset_dir\n", - "\n", - " url = get_decisionpolicy_demo_url()\n", - " data_root.mkdir(parents=True, exist_ok=True)\n", - " print(f\"[info] downloading {dataset_name} from {url}\")\n", - " urllib.request.urlretrieve(url, zip_path)\n", - "\n", - " print(f\"[info] extracting {zip_path} to {data_root}\")\n", - " with zipfile.ZipFile(zip_path, \"r\") as zipf:\n", - " zipf.extractall(data_root)\n", - "\n", - " if not dataset_dir.exists():\n", - " raise FileNotFoundError(f\"expected extracted folder missing: {dataset_dir}\")\n", - " return dataset_dir\n", - "\n", - "base = download_decisionpolicy_demo()" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Unsloth: Training embed_tokens in mixed precision to save VRAM\n", + "Unsloth: Training lm_head in mixed precision to save VRAM\n" + ] + } + ], + "source": [ + "simulator_model = UnslothUtteranceSimulatorModel(\n", + " model_name=\"/reef/lyk25/dynamic_training/game_analysis/outputs/checkpoint-74\",\n", + " train_config=SIMULATOR_TRAIN_CONFIG,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "407b2444", + "metadata": {}, + "source": [ + "## 3. Performance benchmarking" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "2f4a29c2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unsloth: If you want to finetune Gemma 2, install flash-attn to make it faster!\n", + "To install flash-attn, do the below:\n", + "\n", + "pip install --no-deps --upgrade \"flash-attn>=2.6.3\"\n", + "==((====))== Unsloth 2025.7.11: Fast Gemma2 patching. Transformers: 4.53.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", + "---\n", + "fitting policy ThresholdDecisionPolicy for seed 1\n", + "starting transformation.\n" + ] }, { - "cell_type": "code", - "execution_count": 6, - "id": "858a8431", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] using cached decisionpolicy-demo at /home/lyk25/.convokit/saved-corpora/decisionpolicy-demo\n", - "[info] test-seed corpora: 5 (test-seed-1, test-seed-2, test-seed-3, test-seed-4, test-seed-5); seed-* policy corpora in corpora_all: 25\n" - ] - } - ], - "source": [ - "import re\n", - "corpus_dirs = sorted(\n", - " corpus_dir\n", - " for corpus_dir in base.rglob(\"*\")\n", - " if corpus_dir.is_dir() and (corpus_dir / \"index.json\").exists()\n", - ")\n", - "if not corpus_dirs:\n", - " raise FileNotFoundError(f\"no convokit corpora found under {base}\")\n", - "_seed_policy_re = re.compile(r\"^seed-(\\d+)-(.+)$\")\n", - "_test_seed_re = re.compile(r\"^test-seed-(\\d+)$\")\n", - "corpora_all = {}\n", - "corpora = {}\n", - "for corpus_dir in corpus_dirs:\n", - " if _test_seed_re.match(corpus_dir.name):\n", - " corpora[corpus_dir.name] = Corpus(filename=str(corpus_dir))\n", - " continue\n", - " m_test = _test_seed_re.match(corpus_dir.parent.name)\n", - " if m_test:\n", - " corpora[f\"test-seed-{m_test.group(1)}\"] = Corpus(filename=str(corpus_dir))\n", - " continue\n", - " m = _seed_policy_re.match(corpus_dir.parent.name)\n", - " if m and corpus_dir.name == m.group(2):\n", - " corpora_all[f\"seed-{m.group(1)}-{m.group(2)}\"] = Corpus(filename=str(corpus_dir))\n", - "CORPUS_POLICY_PER_SEED = \"DeferralDecisionPolicy\"\n", - "if not corpora:\n", - " for key in sorted(corpora_all):\n", - " m = _seed_policy_re.match(key)\n", - " if m and m.group(2) == CORPUS_POLICY_PER_SEED:\n", - " corpora[f\"test-seed-{m.group(1)}\"] = corpora_all[key]\n", - "if not corpora:\n", - " raise FileNotFoundError(\n", - " f\"no test-seed- corpora under {base} and none derived from {CORPUS_POLICY_PER_SEED!r}\"\n", - " )\n", - "print(\n", - " f\"[info] test-seed corpora: {len(corpora)} ({', '.join(sorted(corpora))}); \"\n", - " f\"seed-* policy corpora in corpora_all: {len(corpora_all)}\"\n", - ")" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:00, 47182.98it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": 8, - "id": "a0bbbd7f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'seed-1-DeferralDecisionPolicy': ,\n", - " 'seed-1-RandomDeferralDecisionPolicy': ,\n", - " 'seed-1-SimulationAverageDecisionPolicy': ,\n", - " 'seed-1-SimulationMajorityDecisionPolicy': ,\n", - " 'seed-1-ThresholdDecisionPolicy': ,\n", - " 'seed-2-DeferralDecisionPolicy': ,\n", - " 'seed-2-RandomDeferralDecisionPolicy': ,\n", - " 'seed-2-SimulationAverageDecisionPolicy': ,\n", - " 'seed-2-SimulationMajorityDecisionPolicy': ,\n", - " 'seed-2-ThresholdDecisionPolicy': ,\n", - " 'seed-3-DeferralDecisionPolicy': ,\n", - " 'seed-3-RandomDeferralDecisionPolicy': ,\n", - " 'seed-3-SimulationAverageDecisionPolicy': ,\n", - " 'seed-3-SimulationMajorityDecisionPolicy': ,\n", - " 'seed-3-ThresholdDecisionPolicy': ,\n", - " 'seed-4-DeferralDecisionPolicy': ,\n", - " 'seed-4-RandomDeferralDecisionPolicy': ,\n", - " 'seed-4-SimulationAverageDecisionPolicy': ,\n", - " 'seed-4-SimulationMajorityDecisionPolicy': ,\n", - " 'seed-4-ThresholdDecisionPolicy': ,\n", - " 'seed-5-DeferralDecisionPolicy': ,\n", - " 'seed-5-RandomDeferralDecisionPolicy': ,\n", - " 'seed-5-SimulationAverageDecisionPolicy': ,\n", - " 'seed-5-SimulationMajorityDecisionPolicy': ,\n", - " 'seed-5-ThresholdDecisionPolicy': }" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "corpora_all" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7104, p=0.6716, r=0.8237, fpr=0.4028, f1=0.7399\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] }, { - "cell_type": "markdown", - "id": "dab74642", - "metadata": {}, - "source": [ - "Having imported our DeferralDecisionPolicy and ThresholdDecisionPolicy, we now will first define all of the other decision policies to benchmark. " + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": null, - "id": "5dabf0bd", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Callable, List, Optional, Dict, Any, Tuple\n", - "import numpy as np\n", - "from convokit.decisionpolicy import DecisionPolicy\n", - "\n", - "\n", - "class _synthetic_speaker:\n", - " def __init__(self, speaker_id: str):\n", - " self.id = speaker_id\n", - "\n", - "\n", - "class _synthetic_utterance:\n", - " def __init__(self, text: str, utterance_id: str, speaker_id: str):\n", - " self.text = text\n", - " self.id = utterance_id\n", - " self.speaker_ = _synthetic_speaker(speaker_id)\n", - " self.meta = {}\n", - "\n", - " def get_conversation(self):\n", - " return None\n", - "\n", - "\n", - "class RandomDeferralDecisionPolicy(DecisionPolicy):\n", - " \"\"\"\n", - " Decision policy that defers intervention by looking ahead at simulated next utterances.\n", - "\n", - " :param simulator: utterance simulator model (must have a ``transform(contexts)`` method\n", - " returning a DataFrame indexed by utterance id). if the simulator exposes\n", - " ``get_num_simulations()``, ``num_simulations`` is capped to that value.\n", - " :param threshold: probability threshold above which a context is flagged.\n", - " :param tau: minimum number of simulated branches that must exceed the threshold\n", - " before an intervention is issued.\n", - " :param num_simulations: how many simulated branches to use per context (capped to\n", - " simulator's ``get_num_simulations()`` if available).\n", - " :param store_simulations: if True, simulated reply strings are cached during decide()\n", - " and written to corpus utterance metadata by post_transform().\n", - " :param simulated_reply_attribute_name: metadata field name used when storing simulations\n", - " on corpus utterances (only relevant when store_simulations=True).\n", - " \"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " simulator,\n", - " threshold,\n", - " deferral_probability: float = 0.1515,\n", - " reuse_cached_forecast_probs: bool = True,\n", - " forecast_prob_attribute_name: str = \"forecast_prob\",\n", - " ):\n", - " # forward the cache flag to the base class so its _score helper honors it.\n", - " # without this, reuse_cached_probabilities on this subclass had no effect.\n", - " super().__init__(\n", - " forecast_prob_attribute_name=forecast_prob_attribute_name,\n", - " reuse_cached_forecast_probs=reuse_cached_forecast_probs,\n", - " )\n", - " self.simulator = simulator\n", - " self.threshold = float(threshold)\n", - " self.deferral_probability = float(deferral_probability)\n", - "\n", - " def _decision_score(self, context, score_fn: Callable):\n", - " # use base _score so a cached forecast_prob on the utterance meta is reused\n", - " # instead of re-invoking the belief estimator.\n", - " return self._score(context, score_fn)\n", - "\n", - " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", - " decision_score = self._score(context, score_fn)\n", - "\n", - " p = float(np.random.rand())\n", - " \n", - "\n", - " # return an empty metadata dict (not None) so downstream code that iterates\n", - " # utt_metadata.items() in TransformerDecoderModel.transform doesn't crash.\n", - " return (decision_score,\n", - " 1 if decision_score > self.threshold and p > self.deferral_probability else 0,\n", - " {}\n", - " )\n", - "\n", - " def fit(self, contexts, val_contexts=None, score_fn: Callable = None):\n", - " if val_contexts is None or score_fn is None or self.labeler is None:\n", - " print(\"either no validation contexts/score function/labeler were provided, returning current threshold\")\n", - " return {\"best_threshold\": self.threshold}\n", - "\n", - " val_contexts = list(val_contexts)\n", - " if len(val_contexts) == 0:\n", - " print(\"no validation contexts were provided, returning current threshold\")\n", - " return {\"best_threshold\": self.threshold}\n", - "\n", - " fit_result = self._fit_with_model_checkpoint_selection(val_contexts, score_fn=score_fn)\n", - " if isinstance(fit_result, dict):\n", - " if \"best_threshold\" in fit_result:\n", - " self.threshold = float(fit_result[\"best_threshold\"])\n", - " return fit_result\n", - "\n", - " fit_result = self._fit_threshold_for_loaded_model(val_contexts, score_fn=score_fn)\n", - " if \"best_threshold\" in fit_result:\n", - " self.threshold = float(fit_result[\"best_threshold\"])\n", - " return fit_result" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.100439422473321, Median = 2.0\n", + "Accuracy 0.710445\n", + "Precision 0.671585\n", + "Recall 0.823681\n", + "FPR 0.402792\n", + "F1 0.739898\n", + "Mean H 3.100439\n", + "Correct Adjustment 0.098501\n", + "Incorrect Adjustment 0.063599\n", + "Recovery 0.034902\n", + "Leaderboard String | MODEL_NAME | 71.0 | 67.2 | 82.4 | 74....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "fitting policy DeferralDecisionPolicy for seed 1\n", + "starting transformation.\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "id": "9d3db5bc", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Callable, Optional, Dict, Any, Tuple\n", - "\n", - "from convokit.decisionpolicy import DeferralDecisionPolicy\n", - "\n", - "\n", - "class SimulationAverageDecisionPolicy(DeferralDecisionPolicy):\n", - " \"\"\"\n", - " decision policy that intervenes if the mean of the simulated next-utterance\n", - " scores is at or above the threshold.\n", - "\n", - " this subclass inherits all simulation fetching, per-utterance metadata\n", - " caching, sim-score caching, and threshold fitting from\n", - " DeferralDecisionPolicy. the only differences are:\n", - " * no ``tau`` parameter (unused; forwarded as 0 to super)\n", - " * ``decide`` predicts based on mean(simulation_scores) >= threshold\n", - " \"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " simulator,\n", - " threshold,\n", - " num_simulations: int = 10,\n", - " store_simulations: bool = False,\n", - " simulated_reply_attribute_name: str = \"sim_replies\",\n", - " sim_replies_forecast_probs_attribute_name: str = \"sim_replies_forecast_probs\",\n", - " reuse_cached_simulations: bool = True,\n", - " ):\n", - " # tau is irrelevant for the mean-based decision rule, so we pin it to 0\n", - " # upstream rather than expose it to callers of this subclass.\n", - " super().__init__(\n", - " simulator=simulator,\n", - " threshold=threshold,\n", - " tau=0,\n", - " num_simulations=num_simulations,\n", - " store_simulations=store_simulations,\n", - " simulated_reply_attribute_name=simulated_reply_attribute_name,\n", - " sim_replies_forecast_probs_attribute_name=sim_replies_forecast_probs_attribute_name,\n", - " reuse_cached_simulations=reuse_cached_simulations,\n", - " )\n", - "\n", - " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", - " decision_score, simulations, simulation_scores = self._decision_score(context, score_fn)\n", - " # empty simulation_scores would zero-divide. this happens when the\n", - " # simulator returns no completions for a context (e.g. end-of-conversation\n", - " # contexts that slip through the selector). treat as no intervention so\n", - " # a single degenerate context doesn't abort the whole transform run.\n", - " if len(simulation_scores) == 0:\n", - " average_simulation_score = 0.0\n", - " pred = 0\n", - " else:\n", - " average_simulation_score = sum(simulation_scores) / len(simulation_scores)\n", - " pred = 1 if average_simulation_score >= self.threshold else 0\n", - " return (\n", - " decision_score,\n", - " pred,\n", - " {\n", - " self.simulated_reply_attribute_name: simulations,\n", - " self.sim_replies_forecast_probs_attribute_name: simulation_scores,\n", - " },\n", - " )\n" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4346.34it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "id": "d0d1ea7a", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Callable, Optional, Dict, Any, Tuple\n", - "\n", - "from convokit.decisionpolicy import DeferralDecisionPolicy\n", - "\n", - "\n", - "class SimulationMajorityDecisionPolicy(DeferralDecisionPolicy):\n", - " \"\"\"\n", - " decision policy that intervenes if at least ``tau`` of the simulated next\n", - " utterances score above the threshold, ignoring the current utterance score.\n", - "\n", - " this subclass inherits all simulation fetching, per-utterance metadata\n", - " caching, sim-score caching, and threshold fitting from\n", - " DeferralDecisionPolicy. the only difference is in ``decide``: the gate\n", - " ``decision_score > threshold`` is dropped so that only the simulated-branch\n", - " vote count drives the prediction.\n", - " \"\"\"\n", - "\n", - " def decide(self, context, score_fn: Callable) -> Tuple[float, int, Optional[Dict[str, Any]]]:\n", - " decision_score, simulations, simulation_scores = self._decision_score(context, score_fn)\n", - " num_simulations_above_threshold = sum(\n", - " 1 for score in simulation_scores if score > self.threshold\n", - " )\n", - " return (\n", - " decision_score,\n", - " 1 if num_simulations_above_threshold >= self.tau else 0,\n", - " {\n", - " self.simulated_reply_attribute_name: simulations,\n", - " self.sim_replies_forecast_probs_attribute_name: simulation_scores,\n", - " },\n", - " )\n" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7182, p=0.7063, r=0.7472, fpr=0.3108, f1=0.7261\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] }, { - "cell_type": "markdown", - "id": "0498693e", - "metadata": {}, - "source": [ - "Since we use simulations in our baselines, we must define a simulation configuration as follows: " + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": null, - "id": "638fb31c", - "metadata": {}, - "outputs": [], - "source": [ - "SIMULATOR_TRAIN_CONFIG = {\n", - " \"per_device_train_batch_size\": 16,\n", - " \"per_device_eval_batch_size\": 16,\n", - " \"eval_strategy\": \"steps\",\n", - " \"save_strategy\": \"steps\",\n", - " \"save_steps\": 30,\n", - " \"gradient_accumulation_steps\": 4,\n", - " \"warmup_steps\": 5,\n", - " \"num_train_epochs\": 1,\n", - " \"eval_steps\": 30,\n", - " \"learning_rate\": 2e-4,\n", - " \"logging_steps\": 5,\n", - " \"optim\": \"adamw_8bit\",\n", - " \"weight_decay\": 0.01,\n", - " \"lr_scheduler_type\": \"linear\",\n", - " \"output_dir\": \"outputs/simulator_finetune\",\n", - " \"logging_dir\": \"logs\",\n", - " \"load_best_model_at_end\": True,\n", - "}" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.8996539792387543, Median = 2.0\n", + "Accuracy 0.718201\n", + "Precision 0.706256\n", + "Recall 0.747156\n", + "FPR 0.310755\n", + "F1 0.726131\n", + "Mean H 2.899654\n", + "Correct Adjustment 0.077301\n", + "Incorrect Adjustment 0.069028\n", + "Recovery 0.008273\n", + "Leaderboard String | MODEL_NAME | 71.8 | 70.6 | 74.7 | 72....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "[info] summarize only: RandomDeferralDecisionPolicy seed 1\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "id": "bf55d140", - "metadata": {}, - "outputs": [], - "source": [ - "TAU = 7\n", - "DEFERRAL_PROBABILITY_THRESHOLD = 0.2518938553561718\n", - "NUM_SIMULATIONS = 10\n", - "OUTPUT_DIR = \"benchmark_preannotated\"\n", - "SEEDS = [1,2,3,4,5]" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": null, - "id": "aedd02fe", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "==((====))== Unsloth 2025.7.11: Fast Llama patching. Transformers: 4.53.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Unsloth 2025.7.11 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n", - "Unsloth: Already have LoRA adapters! We shall skip this step.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Unsloth: Training embed_tokens in mixed precision to save VRAM\n", - "Unsloth: Training lm_head in mixed precision to save VRAM\n" - ] - } - ], - "source": [ - "simulator_model = UnslothUtteranceSimulatorModel(\n", - " model_name=\"/reef/lyk25/dynamic_training/game_analysis/outputs/checkpoint-74\",\n", - " train_config=SIMULATOR_TRAIN_CONFIG,\n", - ")" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.984858912594632, Median = 2.0\n", + "Accuracy 0.696484\n", + "Precision 0.677074\n", + "Recall 0.751293\n", + "FPR 0.358325\n", + "F1 0.712255\n", + "Mean H 2.984859\n", + "Correct Adjustment 0.102637\n", + "Incorrect Adjustment 0.119442\n", + "Recovery -0.016805\n", + "Leaderboard String | MODEL_NAME | 69.6 | 67.7 | 75.1 | 71....\n", + "dtype: object\n", + "---\n", + "fitting policy SimulationAverageDecisionPolicy for seed 1\n", + "starting transformation.\n" + ] }, { - "cell_type": "markdown", - "id": "fe147ae8", - "metadata": {}, - "source": [ - "After loading the simulator model, we define context selectors." - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4338.39it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": 13, - "id": "a9502041", - "metadata": {}, - "outputs": [], - "source": [ - "def context_selector(context_tuple, split):\n", - " \"\"\"\n", - " We use this generic function for both training and validation data.\n", - " In both cases, its job is to select only those contexts for which the\n", - " FUTURE context is not empty, so we have a next utterance to predict.\n", - " \"\"\"\n", - " matches_split = (context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split)\n", - " is_end = (len(context_tuple.future_context) == 0)\n", - " return matches_split and not is_end\n", - "\n", - "def make_data_selector(split):\n", - " return lambda context_tuple: context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split\n", - "\n", - "train_context_selector = partial(context_selector, split=\"train\")\n", - "val_context_selector = partial(context_selector, split=\"val\")\n", - "test_context_selector = partial(context_selector, split=\"test\")" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7014, p=0.6571, r=0.8423, fpr=0.4395, f1=0.7383\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] }, { - "cell_type": "markdown", - "id": "f707a3a5", - "metadata": {}, - "source": [ - "Below is a script to fully reproduce, sans regenerating simulations (simulations requires substantially more compute)." + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": null, - "id": "dde130ed", - "metadata": {}, - "outputs": [], - "source": [ - "for seed_idx in SEEDS:\n", - " train_corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", - " # corpus = Corpus(filename=f'/reef/lyk25/theres-a-way-out-ACL26-internal/outputs/benchmark_preannotated/seed-{seed_idx}-ThresholdDecisionPolicy/ThresholdDecisionPolicy')\n", - " # corpus = Corpus(filename=f'/reef/lyk25/dynamic_training/game_analysis/corpi/test/test-son-seed-{seed_idx}')\n", - " corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", - " corpus.filter_conversations_by(lambda convo: convo.meta['split'] == 'test')\n", - "\n", - " config = TransformerForecasterConfig(\n", - " output_dir=f\"outputs/{OUTPUT_DIR}/forecaster_{seed_idx}\",\n", - " per_device_batch_size=16,\n", - " gradient_accumulation_steps=1,\n", - " num_train_epochs=1,\n", - " learning_rate=1e-5,\n", - " random_seed=seed_idx,\n", - " context_mode=\"normal\",\n", - " device=\"cuda\",\n", - " )\n", - "\n", - " # TODO this will have to be edited\n", - " forecaster_model = TransformerDecoderModel(\n", - " model_name_or_path=\"google/gemma-2-9b-it\",\n", - " config=config,\n", - " )\n", - "\n", - " forecaster = Forecaster(\n", - " forecaster_model=forecaster_model,\n", - " labeler='has_removed_comment',\n", - " )\n", - "\n", - " forecaster.fit_belief_estimator(\n", - " corpus=train_corpus,\n", - " context_selector=train_context_selector,\n", - " val_context_selector=val_context_selector,\n", - " )\n", - "\n", - " # ---\n", - " cfg_path = os.path.join(repo_root, \"saves\", f\"seed-{seed_idx}\", \"dev_config.json\")\n", - " with open(cfg_path) as f:\n", - " cfg = json.load(f)\n", - " best_threshold = cfg['best_threshold']\n", - "\n", - " for policy_trial in [ThresholdDecisionPolicy, DeferralDecisionPolicy, RandomDeferralDecisionPolicy, SimulationAverageDecisionPolicy, SimulationMajorityDecisionPolicy]:\n", - " print('---')\n", - " print(f\"Fitting policy {policy_trial.__name__} for seed {seed_idx}\")\n", - " if policy_trial == ThresholdDecisionPolicy:\n", - " policy = ThresholdDecisionPolicy(\n", - " threshold=best_threshold,\n", - " reuse_cached_forecast_probs=False,\n", - " )\n", - " elif policy_trial == DeferralDecisionPolicy:\n", - " policy = DeferralDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " tau=TAU,\n", - " reuse_cached_forecast_probs=False,\n", - " )\n", - " elif policy_trial == RandomDeferralDecisionPolicy:\n", - " policy = RandomDeferralDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " deferral_probability=DEFERRAL_PROBABILITY_THRESHOLD,\n", - " reuse_cached_forecast_probs=False,\n", - " )\n", - " elif policy_trial == SimulationAverageDecisionPolicy:\n", - " policy = SimulationAverageDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " num_simulations=NUM_SIMULATIONS,\n", - " store_simulations=False,\n", - " simulated_reply_attribute_name=\"sim_replies\",\n", - " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", - " reuse_cached_forecast_probs=False,\n", - " )\n", - " elif policy_trial == SimulationMajorityDecisionPolicy:\n", - " policy = SimulationMajorityDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " tau=TAU,\n", - " num_simulations=NUM_SIMULATIONS,\n", - " store_simulations=False,\n", - " simulated_reply_attribute_name=\"sim_replies\",\n", - " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", - " reuse_cached_forecast_probs=False,\n", - " )\n", - " \n", - " # attach the decision policy to the underlying forecaster model;\n", - " # Forecaster itself does not accept decision_policy in its constructor.\n", - " forecaster_model.decision_policy = policy\n", - "\n", - " forecaster = Forecaster(\n", - " forecaster_model=forecaster_model,\n", - " labeler='has_removed_comment',\n", - " )\n", - "\n", - " print('starting transformation.')\n", - " # evaluate the forecaster on the test set\n", - " forecaster.transform(\n", - " corpus=corpus,\n", - " context_selector=make_data_selector('test'),\n", - " verbose=True,\n", - " )\n", - " print('transformation complete.')\n", - "\n", - " output_dir = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", - " os.makedirs(output_dir, exist_ok=True)\n", - " corpus.dump(name=f\"{policy_trial.__name__}\", base_path=output_dir)\n", - " print('corpus dumped.')\n", - "\n", - " print('starting summarization.')\n", - " # forecaster.summarize expects a conversation-level selector (Callable[[Conversation], bool]),\n", - " # unlike the context-tuple selectors used in fit/transform.\n", - " def summarize_selector(convo):\n", - " return convo.meta.get(\"split\") == \"test\"\n", - " conversational_forecasts_df, metrics = forecaster.summarize(\n", - " corpus=corpus,\n", - " selector=summarize_selector,\n", - " )\n", - " print('summarization complete.')\n", - " \n", - " # path to the seed output directory\n", - " seed_folder = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", - "\n", - " # ensure the directory exists\n", - " os.makedirs(seed_folder, exist_ok=True)\n", - "\n", - " # save conversational_forecasts_df as CSV\n", - " conversational_forecasts_df.to_csv(os.path.join(seed_folder, \"conversational_forecasts.csv\"), index=False)\n", - "\n", - " # save metrics as JSON\n", - " with open(os.path.join(seed_folder, \"metrics.json\"), \"w\") as f:\n", - " json.dump(metrics, f, indent=2)" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.1964395334561084, Median = 3.0\n", + "Accuracy 0.701396\n", + "Precision 0.65712\n", + "Recall 0.842296\n", + "FPR 0.439504\n", + "F1 0.738273\n", + "Mean H 3.19644\n", + "Correct Adjustment 0.105739\n", + "Incorrect Adjustment 0.104188\n", + "Recovery 0.001551\n", + "Leaderboard String | MODEL_NAME | 70.1 | 65.7 | 84.2 | 73....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "fitting policy SimulationMajorityDecisionPolicy for seed 1\n", + "starting transformation.\n" + ] }, { - "cell_type": "markdown", - "id": "e3c6f428", - "metadata": {}, - "source": [ - "A faster reproduction is possible by skipping the training and transformation." - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4302.22it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "id": "2f4a29c2", - "metadata": {}, - "outputs": [], - "source": [ - "for seed_idx in SEEDS:\n", - " config = TransformerForecasterConfig(\n", - " output_dir=f\"outputs/{OUTPUT_DIR}/forecaster_{seed_idx}\",\n", - " per_device_batch_size=16,\n", - " gradient_accumulation_steps=1,\n", - " num_train_epochs=1,\n", - " learning_rate=1e-5,\n", - " random_seed=seed_idx,\n", - " context_mode=\"normal\",\n", - " device=\"cuda\",\n", - " )\n", - "\n", - " # TODO this will have to be edited\n", - " forecaster_model = TransformerDecoderModel(\n", - " model_name_or_path=\"google/gemma-2-9b-it\",\n", - " config=config,\n", - " )\n", - "\n", - " forecaster = Forecaster(\n", - " forecaster_model=forecaster_model,\n", - " labeler='has_removed_comment',\n", - " )\n", - "\n", - " # remove training---we can instead use the cached forecast probabilities.\n", - "\n", - " # ---\n", - " cfg_path = os.path.join(repo_root, \"saves\", f\"seed-{seed_idx}\", \"dev_config.json\")\n", - " with open(cfg_path) as f:\n", - " cfg = json.load(f)\n", - " best_threshold = cfg['best_threshold']\n", - "\n", - " for policy_trial in [ThresholdDecisionPolicy, DeferralDecisionPolicy, RandomDeferralDecisionPolicy, SimulationAverageDecisionPolicy, SimulationMajorityDecisionPolicy]:\n", - " corpus_name = f\"seed-{seed_idx}-{policy_trial.__name__}\"\n", - " if corpus_name in corpora:\n", - " corpus = corpora_all[corpus_name]\n", - " else:\n", - " raise KeyError(f\"missing corpus {corpus_name}\")\n", - "\n", - " print('---')\n", - " print(f\"fitting policy {policy_trial.__name__} for seed {seed_idx}\")\n", - " if policy_trial == ThresholdDecisionPolicy:\n", - " policy = ThresholdDecisionPolicy(\n", - " threshold=best_threshold,\n", - " )\n", - " elif policy_trial == DeferralDecisionPolicy:\n", - " policy = DeferralDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " tau=TAU,\n", - " )\n", - " elif policy_trial == RandomDeferralDecisionPolicy:\n", - " policy = RandomDeferralDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " deferral_probability=DEFERRAL_PROBABILITY_THRESHOLD,\n", - " )\n", - " elif policy_trial == SimulationAverageDecisionPolicy:\n", - " policy = SimulationAverageDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " num_simulations=NUM_SIMULATIONS,\n", - " store_simulations=False,\n", - " simulated_reply_attribute_name=\"sim_replies\",\n", - " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", - " )\n", - " elif policy_trial == SimulationMajorityDecisionPolicy:\n", - " policy = SimulationMajorityDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=best_threshold,\n", - " tau=TAU,\n", - " num_simulations=NUM_SIMULATIONS,\n", - " store_simulations=False,\n", - " simulated_reply_attribute_name=\"sim_replies\",\n", - " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", - " )\n", - " \n", - " # attach the decision policy to the underlying forecaster model;\n", - " # Forecaster itself does not accept decision_policy in its constructor.\n", - " forecaster_model.decision_policy = policy\n", - "\n", - " forecaster = Forecaster(\n", - " forecaster_model=forecaster_model,\n", - " labeler='has_removed_comment',\n", - " )\n", - "\n", - " print('starting transformation.')\n", - " # evaluate the forecaster on the test set\n", - " forecaster.transform(\n", - " corpus=corpus,\n", - " context_selector=make_data_selector('test'),\n", - " verbose=True,\n", - " )\n", - " print('transformation complete.')\n", - "\n", - " output_dir = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", - " os.makedirs(output_dir, exist_ok=True)\n", - " corpus.dump(name=f\"{policy_trial.__name__}\", base_path=output_dir)\n", - " print('corpus dumped.')\n", - "\n", - " print('starting summarization.')\n", - " # forecaster.summarize expects a conversation-level selector (Callable[[Conversation], bool]),\n", - " # unlike the context-tuple selectors used in fit/transform.\n", - " def summarize_selector(convo):\n", - " return convo.meta.get(\"split\") == \"test\"\n", - " conversational_forecasts_df, metrics = forecaster.summarize(\n", - " corpus=corpus,\n", - " selector=summarize_selector,\n", - " )\n", - " print('summarization complete.')\n", - " \n", - " # path to the seed output directory\n", - " seed_folder = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", - "\n", - " # ensure the directory exists\n", - " os.makedirs(seed_folder, exist_ok=True)\n", - "\n", - " # save conversational_forecasts_df as CSV\n", - " conversational_forecasts_df.to_csv(os.path.join(seed_folder, \"conversational_forecasts.csv\"), index=False)\n", - "\n", - " # save metrics as JSON\n", - " with open(os.path.join(seed_folder, \"metrics.json\"), \"w\") as f:\n", - " json.dump(metrics, f, indent=2)" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.6944, p=0.6519, r=0.8345, fpr=0.4457, f1=0.7320\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] }, { - "cell_type": "markdown", - "id": "29a0cdc1", - "metadata": {}, - "source": [ - "## Human benchmark analysis" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 12, - "id": "d673d0d6", - "metadata": {}, - "outputs": [], - "source": [ - "# import human data SQL here" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.2280049566294924, Median = 3.0\n", + "Accuracy 0.694416\n", + "Precision 0.651858\n", + "Recall 0.83454\n", + "FPR 0.445708\n", + "F1 0.731973\n", + "Mean H 3.228005\n", + "Correct Adjustment 0.115564\n", + "Incorrect Adjustment 0.109876\n", + "Recovery 0.005688\n", + "Leaderboard String | MODEL_NAME | 69.4 | 65.2 | 83.5 | 73....\n", + "dtype: object\n", + "summarization complete.\n", + "Unsloth: If you want to finetune Gemma 2, install flash-attn to make it faster!\n", + "To install flash-attn, do the below:\n", + "\n", + "pip install --no-deps --upgrade \"flash-attn>=2.6.3\"\n", + "==((====))== Unsloth 2025.7.11: Fast Gemma2 patching. Transformers: 4.53.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", + "---\n", + "fitting policy ThresholdDecisionPolicy for seed 2\n", + "starting transformation.\n" + ] }, { - "cell_type": "code", - "execution_count": 13, - "id": "d55b3bab", - "metadata": {}, - "outputs": [], - "source": [ - "import sqlite3" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "21768it [00:00, 43078.91it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": 16, - "id": "6047d55a", - "metadata": {}, - "outputs": [], - "source": [ - "round_n = 1" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=21768, conversations=3668, acc=0.7132, p=0.6875, r=0.7881, fpr=0.3626, f1=0.7343\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] }, { - "cell_type": "code", - "execution_count": 17, - "id": "92766a80", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] connected to database: /reef/sqt2/cga-eval/human/game_db.sqlite\n" - ] - } - ], - "source": [ - "# connect to the game database\n", - "db_path = '/reef/sqt2/cga-eval/human/game_db.sqlite'\n", - "connection = sqlite3.connect(db_path)\n", - "cursor = connection.cursor()\n", - "\n", - "print(f\"[info] connected to database: {db_path}\")\n", - "cursor.execute(\"SELECT COUNT(*) FROM results\")\n", - "\n", - "# # names_list = []\n", - "# # answers_list = []\n", - "# # scores_list = []\n", - "# # comments_list = []\n", - "\n", - "# TIME_CUTOFF = 1714059814630 # timestamp to cut off previous results\n", - "# TIME_CUTOFF_END = 1730385762530\n", - "\n", - "# for row in connection.execute('SELECT * FROM results'):\n", - "# if row[0] != 'yc2727' and row[0] != 'sqt2':\n", - "# answers = json.loads(row[1])\n", - "# if answers[0]['start_time'] > TIME_CUTOFF and answers[0]['start_time'] < TIME_CUTOFF_END:\n", - "# names_list.append(row[0])\n", - "# answers_list.append(answers)\n", - "# scores_list.append(row[2])\n", - "# comments_list.append(row[3])\n", - "\n", - "if round_n == 1:\n", - " # for round_n 1\n", - " names_list_1 = []\n", - " answers_list_1 = []\n", - " scores_list_1 = []\n", - " comments_list_1 = []\n", - "\n", - " TIME_CUTOFF_1 = 1730395000000\n", - " TIME_CUTOFF_END_1 = 1730397199000\n", - "\n", - " for row in connection.execute('SELECT * FROM results'):\n", - " if row[0] != 'yc2727' and row[0] != 'sqt2':\n", - " answers = json.loads(row[1])\n", - " if answers[0]['start_time'] > TIME_CUTOFF_1 and answers[0]['start_time'] < TIME_CUTOFF_END_1:\n", - " names_list_1.append(row[0])\n", - " answers_list_1.append(answers)\n", - " scores_list_1.append(row[2])\n", - " comments_list_1.append(row[3])\n", - "elif round_n == 2:\n", - " # for round 2\n", - " names_list_2 = []\n", - " answers_list_2 = []\n", - " scores_list_2 = []\n", - " comments_list_2 = []\n", - "\n", - " TIME_CUTOFF_2_a = 1731002910000\n", - " TIME_CUTOFF_END_2_a = 1731016180000\n", - "\n", - " for row in connection.execute('SELECT * FROM results'):\n", - " if row[0] != 'yc2727' and row[0] != 'sqt2':\n", - " answers = json.loads(row[1])\n", - " if answers[0]['start_time'] > TIME_CUTOFF_2_a and answers[0]['start_time'] < TIME_CUTOFF_END_2_a:\n", - " names_list_2.append(row[0])\n", - " answers_list_2.append(answers)\n", - " scores_list_2.append(row[2])\n", - " comments_list_2.append(row[3])\n", - "\n", - " # The 2_b cutoff below is to specifically add data from 'ljl2' for a later second round window,\n", - " # likely because they submitted their data late or for a different time block.\n", - " TIME_CUTOFF_2_b = 1732212720000\n", - " TIME_CUTOFF_END_2_b = 1740000000000\n", - "\n", - " for row in connection.execute('SELECT * FROM results'):\n", - " if row[0].lower() == 'ljl2':\n", - " answers = json.loads(row[1])\n", - " if answers[0]['start_time'] > TIME_CUTOFF_2_b and answers[0]['start_time'] < TIME_CUTOFF_END_2_b:\n", - " names_list_2.append(row[0])\n", - " answers_list_2.append(answers)\n", - " scores_list_2.append(row[2])\n", - " comments_list_2.append(row[3])\n", - "\n", - " # print(f\"Round 1: {len(names_list_1)} entries\")\n", - " # print(f\"Round 2: {len(names_list_2)} entries\")\n", - " # names_list_1, names_list_2" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 18, - "id": "889d7ede", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] total unique conversation ids: 84\n", - "['givp578', 'e1vstxd', 'f1353ra', 'ewr7ls3', 'dmlny27', 'dg7wmdb', 'flixm8f', 'f13u0n2', 'ggwdbsa', 'd3f07tv', 'isz5n6g', 'givok1i', 'dyx3au1', 'g1sm9mt', 'f0dryv4', 'doi44j8', 'g2998qp', 'dpirnlc', 'h2h7yl0', 'dg7x3eu', 'ej6jusi', 'ikzb571', 'e1vv6x1', 'ifkoazb', 'dpkib9q', 'g1q3upb', 'dydawov', 'g1q1973', 'dm8exht', 'fphcwq0', 'gmxqrdz', 'dmlqnzz', 'dyd7cfv', 'i4rgtqf', 'doi3vuz', 'd0fyu9x', 'f014doo', 'dm8qu78', 'gmxoyuu', 'fmre7l9', 'ii3cpve', 'ii4ivim', 'e9mynuy', 'djh1bt1', 'f83hb2k', 'ewtowqu', 'dbnxbzn', 'fixjxxs', 'dvivs9p', 'ej6ollb', 'g1spg0k', 'ggwei5y', 'd0fzp40', 'gvb1ekl', 'djh2v24', 'dvisfl0', 'ewtjxp2', 'dyx2jn4', 'ewr7msm', 'd3efg03', 'fixlxvy', 'fegw71k', 'ikzcblg', 'ffpk80c', 'fmspcex', 'f00nxjs', 'gvdnrrb', 'h28ltfw', 'f0dsbw4', 'dbnr5nd', 'ikpw1ol', 'ffpj88q', 'i4rh1id', 'e9mybxp', 'isz6a7m', 'ifknq44', 'g297nn7', 'fegwvia', 'ikpxahv', 'f83akyz', 'h2hauaj', 'h28lknz', 'g3hmlew', 'fljdrtt']\n" - ] - } - ], - "source": [ - "human_map1 = {\n", - " \"vn72\": ['d3efg03', 'd3f07tv', 'f1353ra', 'f13u0n2', 'fegw71k', 'fegwvia', 'ikpw1ol', 'ikpxahv', 'isz5n6g', 'isz6a7m'],\n", - " \"nac86\": ['dyd7cfv', 'dydawov', 'ewtjxp2', 'ewtowqu', 'f00nxjs', 'f014doo', 'ii3cpve', 'ii4ivim', 'ikzb571', 'ikzcblg'],\n", - " # \"sj597\": ['dbnr5nd', 'dbnxbzn', 'g1sm9mt', 'g1spg0k', 'g297nn7', 'g2998qp', 'h2h7yl0', 'h2hauaj', 'ifknq44', 'ifkoazb'],\n", - " \"yc2727\": ['d08x3kl', 'd08x4q0', 'd3efg03', 'd3f07tv', 'ewtjxp2', 'ewtowqu', 'hnupywh', 'hnuu3ip', 'ih2fn94', 'ih3iwph'],\n", - " # \"ex36\": ['d0fyu9x', 'd0fzp40', 'dg7wmdb', 'dg7x3eu', 'ej6jusi', 'ej6ollb', 'ewtjxp2', 'ewtowqu', 'f0dryv4', 'f0dsbw4'],\n", - " \"kz88\": ['doi3vuz', 'doi44j8', 'e9mybxp', 'e9mynuy', 'g1q1973', 'g1q3upb', 'ggwdbsa', 'ggwei5y', 'gmxoyuu', 'gmxqrdz'],\n", - " \"LJL2\": ['ffpj88q', 'ffpk80c', 'flixm8f', 'fljdrtt', 'fmre7l9', 'fmspcex', 'fphcwq0', 'g3hmlew', 'givok1i', 'givp578'],\n", - " \"lyk25\": ['dpirnlc', 'dpkib9q', 'e1vstxd', 'e1vv6x1', 'ewr7ls3', 'ewr7msm', 'fixjxxs', 'fixlxvy', 'fmre7l9', 'fmspcex'],\n", - " \"sqt2\": ['d3efg03', 'd3f07tv', 'g0fwpzc', 'g0ggz8e', 'g8nyz4f', 'g8nzx3m', 'h4i75b9', 'h4i79lc', 'h6ikmzc', 'h6ime20'],\n", - " \"cd326\": ['djh1bt1', 'djh2v24', 'dmlny27', 'dmlqnzz', 'f83akyz', 'f83hb2k', 'h28lknz', 'h28ltfw', 'i4rgtqf', 'i4rh1id'],\n", - " \"tg352\": ['dm8exht', 'dm8qu78', 'dvisfl0', 'dvivs9p', 'dyx2jn4', 'dyx3au1', 'gvb1ekl', 'gvdnrrb', 'i4rgtqf', 'i4rh1id'],\n", - "}\n", - "\n", - "# all_convo_ids = []\n", - "# for k,v in human_map1.items():\n", - "# all_convo_ids.extend(v)\n", - "# all_convo_ids = list(set(all_convo_ids))\n", - "# len(all_convo_ids)\n", - "\n", - "all_convo_ids = []\n", - "# # collect from round 1\n", - "if round_n == 1:\n", - " for i in range(len(answers_list_1)):\n", - " for j in range(len(answers_list_1[i])):\n", - " all_convo_ids.append(answers_list_1[i][j]['id'])\n", - "# collect from round 2\n", - "elif round_n == 2:\n", - " for i in range(len(answers_list_2)):\n", - " for j in range(len(answers_list_2[i])):\n", - " all_convo_ids.append(answers_list_2[i][j]['id'])\n", - "all_convo_ids = list(set(all_convo_ids))\n", - "print(f\"[info] total unique conversation ids: {len(all_convo_ids)}\")\n", - "print(all_convo_ids)" + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.9752407152682254, Median = 2.0\n", + "Accuracy 0.713195\n", + "Precision 0.68747\n", + "Recall 0.788076\n", + "FPR 0.362589\n", + "F1 0.734343\n", + "Mean H 2.975241\n", + "Correct Adjustment 0.091876\n", + "Incorrect Adjustment 0.067067\n", + "Recovery 0.024809\n", + "Leaderboard String | MODEL_NAME | 71.3 | 68.7 | 78.8 | 73....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "fitting policy DeferralDecisionPolicy for seed 2\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "21768it [00:05, 4271.72it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=21768, conversations=3668, acc=0.7156, p=0.7165, r=0.7192, fpr=0.2880, f1=0.7179\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 20, - "id": "e55a3803", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset already exists at /reef/lyk25/ConvoKit/examples/forecaster/conversations-gone-awry-cmv-corpus-large\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", - "corpus.filter_conversations_by(lambda convo: convo.id in all_convo_ids)" + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.841748304446119, Median = 2.0\n", + "Accuracy 0.715649\n", + "Precision 0.716523\n", + "Recall 0.719241\n", + "FPR 0.287987\n", + "F1 0.717879\n", + "Mean H 2.841748\n", + "Correct Adjustment 0.077426\n", + "Incorrect Adjustment 0.070883\n", + "Recovery 0.006543\n", + "Leaderboard String | MODEL_NAME | 71.6 | 71.7 | 71.9 | 71....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "[info] summarize only: RandomDeferralDecisionPolicy seed 2\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.8620178041543025, Median = 2.0\n", + "Accuracy 0.704471\n", + "Precision 0.696641\n", + "Recall 0.730623\n", + "FPR 0.321997\n", + "F1 0.713228\n", + "Mean H 2.862018\n", + "Correct Adjustment 0.093511\n", + "Incorrect Adjustment 0.121865\n", + "Recovery -0.028353\n", + "Leaderboard String | MODEL_NAME | 70.4 | 69.7 | 73.1 | 71....\n", + "dtype: object\n", + "---\n", + "fitting policy SimulationAverageDecisionPolicy for seed 2\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "21768it [00:05, 4301.26it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": 21, - "id": "168fb025", - "metadata": {}, - "outputs": [], - "source": [ - "# we want all utterances to have a human_guesses meta field\n", - "for convo in corpus.iter_conversations():\n", - " for utt in convo.get_chronological_utterance_list():\n", - " utt.add_meta('human_guesses', [])" + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=21768, conversations=3668, acc=0.7056, p=0.6752, r=0.7989, fpr=0.3889, f1=0.7319\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.0698778833107188, Median = 2.0\n", + "Accuracy 0.705562\n", + "Precision 0.675218\n", + "Recall 0.798916\n", + "FPR 0.388919\n", + "F1 0.731877\n", + "Mean H 3.069878\n", + "Correct Adjustment 0.098691\n", + "Incorrect Adjustment 0.101418\n", + "Recovery -0.002726\n", + "Leaderboard String | MODEL_NAME | 70.6 | 67.5 | 79.9 | 73....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "fitting policy SimulationMajorityDecisionPolicy for seed 2\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "21768it [00:05, 4288.74it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "id": "27fc646a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "vn72\n", - "nac86\n", - "sj597\n", - "ex36\n", - "kz88\n", - "LJL2\n", - "lyk25\n", - "cd326\n", - "tg352\n" - ] - } - ], - "source": [ - "if round_n == 1:\n", - " for i, participant_sessions in enumerate(answers_list_1):\n", - " participant_id = names_list_1[i]\n", - " print(participant_id)\n", - " for session in participant_sessions:\n", - " convo_id = session['id']\n", - " convo = corpus.get_conversation(convo_id)\n", - " utts = convo.get_chronological_utterance_list()\n", - " actions = session.get('actions', [])\n", - "\n", - " for action_idx, action in enumerate(actions):\n", - " if action.get('guess') is True:\n", - " utt = utts[action_idx]\n", - " # get current guesses (returns deep copy if exists, or empty list if not)\n", - " # create a new list to avoid mutating the copy\n", - " current_guesses = list(utt.meta.get('human_guesses', []))\n", - " # append new participant and set back\n", - " current_guesses.append(participant_id)\n", - " utt.add_meta('human_guesses', current_guesses)\n", - "elif round_n == 2:\n", - " for i, participant_sessions in enumerate(answers_list_2):\n", - " participant_id = names_list_2[i]\n", - " print(participant_id)\n", - " for session in participant_sessions:\n", - " convo_id = session['id']\n", - " convo = corpus.get_conversation(convo_id)\n", - " utts = convo.get_chronological_utterance_list()\n", - " actions = session.get('actions', [])\n", - "\n", - " for action_idx, action in enumerate(actions):\n", - " if action.get('guess') is True:\n", - " utt = utts[action_idx]\n", - " # get current guesses (returns deep copy if exists, or empty list if not)\n", - " # create a new list to avoid mutating the copy\n", - " current_guesses = list(utt.meta.get('human_guesses', []))\n", - " # append new participant and set back\n", - " current_guesses.append(participant_id)\n", - " utt.add_meta('human_guesses', current_guesses)" + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=21768, conversations=3668, acc=0.7023, p=0.6714, r=0.7995, fpr=0.3961, f1=0.7298\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAASshJREFUeJzt3XdYFOfePvB7aQvSxEJTAhYiVixYUKPmSILRE0tiYiFii/5ijA01ahLFEgWMMcYjr0bPiZr3tSWxHBNPUEPEGMWKWBFLQCwUGyAaQdnv7w8v5rhSZHWXRef+XNdecZ+dfeY7w87sndlnZjQiIiAiIiJSEQtzF0BERERU0RiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdazMXUBlpNPpcPXqVTg6OkKj0Zi7HCIiIioHEcHt27fh6ekJC4uyj/EwAJXg6tWr8PLyMncZRERE9BQuXbqE2rVrlzkNA1AJHB0dATxcgU5OTmauhoiIiMojNzcXXl5eyvd4WRiASlD0s5eTkxMDEBER0XOmPMNXOAiaiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUx8rcBZD5+EzdZu4SFKmRPcxdAhERqQiPABEREZHqMAARERGR6lSKABQdHQ0fHx/Y2tqibdu2OHjwYKnTrlixAq+88gpcXFzg4uKCoKCgYtMPGTIEGo1G79GtWzdTLwYRERE9J8wegDZs2ICwsDCEh4cjISEB/v7+CA4ORlZWVonTx8XFYcCAAdi1axfi4+Ph5eWF119/HVeuXNGbrlu3bkhPT1ce69atq4jFISIioueA2QPQwoULMWLECAwdOhSNGjXCsmXLUKVKFXz77bclTr9mzRp8+OGHaN68Ofz8/PDPf/4TOp0OsbGxetNptVq4u7srDxcXl4pYHCIiInoOmDUAFRQU4MiRIwgKClLaLCwsEBQUhPj4+HL1cffuXdy/fx/VqlXTa4+Li4OrqysaNGiAUaNG4caNG6X2kZ+fj9zcXL0HERERvbjMGoCuX7+OwsJCuLm56bW7ubkhIyOjXH1MmTIFnp6eeiGqW7du+O677xAbG4uoqCjs3r0bb7zxBgoLC0vsIyIiAs7OzsrDy8vr6ReKiIiIKr3n+jpAkZGRWL9+PeLi4mBra6u09+/fX/l306ZN0axZM9SrVw9xcXHo2rVrsX6mTZuGsLAw5Xlubi5DEBER0QvMrEeAatSoAUtLS2RmZuq1Z2Zmwt3dvcz3LliwAJGRkdixYweaNWtW5rR169ZFjRo1cP78+RJf12q1cHJy0nsQERHRi8usAcjGxgatWrXSG8BcNKA5MDCw1PfNnz8fc+bMQUxMDAICAp44n8uXL+PGjRvw8PAwSt1ERET0fDP7WWBhYWFYsWIFVq9ejaSkJIwaNQp37tzB0KFDAQChoaGYNm2aMn1UVBSmT5+Ob7/9Fj4+PsjIyEBGRgby8vIAAHl5eZg8eTL279+P1NRUxMbGolevXqhfvz6Cg4PNsoxERERUuZh9DFC/fv1w7do1zJgxAxkZGWjevDliYmKUgdFpaWmwsPhvTlu6dCkKCgrQt29fvX7Cw8Mxc+ZMWFpa4vjx41i9ejWys7Ph6emJ119/HXPmzIFWq63QZSMiIqLKSSMiYu4iKpvc3Fw4OzsjJyfnhR4PxJuhEhHRi8SQ72+z/wRGREREVNEYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUqRQCKjo6Gj48PbG1t0bZtWxw8eLDUaVesWIFXXnkFLi4ucHFxQVBQULHpRQQzZsyAh4cH7OzsEBQUhHPnzpl6MYiIiOg5YfYAtGHDBoSFhSE8PBwJCQnw9/dHcHAwsrKySpw+Li4OAwYMwK5duxAfHw8vLy+8/vrruHLlijLN/PnzsXjxYixbtgwHDhyAvb09goODce/evYpaLCIiIqrENCIi5iygbdu2aN26NZYsWQIA0Ol08PLywpgxYzB16tQnvr+wsBAuLi5YsmQJQkNDISLw9PTExIkTMWnSJABATk4O3NzcsGrVKvTv3/+Jfebm5sLZ2Rk5OTlwcnJ6tgWsxHymbjN3CYrUyB7mLoGIiJ5zhnx/m/UIUEFBAY4cOYKgoCClzcLCAkFBQYiPjy9XH3fv3sX9+/dRrVo1AEBKSgoyMjL0+nR2dkbbtm1L7TM/Px+5ubl6DyIiInpxmTUAXb9+HYWFhXBzc9Nrd3NzQ0ZGRrn6mDJlCjw9PZXAU/Q+Q/qMiIiAs7Oz8vDy8jJ0UYiIiOg5YvYxQM8iMjIS69evx+bNm2Fra/vU/UybNg05OTnK49KlS0askoiIiCobK3POvEaNGrC0tERmZqZee2ZmJtzd3ct874IFCxAZGYlff/0VzZo1U9qL3peZmQkPDw+9Pps3b15iX1qtFlqt9imXgoiIiJ43Zj0CZGNjg1atWiE2NlZp0+l0iI2NRWBgYKnvmz9/PubMmYOYmBgEBATovVanTh24u7vr9Zmbm4sDBw6U2ScRERGph1mPAAFAWFgYBg8ejICAALRp0waLFi3CnTt3MHToUABAaGgoatWqhYiICABAVFQUZsyYgbVr18LHx0cZ1+Pg4AAHBwdoNBqMHz8en3/+OXx9fVGnTh1Mnz4dnp6e6N27t7kWk4iIiCoRswegfv364dq1a5gxYwYyMjLQvHlzxMTEKIOY09LSYGHx3wNVS5cuRUFBAfr27avXT3h4OGbOnAkA+Pjjj3Hnzh2MHDkS2dnZ6NixI2JiYp5pnBARERG9OMx+HaDKiNcBqni8DhARET2r5+Y6QERERETmwABEREREqsMARERERKrDAERERESqY3AAWr16NbZt++/g2Y8//hhVq1ZF+/btcfHiRaMWR0RERGQKBgegefPmwc7ODgAQHx+P6OhozJ8/HzVq1MCECROMXiARERGRsRl8HaBLly6hfv36AIAtW7bg7bffxsiRI9GhQwd06dLF2PURERERGZ3BR4AcHBxw48YNAMCOHTvw2muvAQBsbW3x119/Gbc6IiIiIhMw+AjQa6+9hvfffx8tWrTA2bNn0b17dwDAqVOn4OPjY+z6iIiIiIzO4CNA0dHRCAwMxLVr17Bx40ZUr14dAHDkyBEMGDDA6AUSERERGZvBR4CqVq2KJUuWFGufNWuWUQoiIiIiMrWnuhlqdnY2Dh48iKysLOh0OqVdo9Fg0KBBRiuOiIiIyBQMDkA//fQTQkJCkJeXBycnJ2g0GuU1BiAiIiJ6Hhg8BmjixIkYNmwY8vLykJ2djVu3bimPmzdvmqJGIiIiIqMyOABduXIFY8eORZUqVUxRDxEREZHJGRyAgoODcfjwYVPUQkRERFQhDB4D1KNHD0yePBmnT59G06ZNYW1trfd6z549jVYcERERkSkYHIBGjBgBAJg9e3ax1zQaDQoLC5+9KiIiIiITMjgAPXraOxEREdHzyOAxQERERETPu6cKQLt378abb76J+vXro379+ujZsyf27Nlj7NqIiIiITMLgAPR///d/CAoKQpUqVTB27FiMHTsWdnZ26Nq1K9auXWuKGomIiIiMSiMiYsgbGjZsiJEjR2LChAl67QsXLsSKFSuQlJRk1ALNITc3F87OzsjJyYGTk5O5yzEZn6nbzF2CIjWyh7lLICKi55wh398GHwH6888/8eabbxZr79mzJ1JSUgztjoiIiKjCGRyAvLy8EBsbW6z9119/hZeXl1GKIiIiIjIlg0+DnzhxIsaOHYvExES0b98eALB3716sWrUKX3/9tdELJCIiIjI2gwPQqFGj4O7uji+//BLff/89gIfjgjZs2IBevXoZvUAiIiIiYzM4AAFAnz590KdPH2PXQkRERFQheCFEIiIiUp1yHQGqVq0azp49ixo1asDFxQUajabUaW/evGm04oiIiIhMoVwB6KuvvoKjo6Py77ICEBEREVFlV64ANHjwYOXfQ4YMMVUtRERERBXC4DFAlpaWyMrKKtZ+48YNWFpaGqUoIiIiIlMyOACVdueM/Px82NjYPHNBRERERKZW7tPgFy9eDADQaDT45z//CQcHB+W1wsJC/P777/Dz8zN+hURERERGVu4A9NVXXwF4eARo2bJlej932djYwMfHB8uWLTN+hURERERGVu4AVHSj01dffRWbNm2Ci4uLyYoiIiIiMiWDrwS9a9cuU9RBREREVGGe6lYYly9fxtatW5GWloaCggK91xYuXGiUwoiIiIhMxeAAFBsbi549e6Ju3bo4c+YMmjRpgtTUVIgIWrZsaYoaiYiIiIzK4NPgp02bhkmTJuHEiROwtbXFxo0bcenSJXTu3BnvvPOOKWokIiIiMiqDA1BSUhJCQ0MBAFZWVvjrr7/g4OCA2bNnIyoqyugFEhERERmbwQHI3t5eGffj4eGBCxcuKK9dv37deJURERERmYjBY4DatWuHP/74Aw0bNkT37t0xceJEnDhxAps2bUK7du1MUSMRERGRURkcgBYuXIi8vDwAwKxZs5CXl4cNGzbA19eXZ4ARERHRc8HgAFS3bl3l3/b29rz6MxERET13DB4DdOnSJVy+fFl5fvDgQYwfPx7Lly83amFEREREpmJwABo4cKByNeiMjAwEBQXh4MGD+PTTTzF79myjF0hERERkbAYHoJMnT6JNmzYAgO+//x5NmzbFvn37sGbNGqxatcrY9REREREZncEB6P79+9BqtQCAX3/9FT179gQA+Pn5IT093bjVEREREZmAwQGocePGWLZsGfbs2YOdO3eiW7duAICrV6+ievXqRi+QiIiIyNgMDkBRUVH45ptv0KVLFwwYMAD+/v4AgK1btyo/jRERERFVZgafBt+lSxdcv34dubm5cHFxUdpHjhyJKlWqGLU4IiIiIlMw+AgQAIgIjhw5gm+++Qa3b98GANjY2DAAERER0XPB4CNAFy9eRLdu3ZCWlob8/Hy89tprcHR0RFRUFPLz83lhRCIiIqr0DD4CNG7cOAQEBODWrVuws7NT2vv06YPY2FijFkdERERkCgYfAdqzZw/27dsHGxsbvXYfHx9cuXLFaIURERERmYrBR4B0Oh0KCwuLtV++fBmOjo5GKYqIiIjIlAwOQK+//joWLVqkPNdoNMjLy0N4eDi6d+9ucAHR0dHw8fGBra0t2rZti4MHD5Y67alTp/D222/Dx8cHGo1Gr44iM2fOhEaj0Xv4+fkZXBcRERG9uAwOQF9++SX27t2LRo0a4d69exg4cKDy81dUVJRBfW3YsAFhYWEIDw9HQkIC/P39ERwcjKysrBKnv3v3LurWrYvIyEi4u7uX2m/jxo2Rnp6uPP744w+D6iIiIqIXm8FjgGrXro1jx45h/fr1OH78OPLy8jB8+HCEhIToDYouj4ULF2LEiBEYOnQoAGDZsmXYtm0bvv32W0ydOrXY9K1bt0br1q0BoMTXi1hZWZUZkIjK4jN1m7lLAACkRvYwdwlERC8sgwPQvXv3YGtri/fee++ZZlxQUIAjR45g2rRpSpuFhQWCgoIQHx//TH2fO3cOnp6esLW1RWBgICIiIvDSSy+VOn1+fj7y8/OV57m5uc80fyIiIqrcDP4JzNXVFYMHD8bOnTuh0+meesbXr19HYWEh3Nzc9Nrd3NyQkZHx1P22bdsWq1atQkxMDJYuXYqUlBS88sorygUbSxIREQFnZ2fl4eXl9dTzJyIiosrP4AC0evVq3L17F7169UKtWrUwfvx4HD582BS1PZU33ngD77zzDpo1a4bg4GD85z//QXZ2Nr7//vtS3zNt2jTk5OQoj0uXLlVgxURERFTRDA5Affr0wQ8//IDMzEzMmzcPp0+fRrt27fDyyy9j9uzZ5e6nRo0asLS0RGZmpl57ZmamUcfvVK1aFS+//DLOnz9f6jRarRZOTk56DyIiInpxPdW9wADA0dERQ4cOxY4dO3D8+HHY29tj1qxZ5X6/jY0NWrVqpXf1aJ1Oh9jYWAQGBj5tWcXk5eXhwoUL8PDwMFqfRERE9Hx76gB07949fP/99+jduzdatmyJmzdvYvLkyQb1ERYWhhUrVmD16tVISkrCqFGjcOfOHeWssNDQUL1B0gUFBUhMTERiYiIKCgpw5coVJCYm6h3dmTRpEnbv3o3U1FTs27cPffr0gaWlJQYMGPC0i0pEREQvGIPPAtu+fTvWrl2LLVu2wMrKCn379sWOHTvQqVMng2fer18/XLt2DTNmzEBGRgaaN2+OmJgYZWB0WloaLCz+m9GuXr2KFi1aKM8XLFiABQsWoHPnzoiLiwPw8IrUAwYMwI0bN1CzZk107NgR+/fvR82aNQ2uj4iIiF5MGhERQ95QpUoV/P3vf0dISAi6d+8Oa2trU9VmNrm5uXB2dkZOTs4LPR6oslzvBqhc17ypLOulMq0TIqLngSHf3wYfAcrMzOQ9v55RZfmCJSIiUiuDA5CjoyN0Oh3Onz+PrKysYtcCepqfwoiIiIgqksEBaP/+/Rg4cCAuXryIx38902g0Jd4pnoiIiKgyMTgAffDBBwgICMC2bdvg4eEBjUZjirqIiIiITMbgAHTu3Dn8+OOPqF+/vinqISIiIjI5g68D1LZt2zKvqkxERERU2Rl8BGjMmDGYOHEiMjIy0LRp02KnwTdr1sxoxRERERGZgsEB6O233wYADBs2TGnTaDQQEQ6CJiIioueCwQEoJSXFFHUQERERVRiDA5C3t7cp6iAiIiKqMAYHIAC4cOECFi1ahKSkJABAo0aNMG7cONSrV8+oxRERERGZgsFngW3fvh2NGjXCwYMH0axZMzRr1gwHDhxA48aNsXPnTlPUSERERGRUBh8Bmjp1KiZMmIDIyMhi7VOmTMFrr71mtOKIiIiITMHgI0BJSUkYPnx4sfZhw4bh9OnTRimKiIiIyJQMDkA1a9ZEYmJisfbExES4uroaoyYiIiIikzL4J7ARI0Zg5MiR+PPPP9G+fXsAwN69exEVFYWwsDCjF0hERERkbAYHoOnTp8PR0RFffvklpk2bBgDw9PTEzJkzMXbsWKMXSERERGRsBgcgjUaDCRMmYMKECbh9+zYAwNHR0eiFEREREZnKU10J+sGDB/D19dULPufOnYO1tTV8fHyMWR8RERGR0Rk8CHrIkCHYt29fsfYDBw5gyJAhxqiJiIiIyKQMDkBHjx5Fhw4dirW3a9euxLPDiIiIiCobgwOQRqNRxv48Kicnh3eCJyIioueCwQGoU6dOiIiI0As7hYWFiIiIQMeOHY1aHBEREZEpGDwIOioqCp06dUKDBg3wyiuvAAD27NmD3Nxc/Pbbb0YvkIiIiMjYDD4C1KhRIxw/fhzvvvsusrKycPv2bYSGhuLMmTNo0qSJKWokIiIiMiqDjwABDy98OG/ePGPXQkRERFQhDD4CRERERPS8YwAiIiIi1WEAIiIiItUpVwDaunUr7t+/b+paiIiIiCpEuQJQnz59kJ2dDQCwtLREVlaWKWsiIiIiMqlyBaCaNWti//79AAARgUajMWlRRERERKZUrtPgP/jgA/Tq1QsajQYajQbu7u6lTsvbYRAREVFlV64ANHPmTPTv3x/nz59Hz549sXLlSlStWtXEpRERERGZRrkvhOjn5wc/Pz+Eh4fjnXfeQZUqVUxZFxEREZHJGHwl6PDwcADAtWvXkJycDABo0KABatasadzKiIiIiEzE4OsA3b17F8OGDYOnpyc6deqETp06wdPTE8OHD8fdu3dNUSMRERGRURkcgCZMmIDdu3dj69atyM7ORnZ2Nv79739j9+7dmDhxoilqJCIiIjIqg38C27hxI3788Ud06dJFaevevTvs7Ozw7rvvYunSpcasj4iIiMjonuonMDc3t2Ltrq6u/AmMiIiIngsGB6DAwECEh4fj3r17Sttff/2FWbNmITAw0KjFEREREZmCwT+Bff311wgODkbt2rXh7+8PADh27BhsbW2xfft2oxdIREREZGwGB6AmTZrg3LlzWLNmDc6cOQMAGDBgAEJCQmBnZ2f0AomIiIiMzeAABABVqlTBiBEjjF0LERERUYUweAwQERER0fOOAYiIiIhUhwGIiIiIVOepxgARGZvP1G3mLoGIiFTE4CNAdevWxY0bN4q1Z2dno27dukYpioiIiMiUDA5AqampKCwsLNaen5+PK1euGKUoIiIiIlMq909gW7duVf69fft2ODs7K88LCwsRGxsLHx8foxZHREREZArlDkC9e/cGAGg0GgwePFjvNWtra/j4+ODLL780anFEREREplDuAKTT6QAAderUwaFDh1CjRg2TFUVERERkSgafBZaSkmKKOoiIiIgqzFOdBh8bG4vY2FhkZWUpR4aKfPvtt0YpjIiIiMhUDA5As2bNwuzZsxEQEAAPDw9oNBpT1EVERERkMgYHoGXLlmHVqlUYNGiQKeohIiIiMjmDrwNUUFCA9u3bm6IWIiIiogphcAB6//33sXbtWqMVEB0dDR8fH9ja2qJt27Y4ePBgqdOeOnUKb7/9Nnx8fKDRaLBo0aJn7pOIiIjUx+CfwO7du4fly5fj119/RbNmzWBtba33+sKFC8vd14YNGxAWFoZly5ahbdu2WLRoEYKDg5GcnAxXV9di09+9exd169bFO++8gwkTJhilTyIiIlIfjYiIIW949dVXS+9Mo8Fvv/1W7r7atm2L1q1bY8mSJQAeXmvIy8sLY8aMwdSpU8t8r4+PD8aPH4/x48cbrc8iubm5cHZ2Rk5ODpycnMq9POXFG39SeaRG9jB3CUREzxVDvr8NPgK0a9eupy7sUQUFBThy5AimTZumtFlYWCAoKAjx8fEV2md+fj7y8/OV57m5uU81fyIiIno+GDwGqMj58+exfft2/PXXXwAAAw8k4fr16ygsLISbm5teu5ubGzIyMp6qpqftMyIiAs7OzsrDy8vrqeZPREREzweDA9CNGzfQtWtXvPzyy+jevTvS09MBAMOHD8fEiRONXmBFmDZtGnJycpTHpUuXzF0SERERmZDBAWjChAmwtrZGWloaqlSporT369cPMTEx5e6nRo0asLS0RGZmpl57ZmYm3N3dDS3rmfrUarVwcnLSexAREdGLy+AAtGPHDkRFRaF27dp67b6+vrh48WK5+7GxsUGrVq0QGxurtOl0OsTGxiIwMNDQskzWJxEREb14DB4EfefOHb0jP0Vu3rwJrVZrUF9hYWEYPHgwAgIC0KZNGyxatAh37tzB0KFDAQChoaGoVasWIiIiADwc5Hz69Gnl31euXEFiYiIcHBxQv379cvVJREREZHAAeuWVV/Ddd99hzpw5AB6e+q7T6TB//vwyT5EvSb9+/XDt2jXMmDEDGRkZaN68OWJiYpRBzGlpabCw+O9BqqtXr6JFixbK8wULFmDBggXo3Lkz4uLiytUnERERkcHXATp58iS6du2Kli1b4rfffkPPnj1x6tQp3Lx5E3v37kW9evVMVWuF4XWAqDLgdYCIiAxjyPe3wWOAmjRpgrNnz6Jjx47o1asX7ty5g7feegtHjx59IcIPERERvfgM/gkMAJydnfHpp58auxYiIiKiCmHwEaCVK1fihx9+KNb+ww8/YPXq1UYpioiIiMiUDD4CFBERgW+++aZYu6urK0aOHInBgwcbpTAiqjwq07g1jo0iImMw+AhQWloa6tSpU6zd29sbaWlpRimKiIiIyJQMDkCurq44fvx4sfZjx46hevXqRimKiIiIyJQMDkADBgzA2LFjsWvXLhQWFqKwsBC//fYbxo0bh/79+5uiRiIiIiKjMngM0Jw5c5CamoquXbvCyurh23U6HUJDQzFv3jyjF0hERERkbAYFIBFBRkYGVq1ahc8//xyJiYmws7ND06ZN4e3tbaoaiYiIiIzK4ABUv359nDp1Cr6+vvD19TVVXUREREQmY9AYIAsLC/j6+uLGjRumqoeIiIjI5AweBB0ZGYnJkyfj5MmTpqiHiIiIyOQMHgQdGhqKu3fvwt/fHzY2NrCzs9N7/ebNm0YrjoiIiMgUDA5AixYtMkEZRERERBXH4ADEW10QERHR887gMUAAcOHCBXz22WcYMGAAsrKyAAC//PILTp06ZdTiiIiIiEzB4AC0e/duNG3aFAcOHMCmTZuQl5cH4OGtMMLDw41eIBEREZGxGRyApk6dis8//xw7d+6EjY2N0v63v/0N+/fvN2pxRERERKZgcAA6ceIE+vTpU6zd1dUV169fN0pRRERERKZkcACqWrUq0tPTi7UfPXoUtWrVMkpRRERERKZkcADq378/pkyZgoyMDGg0Guh0OuzduxeTJk1CaGioKWokIiIiMiqDA9C8efPg5+cHLy8v5OXloVGjRujUqRPat2+Pzz77zBQ1EhERERmVwdcBsrGxwYoVKzBjxgycOHECeXl5aNGiBW+MSkRERM+NcgcgnU6HL774Alu3bkVBQQG6du2K8PDwYrfCICIiIqrsyv0T2Ny5c/HJJ5/AwcEBtWrVwtdff43Ro0ebsjYiIiIikyh3APruu+/wP//zP9i+fTu2bNmCn376CWvWrIFOpzNlfURERERGV+4AlJaWhu7duyvPg4KCoNFocPXqVZMURkRERGQq5Q5ADx48gK2trV6btbU17t+/b/SiiIiIiEyp3IOgRQRDhgyBVqtV2u7du4cPPvgA9vb2StumTZuMWyERERGRkZU7AA0ePLhY23vvvWfUYoiIiIgqQrkD0MqVK01ZBxEREVGFMfhK0ERERETPOwYgIiIiUh2Db4VBRBXDZ+o2c5dARPTC4hEgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHStzFwAA0dHR+OKLL5CRkQF/f3/84x//QJs2bUqd/ocffsD06dORmpoKX19fREVFoXv37srrQ4YMwerVq/XeExwcjJiYGJMtAxFVDJ+p28xdAgAgNbKHuUsgomdg9iNAGzZsQFhYGMLDw5GQkAB/f38EBwcjKyurxOn37duHAQMGYPjw4Th69Ch69+6N3r174+TJk3rTdevWDenp6cpj3bp1FbE4RERE9BwwewBauHAhRowYgaFDh6JRo0ZYtmwZqlSpgm+//bbE6b/++mt069YNkydPRsOGDTFnzhy0bNkSS5Ys0ZtOq9XC3d1debi4uFTE4hAREdFzwKwBqKCgAEeOHEFQUJDSZmFhgaCgIMTHx5f4nvj4eL3pgYc/bz0+fVxcHFxdXdGgQQOMGjUKN27cKLWO/Px85Obm6j2IiIjoxWXWAHT9+nUUFhbCzc1Nr93NzQ0ZGRklvicjI+OJ03fr1g3fffcdYmNjERUVhd27d+ONN95AYWFhiX1GRETA2dlZeXh5eT3jkhEREVFlVikGQRtb//79lX83bdoUzZo1Q7169RAXF4euXbsWm37atGkICwtTnufm5jIEERERvcDMegSoRo0asLS0RGZmpl57ZmYm3N3dS3yPu7u7QdMDQN26dVGjRg2cP3++xNe1Wi2cnJz0HkRERPTiMmsAsrGxQatWrRAbG6u06XQ6xMbGIjAwsMT3BAYG6k0PADt37ix1egC4fPkybty4AQ8PD+MUTkRERM81s58FFhYWhhUrVmD16tVISkrCqFGjcOfOHQwdOhQAEBoaimnTpinTjxs3DjExMfjyyy9x5swZzJw5E4cPH8ZHH30EAMjLy8PkyZOxf/9+pKamIjY2Fr169UL9+vURHBxslmUkIiKiysXsY4D69euHa9euYcaMGcjIyEDz5s0RExOjDHROS0uDhcV/c1r79u2xdu1afPbZZ/jkk0/g6+uLLVu2oEmTJgAAS0tLHD9+HKtXr0Z2djY8PT3x+uuvY86cOdBqtWZZRiIiIqpcNCIi5i6issnNzYWzszNycnJMMh6oslzJloieHq8ETVT5GPL9bfafwIiIiIgqGgMQERERqQ4DEBEREakOAxARERGpDgMQERERqQ4DEBEREamO2a8DRET0PKpMl7PgKflEhuMRICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0rcxdARETPxmfqNnOXoEiN7GHuEojKhQGIiIiMprKEMQYxehL+BEZERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKpjZe4CiIiIjM1n6jZzl6BIjexh7hKoBAxAREREJsQwVjnxJzAiIiJSHQYgIiIiUh3+BEZERKQSleXnuMrwUxyPABEREZHqMAARERGR6jAAERERkeowABEREZHqMAARERGR6jAAERERkeowABEREZHqMAARERGR6lSKABQdHQ0fHx/Y2tqibdu2OHjwYJnT//DDD/Dz84OtrS2aNm2K//znP3qviwhmzJgBDw8P2NnZISgoCOfOnTPlIhAREdFzxOwBaMOGDQgLC0N4eDgSEhLg7++P4OBgZGVllTj9vn37MGDAAAwfPhxHjx5F79690bt3b5w8eVKZZv78+Vi8eDGWLVuGAwcOwN7eHsHBwbh3715FLRYRERFVYhoREXMW0LZtW7Ru3RpLliwBAOh0Onh5eWHMmDGYOnVqsen79euHO3fu4Oeff1ba2rVrh+bNm2PZsmUQEXh6emLixImYNGkSACAnJwdubm5YtWoV+vfv/8SacnNz4ezsjJycHDg5ORlpSf+rslyKnIiIyBxMdSsMQ76/zXovsIKCAhw5cgTTpk1T2iwsLBAUFIT4+PgS3xMfH4+wsDC9tuDgYGzZsgUAkJKSgoyMDAQFBSmvOzs7o23btoiPjy8xAOXn5yM/P195npOTA+DhijQFXf5dk/RLRET0PDDV92tRv+U5tmPWAHT9+nUUFhbCzc1Nr93NzQ1nzpwp8T0ZGRklTp+RkaG8XtRW2jSPi4iIwKxZs4q1e3l5lW9BiIiIqNycF5m2/9u3b8PZ2bnMaXg3eADTpk3TO6qk0+lw8+ZNVK9eHRqNxoyVmU5ubi68vLxw6dIlk/zM97zieimO66Q4rpOScb0Ux3VSnCnXiYjg9u3b8PT0fOK0Zg1ANWrUgKWlJTIzM/XaMzMz4e7uXuJ73N3dy5y+6L+ZmZnw8PDQm6Z58+Yl9qnVaqHVavXaqlatasiiPLecnJy4UZaA66U4rpPiuE5KxvVSHNdJcaZaJ0868lPErGeB2djYoFWrVoiNjVXadDodYmNjERgYWOJ7AgMD9aYHgJ07dyrT16lTB+7u7nrT5Obm4sCBA6X2SUREROpi9p/AwsLCMHjwYAQEBKBNmzZYtGgR7ty5g6FDhwIAQkNDUatWLURERAAAxo0bh86dO+PLL79Ejx49sH79ehw+fBjLly8HAGg0GowfPx6ff/45fH19UadOHUyfPh2enp7o3bu3uRaTiIiIKhGzB6B+/frh2rVrmDFjBjIyMtC8eXPExMQog5jT0tJgYfHfA1Xt27fH2rVr8dlnn+GTTz6Br68vtmzZgiZNmijTfPzxx7hz5w5GjhyJ7OxsdOzYETExMbC1ta3w5austFotwsPDi/30p3ZcL8VxnRTHdVIyrpfiuE6KqyzrxOzXASIiIiKqaGa/EjQRERFRRWMAIiIiItVhACIiIiLVYQAiIiIi1WEAUpmIiAi0bt0ajo6OcHV1Re/evZGcnGzusiqVyMhI5XIKanflyhW89957qF69Ouzs7NC0aVMcPnzY3GWZTWFhIaZPn446derAzs4O9erVw5w5c8p136EXxe+//44333wTnp6e0Gg0yn0Yi4gIZsyYAQ8PD9jZ2SEoKAjnzp0zT7EVqKz1cv/+fUyZMgVNmzaFvb09PD09ERoaiqtXr5qv4ArwpM/Koz744ANoNBosWrSowupjAFKZ3bt3Y/To0di/fz927tyJ+/fv4/XXX8edO3fMXVqlcOjQIXzzzTdo1qyZuUsxu1u3bqFDhw6wtrbGL7/8gtOnT+PLL7+Ei4uLuUszm6ioKCxduhRLlixBUlISoqKiMH/+fPzjH/8wd2kV5s6dO/D390d0dHSJr8+fPx+LFy/GsmXLcODAAdjb2yM4OBj37t2r4EorVlnr5e7du0hISMD06dORkJCATZs2ITk5GT179jRDpRXnSZ+VIps3b8b+/fvLdfsKoxJStaysLAEgu3fvNncpZnf79m3x9fWVnTt3SufOnWXcuHHmLsmspkyZIh07djR3GZVKjx49ZNiwYXptb731loSEhJipIvMCIJs3b1ae63Q6cXd3ly+++EJpy87OFq1WK+vWrTNDhebx+HopycGDBwWAXLx4sWKKMrPS1snly5elVq1acvLkSfH29pavvvqqwmriESCVy8nJAQBUq1bNzJWY3+jRo9GjRw8EBQWZu5RKYevWrQgICMA777wDV1dXtGjRAitWrDB3WWbVvn17xMbG4uzZswCAY8eO4Y8//sAbb7xh5soqh5SUFGRkZOhtQ87Ozmjbti3i4+PNWFnlk5OTA41Go5r7TpZEp9Nh0KBBmDx5Mho3blzh8zf7laDJfHQ6HcaPH48OHTroXUlbjdavX4+EhAQcOnTI3KVUGn/++SeWLl2KsLAwfPLJJzh06BDGjh0LGxsbDB482NzlmcXUqVORm5sLPz8/WFpaorCwEHPnzkVISIi5S6sUMjIyAEC5kn8RNzc35TUC7t27hylTpmDAgAGqvkFqVFQUrKysMHbsWLPMnwFIxUaPHo2TJ0/ijz/+MHcpZnXp0iWMGzcOO3fu5O1SHqHT6RAQEIB58+YBAFq0aIGTJ09i2bJlqg1A33//PdasWYO1a9eicePGSExMxPjx4+Hp6anadUKGuX//Pt59912ICJYuXWrucszmyJEj+Prrr5GQkACNRmOWGvgTmEp99NFH+Pnnn7Fr1y7Url3b3OWY1ZEjR5CVlYWWLVvCysoKVlZW2L17NxYvXgwrKysUFhaau0Sz8PDwQKNGjfTaGjZsiLS0NDNVZH6TJ0/G1KlT0b9/fzRt2hSDBg3ChAkTlJs1q527uzsAIDMzU689MzNTeU3NisLPxYsXsXPnTlUf/dmzZw+ysrLw0ksvKfvdixcvYuLEifDx8amQGngESGVEBGPGjMHmzZsRFxeHOnXqmLsks+vatStOnDih1zZ06FD4+flhypQpsLS0NFNl5tWhQ4dil0g4e/YsvL29zVSR+d29e1fv5swAYGlpCZ1OZ6aKKpc6derA3d0dsbGxaN68OQAgNzcXBw4cwKhRo8xbnJkVhZ9z585h165dqF69urlLMqtBgwYVG28ZHByMQYMGYejQoRVSAwOQyowePRpr167Fv//9bzg6Oiq/yzs7O8POzs7M1ZmHo6NjsTFQ9vb2qF69uqrHRk2YMAHt27fHvHnz8O677+LgwYNYvnw5li9fbu7SzObNN9/E3Llz8dJLL6Fx48Y4evQoFi5ciGHDhpm7tAqTl5eH8+fPK89TUlKQmJiIatWq4aWXXsL48ePx+eefw9fXF3Xq1MH06dPh6emJ3r17m6/oClDWevHw8EDfvn2RkJCAn3/+GYWFhcq+t1q1arCxsTFX2Sb1pM/K4yHQ2toa7u7uaNCgQcUUWGHnm1GlAKDEx8qVK81dWqXC0+Af+umnn6RJkyai1WrFz89Pli9fbu6SzCo3N1fGjRsnL730ktja2krdunXl008/lfz8fHOXVmF27dpV4j5k8ODBIvLwVPjp06eLm5ubaLVa6dq1qyQnJ5u36ApQ1npJSUkpdd+7a9cuc5duMk/6rDyuok+D14io6BKmREREROAgaCIiIlIhBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSnRcqAKWmpkKj0SAxMdHcpSjOnDmDdu3awdbWVrk3Dj27VatWoWrVquYuw6w0Gg22bNnyTH1UlvVYnu1ERDBy5EhUq1ZN2c67dOmC8ePHV2itpjJkyJAn3i4iLi4OGo0G2dnZJq1l7969aNq0KaytrV/4W1iYkjm/k8rzeXqSu3fv4u2334aTk1OFfO4qmlED0JAhQ6DRaBAZGanXvmXLFrPd7t7cwsPDYW9vj+TkZMTGxpq7nEqhsnzpAsYJEeaSnp6ON954w9xlGEV5tpOYmBisWrUKP//8M9LT09GkSRNs2rQJc+bMeaZ5V5bPwNdff41Vq1Ypz0sKd+3bt0d6ejqcnZ1NWktYWBiaN2+OlJQUvZqeN5VpX/M8Wr16Nfbs2YN9+/ZVyOeuohn9CJCtrS2ioqJw69YtY3dtNgUFBU/93gsXLqBjx47w9vZW/d1/ybjc3d2h1WrNXYZRlGc7uXDhAjw8PNC+fXu4u7vDysoK1apVg6OjY6n9Psu2W9GcnZ2f+GVtY2MDd3d3k/8P5YULF/C3v/0NtWvXfuoA8TyteyrZhQsX0LBhQzRp0qRCPncVqaCgwLg3Qx08eLD8/e9/Fz8/P5k8ebLSvnnzZsEjswoPDxd/f3+993711Vfi7e2t11evXr1k7ty54urqKs7OzjJr1iy5f/++TJo0SVxcXKRWrVry7bffKu8puuHcunXrJDAwULRarTRu3Fji4uL05nXixAnp1q2b2Nvbi6urq7z33nty7do15fXOnTvL6NGjZdy4cVK9enXp0qVLictbWFgos2bNklq1aomNjY34+/vLL7/8oryOx24AFx4eXmo/UVFRUq9ePbGxsREvLy/5/PPPldePHz8ur776qtja2kq1atVkxIgRcvv2baOsqw0bNkjHjh3F1tZWAgICJDk5WQ4ePCitWrUSe3t76datm2RlZenVu2LFCvHz8xOtVisNGjSQ6OjoYv1u3LhRunTpInZ2dtKsWTPZt2+fiJR8c7yi9RIdHS3169cXrVYrrq6u8vbbb5e4vkREVq5cKc7OzrJ582blPa+//rqkpaXpTbdlyxZp0aKFaLVaqVOnjsycOVPu378vIg9vvPdoHd7e3pKdnS0WFhZy6NAh5W/j4uIibdu2Vfr83//9X6ldu7byPC0tTd555x1xdnYWFxcX6dmzp6SkpBhtnZUGgGzevNmgPlauXCleXl5iZ2cnvXv3lgULFoizs3O519msWbPEw8NDrl+/rkzfvXt36dKlixQWFpZYpzG2k8GDBxf7W4kUv2mtt7e3zJ49WwYNGiSOjo4yePBgyc/Pl9GjR4u7u7totVp56aWXZN68ecr0JfX7uPLuW+Li4qR169ZiY2Mj7u7uMmXKFGXdiYj88MMP0qRJE2Vb7tq1q+Tl5SnL2KtXrxKXF4CkpKQo28+tW7ckJydHbG1t5T//+Y9eDZs2bRIHBwe5c+eOiJTv8/n4cj76KLpR8pOWrbT95pP2t0/a/3388cfi6+srdnZ2UqdOHfnss8+koKBAeT0xMVG6dOkiDg4O4ujoKC1btpRDhw6Vua953Pnz56Vnz57i6uoq9vb2EhAQIDt37tSbxtvbW+bOnStDhw4VBwcH8fLykm+++UZvmgMHDkjz5s1Fq9VKq1atZNOmTQJAjh49WuJ8RUTu3bsnEydOFE9PT6lSpYq0adNG7wapRfu6mJgY8fPzE3t7ewkODparV68q0zx48EAmTJggzs7OUq1aNZk8ebKEhoYqn6fS/Pjjj9KoUSOxsbERb29vWbBggfJa586d9dZd586dS+1n69atEhAQIFqtVqpXry69e/dWXrt586YMGjRIqlatKnZ2dtKtWzc5e/ZsuZdv+/btotVq5datW3rzHDt2rLz66qvK8z179ijfZbVr15YxY8Yo25ZIyfsGowegXr16yaZNm8TW1lYuXbokIk8fgBwdHWX06NFy5swZ+de//iUAJDg4WObOnStnz56VOXPmiLW1tTKfoo23du3a8uOPP8rp06fl/fffF0dHR2WHfevWLalZs6ZMmzZNkpKSJCEhQV577TW9Fdm5c2dxcHCQyZMny5kzZ+TMmTMlLu/ChQvFyclJ1q1bJ2fOnJGPP/5YrK2tlT9uenq6NG7cWCZOnCjp6el6oeVRH3/8sbi4uMiqVavk/PnzsmfPHlmxYoWIiOTl5YmHh4e89dZbcuLECYmNjZU6dero3U33WdaVn5+fxMTEyOnTp6Vdu3bSqlUr6dKli/zxxx+SkJAg9evXlw8++ECZ1//93/+Jh4eHbNy4Uf7880/ZuHGjVKtWTVatWlWs359//lmSk5Olb9++4u3tLffv35f8/HxZtGiRODk5SXp6urJeDh06JJaWlrJ27VpJTU2VhIQE+frrr0v+oMnDjcba2loCAgJk3759cvjwYWnTpo20b99emeb3338XJycnWbVqlVy4cEF27NghPj4+MnPmTBERycrKUnbw6enpStBr2bKlfPHFFyLycOdarVo1sbGxUf5+77//voSEhIiISEFBgTRs2FCGDRsmx48fl9OnT8vAgQOlQYMGyh3Cn3WdlaakAFRWH/v37xcLCwuJioqS5ORk+frrr6Vq1ap6AehJ6+zBgwcSGBio7OCWLFkiVatWlYsXL5ZapzG2k+zsbJk9e7bUrl1b729VUgBycnKSBQsWyPnz5+X8+fPyxRdfiJeXl/z++++Smpoqe/bskbVr15b5GXhcefYtly9flipVqsiHH34oSUlJsnnzZqlRo4bypXv16lWxsrKShQsXSkpKihw/flyio6OV5X00AGVnZ0tgYKCMGDFC2U4ePHigF4BERPr27SvvvfeeXq1vv/220laez+ejHjx4IOnp6eLk5CSLFi2S9PR0uXv37hOXrehv8fh+szz727L2fyIic+bMkb1790pKSops3bpV3NzcJCoqSnm9cePG8t5770lSUpKcPXtWvv/+e0lMTCx1X1OSxMREWbZsmZw4cULOnj0rn332mdja2up9rr29vaVatWoSHR0t586dk4iICLGwsFC+H27fvi01a9aUgQMHysmTJ+Wnn36SunXrPjEAvf/++9K+fXv5/ffflc+rVqtVto+ifV1QUJAcOnRIjhw5Ig0bNpSBAwcqfURFRYmLi4ts3LhRTp8+LcOHDxdHR8cyA9Dhw4fFwsJCZs+eLcnJybJy5Uqxs7NTAu+NGzdkxIgREhgYKOnp6XLjxo0S+/n555/F0tJSZsyYIadPn5bExETlfzBERHr27CkNGzaU33//XRITEyU4OFjq16+vhNgnLd+DBw/Ezc1N/vnPfyp9Pt52/vx5sbe3l6+++krOnj0re/fulRYtWsiQIUP0/n6P7xtMEoBERNq1ayfDhg0TkacPQN7e3nr/V9mgQQN55ZVXlOcPHjwQe3t7WbdunYj8dycVGRmpTHP//n2pXbu2ssHMmTNHXn/9db15X7p0SQBIcnKyiDzckFu0aPHE5fX09JS5c+fqtbVu3Vo+/PBD5bm/v3+p/9chIpKbmytarVZvg3/U8uXLxcXFRS/Jbtu2TSwsLCQjI0NEnm1dPfqhWrdunQCQ2NhYpS0iIkIaNGigPK9Xr57y5VFkzpw5EhgYWGq/p06dEgCSlJQkIv9N/I/auHGjODk5SW5ubqnr6lErV64UALJ//36lLSkpSQDIgQMHRESka9euehuiyMOjNx4eHsrzR0NEkbCwMOnRo4eIiCxatEj69eund9Sifv36snz5cqW/Bg0aiE6nU96fn58vdnZ2sn37dhExzjorSUkBqKw+BgwYIN27d9fro1+/fnp/i/KsswsXLoijo6NMmTJF7OzsZM2aNaXWKGKc7USk+D5CpOQA9Oj/fYqIjBkzRv72t7/p/Y0eVdJn4HHl2bd88sknxT4L0dHR4uDgIIWFhXLkyBEBIKmpqSXO49H9Z0nLJiLFAtDmzZv1jvYUHRUq+qyW5/NZEmdnZ+WLsDzLVlTv4/vNJ+1vn7T/K8kXX3whrVq1Up47Ojoq/zPxuJL2NeXVuHFj+cc//qE89/b21gubOp1OXF1dZenSpSIi8s0330j16tXlr7/+UqZZunRpmQHo4sWLYmlpKVeuXNFr79q1q0ybNk1ZBgBy/vx55fXo6Ghxc3NTnnt4eMj8+fOV50WfzbIC0MCBA+W1117Ta5s8ebI0atRIeT5u3Lgyj/yIiAQGBir/Q/i4s2fPCgDZu3ev0nb9+nWxs7OT77//vtzLN27cOPnb3/6mPH/8qNDw4cNl5MiRevPes2ePWFhYKH+PkvYNJjsLLCoqCqtXr0ZSUtJT99G4cWNYWPy3RDc3NzRt2lR5bmlpierVqyMrK0vvfYGBgcq/raysEBAQoNRx7Ngx7Nq1Cw4ODsrDz88PwMPfO4u0atWqzNpyc3Nx9epVdOjQQa+9Q4cOBi1zUlIS8vPz0bVr11Jf9/f3h729vd48dDodkpOTlbanXVfNmjXTew8Avfe5ubkp77lz5w4uXLiA4cOH662/zz//XG/dPd6vh4cHABSb96Nee+01eHt7o27duhg0aBDWrFmDu3fvljo98PBv27p1a+W5n58fqlatqve3nj17tl6tI0aMQHp6epl9d+7cGX/88QcKCwuxe/dudOnSBV26dEFcXByuXr2K8+fPo0uXLso8zp8/D0dHR2Ue1apVw71793DhwgWTrrOSlNVHUlIS2rZtqzf9o9tKeddZ3bp1sWDBAkRFRaFnz54YOHBgqfUYazsxREBAgN7zIUOGIDExEQ0aNMDYsWOxY8eOp+67rH1LUlISAgMD9cZJdOjQAXl5ebh8+TL8/f3RtWtXNG3aFO+88w5WrFjxzGMlu3fvDmtra2zduhUAsHHjRjg5OSEoKAjAkz+f5fWkZSvy+H7zSfvbJ+3/AGDDhg3o0KED3N3d4eDggM8++wxpaWnK62FhYXj//fcRFBSEyMhIg5arSF5eHiZNmoSGDRuiatWqcHBwQFJSkt58AP3tS6PRwN3dXW/7atasGWxtbZVpHt++HnfixAkUFhbi5Zdf1ltHu3fv1luOKlWqoF69espzDw8PZb45OTlIT0/X27aLPptlSUpKKnG7PHfuHAoLC8t876MSExPL/P6ysrLSq6169epo0KCB3vZf1vIBQEhIiLL/BYA1a9agR48eyvi0Y8eOYdWqVXrrMDg4GDqdDikpKUo/j68Tq3IvpYE6deqE4OBgTJs2DUOGDNF7zcLCAiKi13b//v1ifVhbW+s912g0JbbpdLpy15WXl4c333wTUVFRxV4r+sIAoBc4TMnOzs4o/Tztunp0mqKd2+NtRe/Jy8sDAKxYsaLYF6mlpeUT+y3r7+To6IiEhATExcVhx44dmDFjBmbOnIlDhw499SDMvLw8zJo1C2+99Vax1x7dST2uU6dOuH37NhISEvD7779j3rx5cHd3R2RkJPz9/eHp6QlfX19lHq1atcKaNWuK9VOzZk2TrrOSPGsf5V1nv//+OywtLZGamooHDx7AyspkuxKDPb7ttmzZEikpKfjll1/w66+/4t1330VQUBB+/PHHCq3L0tISO3fuxL59+7Bjxw784x//wKeffooDBw6gTp06T9WnjY0N+vbti7Vr16J///5Yu3Yt+vXrp/w9nvT5NLbH1/2T9rd//vlnmf3Fx8cjJCQEs2bNQnBwMJydnbF+/Xp8+eWXyjQzZ87EwIEDsW3bNvzyyy8IDw/H+vXr0adPn3LXPWnSJOzcuRMLFixA/fr1YWdnh759+xYbyP2s3z+Py8vLg6WlJY4cOVJsf+Dg4FDmfB//DjUXY3yHPWn5WrdujXr16mH9+vUYNWoUNm/erHd2Yl5eHv7f//t/GDt2bLG+X3rpJeXfj38+TXodoMjISPz000+Ij4/Xa69ZsyYyMjL0FtCY10nYv3+/8u8HDx7gyJEjaNiwIYCHO8NTp07Bx8cH9evX13sYEnqcnJzg6emJvXv36rXv3bsXjRo1Knc/vr6+sLOzK/XU34YNG+LYsWO4c+eO3jwsLCzQoEGDcs/HGNzc3ODp6Yk///yz2LozZAduY2NT4v9hWFlZISgoCPPnz8fx48eRmpqK3377rdR+Hjx4gMOHDyvPk5OTkZ2drfe3Tk5OLlZr/fr1laNl1tbWxWqpWrUqmjVrhiVLlsDa2hp+fn7o1KkTjh49ip9//hmdO3dWpm3ZsiXOnTsHV1fXYvNwdnY22jozhoYNG+LAgQN6bY9uK0D51tmGDRuwadMmxMXFIS0trczT0I21nTwrJycn9OvXDytWrMCGDRuwceNG3Lx5E0DJn4HSlLVvadiwIeLj4/X2a3v37oWjoyNq164N4OGOvUOHDpg1axaOHj0KGxsbbN68ucR5lbadPC4kJAQxMTE4deoUfvvtN4SEhCivPenzWV7lWbaSPGl/+6T93759++Dt7Y1PP/0UAQEB8PX1xcWLF4tN9/LLL2PChAnYsWMH3nrrLaxcuRJA+dfh3r17MWTIEPTp0wdNmzaFu7s7UlNTn/i+RzVs2BDHjx/HvXv3lLbHt6/HtWjRAoWFhcjKyiq2ftzd3cs1X2dnZ3h4eOht20WfzSfVW9J2+fLLLxcLY2Vp1qxZmd9fDx480Kvtxo0bSE5ONnj7DwkJwZo1a/DTTz/BwsICPXr0UF5r2bIlTp8+XeJ+y8bGptQ+TRqAmjZtipCQECxevFivvUuXLrh27Rrmz5+PCxcuIDo6Gr/88ovR5hsdHY3NmzfjzJkzGD16NG7duoVhw4YBAEaPHo2bN29iwIABOHToEC5cuIDt27dj6NChBh32A4DJkycjKioKGzZsQHJyMqZOnYrExESMGzeu3H3Y2tpiypQp+Pjjj/Hdd9/hwoUL2L9/P/71r38BePhHt7W1xeDBg3Hy5Ens2rULY8aMwaBBg5SfrCrSrFmzEBERgcWLF+Ps2bM4ceIEVq5ciYULF5a7Dx8fH+Tl5SE2NhbXr1/H3bt38fPPP2Px4sVITEzExYsX8d1330Gn05UZ8qytrTFmzBgcOHAAR44cwZAhQ9CuXTu0adMGADBjxgx89913mDVrFk6dOoWkpCSsX78en332mV4tsbGxyMjI0Ps5okuXLlizZo0SdqpVq4aGDRtiw4YNegEoJCQENWrUQK9evbBnzx6kpKQgLi4OY8eOVX4aMMY6M4axY8ciJiYGCxYswLlz57BkyRLExMToTfOkdXb58mWMGjUKUVFR6NixI1auXIl58+aVuaM3xnbyLBYuXIh169bhzJkzOHv2LH744Qe4u7srRxZL+wyUpKx9y4cffohLly5hzJgxOHPmDP79738jPDwcYWFhsLCwwIEDBzBv3jwcPnwYaWlp2LRpE65du6YEqMf5+PjgwIEDSE1NxfXr10s90tCpUye4u7sjJCQEderU0TvSWJ7PZ3k8adlK86T97ZP2f76+vkhLS8P69etx4cIFLF68WC8w/vXXX/joo48QFxeHixcvYu/evTh06JCyTkva15TE19cXmzZtQmJiIo4dO4aBAwcafGRn4MCB0Gg0GDFiBE6fPo3//Oc/WLBgQZnvefnllxESEoLQ0FBs2rQJKSkpOHjwICIiIrBt27Zyz3vcuHGIjIzEli1bcObMGXz44YdPvGjhxIkTERsbizlz5uDs2bNYvXo1lixZgkmTJpV7vsDDa3itW7cO4eHhSEpKwokTJ5Qjfr6+vujVqxdGjBiBP/74A8eOHcN7772HWrVqoVevXgbNJyQkBAkJCZg7dy769u2rdwmQKVOmYN++ffjoo4+QmJiIc+fO4d///jc++uijsjstc3STgR4fxCfycPCgjY2NPD6rpUuXipeXl9jb20toaKjMnTu3xNPgH1XSoEBvb2/56quvlHkBkLVr10qbNm3ExsZGGjVqJL/99pvee86ePSt9+vRRTsvz8/OT8ePHKwP8SppPSQoLC2XmzJlSq1Ytsba2LnZ6r0j5BncWFhbK559/Lt7e3mJtba13mq5I+U+Df5p19ejgvMcHWIqUPIhwzZo10rx5c7GxsREXFxfp1KmTbNq0qdR+b926JQD0Tu384IMPpHr16sqpqXv27JHOnTuLi4uLcgr3hg0bSl1nRXVt3LhR6tatK1qtVoKCgoqdjRQTEyPt27cXOzs7cXJykjZt2igDmEUenr5Zv359sbKy0vv8FQ3cLxrgKPJwIB6AYmcFpqenS2hoqNSoUUO0Wq3UrVtXRowYITk5OUZdZ49DCYOgn9THv/71L6ldu7bY2dnJm2++WeJp8KWtM51OJ127dpXg4GC9wbBjxoyRevXqlXqGjbG2k/IOgi76jBdZvny5NG/eXOzt7cXJyUm6du0qCQkJyuulfQYeVd59S1mnip8+fVqCg4OlZs2aotVq5eWXX9YbZPv4dpycnCzt2rUTOzu7Ek+Df9THH38sAGTGjBnFai/P5/Nxjw+CftKyiZS+33zS/vZJ+7/JkydL9erVxcHBQfr16ydfffWV8pnNz8+X/v37i5eXl9jY2Iinp6d89NFHegORH9/XlCQlJUVeffVVsbOzEy8vL1myZEm5PluPf27j4+PF399fbGxspHnz5rJx48YnngVWUFAgM2bMEB8fH7G2thYPDw/p06ePHD9+XERK3gc/fmLR/fv3Zdy4ceLk5CRVq1aVsLAwg06DL1rvRWe/FinPIGiRhyexFO3fatSoIW+99ZbyWtFp8M7OzmJnZyfBwcElngZf1vIVadOmjQAott2JiBw8eFBee+01cXBwEHt7e2nWrJneyRcl/f00IpXkh0QiokoqNTUVderUwdGjR3lLG6IXxAt1LzAiIiKi8mAAIiIiItXhT2BERESkOjwCRERERKrDAERERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKrDAERERESq8/8BmUA661OKEyYAAAAASUVORK5CYII=", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.0691525423728816, Median = 2.0\n", + "Accuracy 0.70229\n", + "Precision 0.67137\n", + "Recall 0.799458\n", + "FPR 0.39605\n", + "F1 0.729837\n", + "Mean H 3.069153\n", + "Correct Adjustment 0.104689\n", + "Incorrect Adjustment 0.10578\n", + "Recovery -0.001091\n", + "Leaderboard String | MODEL_NAME | 70.2 | 67.1 | 79.9 | 73....\n", + "dtype: object\n", + "summarization complete.\n", + "Unsloth: If you want to finetune Gemma 2, install flash-attn to make it faster!\n", + "To install flash-attn, do the below:\n", + "\n", + "pip install --no-deps --upgrade \"flash-attn>=2.6.3\"\n", + "==((====))== Unsloth 2025.7.11: Fast Gemma2 patching. Transformers: 4.53.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", + "---\n", + "fitting policy ThresholdDecisionPolicy for seed 3\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:00, 46590.36it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": 23, - "id": "fd613b4b", - "metadata": {}, - "outputs": [], - "source": [ - "# initialize model prediction metadata fields for each utterance\n", - "for convo in corpus.iter_conversations():\n", - " for utt in convo.get_chronological_utterance_list():\n", - " utt.add_meta('model_forecast_probs', {}) # will store {seed: prob}\n", - " utt.add_meta('model_forecasts', {}) # will store {seed: binary_forecast}" + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7104, p=0.7033, r=0.7280, fpr=0.3071, f1=0.7154\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.7670454545454546, Median = 2.0\n", + "Accuracy 0.710445\n", + "Precision 0.703297\n", + "Recall 0.728025\n", + "FPR 0.307135\n", + "F1 0.715447\n", + "Mean H 2.767045\n", + "Correct Adjustment 0.075491\n", + "Incorrect Adjustment 0.065667\n", + "Recovery 0.009824\n", + "Leaderboard String | MODEL_NAME | 71.0 | 70.3 | 72.8 | 71....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "fitting policy DeferralDecisionPolicy for seed 3\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4293.18it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "id": "873cb706", - "metadata": {}, - "outputs": [], - "source": [ - "# copy model predictions from the corpora loaded above\n", - "loaded_seed_nums = sorted(\n", - " int(corpus_name.rsplit(\"-\", 1)[-1])\n", - " for corpus_name in corpora\n", - " if corpus_name.startswith(\"test-seed-\")\n", - ")\n", - "\n", - "if not loaded_seed_nums:\n", - " available = \", \".join(sorted(corpora))\n", - " raise KeyError(f\"no test seed corpora found; available corpora: {available}\")\n", - "\n", - "for seed_num in loaded_seed_nums:\n", - " seed_key = f\"test-seed-{seed_num}\"\n", - " print(f\"[info] loading predictions from seed {seed_num}: {seed_key}\")\n", - " seed_corpus = corpora[seed_key]\n", - "\n", - " for convo in corpus.iter_conversations():\n", - " seed_convo = seed_corpus.get_conversation(convo.id)\n", - " main_utts = convo.get_chronological_utterance_list()\n", - " seed_utts = seed_convo.get_chronological_utterance_list()\n", - "\n", - " for main_utt, seed_utt in zip(main_utts, seed_utts):\n", - " forecast_prob = seed_utt.meta.get(\"forecast_prob\")\n", - " forecast = seed_utt.meta.get(\"forecast\")\n", - "\n", - " if forecast_prob is not None:\n", - " current_probs = dict(main_utt.meta.get(\"model_forecast_probs\", {}))\n", - " current_probs[f\"seed_{seed_num}\"] = forecast_prob\n", - " main_utt.add_meta(\"model_forecast_probs\", current_probs)\n", - "\n", - " if forecast is not None:\n", - " current_forecasts = dict(main_utt.meta.get(\"model_forecasts\", {}))\n", - " current_forecasts[f\"seed_{seed_num}\"] = forecast\n", - " main_utt.add_meta(\"model_forecasts\", current_forecasts)\n", - "\n", - "print(\"\\n[pass] model predictions from all seeds added to corpus\")\n" + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7027, p=0.7292, r=0.6448, fpr=0.2394, f1=0.6844\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAARydJREFUeJzt3Xd8FOXe///3JqQRktBTICY06U16EfAQjQduKYrSlCp89SggQQQsBERKEBE5cINynwN43zSVclCOFCMg0lsEIVQDQSF0CAFpyfX7wx97WBIgi7tsYF7Px2MfstfMXvOZyc7s29lrdmzGGCMAAAAL8fJ0AQAAAPcbAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFhOPk8XkBdlZWXp6NGjCgoKks1m83Q5AAAgF4wxunDhgiIiIuTldedzPASgHBw9elSRkZGeLgMAANyDI0eOqGTJknechwCUg6CgIEl/bMDg4GAPVwMAAHIjPT1dkZGR9s/xOyEA5eDG117BwcEEIAAAHjC5Gb7CIGgAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5+TxdAPKG6MFLPF1Cjg6NaenpEgAADyHOAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMshAAEAAMvJ5+kCrCh68BJPlwAAgKVxBggAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFgOAQgAAFhOnghAkydPVnR0tPz9/VWvXj1t2rTptvNOmzZNjz/+uAoVKqRChQopJiYm2/zGGA0dOlTh4eEKCAhQTEyM9u/f7+7VAAAADwiPB6B58+YpLi5O8fHx2rZtm6pXr67Y2FidOHEix/lXrVqljh07auXKlVq/fr0iIyP11FNP6bfffrPPM3bsWE2cOFFTp07Vxo0bFRgYqNjYWF2+fPl+rRYAAMjDbMYY48kC6tWrpzp16mjSpEmSpKysLEVGRqpPnz4aPHjwXV+fmZmpQoUKadKkSerSpYuMMYqIiNCAAQP05ptvSpLOnz+v0NBQzZgxQx06dLhrn+np6QoJCdH58+cVHBz851YwB9GDl7i8z4fVoTEtPV0CAOAB4cznt0fPAF29elVbt25VTEyMvc3Ly0sxMTFav359rvq4dOmSrl27psKFC0uSUlJSlJaW5tBnSEiI6tWrd9s+r1y5ovT0dIcHAAB4eHk0AJ06dUqZmZkKDQ11aA8NDVVaWlqu+hg0aJAiIiLsgefG65zpc/To0QoJCbE/IiMjnV0VAADwAPH4GKA/Y8yYMZo7d64WLlwof3//e+5nyJAhOn/+vP1x5MgRF1YJAADymnyeXHjRokXl7e2t48ePO7QfP35cYWFhd3ztuHHjNGbMGH333XeqVq2avf3G644fP67w8HCHPmvUqJFjX35+fvLz87vHtQAAAA8aj54B8vX1Va1atZSYmGhvy8rKUmJioho0aHDb140dO1YjRozQ0qVLVbt2bYdppUqVUlhYmEOf6enp2rhx4x37BAAA1uHRM0CSFBcXp65du6p27dqqW7euJkyYoIsXL6p79+6SpC5duqhEiRIaPXq0JCkhIUFDhw7V7NmzFR0dbR/XU6BAARUoUEA2m01vvPGGPvjgA5UrV06lSpXSe++9p4iICLVp08ZTqwkAAPIQjweg9u3b6+TJkxo6dKjS0tJUo0YNLV261D6IOTU1VV5e/zlRNWXKFF29elXt2rVz6Cc+Pl7Dhg2TJL311lu6ePGievfurXPnzqlx48ZaunTpnxonBAAAHh4e/x2gvIjfAco7+B0gAEBuPTC/AwQAAOAJBCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5TgegmTNnasmSJfbnb731lgoWLKiGDRvq8OHDLi0OAADAHZwOQKNGjVJAQIAkaf369Zo8ebLGjh2rokWLqn///i4vEAAAwNXyOfuCI0eOqGzZspKkRYsW6bnnnlPv3r3VqFEjNWvWzNX1AQAAuJzTZ4AKFCig06dPS5KWL1+uJ598UpLk7++v33//3bXVAQAAuIHTZ4CefPJJvfzyy6pZs6b27dunFi1aSJJ27dql6OhoV9cHAADgck6fAZo8ebIaNGigkydPav78+SpSpIgkaevWrerYsaPLCwQAAHA1p88AFSxYUJMmTcrWPnz4cJcUBAAA4G5OByBJOnfunDZt2qQTJ04oKyvL3m6z2fTSSy+5rDgAAAB3cDoAff311+rcubMyMjIUHBwsm81mn0YAAgAADwKnxwANGDBAPXr0UEZGhs6dO6ezZ8/aH2fOnHFHjQAAAC7ldAD67bff1LdvX+XPn98d9QAAALid0wEoNjZWW7ZscUctAAAA94XTY4BatmypgQMHavfu3apatap8fHwcprdq1cplxQEAALiD0wGoV69ekqT3338/2zSbzabMzMw/XxUAAIAbOR2Abr7sHQAA4EHk9BggAACAB909BaDVq1frmWeeUdmyZVW2bFm1atVKa9ascXVtAAAAbuF0APq///s/xcTEKH/+/Orbt6/69u2rgIAANW/eXLNnz3ZHjQAAAC5lM8YYZ15QsWJF9e7dW/3793doHz9+vKZNm6bk5GSXFugJ6enpCgkJ0fnz5xUcHOzy/qMHL3F5nw+rQ2NaeroEAMADwpnPb6fPAP3yyy965plnsrW3atVKKSkpznYHAABw3zkdgCIjI5WYmJit/bvvvlNkZKRLigIAAHAnpy+DHzBggPr27aukpCQ1bNhQkrR27VrNmDFDn3zyicsLBAAAcDWnA9Crr76qsLAwffTRR/riiy8k/TEuaN68eWrdurXLCwQAAHA1pwOQJLVt21Zt27Z1dS0AAAD3BT+ECAAALCdXZ4AKFy6sffv2qWjRoipUqJBsNttt5z1z5ozLigMAAHCHXAWgjz/+WEFBQfZ/3ykAAQAA5HW5CkBdu3a1/7tbt27uqgUAAOC+cHoMkLe3t06cOJGt/fTp0/L29nZJUQAAAO7kdAC63Z0zrly5Il9f3z9dEAAAgLvl+jL4iRMnSpJsNpv+53/+RwUKFLBPy8zM1A8//KAKFSq4vkIAAAAXy3UA+vjjjyX9cQZo6tSpDl93+fr6Kjo6WlOnTnV9hQAAAC6W6wB040anTzzxhBYsWKBChQq5rSgAAAB3cvqXoFeuXOmOOgAAAO6be7oVxq+//qrFixcrNTVVV69edZg2fvx4lxQGAADgLk4HoMTERLVq1UqlS5fWnj17VKVKFR06dEjGGD322GPuqBEAAMClnL4MfsiQIXrzzTe1c+dO+fv7a/78+Tpy5IiaNm2q559/3ukCJk+erOjoaPn7+6tevXratGnTbefdtWuXnnvuOUVHR8tms2nChAnZ5hk2bJhsNpvDg6vTAADAzZwOQMnJyerSpYskKV++fPr9999VoEABvf/++0pISHCqr3nz5ikuLk7x8fHatm2bqlevrtjY2Bx/aFGSLl26pNKlS2vMmDEKCwu7bb+VK1fWsWPH7I8ff/zRqboAAMDDzekAFBgYaB/3Ex4eroMHD9qnnTp1yqm+xo8fr169eql79+6qVKmSpk6dqvz58+uf//xnjvPXqVNHH374oTp06CA/P7/b9psvXz6FhYXZH0WLFnWqLgAA8HBzOgDVr1/ffkalRYsWGjBggEaOHKkePXqofv36ue7n6tWr2rp1q2JiYv5TjJeXYmJitH79emfLcrB//35FRESodOnS6ty5s1JTU+84/5UrV5Senu7wAAAADy+nA9D48eNVr149SdLw4cPVvHlzzZs3T9HR0frHP/6R635OnTqlzMxMhYaGOrSHhoYqLS3N2bLs6tWrpxkzZmjp0qWaMmWKUlJS9Pjjj+vChQu3fc3o0aMVEhJif0RGRt7z8gEAQN7n9FVgpUuXtv87MDAwz/3681//+lf7v6tVq6Z69eopKipKX3zxhXr27Jnja4YMGaK4uDj78/T0dEIQAAAPMacD0JEjR2Sz2VSyZElJ0qZNmzR79mxVqlRJvXv3znU/RYsWlbe3t44fP+7Qfvz48TsOcHZWwYIF9eijj+rAgQO3ncfPz++OY4oAAMDDxemvwDp16mT/Nei0tDTFxMRo06ZNeuedd/T+++/nuh9fX1/VqlVLiYmJ9rasrCwlJiaqQYMGzpZ1WxkZGTp48KDCw8Nd1icAAHiwOR2Afv75Z9WtW1eS9MUXX6hq1apat26dZs2apRkzZjjVV1xcnKZNm6aZM2cqOTlZr776qi5evKju3btLkrp06aIhQ4bY57969aqSkpKUlJSkq1ev6rffflNSUpLD2Z0333xTq1ev1qFDh7Ru3Tq1bdtW3t7e6tixo7OrCgAAHlJOfwV27do1+9dF3333nVq1aiVJqlChgo4dO+ZUX+3bt9fJkyc1dOhQpaWlqUaNGlq6dKl9YHRqaqq8vP6T0Y4ePaqaNWvan48bN07jxo1T06ZNtWrVKkl/3KajY8eOOn36tIoVK6bGjRtrw4YNKlasmLOrCgAAHlI2Y4xx5gX16tXTE088oZYtW+qpp57Shg0bVL16dW3YsEHt2rXTr7/+6q5a75v09HSFhITo/PnzCg4Odnn/0YOXuLzPh9WhMS09XQIA4AHhzOe301+BJSQk6NNPP1WzZs3UsWNHVa9eXZK0ePFi+1djAAAAeZnTX4E1a9ZMp06dUnp6ugoVKmRv7927t/Lnz+/S4gAAANzB6TNAkmSM0datW/Xpp5/af2DQ19eXAAQAAB4ITp8BOnz4sJ5++mmlpqbqypUrevLJJxUUFKSEhARduXIlz/0wIgAAwK2cPgPUr18/1a5dW2fPnlVAQIC9vW3btg6/6QMAAJBXOX0GaM2aNVq3bp18fX0d2qOjo/Xbb7+5rDAAAAB3cfoMUFZWljIzM7O1//rrrwoKCnJJUQAAAO7kdAB66qmnNGHCBPtzm82mjIwMxcfHq0WLFq6sDQAAwC2c/grso48+UmxsrCpVqqTLly+rU6dO2r9/v4oWLao5c+a4o0YAAACXcjoAlSxZUj/99JPmzp2rHTt2KCMjQz179lTnzp0dBkUDAADkVU4HoMuXL8vf318vvviiO+oBAABwO6fHABUvXlxdu3bVihUrlJWV5Y6aAAAA3MrpADRz5kxdunRJrVu3VokSJfTGG29oy5Yt7qgNAADALZz+Cqxt27Zq27atLly4oK+++kpz5sxR/fr1Vbp0ab344osaOnSoO+oE8ozowUs8XUKODo1p6ekSAOCBcU/3ApOkoKAgde/eXcuXL9eOHTsUGBio4cOHu7I2AAAAt7jnAHT58mV98cUXatOmjR577DGdOXNGAwcOdGVtAAAAbuH0V2DLli3T7NmztWjRIuXLl0/t2rXT8uXL1aRJE3fUBwAA4HL3NAbov/7rv/T555+rRYsW8vHxcUddAAAAbuN0ADp+/Dj3/AIAAA80pwNQUFCQsrKydODAAZ04cSLbbwHxVRgAAMjrnA5AGzZsUKdOnXT48GEZYxym2Wy2HO8UDwAAkJc4HYBeeeUV1a5dW0uWLFF4eLhsNps76gIAAHAbpwPQ/v379dVXX6ls2bLuqAcAAMDtnP4doHr16unAgQPuqAUAAOC+cPoMUJ8+fTRgwAClpaWpatWq2S6Dr1atmsuKAwAAcAenA9Bzzz0nSerRo4e9zWazyRjDIGgAAPBAcDoApaSkuKMOAACA+8bpABQVFeWOOgAAAO4bpwOQJB08eFATJkxQcnKyJKlSpUrq16+fypQp49LiAAAA3MHpq8CWLVumSpUqadOmTapWrZqqVaumjRs3qnLlylqxYoU7agQAAHApp88ADR48WP3799eYMWOytQ8aNEhPPvmky4oDAABwB6fPACUnJ6tnz57Z2nv06KHdu3e7pCgAAAB3cjoAFStWTElJSdnak5KSVLx4cVfUBAAA4FZOfwXWq1cv9e7dW7/88osaNmwoSVq7dq0SEhIUFxfn8gIBAABczekA9N577ykoKEgfffSRhgwZIkmKiIjQsGHD1LdvX5cXCAAA4GpOByCbzab+/furf//+unDhgiQpKCjI5YUBAAC4yz39EvT169dVrlw5h+Czf/9++fj4KDo62pX1weKiBy/xdAkAgIeQ04Ogu3XrpnXr1mVr37hxo7p16+aKmgAAANzK6QC0fft2NWrUKFt7/fr1c7w6DAAAIK9xOgDZbDb72J+bnT9/njvBAwCAB4LTAahJkyYaPXq0Q9jJzMzU6NGj1bhxY5cWBwAA4A5OD4JOSEhQkyZNVL58eT3++OOSpDVr1ig9PV3ff/+9ywsEAABwNafPAFWqVEk7duzQCy+8oBMnTujChQvq0qWL9uzZoypVqrijRgAAAJdy+gyQ9McPH44aNcrVtQAAANwXTp8BAgAAeNARgAAAgOUQgAAAgOXkKgAtXrxY165dc3ctAAAA90WuAlDbtm117tw5SZK3t7dOnDjhzpoAAADcKlcBqFixYtqwYYMkyRgjm83m1qIAAADcKVeXwb/yyitq3bq1bDabbDabwsLCbjsvt8MAAAB5Xa4C0LBhw9ShQwcdOHBArVq10vTp01WwYEE3lwYAAOAeuf4hxAoVKqhChQqKj4/X888/r/z587uzLgAAALdx+peg4+PjJUknT57U3r17JUnly5dXsWLFXFsZAACAmzj9O0CXLl1Sjx49FBERoSZNmqhJkyaKiIhQz549denSJXfUCAAA4FJOB6D+/ftr9erVWrx4sc6dO6dz587pX//6l1avXq0BAwa4o0YAAACXcvorsPnz5+urr75Ss2bN7G0tWrRQQECAXnjhBU2ZMsWV9QEAALjcPX0FFhoamq29ePHifAUGAAAeCE4HoAYNGig+Pl6XL1+2t/3+++8aPny4GjRo4NLiAAAA3MHpr8A++eQTxcbGqmTJkqpevbok6aeffpK/v7+WLVvm8gIBAABczekAVKVKFe3fv1+zZs3Snj17JEkdO3ZU586dFRAQ4PICAQAAXM3pACRJ+fPnV69evVxdCwAAwH3h9BggAACABx0BCAAAWI7HA9DkyZMVHR0tf39/1atXT5s2bbrtvLt27dJzzz2n6Oho2Ww2TZgw4U/3CQAArMejAWjevHmKi4tTfHy8tm3bpurVqys2NlYnTpzIcf5Lly6pdOnSGjNmjMLCwlzSJwAAsB6nA1Dp0qV1+vTpbO3nzp1T6dKlnepr/Pjx6tWrl7p3765KlSpp6tSpyp8/v/75z3/mOH+dOnX04YcfqkOHDvLz83NJnwAAwHqcDkCHDh1SZmZmtvYrV67ot99+y3U/V69e1datWxUTE/OfYry8FBMTo/Xr1ztb1p/q88qVK0pPT3d4AACAh1euL4NfvHix/d/Lli1TSEiI/XlmZqYSExMVHR2d6wWfOnVKmZmZ2W6rERoaav99IWfda5+jR4/W8OHD72mZAADgwZPrANSmTRtJks1mU9euXR2m+fj4KDo6Wh999JFLi7tfhgwZori4OPvz9PR0RUZGerAiAADgTrkOQFlZWZKkUqVKafPmzSpatOifWnDRokXl7e2t48ePO7QfP378tgOc3dWnn5/fbccUAQCAh4/TY4BSUlL+dPiRJF9fX9WqVUuJiYn2tqysLCUmJt7zTVXd0ScAAHj43NOtMBITE5WYmKgTJ07Yzwzd4MzVVnFxceratatq166tunXrasKECbp48aK6d+8uSerSpYtKlCih0aNHS/pjkPPu3bvt//7tt9+UlJSkAgUKqGzZsrnqEwAAwOkANHz4cL3//vuqXbu2wsPDZbPZ7nnh7du318mTJzV06FClpaWpRo0aWrp0qX0Qc2pqqry8/nOS6ujRo6pZs6b9+bhx4zRu3Dg1bdpUq1atylWfAAAANmOMceYF4eHhGjt2rF566SV31eRx6enpCgkJ0fnz5xUcHOzy/qMHL3F5n8ChMS09XQIAeJQzn99OjwG6evWqGjZseM/FAQAAeJrTAejll1/W7Nmz3VELAADAfeH0GKDLly/rs88+03fffadq1arJx8fHYfr48eNdVhwAAIA7OB2AduzYoRo1akiSfv75Z4dpf2ZANAAAwP3idABauXKlO+oAAAC4b5weA3TDgQMHtGzZMv3++++SJCcvJgMAAPAYpwPQ6dOn1bx5cz366KNq0aKFjh07Jknq2bOnBgwY4PICAQAAXM3pANS/f3/5+PgoNTVV+fPnt7e3b99eS5cudWlxAAAA7uD0GKDly5dr2bJlKlmypEN7uXLldPjwYZcVBgAA4C5OnwG6ePGiw5mfG86cOcMd1QEAwAPB6QD0+OOP6/PPP7c/t9lsysrK0tixY/XEE0+4tDgAAAB3cPorsLFjx6p58+basmWLrl69qrfeeku7du3SmTNntHbtWnfUCAAA4FJOnwGqUqWK9u3bp8aNG6t169a6ePGinn32WW3fvl1lypRxR40AAAAu5fQZIEkKCQnRO++84+paAAAA7gunzwBNnz5dX375Zbb2L7/8UjNnznRJUQAAAO7kdAAaPXq0ihYtmq29ePHiGjVqlEuKAgAAcCenA1BqaqpKlSqVrT0qKkqpqakuKQoAAMCdnA5AxYsX144dO7K1//TTTypSpIhLigIAAHAnpwNQx44d1bdvX61cuVKZmZnKzMzU999/r379+qlDhw7uqBEAAMClnL4KbMSIETp06JCaN2+ufPn+eHlWVpa6dOnCGCAAAPBAcCoAGWOUlpamGTNm6IMPPlBSUpICAgJUtWpVRUVFuatGAAAAl3I6AJUtW1a7du1SuXLlVK5cOXfVBQAA4DZOjQHy8vJSuXLldPr0aXfVAwAA4HZOD4IeM2aMBg4cqJ9//tkd9QAAALid04Ogu3TpokuXLql69ery9fVVQECAw/QzZ864rDgAAAB3cDoATZgwwQ1lAAAA3D9OB6CuXbu6ow4AAID7xukxQJJ08OBBvfvuu+rYsaNOnDghSfr222+1a9culxYHAADgDk4HoNWrV6tq1arauHGjFixYoIyMDEl/3AojPj7e5QUCAAC4mtMBaPDgwfrggw+0YsUK+fr62tv/8pe/aMOGDS4tDgAAwB2cDkA7d+5U27Zts7UXL15cp06dcklRAAAA7uR0ACpYsKCOHTuWrX379u0qUaKES4oCAABwJ6cDUIcOHTRo0CClpaXJZrMpKytLa9eu1ZtvvqkuXbq4o0YAAACXcjoAjRo1ShUqVFBkZKQyMjJUqVIlNWnSRA0bNtS7777rjhoBAABcyunfAfL19dW0adM0dOhQ7dy5UxkZGapZsyY3RgUAAA+MXAegrKwsffjhh1q8eLGuXr2q5s2bKz4+PtutMAAAAPK6XH8FNnLkSL399tsqUKCASpQooU8++USvvfaaO2sDAABwi1wHoM8//1z//d//rWXLlmnRokX6+uuvNWvWLGVlZbmzPgAAAJfLdQBKTU1VixYt7M9jYmJks9l09OhRtxQGAADgLrkeA3T9+nX5+/s7tPn4+OjatWsuLwrAwyF68BJPl5CjQ2NaeroEAB6W6wBkjFG3bt3k5+dnb7t8+bJeeeUVBQYG2tsWLFjg2goBAABcLNcBqGvXrtnaXnzxRZcWA+De5dWzLQCQF+U6AE2fPt2ddQAAANw3Tv8SNAAAwIOOAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACyHAAQAACwnTwSgyZMnKzo6Wv7+/qpXr542bdp0x/m//PJLVahQQf7+/qpatar+/e9/O0zv1q2bbDabw+Ppp5925yoAAIAHiMcD0Lx58xQXF6f4+Hht27ZN1atXV2xsrE6cOJHj/OvWrVPHjh3Vs2dPbd++XW3atFGbNm30888/O8z39NNP69ixY/bHnDlz7sfqAACAB4DHA9D48ePVq1cvde/eXZUqVdLUqVOVP39+/fOf/8xx/k8++URPP/20Bg4cqIoVK2rEiBF67LHHNGnSJIf5/Pz8FBYWZn8UKlTofqwOAAB4AHg0AF29elVbt25VTEyMvc3Ly0sxMTFav359jq9Zv369w/ySFBsbm23+VatWqXjx4ipfvrxeffVVnT59+rZ1XLlyRenp6Q4PAADw8PJoADp16pQyMzMVGhrq0B4aGqq0tLQcX5OWlnbX+Z9++ml9/vnnSkxMVEJCglavXq2//vWvyszMzLHP0aNHKyQkxP6IjIz8k2sGAADysnyeLsAdOnToYP931apVVa1aNZUpU0arVq1S8+bNs80/ZMgQxcXF2Z+np6cTggAAeIh59AxQ0aJF5e3trePHjzu0Hz9+XGFhYTm+JiwszKn5Jal06dIqWrSoDhw4kON0Pz8/BQcHOzwAAMDDy6MByNfXV7Vq1VJiYqK9LSsrS4mJiWrQoEGOr2nQoIHD/JK0YsWK284vSb/++qtOnz6t8PBw1xQOAAAeaB6/CiwuLk7Tpk3TzJkzlZycrFdffVUXL15U9+7dJUldunTRkCFD7PP369dPS5cu1UcffaQ9e/Zo2LBh2rJli15//XVJUkZGhgYOHKgNGzbo0KFDSkxMVOvWrVW2bFnFxsZ6ZB0BAEDe4vExQO3bt9fJkyc1dOhQpaWlqUaNGlq6dKl9oHNqaqq8vP6T0xo2bKjZs2fr3Xff1dtvv61y5cpp0aJFqlKliiTJ29tbO3bs0MyZM3Xu3DlFREToqaee0ogRI+Tn5+eRdQQAAHmLzRhjPF1EXpOenq6QkBCdP3/eLeOBogcvcXmfAB58h8a09HQJwAPNmc9vj38FBgAAcL8RgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOXk83QBAIA/RA9e4ukSsjk0pqWnSwDcgjNAAADAcghAAADAcghAAADAcghAAADAcghAAADAcrgKDABwW3nxyjSJq9Pw53EGCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWA4BCAAAWE4+TxcAAMDDIHrwEk+XkKNDY1p6uoQ8iTNAAADAcjgDBAB44OTVsy14cHAGCAAAWA4BCAAAWA5fgQEA8BDLi18X5oWB2ZwBAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlpMnAtDkyZMVHR0tf39/1atXT5s2bbrj/F9++aUqVKggf39/Va1aVf/+978dphtjNHToUIWHhysgIEAxMTHav3+/O1cBAAA8QDwegObNm6e4uDjFx8dr27Ztql69umJjY3XixIkc51+3bp06duyonj17avv27WrTpo3atGmjn3/+2T7P2LFjNXHiRE2dOlUbN25UYGCgYmNjdfny5fu1WgAAIA+zGWOMJwuoV6+e6tSpo0mTJkmSsrKyFBkZqT59+mjw4MHZ5m/fvr0uXryob775xt5Wv3591ahRQ1OnTpUxRhERERowYIDefPNNSdL58+cVGhqqGTNmqEOHDnetKT09XSEhITp//ryCg4NdtKb/ET14icv7BADgQXFoTEu39OvM53c+t1SQS1evXtXWrVs1ZMgQe5uXl5diYmK0fv36HF+zfv16xcXFObTFxsZq0aJFkqSUlBSlpaUpJibGPj0kJET16tXT+vXrcwxAV65c0ZUrV+zPz58/L+mPDekOWVcuuaVfAAAeBO76fL3Rb27O7Xg0AJ06dUqZmZkKDQ11aA8NDdWePXtyfE1aWlqO86elpdmn32i73Ty3Gj16tIYPH56tPTIyMncrAgAAci1kgnv7v3DhgkJCQu44j0cDUF4xZMgQh7NKWVlZOnPmjIoUKSKbzebByu6P9PR0RUZG6siRI275yu9hwrbKPbaVc9heuce2yj2rbStjjC5cuKCIiIi7zuvRAFS0aFF5e3vr+PHjDu3Hjx9XWFhYjq8JCwu74/w3/nv8+HGFh4c7zFOjRo0c+/Tz85Ofn59DW8GCBZ1ZlYdCcHCwJXYQV2Bb5R7byjlsr9xjW+WelbbV3c783ODRq8B8fX1Vq1YtJSYm2tuysrKUmJioBg0a5PiaBg0aOMwvSStWrLDPX6pUKYWFhTnMk56ero0bN962TwAAYC0e/wosLi5OXbt2Ve3atVW3bl1NmDBBFy9eVPfu3SVJXbp0UYkSJTR69GhJUr9+/dS0aVN99NFHatmypebOnastW7bos88+kyTZbDa98cYb+uCDD1SuXDmVKlVK7733niIiItSmTRtPrSYAAMhDPB6A2rdvr5MnT2ro0KFKS0tTjRo1tHTpUvsg5tTUVHl5/edEVcOGDTV79my9++67evvtt1WuXDktWrRIVapUsc/z1ltv6eLFi+rdu7fOnTunxo0ba+nSpfL397/v6/cg8PPzU3x8fLavAZEd2yr32FbOYXvlHtsq99hWt+fx3wECAAC43zz+S9AAAAD3GwEIAABYDgEIAABYDgEIAABYDgHIwkaPHq06deooKChIxYsXV5s2bbR3715Pl/VAGDNmjP0nF5Ddb7/9phdffFFFihRRQECAqlatqi1btni6rDwnMzNT7733nkqVKqWAgACVKVNGI0aMyNV9jKzghx9+0DPPPKOIiAjZbDb7PR9vMMZo6NChCg8PV0BAgGJiYrR//37PFOthd9pW165d06BBg1S1alUFBgYqIiJCXbp00dGjRz1XcB5AALKw1atX67XXXtOGDRu0YsUKXbt2TU899ZQuXrzo6dLytM2bN+vTTz9VtWrVPF1KnnT27Fk1atRIPj4++vbbb7V792599NFHKlSokKdLy3MSEhI0ZcoUTZo0ScnJyUpISNDYsWP197//3dOl5QkXL15U9erVNXny5Bynjx07VhMnTtTUqVO1ceNGBQYGKjY2VpcvX77PlXrenbbVpUuXtG3bNr333nvatm2bFixYoL1796pVq1YeqDQPMcD/78SJE0aSWb16tadLybMuXLhgypUrZ1asWGGaNm1q+vXr5+mS8pxBgwaZxo0be7qMB0LLli1Njx49HNqeffZZ07lzZw9VlHdJMgsXLrQ/z8rKMmFhYebDDz+0t507d874+fmZOXPmeKDCvOPWbZWTTZs2GUnm8OHD96eoPIgzQLA7f/68JKlw4cIeriTveu2119SyZUvFxMR4upQ8a/Hixapdu7aef/55FS9eXDVr1tS0adM8XVae1LBhQyUmJmrfvn2SpJ9++kk//vij/vrXv3q4srwvJSVFaWlpDvtiSEiI6tWrp/Xr13uwsgfD+fPnZbPZLHnfyxs8/kvQyBuysrL0xhtvqFGjRg6/qo3/mDt3rrZt26bNmzd7upQ87ZdfftGUKVMUFxent99+W5s3b1bfvn3l6+urrl27erq8PGXw4MFKT09XhQoV5O3trczMTI0cOVKdO3f2dGl5XlpamiTZ7xpwQ2hoqH0acnb58mUNGjRIHTt2tMwNUnNCAIKkP85s/Pzzz/rxxx89XUqedOTIEfXr108rVqzglip3kZWVpdq1a2vUqFGSpJo1a+rnn3/W1KlTCUC3+OKLLzRr1izNnj1blStXVlJSkt544w1FRESwreAW165d0wsvvCBjjKZMmeLpcjyKr8Cg119/Xd98841WrlypkiVLerqcPGnr1q06ceKEHnvsMeXLl0/58uXT6tWrNXHiROXLl0+ZmZmeLjHPCA8PV6VKlRzaKlasqNTUVA9VlHcNHDhQgwcPVocOHVS1alW99NJL6t+/v/3mz7i9sLAwSdLx48cd2o8fP26fBkc3ws/hw4e1YsUKS5/9kQhAlmaM0euvv66FCxfq+++/V6lSpTxdUp7VvHlz7dy5U0lJSfZH7dq11blzZyUlJcnb29vTJeYZjRo1yvZzCvv27VNUVJSHKsq7Ll265HCzZ0ny9vZWVlaWhyp6cJQqVUphYWFKTEy0t6Wnp2vjxo1q0KCBByvLm26En/379+u7775TkSJFPF2Sx/EVmIW99tprmj17tv71r38pKCjI/r15SEiIAgICPFxd3hIUFJRtbFRgYKCKFCnCmKlb9O/fXw0bNtSoUaP0wgsvaNOmTfrss8/02Wefebq0POeZZ57RyJEj9cgjj6hy5cravn27xo8frx49eni6tDwhIyNDBw4csD9PSUlRUlKSChcurEceeURvvPGGPvjgA5UrV06lSpXSe++9p4iICLVp08ZzRXvInbZVeHi42rVrp23btumbb75RZmam/XhfuHBh+fr6eqpsz/L0ZWjwHEk5PqZPn+7p0h4IXAZ/e19//bWpUqWK8fPzMxUqVDCfffaZp0vKk9LT002/fv3MI488Yvz9/U3p0qXNO++8Y65cueLp0vKElStX5niM6tq1qzHmj0vh33vvPRMaGmr8/PxM8+bNzd69ez1btIfcaVulpKTc9ni/cuVKT5fuMTZj+MlRAABgLYwBAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlvNQBaBDhw7JZrMpKSnJ06XY7dmzR/Xr15e/v79q1Kjh6XIeGjNmzFDBggU9XYZH2Ww2LVq06E/1kVe2Y272E2OMevfurcKFC9v382bNmumNN964r7W6S7du3e56C4dVq1bJZrPp3Llzbq1l7dq1qlq1qnx8fCx5WwlX8eRnUm7eT3dz6dIlPffccwoODr4v77v7zaUBqFu3brLZbBozZoxD+6JFi2Sz2Vy5qAdGfHy8AgMDtXfvXoeb9llZXvnQlVwTIjzl2LFj+utf/+rpMlwiN/vJ0qVLNWPGDH3zzTc6duyYqlSpogULFmjEiBF/atl55T3wySefaMaMGfbnOYW7hg0b6tixYwoJCXFrLXFxcapRo4ZSUlIcanrQ5KVjzYNo5syZWrNmjdatW3df3nf3m8vPAPn7+yshIUFnz551ddcec/Xq1Xt+7cGDB9W4cWNFRUVx9124VFhYmPz8/DxdhkvkZj85ePCgwsPD1bBhQ4WFhSlfvnwqXLiwgoKCbtvvn9l377eQkJC7flj7+voqLCzM7f9DefDgQf3lL39RyZIl7zlAPEjbHjk7ePCgKlasqCpVqtyX9939dPXqVdfeDLVr167mv/7rv0yFChXMwIED7e0LFy40umlR8fHxpnr16g6v/fjjj01UVJRDX61btzYjR440xYsXNyEhIWb48OHm2rVr5s033zSFChUyJUqUMP/85z/tr7lxw7c5c+aYBg0aGD8/P1O5cmWzatUqh2Xt3LnTPP300yYwMNAUL17cvPjii+bkyZP26U2bNjWvvfaa6devnylSpIhp1qxZjuubmZlphg8fbkqUKGF8fX1N9erVzbfffmufrltuOhcfH3/bfhISEkyZMmWMr6+viYyMNB988IF9+o4dO8wTTzxh/P39TeHChU2vXr3MhQsXXLKt5s2bZxo3bmz8/f1N7dq1zd69e82mTZtMrVq1TGBgoHn66afNiRMnHOqdNm2aqVChgvHz8zPly5c3kydPztbv/PnzTbNmzUxAQICpVq2aWbdunTEm5xv23dgukydPNmXLljV+fn6mePHi5rnnnstxexljzPTp001ISIhZuHCh/TVPPfWUSU1NdZhv0aJFpmbNmsbPz8+UKlXKDBs2zFy7ds0YY0xUVJRDHVFRUebcuXPGy8vLbN682f63KVSokKlXr569z//93/81JUuWtD9PTU01zz//vAkJCTGFChUyrVq1MikpKS7bZrcjySxcuNCpPqZPn24iIyNNQECAadOmjRk3bpwJCQnJ9TYbPny4CQ8PN6dOnbLP36JFC9OsWTOTmZmZY52u2E+6du2a7W9lTPYb0kZFRZn333/fvPTSSyYoKMh07drVXLlyxbz22msmLCzM+Pn5mUceecSMGjXKPn9O/d4qt8eWVatWmTp16hhfX18TFhZmBg0aZN92xhjz5ZdfmipVqtj35ebNm5uMjAz7OrZu3TrH9ZVkUlJS7PvP2bNnzfnz542/v7/597//7VDDggULTIECBczFixeNMbl7f966njc/btwc+W7rdrvj5t2Ot3c7/r311lumXLlyJiAgwJQqVcq8++675urVq/bpSUlJplmzZqZAgQImKCjIPPbYY2bz5s13PNbc6sCBA6ZVq1amePHiJjAw0NSuXdusWLHCYZ6oqCgzcuRI0717d1OgQAETGRlpPv30U4d5Nm7caGrUqGH8/PxMrVq1zIIFC4wks3379hyXa4wxly9fNgMGDDAREREmf/78pm7dug43KL1xrFu6dKmpUKGCCQwMNLGxsebo0aP2ea5fv2769+9vQkJCTOHChc3AgQNNly5d7O+n2/nqq69MpUqVjK+vr4mKijLjxo2zT2vatKnDtmvatOlt+1m8eLGpXbu28fPzM0WKFDFt2rSxTztz5ox56aWXTMGCBU1AQIB5+umnzb59+3K9fsuWLTN+fn7m7NmzDsvs27eveeKJJ+zP16xZY/8sK1mypOnTp4993zIm52ODywNQ69atzYIFC4y/v785cuSIMebeA1BQUJB57bXXzJ49e8w//vEPI8nExsaakSNHmn379pkRI0YYHx8f+3Ju7LwlS5Y0X331ldm9e7d5+eWXTVBQkP2AffbsWVOsWDEzZMgQk5ycbLZt22aefPJJhw3ZtGlTU6BAATNw4ECzZ88es2fPnhzXd/z48SY4ONjMmTPH7Nmzx7z11lvGx8fH/sc9duyYqVy5shkwYIA5duyYQ2i52VtvvWUKFSpkZsyYYQ4cOGDWrFljpk2bZowxJiMjw4SHh5tnn33W7Ny50yQmJppSpUrZ74b8Z7dVhQoVzNKlS83u3btN/fr1Ta1atUyzZs3Mjz/+aLZt22bKli1rXnnlFfuy/u///s+Eh4eb+fPnm19++cXMnz/fFC5c2MyYMSNbv998843Zu3evadeunYmKijLXrl0zV65cMRMmTDDBwcHm2LFj9u2yefNm4+3tbWbPnm0OHTpktm3bZj755JOc32jmj53Gx8fH1K5d26xbt85s2bLF1K1b1zRs2NA+zw8//GCCg4PNjBkzzMGDB83y5ctNdHS0GTZsmDHGmBMnTtgP8MeOHbMHvccee8x8+OGHxpg/Dq6FCxc2vr6+9r/fyy+/bDp37myMMebq1aumYsWKpkePHmbHjh1m9+7dplOnTqZ8+fL2O3r/2W12OzkFoDv1sWHDBuPl5WUSEhLM3r17zSeffGIKFizoEIDuts2uX79uGjRoYD/ATZo0yRQsWNAcPnz4tnW6Yj85d+6cef/9903JkiUd/lY5BaDg4GAzbtw4c+DAAXPgwAHz4YcfmsjISPPDDz+YQ4cOmTVr1pjZs2ff8T1wq9wcW3799VeTP39+87e//c0kJyebhQsXmqJFi9o/dI8ePWry5ctnxo8fb1JSUsyOHTvM5MmT7et7cwA6d+6cadCggenVq5d9P7l+/bpDADLGmHbt2pkXX3zRodbnnnvO3pab9+fNrl+/bo4dO2aCg4PNhAkTzLFjx8ylS5fuum43/ha3Hjdzc7y90/HPGGNGjBhh1q5da1JSUszixYtNaGioSUhIsE+vXLmyefHFF01ycrLZt2+f+eKLL0xSUtJtjzU5SUpKMlOnTjU7d+40+/btM++++67x9/d3eF9HRUWZwoULm8mTJ5v9+/eb0aNHGy8vL/vnw4ULF0yxYsVMp06dzM8//2y+/vprU7p06bsGoJdfftk0bNjQ/PDDD/b3q5+fn33/uHGsi4mJMZs3bzZbt241FStWNJ06dbL3kZCQYAoVKmTmz59vdu/ebXr27GmCgoLuGIC2bNlivLy8zPvvv2/27t1rpk+fbgICAuyB9/Tp06ZXr16mQYMG5tixY+b06dM59vPNN98Yb29vM3ToULN7926TlJRk/x8MY4xp1aqVqVixovnhhx9MUlKSiY2NNWXLlrWH2Lut3/Xr101oaKj5n//5H3uft7YdOHDABAYGmo8//tjs27fPrF271tSsWdN069bN4e9367HBLQHIGGPq169vevToYYy59wAUFRXl8H+V5cuXN48//rj9+fXr101gYKCZM2eOMeY/B6kxY8bY57l27ZopWbKkfYcZMWKEeeqppxyWfeTIESPJ7N271xjzx45cs2bNu65vRESEGTlypENbnTp1zN/+9jf78+rVq9/2/zqMMSY9Pd34+fk57PA3++yzz0yhQoUckuySJUuMl5eXSUtLM8b8uW1185tqzpw5RpJJTEy0t40ePdqUL1/e/rxMmTL2D48bRowYYRo0aHDbfnft2mUkmeTkZGPMfxL/zebPn2+Cg4NNenr6bbfVzaZPn24kmQ0bNtjbkpOTjSSzceNGY4wxzZs3d9gRjfnj7E14eLj9+c0h4oa4uDjTsmVLY4wxEyZMMO3bt3c4a1G2bFnz2Wef2fsrX768ycrKsr/+ypUrJiAgwCxbtswY45ptlpOcAtCd+ujYsaNp0aKFQx/t27d3+FvkZpsdPHjQBAUFmUGDBpmAgAAza9as29ZojGv2E2OyHyOMyTkA3fx/n8YY06dPH/OXv/zF4W90s5zeA7fKzbHl7bffzvZemDx5silQoIDJzMw0W7duNZLMoUOHclzGzcfPnNbNGJMtAC1cuNDhbM+Ns0I33qu5eX/mJCQkxP5BmJt1u1HvrcfNux1v73b8y8mHH35oatWqZX8eFBRk/5+JW+V0rMmtypUrm7///e/251FRUQ5hMysryxQvXtxMmTLFGGPMp59+aooUKWJ+//13+zxTpky5YwA6fPiw8fb2Nr/99ptDe/Pmzc2QIUPs6yDJHDhwwD598uTJJjQ01P48PDzcjB071v78xnvzTgGoU6dO5sknn3RoGzhwoKlUqZL9eb9+/e545scYYxo0aGD/H8Jb7du3z0gya9eutbedOnXKBAQEmC+++CLX69evXz/zl7/8xf781rNCPXv2NL1793ZY9po1a4yXl5f975HTscFtV4ElJCRo5syZSk5Ovuc+KleuLC+v/5QYGhqqqlWr2p97e3urSJEiOnHihMPrGjRoYP93vnz5VLt2bXsdP/30k1auXKkCBQrYHxUqVJD0x/edN9SqVeuOtaWnp+vo0aNq1KiRQ3ujRo2cWufk5GRduXJFzZs3v+306tWrKzAw0GEZWVlZ2rt3r73tXrdVtWrVHF4jyeF1oaGh9tdcvHhRBw8eVM+ePR223wcffOCw7W7tNzw8XJKyLftmTz75pKKiolS6dGm99NJLmjVrli5dunTb+aU//rZ16tSxP69QoYIKFizo8Ld+//33HWrt1auXjh07dse+mzZtqh9//FGZmZlavXq1mjVrpmbNmmnVqlU6evSoDhw4oGbNmtmXceDAAQUFBdmXUbhwYV2+fFkHDx506zbLyZ36SE5OVr169Rzmv3lfye02K126tMaNG6eEhAS1atVKnTp1um09rtpPnFG7dm2H5926dVNSUpLKly+vvn37avny5ffc952OLcnJyWrQoIHDOIlGjRopIyNDv/76q6pXr67mzZuratWqev755zVt2rQ/PVayRYsW8vHx0eLFiyVJ8+fPV3BwsGJiYiTd/f2ZW3dbtxtuPW7e7Xh7t+OfJM2bN0+NGjVSWFiYChQooHfffVepqan26XFxcXr55ZcVExOjMWPGOLVeN2RkZOjNN99UxYoVVbBgQRUoUEDJyckOy5Ec9y+bzaawsDCH/atatWry9/e3z3Pr/nWrnTt3KjMzU48++qjDNlq9erXDeuTPn19lypSxPw8PD7cv9/z58zp27JjDvn3jvXknycnJOe6X+/fvV2Zm5h1fe7OkpKQ7fn7ly5fPobYiRYqofPnyDvv/ndZPkjp37mw//krSrFmz1LJlS/v4tJ9++kkzZsxw2IaxsbHKyspSSkqKvZ9bt0m+XK+lk5o0aaLY2FgNGTJE3bp1c5jm5eUlY4xD27Vr17L14ePj4/DcZrPl2JaVlZXrujIyMvTMM88oISEh27QbHxiSHAKHOwUEBLikn3vdVjfPc+PgdmvbjddkZGRIkqZNm5btg9Tb2/uu/d7p7xQUFKRt27Zp1apVWr58uYYOHaphw4Zp8+bN9zwIMyMjQ8OHD9ezzz6bbdrNB6lbNWnSRBcuXNC2bdv0ww8/aNSoUQoLC9OYMWNUvXp1RUREqFy5cvZl1KpVS7NmzcrWT7Fixdy6zXLyZ/vI7Tb74Ycf5O3trUOHDun69evKl89thxKn3brvPvbYY0pJSdG3336r7777Ti+88IJiYmL01Vdf3de6vL29tWLFCq1bt07Lly/X3//+d73zzjvauHGjSpUqdU99+vr6ql27dpo9e7Y6dOig2bNnq3379va/x93en65267a/2/H2l19+uWN/69evV+fOnTV8+HDFxsYqJCREc+fO1UcffWSfZ9iwYerUqZOWLFmib7/9VvHx8Zo7d67atm2b67rffPNNrVixQuPGjVPZsmUVEBCgdu3aZRvI/Wc/f26VkZEhb29vbd26NdvxoECBAndc7q2foZ7iis+wu61fnTp1VKZMGc2dO1evvvqqFi5c6HB1YkZGhv7f//t/6tu3b7a+H3nkEfu/b31/uvV3gMaMGaOvv/5a69evd2gvVqyY0tLSHFbQlb+TsGHDBvu/r1+/rq1bt6pixYqS/jgY7tq1S9HR0SpbtqzDw5nQExwcrIiICK1du9ahfe3atapUqVKu+ylXrpwCAgJue+lvxYoV9dNPP+nixYsOy/Dy8lL58uVzvRxXCA0NVUREhH755Zds286ZA7ivr2+O/4eRL18+xcTEaOzYsdqxY4cOHTqk77///rb9XL9+XVu2bLE/37t3r86dO+fwt967d2+2WsuWLWs/W+bj45OtloIFC6patWqaNGmSfHx8VKFCBTVp0kTbt2/XN998o6ZNm9rnfeyxx7R//34VL1482zJCQkJcts1coWLFitq4caND2837ipS7bTZv3jwtWLBAq1atUmpq6h0vQ3fVfvJnBQcHq3379po2bZrmzZun+fPn68yZM5Jyfg/czp2OLRUrVtT69esdjmtr165VUFCQSpYsKemPA3ujRo00fPhwbd++Xb6+vlq4cGGOy7rdfnKrzp07a+nSpdq1a5e+//57de7c2T7tbu/P3MrNuuXkbsfbux3/1q1bp6ioKL3zzjuqXbu2ypUrp8OHD2eb79FHH1X//v21fPlyPfvss5o+fbqk3G/DtWvXqlu3bmrbtq2qVq2qsLAwHTp06K6vu1nFihW1Y8cOXb582d526/51q5o1ayozM1MnTpzItn3CwsJytdyQkBCFh4c77Ns33pt3qzen/fLRRx/NFsbupFq1anf8/Lp+/bpDbadPn9bevXud3v87d+6sWbNm6euvv5aXl5datmxpn/bYY49p9+7dOR63fH19b9unWwNQ1apV1blzZ02cONGhvVmzZjp58qTGjh2rgwcPavLkyfr2229dttzJkydr4cKF2rNnj1577TWdPXtWPXr0kCS99tprOnPmjDp27KjNmzfr4MGDWrZsmbp37+7UaT9JGjhwoBISEjRv3jzt3btXgwcPVlJSkvr165frPvz9/TVo0CC99dZb+vzzz3Xw4EFt2LBB//jHPyT98Uf39/dX165d9fPPP2vlypXq06ePXnrpJftXVvfT8OHDNXr0aE2cOFH79u3Tzp07NX36dI0fPz7XfURHRysjI0OJiYk6deqULl26pG+++UYTJ05UUlKSDh8+rM8//1xZWVl3DHk+Pj7q06ePNm7cqK1bt6pbt26qX7++6tatK0kaOnSoPv/8cw0fPly7du1ScnKy5s6dq3fffdehlsTERKWlpTl8HdGsWTPNmjXLHnYKFy6sihUrat68eQ4BqHPnzipatKhat26tNWvWKCUlRatWrVLfvn3tXw24Ypu5Qt++fbV06VKNGzdO+/fv16RJk7R06VKHee62zX799Ve9+uqrSkhIUOPGjTV9+nSNGjXqjgd6V+wnf8b48eM1Z84c7dmzR/v27dOXX36psLAw+5nF270HcnKnY8vf/vY3HTlyRH369NGePXv0r3/9S/Hx8YqLi5OXl5c2btyoUaNGacuWLUpNTdWCBQt08uRJe4C6VXR0tDZu3KhDhw7p1KlTtz3T0KRJE4WFhalz584qVaqUw5nG3Lw/c+Nu63Y7dzve3u34V65cOaWmpmru3Lk6ePCgJk6c6BAYf//9d73++utatWqVDh8+rLVr12rz5s32bZrTsSYn5cqV04IFC5SUlKSffvpJnTp1cvrMTqdOnWSz2dSrVy/t3r1b//73vzVu3Lg7vubRRx9V586d1aVLFy1YsEApKSnatGmTRo8erSVLluR62f369dOYMWO0aNEi7dmzR3/729/u+qOFAwYMUGJiokaMGKF9+/Zp5syZmjRpkt58881cL1f64ze85syZo/j4eCUnJ2vnzp32M37lypVT69at1atXL/3444/66aef9OKLL6pEiRJq3bq1U8vp3Lmztm3bppEjR6pdu3YOPwEyaNAgrVu3Tq+//rqSkpK0f/9+/etf/9Lrr79+507vOLrJSbcO4jPmj8GDvr6+5tZFTZkyxURGRprAwEDTpUsXM3LkyBwvg79ZToMCo6KizMcff2xfliQze/ZsU7duXePr62sqVapkvv/+e4fX7Nu3z7Rt29Z+WV6FChXMG2+8YR/gl9NycpKZmWmGDRtmSpQoYXx8fLJd3mtM7gZ3ZmZmmg8++MBERUUZHx8fh8t0jcn9ZfD3sq1uHpx36wBLY3IeRDhr1ixTo0YN4+vrawoVKmSaNGliFixYcNt+z549ayQ5XNr5yiuvmCJFitgvTV2zZo1p2rSpKVSokP0S7nnz5t12m92oa/78+aZ06dLGz8/PxMTEZLsaaenSpaZhw4YmICDABAcHm7p169oHMBvzx+WbZcuWNfny5XN4/90YuH9jgKMxfwzEk5TtqsBjx46ZLl26mKJFixo/Pz9TunRp06tXL3P+/HmXbrNbKYdB0Hfr4x//+IcpWbKkCQgIMM8880yOl8HfbptlZWWZ5s2bm9jYWIfBsH369DFlypS57RU2rtpPcjsI+sZ7/IbPPvvM1KhRwwQGBprg4GDTvHlzs23bNvv0270HbpbbY8udLhXfvXu3iY2NNcWKFTN+fn7m0UcfdRhke+t+vHfvXlO/fn0TEBCQ42XwN3vrrbeMJDN06NBstefm/XmrWwdB323djLn9cfNux9u7Hf8GDhxoihQpYgoUKGDat29vPv74Y/t79sqVK6ZDhw4mMjLS+Pr6moiICPP66687DES+9ViTk5SUFPPEE0+YgIAAExkZaSZNmpSr99at79v169eb6tWrG19fX1OjRg0zf/78u14FdvXqVTN06FATHR1tfHx8THh4uGnbtq3ZsWOHMSbnY/CtFxZdu3bN9OvXzwQHB5uCBQuauLg4py6Dv7Hdb1z9ekNuBkEb88dFLDeOb0WLFjXPPvusfdqNy+BDQkJMQECAiY2NzfEy+Dut3w1169Y1krLtd8YYs2nTJvPkk0+aAgUKmMDAQFOtWjWHiy9y+vvZjMkjXyQCQB516NAhlSpVStu3b+eWNsBD4qG6FxgAAEBuEIAAAIDl8BUYAACwHM4AAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAyyEAAQAAy/n/ALMAzQmeGBsZAAAAAElFTkSuQmCC", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.6663993584603047, Median = 2.0\n", + "Accuracy 0.702689\n", + "Precision 0.72924\n", + "Recall 0.644778\n", + "FPR 0.2394\n", + "F1 0.684413\n", + "Mean H 2.666399\n", + "Correct Adjustment 0.063082\n", + "Incorrect Adjustment 0.066443\n", + "Recovery -0.003361\n", + "Leaderboard String | MODEL_NAME | 70.3 | 72.9 | 64.5 | 68....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "[info] summarize only: RandomDeferralDecisionPolicy seed 3\n" + ] }, { - "cell_type": "code", - "execution_count": 5, - "id": "5b0f0e44", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "gemma horizon (TPs only, mean - 1):\n", - " mean over seeds: h=nan\n", - " pooled: n=0, h=nan\n", - "human horizon (round 1, TPs only, mean - 1):\n", - " player vn72: n=1, h=6.0000\n", - " player nac86: n=2, h=0.5000\n", - " player sj597: n=4, h=2.2500\n", - " player ex36: n=1, h=2.0000\n", - " player kz88: n=2, h=2.5000\n", - " player LJL2: n=4, h=1.5000\n", - " player lyk25: n=4, h=2.5000\n", - " player cd326: n=2, h=1.5000\n", - " player tg352: n=2, h=5.0000\n", - " mean over players: h=2.6389\n", - " pooled: n=22, h=2.3636\n", - "human horizon (round 2, TPs only, mean - 1):\n", - " player sj597: n=4, h=1.2500\n", - " player nac86: n=2, h=4.0000\n", - " player ex36: n=2, h=0.5000\n", - " player vn72: n=3, h=1.6667\n", - " player lyk25: n=4, h=3.0000\n", - " player kz88: n=1, h=3.0000\n", - " player cd326: n=4, h=3.2500\n", - " player tg352: n=3, h=2.0000\n", - " player LJL2: n=2, h=0.5000\n", - " mean over players: h=2.1296\n", - " pooled: n=25, h=2.1600\n", - "\n", - "summary (comparable to h in performance_utils_wiki):\n", - " gemma h (mean over seeds): nan\n", - " round1 h (mean over players): 2.6389\n", - " round2 h (mean over players): 2.1296\n" - ] - } - ], - "source": [ - "# horizon comparison between gemma and humans, using the same convention as\n", - "# performance_utils_wiki.calculate_current_performance:\n", - "# - only count true positives (ground truth awry AND trigger fired)\n", - "# - horizon = (len(utts) - first_trigger_index) - 1\n", - "# - first trigger only (break after first positive)\n", - "#\n", - "# reports per-round results for humans (round 1 and round 2), pulling data\n", - "# directly from the game sqlite so it works regardless of which round_n the\n", - "# rest of the notebook was run under. ljl2 is excluded.\n", - "\n", - "import sqlite3\n", - "import json as _json\n", - "from collections import defaultdict\n", - "import numpy as np\n", - "\n", - "def _horizon_mean(horizons):\n", - " # matches performance_utils_wiki: h = mean(horizons) - 1\n", - " if len(horizons) == 0:\n", - " return float('nan'), 0\n", - " return float(np.mean(horizons)) - 1, len(horizons)\n", - "\n", - "# always excluded (staff/test accounts). ljl2 is a legitimate late submitter\n", - "# in the round 2_b window, not an exclusion.\n", - "base_excluded = {'yc2727', 'sqt2'}\n", - "round1_excluded = set(base_excluded)\n", - "round2_excluded = set(base_excluded)\n", - "\n", - "# gemma: per-seed first-trigger horizons on TP convos only (ground truth awry)\n", - "gemma_horizons_by_seed = defaultdict(list)\n", - "for convo in corpus.iter_conversations():\n", - " if not convo.meta.get('has_removed_comment', False):\n", - " continue # skip non-awry convos; horizon is only meaningful on TPs\n", - " utts = convo.get_chronological_utterance_list()\n", - " for seed_num in range(1, 6):\n", - " for i, utt in enumerate(utts):\n", - " if utt.meta.get('model_forecasts', {}).get(f'seed_{seed_num}') == 1:\n", - " gemma_horizons_by_seed[seed_num].append(len(utts) - i)\n", - " break\n", - "\n", - "print('gemma horizon (TPs only, mean - 1):')\n", - "gemma_per_seed_h = []\n", - "for seed_num in sorted(gemma_horizons_by_seed.keys()):\n", - " h, n = _horizon_mean(gemma_horizons_by_seed[seed_num])\n", - " gemma_per_seed_h.append(h)\n", - " print(f' seed {seed_num}: n={n}, h={h:.4f}')\n", - "gemma_h_mean_of_seeds = float(np.mean(gemma_per_seed_h)) if gemma_per_seed_h else float('nan')\n", - "all_gemma_vals = [v for vs in gemma_horizons_by_seed.values() for v in vs]\n", - "gemma_h_pooled, gemma_n_pooled = _horizon_mean(all_gemma_vals)\n", - "print(f' mean over seeds: h={gemma_h_mean_of_seeds:.4f}')\n", - "print(f' pooled: n={gemma_n_pooled}, h={gemma_h_pooled:.4f}')\n", - "\n", - "# pull round-specific human guesses directly from the sqlite db\n", - "db_path = '/reef/sqt2/cga-eval/human/game_db.sqlite'\n", - "_conn = sqlite3.connect(db_path)\n", - "\n", - "def _load_round_answers(round_n):\n", - " # returns list of (participant_id, sessions) for the given round\n", - " entries = []\n", - " if round_n == 1:\n", - " excluded = round1_excluded\n", - " t_start, t_end = 1730395000000, 1730397199000\n", - " for row in _conn.execute('SELECT * FROM results'):\n", - " if row[0] in excluded:\n", - " continue\n", - " answers = _json.loads(row[1])\n", - " if answers and answers[0]['start_time'] > t_start and answers[0]['start_time'] < t_end:\n", - " entries.append((row[0], answers))\n", - " elif round_n == 2:\n", - " excluded = round2_excluded\n", - " t_start_a, t_end_a = 1731002910000, 1731016180000\n", - " t_start_b, t_end_b = 1732212720000, 1740000000000\n", - " for row in _conn.execute('SELECT * FROM results'):\n", - " name = row[0]\n", - " if name in excluded:\n", - " continue\n", - " answers = _json.loads(row[1])\n", - " if not answers:\n", - " continue\n", - " st = answers[0]['start_time']\n", - " in_a = t_start_a < st < t_end_a\n", - " # the 2_b late window is only valid for ljl2 (matches cell 7)\n", - " in_b = (name.lower() == 'ljl2') and (t_start_b < st < t_end_b)\n", - " if in_a or in_b:\n", - " entries.append((name, answers))\n", - " return entries\n", - "\n", - "def _unique_convo_ids(entries):\n", - " # unique convo ids seen across all included players' sessions\n", - " ids = set()\n", - " for _, sessions in entries:\n", - " for session in sessions:\n", - " cid = session.get('id')\n", - " if cid is not None:\n", - " ids.add(cid)\n", - " return ids\n", - "\n", - "def _compute_human_horizons(entries):\n", - " # returns dict: player_id -> list of horizons (non-awry convos only, first guess per convo)\n", - " by_player = defaultdict(list)\n", - " for participant_id, sessions in entries:\n", - " for session in sessions:\n", - " convo_id = session.get('id')\n", - " if convo_id is None:\n", - " continue\n", - " try:\n", - " convo = corpus.get_conversation(convo_id)\n", - " except KeyError:\n", - " # convo not in the loaded corpus (e.g., different round loaded)\n", - " continue\n", - " if not convo.meta.get('has_removed_comment', False):\n", - " continue # skip non-awry convos; horizon only counted on TPs\n", - " utts = convo.get_chronological_utterance_list()\n", - " for action_idx, action in enumerate(session.get('actions', [])):\n", - " if action.get('guess') is True:\n", - " if action_idx < len(utts):\n", - " by_player[participant_id].append(len(utts) - action_idx)\n", - " break # only first guess per (player, convo)\n", - " return by_player\n", - "\n", - "def _print_human_horizons(label, by_player):\n", - " print(f'human horizon ({label}, TPs only, mean - 1):')\n", - " player_h = []\n", - " for player, horizons in by_player.items():\n", - " h, n = _horizon_mean(horizons)\n", - " player_h.append(h)\n", - " print(f' player {player}: n={n}, h={h:.4f}')\n", - " mean_of_players = float(np.mean(player_h)) if player_h else float('nan')\n", - " all_vals = [v for vs in by_player.values() for v in vs]\n", - " h_pooled, n_pooled = _horizon_mean(all_vals)\n", - " print(f' mean over players: h={mean_of_players:.4f}')\n", - " print(f' pooled: n={n_pooled}, h={h_pooled:.4f}')\n", - " return mean_of_players, h_pooled\n", - "\n", - "EXPECTED_N_CONVOS = 84\n", - "round1_entries = _load_round_answers(1)\n", - "round1_convo_ids = _unique_convo_ids(round1_entries)\n", - "round1_by_player = _compute_human_horizons(round1_entries)\n", - "r1_mean, r1_pooled = _print_human_horizons('round 1', round1_by_player)\n", - "\n", - "round2_entries = _load_round_answers(2)\n", - "round2_convo_ids = _unique_convo_ids(round2_entries)\n", - "round2_by_player = _compute_human_horizons(round2_entries)\n", - "r2_mean, r2_pooled = _print_human_horizons('round 2', round2_by_player)\n", - "\n", - "_conn.close()\n", - "\n", - "print()\n", - "print('summary (comparable to h in performance_utils_wiki):')\n", - "print(f' gemma h (mean over seeds): {gemma_h_mean_of_seeds:.4f}')\n", - "print(f' round1 h (mean over players): {r1_mean:.4f}')\n", - "print(f' round2 h (mean over players): {r2_mean:.4f}')\n" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.716323296354992, Median = 2.0\n", + "Accuracy 0.695191\n", + "Precision 0.713397\n", + "Recall 0.652534\n", + "FPR 0.262151\n", + "F1 0.68161\n", + "Mean H 2.716323\n", + "Correct Adjustment 0.074199\n", + "Incorrect Adjustment 0.102637\n", + "Recovery -0.028438\n", + "Leaderboard String | MODEL_NAME | 69.5 | 71.3 | 65.3 | 68....\n", + "dtype: object\n", + "---\n", + "fitting policy SimulationAverageDecisionPolicy for seed 3\n", + "starting transformation.\n" + ] }, { - "cell_type": "code", - "execution_count": 6, - "id": "44ed25ac", - "metadata": {}, - "outputs": [], - "source": [ - "from collections import defaultdict\n", - "import numpy as np\n", - "def _compute_metrics(tp, fp, tn, fn):\n", - " total = tp + fp + tn + fn\n", - " accuracy = (tp + tn) / total if total > 0 else 0.0\n", - " precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0\n", - " recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0\n", - " f1 = (2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0.0\n", - " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0.0\n", - " specificity = tn / (tn + fp) if (tn + fp) > 0 else 0.0\n", - " fnr = fn / (fn + tp) if (fn + tp) > 0 else 0.0\n", - " return {\n", - " 'tp': tp, 'fp': fp, 'tn': tn, 'fn': fn,\n", - " 'accuracy': accuracy, 'precision': precision, 'recall': recall,\n", - " 'f1': f1, 'fpr': fpr, 'specificity': specificity, 'fnr': fnr,\n", - " }\n", - "def _gt(convo):\n", - " return bool(convo.meta.get('has_removed_comment', False))\n", - "# gemma benchmark, per seed, then mean and std\n", - "gemma_per_seed = []\n", - "for seed_num in range(1, 6):\n", - " tp = fp = tn = fn = 0\n", - " for convo in corpus.iter_conversations():\n", - " utts = convo.get_chronological_utterance_list()\n", - " pred = any(\n", - " utt.meta.get('model_forecasts', {}).get(f'seed_{seed_num}') == 1\n", - " for utt in utts\n", - " )\n", - " truth = _gt(convo)\n", - " if pred and truth: tp += 1\n", - " elif pred and not truth: fp += 1\n", - " elif not pred and not truth: tn += 1\n", - " elif not pred and truth: fn += 1\n", - " gemma_per_seed.append(_compute_metrics(tp, fp, tn, fn))\n", - "gemma_mean = {k: float(np.mean([m[k] for m in gemma_per_seed])) for k in gemma_per_seed[0]}\n", - "gemma_std = {k: float(np.std([m[k] for m in gemma_per_seed], ddof=1)) for k in gemma_per_seed[0]}\n", - "def _build_per_player_preds(entries):\n", - " # returns dict[player_id] -> dict[convo_id] -> 0/1\n", - " preds = defaultdict(dict)\n", - " for player, sessions in entries:\n", - " for s in sessions:\n", - " cid = s.get('id')\n", - " if cid is None:\n", - " continue\n", - " try:\n", - " corpus.get_conversation(cid)\n", - " except KeyError:\n", - " continue\n", - " actions = s.get('actions', [])\n", - " preds[player][cid] = 1 if any(a.get('guess') is True for a in actions) else 0\n", - " return preds\n", - "def _aggregate_any(preds):\n", - " # per-convo prediction = 1 if any player who saw it guessed\n", - " by_convo = defaultdict(list)\n", - " for player, convo_preds in preds.items():\n", - " for cid, p in convo_preds.items():\n", - " by_convo[cid].append(p)\n", - " tp = fp = tn = fn = 0\n", - " for cid, plist in by_convo.items():\n", - " try:\n", - " convo = corpus.get_conversation(cid)\n", - " except KeyError:\n", - " continue\n", - " pred = 1 if any(plist) else 0\n", - " truth = 1 if _gt(convo) else 0\n", - " if pred and truth: tp += 1\n", - " elif pred and not truth: fp += 1\n", - " elif not pred and not truth: tn += 1\n", - " elif not pred and truth: fn += 1\n", - " return _compute_metrics(tp, fp, tn, fn), len(by_convo)\n", - "def _per_player_metrics(preds):\n", - " rows = {}\n", - " for player, convo_preds in preds.items():\n", - " tp = fp = tn = fn = 0\n", - " for cid, p in convo_preds.items():\n", - " try:\n", - " convo = corpus.get_conversation(cid)\n", - " except KeyError:\n", - " continue\n", - " truth = 1 if _gt(convo) else 0\n", - " if p and truth: tp += 1\n", - " elif p and not truth: fp += 1\n", - " elif not p and not truth: tn += 1\n", - " elif not p and truth: fn += 1\n", - " rows[player] = _compute_metrics(tp, fp, tn, fn)\n", - " return rows\n", - "# round 1 and round 2 humans\n", - "round1_preds = _build_per_player_preds(round1_entries)\n", - "round1_agg, round1_n_convos = _aggregate_any(round1_preds)\n", - "round1_per_player = _per_player_metrics(round1_preds)\n", - "round2_preds = _build_per_player_preds(round2_entries)\n", - "round2_agg, round2_n_convos = _aggregate_any(round2_preds)\n", - "round2_per_player = _per_player_metrics(round2_preds)\n", - "# metric mean over players (a different aggregation view)\n", - "def _mean_over_players(per_player):\n", - " keys = ['accuracy', 'precision', 'recall', 'f1', 'fpr', 'specificity', 'fnr']\n", - " return {k: float(np.mean([m[k] for m in per_player.values()])) for k in keys}\n", - "round1_mean_over_players = _mean_over_players(round1_per_player)\n", - "round2_mean_over_players = _mean_over_players(round2_per_player)\n", - "# printing\n", - "metric_order = ['accuracy', 'precision', 'recall', 'f1', 'fpr', 'specificity', 'fnr']\n", - "def _print_per_player(label, per_player):\n", - " print(f'{label} - per-player metrics:')\n", - " header = f\" {'player':<10}\" + \"\".join(f\"{m:>12}\" for m in metric_order) + f\"{'n_convos':>10}\"\n", - " print(header)\n", - " print(' ' + '-' * (len(header) - 2))\n", - " for player in sorted(per_player):\n", - " m = per_player[player]\n", - " n = m['tp'] + m['fp'] + m['tn'] + m['fn']\n", - " row = f\" {player:<10}\" + \"\".join(f\"{m[k]:>12.4f}\" for k in metric_order) + f\"{n:>10d}\"\n", - " print(row)\n" + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4320.97it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7006, p=0.6932, r=0.7198, fpr=0.3185, f1=0.7062\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.9597701149425286, Median = 2.0\n", + "Accuracy 0.70062\n", + "Precision 0.693227\n", + "Recall 0.719752\n", + "FPR 0.318511\n", + "F1 0.70624\n", + "Mean H 2.95977\n", + "Correct Adjustment 0.08454\n", + "Incorrect Adjustment 0.103154\n", + "Recovery -0.018614\n", + "Leaderboard String | MODEL_NAME | 70.1 | 69.3 | 72.0 | 70....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "fitting policy SimulationMajorityDecisionPolicy for seed 3\n", + "starting transformation.\n" + ] }, { - "cell_type": "code", - "execution_count": 29, - "id": "68c5005a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "round 1 - per-player metrics:\n", - " player accuracy precision recall f1 fpr specificity fnr n_convos\n", - " --------------------------------------------------------------------------------------------------------\n", - " LJL2 0.8000 0.8000 0.8000 0.8000 0.2000 0.8000 0.2000 10\n", - " cd326 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", - " ex36 0.4000 0.3333 0.2000 0.2500 0.4000 0.6000 0.8000 10\n", - " kz88 0.7000 1.0000 0.4000 0.5714 0.0000 1.0000 0.6000 10\n", - " lyk25 0.7000 0.6667 0.8000 0.7273 0.4000 0.6000 0.2000 10\n", - " nac86 0.7000 1.0000 0.4000 0.5714 0.0000 1.0000 0.6000 10\n", - " sj597 0.8000 0.8000 0.8000 0.8000 0.2000 0.8000 0.2000 10\n", - " tg352 0.5000 0.5000 0.4000 0.4444 0.4000 0.6000 0.6000 10\n", - " vn72 0.4000 0.3333 0.2000 0.2500 0.4000 0.6000 0.8000 10\n", - "\n", - "round 2 - per-player metrics:\n", - " player accuracy precision recall f1 fpr specificity fnr n_convos\n", - " --------------------------------------------------------------------------------------------------------\n", - " LJL2 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", - " cd326 0.9000 1.0000 0.8000 0.8889 0.0000 1.0000 0.2000 10\n", - " ex36 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", - " kz88 0.4000 0.3333 0.2000 0.2500 0.4000 0.6000 0.8000 10\n", - " lyk25 0.9000 1.0000 0.8000 0.8889 0.0000 1.0000 0.2000 10\n", - " nac86 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", - " sj597 0.9000 1.0000 0.8000 0.8889 0.0000 1.0000 0.2000 10\n", - " tg352 0.7000 0.7500 0.6000 0.6667 0.2000 0.8000 0.4000 10\n", - " vn72 0.7000 0.7500 0.6000 0.6667 0.2000 0.8000 0.4000 10\n", - "\n", - "aggregate benchmark (gemma: mean±std over 5 seeds; humans: any-player rule + mean over players)\n", - "group accuracy precision recall f1 fpr specificity fnr\n", - "--------------------------------------------------------------------------------------------------------------------------------------\n", - "gemma (mean±std over seeds) 0.700±0.018 0.679±0.026 0.762±0.029 0.718±0.012 0.362±0.052 0.638±0.052 0.238±0.029\n", - "round1 humans (mean over players) 0.6222 0.6778 0.4889 0.5461 0.2444 0.7556 0.5111\n", - "round2 humans (mean over players) 0.7000 0.7593 0.5556 0.6389 0.1556 0.8444 0.4444\n", - "\n", - "round 1 unique convos: 84\n", - "round 2 unique convos: 84\n" - ] - } - ], - "source": [ - "pm = '\\u00b1'\n", - "metric_order = ['accuracy', 'precision', 'recall', 'f1', 'fpr', 'specificity', 'fnr']\n", - "\n", - "def _print_per_player(label, per_player):\n", - " print(f'{label} - per-player metrics:')\n", - " header = f\" {'player':<10}\" + \"\".join(f\"{m:>12}\" for m in metric_order) + f\"{'n_convos':>10}\"\n", - " print(header)\n", - " print(' ' + '-' * (len(header) - 2))\n", - " for player in sorted(per_player):\n", - " m = per_player[player]\n", - " n = m['tp'] + m['fp'] + m['tn'] + m['fn']\n", - " row = f\" {player:<10}\" + \"\".join(f\"{m[k]:>12.4f}\" for k in metric_order) + f\"{n:>10d}\"\n", - " print(row)\n", - "\n", - "_print_per_player('round 1', round1_per_player)\n", - "print()\n", - "_print_per_player('round 2', round2_per_player)\n", - "\n", - "print()\n", - "print(f'aggregate benchmark (gemma: mean{pm}std over 5 seeds; humans: any-player rule + mean over players)')\n", - "\n", - "header = f\"{'group':<36}\" + \"\".join(f\"{m:>14}\" for m in metric_order)\n", - "print(header)\n", - "print('-' * len(header))\n", - "\n", - "def _fmt_mean_std(mean_dict, std_dict):\n", - " return \"\".join(f\" {mean_dict[k]:.3f}{pm}{std_dict[k]:.3f}\" for k in metric_order)\n", - "\n", - "def _fmt_mean(mean_dict):\n", - " return \"\".join(f\"{mean_dict[k]:>14.4f}\" for k in metric_order)\n", - "\n", - "gemma_label = f'gemma (mean{pm}std over seeds)'\n", - "print(f\"{gemma_label:<36}\" + _fmt_mean_std(gemma_mean, gemma_std))\n", - "print(f\"{'round1 humans (mean over players)':<36}\" + _fmt_mean(round1_mean_over_players))\n", - "print(f\"{'round2 humans (mean over players)':<36}\" + _fmt_mean(round2_mean_over_players))\n", - "\n", - "print()\n", - "print(f'round 1 unique convos: {round1_n_convos}')\n", - "print(f'round 2 unique convos: {round2_n_convos}')" + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4280.84it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.6988, p=0.6891, r=0.7244, fpr=0.3268, f1=0.7063\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.9864382583868667, Median = 2.0\n", + "Accuracy 0.698811\n", + "Precision 0.689129\n", + "Recall 0.724405\n", + "FPR 0.326784\n", + "F1 0.706327\n", + "Mean H 2.986438\n", + "Correct Adjustment 0.087642\n", + "Incorrect Adjustment 0.108066\n", + "Recovery -0.020424\n", + "Leaderboard String | MODEL_NAME | 69.9 | 68.9 | 72.4 | 70....\n", + "dtype: object\n", + "summarization complete.\n", + "Unsloth: If you want to finetune Gemma 2, install flash-attn to make it faster!\n", + "To install flash-attn, do the below:\n", + "\n", + "pip install --no-deps --upgrade \"flash-attn>=2.6.3\"\n", + "==((====))== Unsloth 2025.7.11: Fast Gemma2 patching. Transformers: 4.53.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", + "---\n", + "fitting policy ThresholdDecisionPolicy for seed 4\n", + "starting transformation.\n" + ] }, { - "cell_type": "markdown", - "id": "9c68d1bd", - "metadata": {}, - "source": [ - "## Validation of forecast probability decrease" + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:00, 46478.45it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7045, p=0.6930, r=0.7342, fpr=0.3252, f1=0.7130\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAGwCAYAAABSN5pGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAWG5JREFUeJzt3XlcVPX+P/DXsMyALIOAbIrgQuKCoqKIdtWSwvSmKBYqCS7preuOmdI1cSkBt8grV65+S+t3Jc1cMi0MKZcUUUFyA1RScWFxCRBItvn8/vDhyRnWUWCQXs/HYx4xn/OZz3mf48yZV2fOIhNCCBARERGRRE/XBRARERE1NQxIRERERBoYkIiIiIg0MCARERERaWBAIiIiItLAgERERESkgQGJiIiISIOBrgt4XqlUKty+fRtmZmaQyWS6LoeIiIjqQAiBBw8ewMHBAXp61e8nYkB6Srdv34ajo6OuyyAiIqKncOPGDbRp06ba6QxIT8nMzAzAoxVsbm6u42qIiIioLgoKCuDo6Ch9j1eHAekpPf5ZzdzcnAGJiIjoOVPb4TE8SJuIiIhIAwMSERERkQYGJCIiIiINDEhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIAwMSERERkQYGJCIiIiINDEhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0mCg6wKoMueF+3VdguRa+HBdl0BERNTomsQepKioKDg7O8PIyAienp44efJktX03bdqEv/3tb2jZsiVatmwJb2/vSv2FEFi8eDHs7e1hbGwMb29vXL58Wa3P/fv3ERAQAHNzc1hYWGDKlCkoLCxskOUjIiKi54vO9yBt374dwcHBiI6OhqenJyIjI+Hj44P09HTY2NhU6n/o0CGMGzcO/fv3h5GRESIiIvDqq6/iwoULaN26NQBg5cqVWLduHb744gu0a9cOH374IXx8fHDx4kUYGRkBAAICApCVlYW4uDiUlZVh0qRJmDZtGmJiYhp1+Zs67s0iIqK/IpkQQuiyAE9PT/Tp0wfr168HAKhUKjg6OmLmzJlYuHBhra+vqKhAy5YtsX79egQGBkIIAQcHB8ybNw/vvfceACA/Px+2trbYsmULxo4di9TUVHTp0gWnTp2Ch4cHACA2NhbDhg3DzZs34eDgUOt8CwoKoFQqkZ+fD3Nz82dYA5U1pVDSlDAgERHRs6rr97dOf2IrLS1FUlISvL29pTY9PT14e3sjISGhTmMUFxejrKwMlpaWAICrV68iOztbbUylUglPT09pzISEBFhYWEjhCAC8vb2hp6eHxMTEKudTUlKCgoICtQcRERE1TzoNSHfv3kVFRQVsbW3V2m1tbZGdnV2nMRYsWAAHBwcpED1+XU1jZmdnV/r5zsDAAJaWltXONywsDEqlUno4OjrWqT4iIiJ6/jSJg7SfVnh4OLZt24bdu3dLxxY1lJCQEOTn50uPGzduNOj8iIiISHd0epC2tbU19PX1kZOTo9aek5MDOzu7Gl+7evVqhIeH4+DBg+jevbvU/vh1OTk5sLe3VxvT3d1d6pObm6s2Xnl5Oe7fv1/tfBUKBRQKRZ2XjYiIiJ5fOt2DJJfL0bt3b8THx0ttKpUK8fHx8PLyqvZ1K1euxPLlyxEbG6t2HBEAtGvXDnZ2dmpjFhQUIDExURrTy8sLeXl5SEpKkvr89NNPUKlU8PT0rK/FIyIioueUzk/zDw4ORlBQEDw8PNC3b19ERkaiqKgIkyZNAgAEBgaidevWCAsLAwBERERg8eLFiImJgbOzs3TMkKmpKUxNTSGTyTBnzhx89NFHcHFxkU7zd3BwgK+vLwCgc+fOGDp0KKZOnYro6GiUlZVhxowZGDt2bJ3OYCMiIqLmTecByd/fH3fu3MHixYuRnZ0Nd3d3xMbGSgdZZ2ZmQk/vzx1dGzZsQGlpKcaMGaM2TmhoKJYsWQIAeP/991FUVIRp06YhLy8PL774ImJjY9WOU9q6dStmzJiBIUOGQE9PD35+fli3bl3DLzARERE1eTq/DtLzitdBany8DhIRET2r5+I6SERERERNEQMSERERkQYGJCIiIiINDEhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIAwMSERERkQYGJCIiIiINDEhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIAwMSERERkQYGJCIiIiINDEhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIAwMSERERkQYGJCIiIiINDEhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIg84DUlRUFJydnWFkZARPT0+cPHmy2r4XLlyAn58fnJ2dIZPJEBkZWanP42maj+nTp0t9Bg8eXGn6O++80xCLR0RERM8hnQak7du3Izg4GKGhoUhOTkaPHj3g4+OD3NzcKvsXFxejffv2CA8Ph52dXZV9Tp06haysLOkRFxcHAHjjjTfU+k2dOlWt38qVK+t34YiIiOi5ZaDLma9duxZTp07FpEmTAADR0dHYv38/Pv/8cyxcuLBS/z59+qBPnz4AUOV0AGjVqpXa8/DwcHTo0AGDBg1Sa2/RokW1IasqJSUlKCkpkZ4XFBTU+bVERET0fNHZHqTS0lIkJSXB29v7z2L09ODt7Y2EhIR6m8f//vc/TJ48GTKZTG3a1q1bYW1tjW7duiEkJATFxcU1jhUWFgalUik9HB0d66VGIiIianp0tgfp7t27qKiogK2trVq7ra0t0tLS6mUee/bsQV5eHiZOnKjWPn78eDg5OcHBwQFnz57FggULkJ6ejl27dlU7VkhICIKDg6XnBQUFDElERETNlE5/Ymton332GV577TU4ODiotU+bNk36283NDfb29hgyZAgyMjLQoUOHKsdSKBRQKBQNWi8RERE1DTr7ic3a2hr6+vrIyclRa8/JydHq2KDqXL9+HQcPHsTbb79da19PT08AwJUrV555vkRERPT801lAksvl6N27N+Lj46U2lUqF+Ph4eHl5PfP4mzdvho2NDYYPH15r35SUFACAvb39M8+XiIiInn86/YktODgYQUFB8PDwQN++fREZGYmioiLprLbAwEC0bt0aYWFhAB4ddH3x4kXp71u3biElJQWmpqbo2LGjNK5KpcLmzZsRFBQEAwP1RczIyEBMTAyGDRsGKysrnD17FnPnzsXAgQPRvXv3RlpyIiIiasp0GpD8/f1x584dLF68GNnZ2XB3d0dsbKx04HZmZib09P7cyXX79m307NlTer569WqsXr0agwYNwqFDh6T2gwcPIjMzE5MnT640T7lcjoMHD0phzNHREX5+fli0aFHDLSgRERE9V2RCCKHrIp5HBQUFUCqVyM/Ph7m5eb2O7bxwf72O11xcC6/951IiIqKa1PX7W+e3GiEiIiJqahiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIAwMSERERkQYGJCIiIiINDEhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIAwMSERERkQYGJCIiIiINDEhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIAwMSERERkQYGJCIiIiINDEhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIAwMSERERkQatA9IXX3yB/fv3S8/ff/99WFhYoH///rh+/Xq9FkdERESkC1oHpBUrVsDY2BgAkJCQgKioKKxcuRLW1taYO3eu1gVERUXB2dkZRkZG8PT0xMmTJ6vte+HCBfj5+cHZ2RkymQyRkZGV+ixZsgQymUzt4erqqtbn4cOHmD59OqysrGBqago/Pz/k5ORoXTsRERE1T1oHpBs3bqBjx44AgD179sDPzw/Tpk1DWFgYjh49qtVY27dvR3BwMEJDQ5GcnIwePXrAx8cHubm5VfYvLi5G+/btER4eDjs7u2rH7dq1K7KysqTHL7/8ojZ97ty5+O6777Bjxw4cPnwYt2/fxujRo7WqnYiIiJovrQOSqakp7t27BwD48ccf8corrwAAjIyM8Mcff2g11tq1azF16lRMmjQJXbp0QXR0NFq0aIHPP/+8yv59+vTBqlWrMHbsWCgUimrHNTAwgJ2dnfSwtraWpuXn5+Ozzz7D2rVr8fLLL6N3797YvHkzjh8/jhMnTmhVPxERETVPWgekV155BW+//TbefvttXLp0CcOGDQPw6OcvZ2fnOo9TWlqKpKQkeHt7/1mMnh68vb2RkJCgbVlqLl++DAcHB7Rv3x4BAQHIzMyUpiUlJaGsrExtvq6urmjbtm2N8y0pKUFBQYHag4iIiJonrQNSVFQUvLy8cOfOHezcuRNWVlYAHgWPcePG1Xmcu3fvoqKiAra2tmrttra2yM7O1rYsiaenJ7Zs2YLY2Fhs2LABV69exd/+9jc8ePAAAJCdnQ25XA4LCwut5hsWFgalUik9HB0dn7pGIiIiatoMtH2BhYUF1q9fX6l96dKl9VLQs3rttdekv7t37w5PT084OTnh66+/xpQpU5563JCQEAQHB0vPCwoKGJIamfPC/bV3agTXwofrugQiImpgWgckAMjLy8PJkyeRm5sLlUoltctkMkyYMKFOY1hbW0NfX7/S2WM5OTk1HoCtLQsLC7zwwgu4cuUKAMDOzg6lpaXIy8tT24tU23wVCkWNxz0RERFR86F1QPruu+8QEBCAwsJCmJubQyaTSdO0CUhyuRy9e/dGfHw8fH19AQAqlQrx8fGYMWOGtmVVq7CwEBkZGVJdvXv3hqGhIeLj4+Hn5wcASE9PR2ZmJry8vOptvkRERPT80jogzZs3D5MnT8aKFSvQokWLZ5p5cHAwgoKC4OHhgb59+yIyMhJFRUWYNGkSACAwMBCtW7dGWFgYgEcHdl+8eFH6+9atW0hJSYGpqal06YH33nsPr7/+OpycnHD79m2EhoZCX19fOj5KqVRiypQpCA4OhqWlJczNzTFz5kx4eXmhX79+z7Q8RERE1DxoHZBu3bqFWbNmPXM4AgB/f3/cuXMHixcvRnZ2Ntzd3REbGysduJ2ZmQk9vT+PI799+zZ69uwpPV+9ejVWr16NQYMG4dChQwCAmzdvYty4cbh37x5atWqFF198ESdOnECrVq2k133yySfQ09ODn58fSkpK4OPjg//85z/PvDxERETUPMiEEEKbF4wePRpjx47Fm2++2VA1PRcKCgqgVCqRn58Pc3Pzeh27qRyMTFXjQdpERM+vun5/a70Hafjw4Zg/fz4uXrwINzc3GBoaqk0fMWKE9tUSERERNSFaB6SpU6cCAJYtW1ZpmkwmQ0VFxbNXRURERKRDWgekJ0/rJyIiImqOtL6SNhEREVFz91QB6fDhw3j99dfRsWNHdOzYESNGjMDRo0fruzYiIiIindA6IP3vf/+Dt7c3WrRogVmzZmHWrFkwNjbGkCFDEBMT0xA1EhERETUqrU/z79y5M6ZNm4a5c+eqta9duxabNm1CampqvRbYVPE0/78unuZPRPT8quv3t9Z7kH777Te8/vrrldpHjBiBq1evajscERERUZOjdUBydHREfHx8pfaDBw/y7vZERETULDzVvdhmzZqFlJQU9O/fHwBw7NgxbNmyBZ9++mm9F0hERETU2LQOSO+++y7s7OywZs0afP311wAeHZe0fft2jBw5st4LJCIiImpsWgckABg1ahRGjRpV37UQERERNQm8UCQRERGRhjrtQbK0tMSlS5dgbW2Nli1bQiaTVdv3/v379VYcERERkS7UKSB98sknMDMzk/6uKSARERERPe/qFJCCgoKkvydOnNhQtRARERE1CVofg6Svr4/c3NxK7ffu3YO+vn69FEVERESkS1oHpOruTFJSUgK5XP7MBRERERHpWp1P81+3bh0AQCaT4f/+7/9gamoqTauoqMCRI0fg6upa/xUSERERNbI6B6RPPvkEwKM9SNHR0Wo/p8nlcjg7OyM6Orr+KyQiIiJqZHUOSI9vRPvSSy9h165daNmyZYMVRURERKRLWl9J++eff26IOoiIiIiajKe61cjNmzexd+9eZGZmorS0VG3a2rVr66UwIiIiIl3ROiDFx8djxIgRaN++PdLS0tCtWzdcu3YNQgj06tWrIWokIiIialRan+YfEhKC9957D+fOnYORkRF27tyJGzduYNCgQXjjjTcaokYiIiKiRqV1QEpNTUVgYCAAwMDAAH/88QdMTU2xbNkyRERE1HuBRERERI1N64BkYmIiHXdkb2+PjIwMadrdu3frrzIiIiIiHdH6GKR+/frhl19+QefOnTFs2DDMmzcP586dw65du9CvX7+GqJGIiIioUWkdkNauXYvCwkIAwNKlS1FYWIjt27fDxcWFZ7ARERFRs6B1QGrfvr30t4mJCa+eTURERM2O1scg3bhxAzdv3pSenzx5EnPmzMHGjRvrtTAiIiIiXdE6II0fP166mnZ2dja8vb1x8uRJ/Otf/8KyZcvqvUAiIiKixqZ1QDp//jz69u0LAPj666/h5uaG48ePY+vWrdiyZYvWBURFRcHZ2RlGRkbw9PTEyZMnq+174cIF+Pn5wdnZGTKZDJGRkZX6hIWFoU+fPjAzM4ONjQ18fX2Rnp6u1mfw4MGQyWRqj3feeUfr2omIiKh50joglZWVQaFQAAAOHjyIESNGAABcXV2RlZWl1Vjbt29HcHAwQkNDkZycjB49esDHxwe5ublV9i8uLkb79u0RHh4OOzu7KvscPnwY06dPx4kTJxAXF4eysjK8+uqrKCoqUus3depUZGVlSY+VK1dqVTsRERE1X1ofpN21a1dER0dj+PDhiIuLw/LlywEAt2/fhpWVlVZjrV27FlOnTsWkSZMAANHR0di/fz8+//xzLFy4sFL/Pn36oE+fPgBQ5XQAiI2NVXu+ZcsW2NjYICkpCQMHDpTaW7RoUW3IIiIior82rfcgRURE4L///S8GDx6McePGoUePHgCAvXv3Sj+91UVpaSmSkpLg7e39ZzF6evD29kZCQoK2ZVUrPz8fAGBpaanWvnXrVlhbW6Nbt24ICQlBcXFxjeOUlJSgoKBA7UFERETNk9Z7kAYPHoy7d++ioKAALVu2lNqnTZuGFi1a1Hmcu3fvoqKiAra2tmrttra2SEtL07asKqlUKsyZMwcDBgxAt27dpPbx48fDyckJDg4OOHv2LBYsWID09HTs2rWr2rHCwsKwdOnSeqmLiIiImjatAxIACCGQlJSEjIwMjB8/HmZmZpDL5VoFpMYwffp0nD9/Hr/88ota+7Rp06S/3dzcYG9vjyFDhiAjIwMdOnSocqyQkBAEBwdLzwsKCuDo6NgwhRMREZFOaR2Qrl+/jqFDhyIzMxMlJSV45ZVXYGZmhoiICJSUlNT5wpHW1tbQ19dHTk6OWntOTk69HBs0Y8YM7Nu3D0eOHEGbNm1q7Ovp6QkAuHLlSrUBSaFQSAenExERUfOm9TFIs2fPhoeHB37//XcYGxtL7aNGjUJ8fHydx5HL5ejdu7faa1QqFeLj4+Hl5aVtWRIhBGbMmIHdu3fjp59+Qrt27Wp9TUpKCoBHN98lIiIi0noP0tGjR3H8+HHI5XK1dmdnZ9y6dUursYKDgxEUFAQPDw/07dsXkZGRKCoqks5qCwwMROvWrREWFgbg0YHdFy9elP6+desWUlJSYGpqio4dOwJ49LNaTEwMvv32W5iZmSE7OxsAoFQqYWxsjIyMDMTExGDYsGGwsrLC2bNnMXfuXAwcOBDdu3fXdnXQX5Dzwv26LkFyLXy4rksgImqWtA5IKpUKFRUVldpv3rwJMzMzrcby9/fHnTt3sHjxYmRnZ8Pd3R2xsbHSgduZmZnQ0/tzJ9ft27fRs2dP6fnq1auxevVqDBo0CIcOHQIAbNiwAcCjg8mftHnzZkycOBFyuRwHDx6UwpijoyP8/PywaNEirWonIiKi5ksmhBDavMDf3x9KpRIbN26EmZkZzp49i1atWmHkyJFo27YtNm/e3FC1NikFBQVQKpXIz8+Hubl5vY7dlPZQUNPGPUhERNqp6/e31nuQ1qxZAx8fH3Tp0gUPHz7E+PHjcfnyZVhbW+Orr756pqKJiIiImgKtA1KbNm3w66+/Ytu2bTh79iwKCwsxZcoUBAQEqB20TURERPS80jogPXz4EEZGRnjrrbcaoh4iIiIindP6NH8bGxsEBQUhLi4OKpWqIWoiIiIi0imtA9IXX3yB4uJijBw5Eq1bt8acOXNw+vTphqiNiIiISCe0DkijRo3Cjh07kJOTgxUrVuDixYvo168fXnjhBSxbtqwhaiQiIiJqVFoHpMfMzMwwadIk/Pjjjzh79ixMTEx4M1ciIiJqFp46ID18+BBff/01fH190atXL9y/fx/z58+vz9qIiIiIdELrs9gOHDiAmJgY7NmzBwYGBhgzZgx+/PFHDBw4sCHqIyIiImp0WgekUaNG4e9//zu+/PJLDBs2DIaGhg1RFxEREZHOaB2QcnJytL7nGhEREdHzROuAZGZmBpVKhStXriA3N7fStZD4UxsRERE977QOSCdOnMD48eNx/fp1aN7nViaToaKiot6KIyIiItIFrQPSO++8Aw8PD+zfvx/29vaQyWQNURcRERGRzmgdkC5fvoxvvvkGHTt2bIh6iIiIiHRO6+sgeXp64sqVKw1RCxEREVGToPUepJkzZ2LevHnIzs6Gm5tbpdP8u3fvXm/FEREREemC1gHJz88PADB58mSpTSaTQQjBg7SJiIioWdA6IF29erUh6iAiIiJqMrQOSE5OTg1RBxEREVGToXVAAoCMjAxERkYiNTUVANClSxfMnj0bHTp0qNfiiIiIiHRB67PYDhw4gC5duuDkyZPo3r07unfvjsTERHTt2hVxcXENUSMRERFRo9J6D9LChQsxd+5chIeHV2pfsGABXnnllXorjoiIiEgXtN6DlJqaiilTplRqnzx5Mi5evFgvRRERERHpktYBqVWrVkhJSanUnpKSAhsbm/qoiYiIiEintP6JberUqZg2bRp+++039O/fHwBw7NgxREREIDg4uN4LJCIiImpsWgekDz/8EGZmZlizZg1CQkIAAA4ODliyZAlmzZpV7wUSERERNTatA5JMJsPcuXMxd+5cPHjwAABgZmZW74URERER6cpTXUm7vLwcLi4uasHo8uXLMDQ0hLOzc33WR0RERNTotD5Ie+LEiTh+/Hil9sTEREycOLE+aiIiIiLSKa0D0pkzZzBgwIBK7f369avy7DYiIiKi543WAUkmk0nHHj0pPz8fFRUV9VIUERERkS5pHZAGDhyIsLAwtTBUUVGBsLAwvPjii/VaHBEREZEuaB2QIiIi8NNPP6FTp06YNGkSJk2ahE6dOuHIkSNYtWqV1gVERUXB2dkZRkZG8PT0xMmTJ6vte+HCBfj5+cHZ2RkymQyRkZFPNebDhw8xffp0WFlZwdTUFH5+fsjJydG6diIiImqetA5IXbp0wdmzZ/Hmm28iNzcXDx48QGBgINLS0tCtWzetxtq+fTuCg4MRGhqK5ORk9OjRAz4+PsjNza2yf3FxMdq3b4/w8HDY2dk99Zhz587Fd999hx07duDw4cO4ffs2Ro8erVXtRERE1HzJhBBCVzP39PREnz59sH79egCASqWCo6MjZs6ciYULF9b4WmdnZ8yZMwdz5szRasz8/Hy0atUKMTExGDNmDAAgLS0NnTt3RkJCAvr161fl/EpKSlBSUiI9LygogKOjI/Lz82Fubv60q6DqZVu4v17Ho+brWvhwXZdARPRcKSgogFKprPX7W+s9SPWltLQUSUlJ8Pb2/rMYPT14e3sjISGhwcZMSkpCWVmZWh9XV1e0bdu2xvmGhYVBqVRKD0dHx6eqkYiIiJo+nQWku3fvoqKiAra2tmrttra2yM7ObrAxs7OzIZfLYWFhodV8Q0JCkJ+fLz1u3LjxVDUSERFR06f1lbT/qhQKBRQKha7LICIiokZQpz1Ie/fuRVlZWb3O2NraGvr6+pXOHsvJyan2AOz6GNPOzg6lpaXIy8urt/kSERFR81KngDRq1CgpUOjr61d7lpk25HI5evfujfj4eKlNpVIhPj4eXl5eDTZm7969YWhoqNYnPT0dmZmZTz1fIiIial7q9BNbq1atcOLECbz++usQQkAmk9XLzIODgxEUFAQPDw/07dsXkZGRKCoqwqRJkwAAgYGBaN26NcLCwgA8Ogj74sWL0t+3bt1CSkoKTE1N0bFjxzqNqVQqMWXKFAQHB8PS0hLm5uaYOXMmvLy8qj2DjYiIiP5a6hSQ3nnnHYwcORIymQwymazGn6K0ud2Iv78/7ty5g8WLFyM7Oxvu7u6IjY2VDrLOzMyEnt6fO7lu376Nnj17Ss9Xr16N1atXY9CgQTh06FCdxgSATz75BHp6evDz80NJSQl8fHzwn//8p851ExERUfNW5+sgpaWl4cqVKxgxYgQ2b95c6Sywx0aOHFmf9TVZdb2OwtPgdZCorngdJCIi7dT1+7vOZ7G5urrC1dUVoaGheOONN9CiRYt6KZSIiIioqdH6NP/Q0FAAwJ07d5Ceng4A6NSpE1q1alW/lRERERHpiNYXiiwuLsbkyZPh4OCAgQMHYuDAgXBwcMCUKVNQXFzcEDUSERERNSqtA9LcuXNx+PBh7N27F3l5ecjLy8O3336Lw4cPY968eQ1RIxEREVGj0vontp07d+Kbb77B4MGDpbZhw4bB2NgYb775JjZs2FCf9RERERE1uqf6iU3zXmcAYGNjw5/YiIiIqFnQOiB5eXkhNDQUDx8+lNr++OMPLF26lFeiJiIiomZB65/YPv30U/j4+KBNmzbo0aMHAODXX3+FkZERDhw4UO8FEhERETU2rQNSt27dcPnyZWzduhVpaWkAgHHjxiEgIADGxsb1XiARERFRY9M6IAFAixYtMHXq1PquhYiIiKhJ0PoYJCIiIqLmjgGJiIiISAMDEhEREZEGBiQiIiIiDVoHpPbt2+PevXuV2vPy8tC+fft6KYqIiIhIl7QOSNeuXUNFRUWl9pKSEty6dateiiIiIiLSpTqf5r93717p7wMHDkCpVErPKyoqEB8fD2dn53otjoiIiEgX6hyQfH19AQAymQxBQUFq0wwNDeHs7Iw1a9bUa3FEREREulDngKRSqQAA7dq1w6lTp2Btbd1gRRFR3Tgv3K/rEiTXwofrugQionqj9ZW0r1692hB1EBERETUZT3Wrkfj4eMTHxyM3N1fas/TY559/Xi+FEREREemK1gFp6dKlWLZsGTw8PGBvbw+ZTNYQdRERERHpjNYBKTo6Glu2bMGECRMaoh4iIiIindP6OkilpaXo379/Q9RCRERE1CRoHZDefvttxMTENEQtRERERE2C1j+xPXz4EBs3bsTBgwfRvXt3GBoaqk1fu3ZtvRVHREREpAtaB6SzZ8/C3d0dAHD+/Hm1aTxgm4iIiJoDrQPSzz//3BB1EBERETUZWh+D9NiVK1dw4MAB/PHHHwAAIUS9FUVERESkS1oHpHv37mHIkCF44YUXMGzYMGRlZQEApkyZgnnz5tV7gURERESNTeuANHfuXBgaGiIzMxMtWrSQ2v39/REbG1uvxRERERHpgtbHIP344484cOAA2rRpo9bu4uKC69ev11thRERERLqi9R6koqIitT1Hj92/fx8KheKpioiKioKzszOMjIzg6emJkydP1th/x44dcHV1hZGREdzc3PD999+rTZfJZFU+Vq1aJfVxdnauND08PPyp6iciIqLmReuA9Le//Q1ffvml9Fwmk0GlUmHlypV46aWXtC5g+/btCA4ORmhoKJKTk9GjRw/4+PggNze3yv7Hjx/HuHHjMGXKFJw5cwa+vr7w9fVVu+RAVlaW2uPzzz+HTCaDn5+f2ljLli1T6zdz5kyt6yciIqLmRya0PP3s/PnzGDJkCHr16oWffvoJI0aMwIULF3D//n0cO3YMHTp00KoAT09P9OnTB+vXrwcAqFQqODo6YubMmVi4cGGl/v7+/igqKsK+ffuktn79+sHd3R3R0dFVzsPX1xcPHjxAfHy81Obs7Iw5c+Zgzpw5WtX7WEFBAZRKJfLz82Fubv5UY1THeeH+eh2PqDFcCx+u6xKIiGpV1+9vrfcgdevWDZcuXcKLL76IkSNHoqioCKNHj8aZM2e0DkelpaVISkqCt7f3nwXp6cHb2xsJCQlVviYhIUGtPwD4+PhU2z8nJwf79+/HlClTKk0LDw+HlZUVevbsiVWrVqG8vLzaWktKSlBQUKD2ICIiouZJ64O0AUCpVOJf//rXM8/87t27qKiogK2trVq7ra0t0tLSqnxNdnZ2lf2zs7Or7P/FF1/AzMwMo0ePVmufNWsWevXqBUtLSxw/fhwhISHIysqq9lYpYWFhWLp0aV0XjYiIiJ5jWgekzZs3w9TUFG+88YZa+44dO1BcXIygoKB6K64+fP755wgICICRkZFae3BwsPR39+7dIZfL8Y9//ANhYWFVHmweEhKi9pqCggI4Ojo2XOFERESkM1r/xBYWFgZra+tK7TY2NlixYoVWY1lbW0NfXx85OTlq7Tk5ObCzs6vyNXZ2dnXuf/ToUaSnp+Ptt9+utRZPT0+Ul5fj2rVrVU5XKBQwNzdXexAREVHzpHVAyszMRLt27Sq1Ozk5ITMzU6ux5HI5evfurXbwtEqlQnx8PLy8vKp8jZeXl1p/AIiLi6uy/2effYbevXujR48etdaSkpICPT092NjYaLUMRERE1Pxo/RObjY0Nzp49C2dnZ7X2X3/9FVZWVloXEBwcjKCgIHh4eKBv376IjIxEUVERJk2aBAAIDAxE69atERYWBgCYPXs2Bg0ahDVr1mD48OHYtm0bTp8+jY0bN6qNW1BQgB07dmDNmjWV5pmQkIDExES89NJLMDMzQ0JCAubOnYu33noLLVu21HoZiIiIqHnROiCNGzcOs2bNgpmZGQYOHAgAOHz4MGbPno2xY8dqXYC/vz/u3LmDxYsXIzs7G+7u7oiNjZUOxM7MzISe3p87uvr374+YmBgsWrQIH3zwAVxcXLBnzx5069ZNbdxt27ZBCIFx48ZVmqdCocC2bduwZMkSlJSUoF27dpg7d67aMUZERET016X1dZBKS0sxYcIE7NixAwYGj/KVSqVCYGAgoqOjIZfLG6TQpobXQSJSx+sgEdHzoK7f31rtQRJCIDs7G1u2bMFHH32ElJQUGBsbw83NDU5OTs9cNBEREVFToHVA6tixIy5cuAAXFxe4uLg0VF1EREREOqPVWWx6enpwcXHBvXv3GqoeIiIiIp3T+jT/8PBwzJ8/X+3msERERETNidYHabds2RLFxcUoLy+HXC6HsbGx2vT79+/Xa4FNFQ/SJmqaeLA4EdWkQQ7SBoDIyMhnqYuIiIioydM6IDW1e60RERER1Tetj0ECgIyMDCxatAjjxo1Dbm4uAOCHH37AhQsX6rU4IiIiIl3QOiAdPnwYbm5uSExMxK5du1BYWAjg0a1GQkND671AIiIiosamdUBauHAhPvroI8TFxaldNfvll1/GiRMn6rU4IiIiIl3QOiCdO3cOo0aNqtRuY2ODu3fv1ktRRERERLqkdUCysLBAVlZWpfYzZ86gdevW9VIUERERkS5pHZDGjh2LBQsWIDs7GzKZDCqVCseOHcN7772HwMDAhqiRiIiIqFFpHZBWrFgBV1dXODo6orCwEF26dMHAgQPRv39/LFq0qCFqJCIiImpUWl8HSS6XY9OmTVi8eDHOnTuHwsJC9OzZkzeuJSIiomajzgFJpVJh1apV2Lt3L0pLSzFkyBCEhoZWutUIERER0fOuzj+xffzxx/jggw9gamqK1q1b49NPP8X06dMbsjYiIiIinahzQPryyy/xn//8BwcOHMCePXvw3XffYevWrVCpVA1ZHxEREVGjq3NAyszMxLBhw6Tn3t7ekMlkuH37doMURkRERKQrdQ5I5eXlMDIyUmszNDREWVlZvRdFREREpEt1PkhbCIGJEydCoVBIbQ8fPsQ777wDExMTqW3Xrl31WyERERFRI6tzQAoKCqrU9tZbb9VrMURERERNQZ0D0ubNmxuyDiIiIqImQ+sraRMRERE1d1pfSZuIqClzXrhf1yVIroUP13UJRPSUuAeJiIiISAMDEhEREZEGBiQiIiIiDQxIRERERBoYkIiIiIg0MCARERERaWBAIiIiItLQJAJSVFQUnJ2dYWRkBE9PT5w8ebLG/jt27ICrqyuMjIzg5uaG77//Xm36xIkTIZPJ1B5Dhw5V63P//n0EBATA3NwcFhYWmDJlCgoLC+t92YiIiOj5o/OAtH37dgQHByM0NBTJycno0aMHfHx8kJubW2X/48ePY9y4cZgyZQrOnDkDX19f+Pr64vz582r9hg4diqysLOnx1VdfqU0PCAjAhQsXEBcXh3379uHIkSOYNm1agy0nERERPT9kQgihywI8PT3Rp08frF+/HgCgUqng6OiImTNnYuHChZX6+/v7o6ioCPv27ZPa+vXrB3d3d0RHRwN4tAcpLy8Pe/bsqXKeqamp6NKlC06dOgUPDw8AQGxsLIYNG4abN2/CwcGh1roLCgqgVCqRn58Pc3NzbRe7Rk3pSsBE9PR4JW2ipqeu39863YNUWlqKpKQkeHt7S216enrw9vZGQkJCla9JSEhQ6w8APj4+lfofOnQINjY26NSpE959913cu3dPbQwLCwspHAGAt7c39PT0kJiYWOV8S0pKUFBQoPYgIiKi5kmnAenu3buoqKiAra2tWrutrS2ys7OrfE12dnat/YcOHYovv/wS8fHxiIiIwOHDh/Haa6+hoqJCGsPGxkZtDAMDA1haWlY737CwMCiVSunh6Oio9fISERHR86FZ3qx27Nix0t9ubm7o3r07OnTogEOHDmHIkCFPNWZISAiCg4Ol5wUFBQxJREREzZRO9yBZW1tDX18fOTk5au05OTmws7Or8jV2dnZa9QeA9u3bw9raGleuXJHG0DwIvLy8HPfv3692HIVCAXNzc7UHERERNU86DUhyuRy9e/dGfHy81KZSqRAfHw8vL68qX+Pl5aXWHwDi4uKq7Q8AN2/exL1792Bvby+NkZeXh6SkJKnPTz/9BJVKBU9Pz2dZJCIiImoGdH6af3BwMDZt2oQvvvgCqampePfdd1FUVIRJkyYBAAIDAxESEiL1nz17NmJjY7FmzRqkpaVhyZIlOH36NGbMmAEAKCwsxPz583HixAlcu3YN8fHxGDlyJDp27AgfHx8AQOfOnTF06FBMnToVJ0+exLFjxzBjxgyMHTu2TmewERERUfOm82OQ/P39cefOHSxevBjZ2dlwd3dHbGysdCB2ZmYm9PT+zHH9+/dHTEwMFi1ahA8++AAuLi7Ys2cPunXrBgDQ19fH2bNn8cUXXyAvLw8ODg549dVXsXz5cigUCmmcrVu3YsaMGRgyZAj09PTg5+eHdevWNe7CExERUZOk8+sgPa94HSQiqg2vg0TU9DwX10EiIiIiaooYkIiIiIg0MCARERERaWBAIiIiItLAgERERESkgQGJiIiISAMDEhEREZEGBiQiIiIiDQxIRERERBoYkIiIiIg0MCARERERaWBAIiIiItLAgERERESkgQGJiIiISAMDEhEREZEGBiQiIiIiDQxIRERERBoYkIiIiIg0MCARERERaWBAIiIiItLAgERERESkgQGJiIiISAMDEhEREZEGBiQiIiIiDQxIRERERBoYkIiIiIg0GOi6ACIianjOC/frugQAwLXw4bougahOGJCIiBpIUwklRKQ9/sRGREREpIEBiYiIiEgDAxIRERGRBgYkIiIiIg0MSEREREQamkRAioqKgrOzM4yMjODp6YmTJ0/W2H/Hjh1wdXWFkZER3Nzc8P3330vTysrKsGDBAri5ucHExAQODg4IDAzE7du31cZwdnaGTCZTe4SHhzfI8hEREdHzRecBafv27QgODkZoaCiSk5PRo0cP+Pj4IDc3t8r+x48fx7hx4zBlyhScOXMGvr6+8PX1xfnz5wEAxcXFSE5Oxocffojk5GTs2rUL6enpGDFiRKWxli1bhqysLOkxc+bMBl1WIiIiej7IhBBClwV4enqiT58+WL9+PQBApVLB0dERM2fOxMKFCyv19/f3R1FREfbt2ye19evXD+7u7oiOjq5yHqdOnULfvn1x/fp1tG3bFsCjPUhz5szBnDlz6lRnSUkJSkpKpOcFBQVwdHREfn4+zM3N67q4dcJrpxBRc8ULRZKuFRQUQKlU1vr9rdM9SKWlpUhKSoK3t7fUpqenB29vbyQkJFT5moSEBLX+AODj41NtfwDIz8+HTCaDhYWFWnt4eDisrKzQs2dPrFq1CuXl5dWOERYWBqVSKT0cHR3rsIRERET0PNLplbTv3r2LiooK2NraqrXb2toiLS2tytdkZ2dX2T87O7vK/g8fPsSCBQswbtw4taQ4a9Ys9OrVC5aWljh+/DhCQkKQlZWFtWvXVjlOSEgIgoODpeeP9yARERFR89OsbzVSVlaGN998E0IIbNiwQW3ak2Gne/fukMvl+Mc//oGwsDAoFIpKYykUiirbiYiIqPnR6U9s1tbW0NfXR05Ojlp7Tk4O7OzsqnyNnZ1dnfo/DkfXr19HXFxcrccJeXp6ory8HNeuXdN+QYiIiKhZ0WlAksvl6N27N+Lj46U2lUqF+Ph4eHl5VfkaLy8vtf4AEBcXp9b/cTi6fPkyDh48CCsrq1prSUlJgZ6eHmxsbJ5yaYiIiKi50PlPbMHBwQgKCoKHhwf69u2LyMhIFBUVYdKkSQCAwMBAtG7dGmFhYQCA2bNnY9CgQVizZg2GDx+Obdu24fTp09i4cSOAR+FozJgxSE5Oxr59+1BRUSEdn2RpaQm5XI6EhAQkJibipZdegpmZGRISEjB37ly89dZbaNmypW5WBBERETUZOg9I/v7+uHPnDhYvXozs7Gy4u7sjNjZWOhA7MzMTenp/7ujq378/YmJisGjRInzwwQdwcXHBnj170K1bNwDArVu3sHfvXgCAu7u72rx+/vlnDB48GAqFAtu2bcOSJUtQUlKCdu3aYe7cuWrHJREREdFfl86vg/S8qut1FJ4Gr4NERM0Vr4NEuvZcXAeJiIiIqCliQCIiIiLSoPNjkIiIiHShKR3OwJ8emx7uQSIiIiLSwIBEREREpIEBiYiIiEgDAxIRERGRBgYkIiIiIg0MSEREREQaGJCIiIiINPA6SERE1Gia0rWHiGrCPUhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIAwMSERERkQYGJCIiIiINDEhEREREGhiQiIiIiDTwViNEREQkaSq3g7kWPlyn82dAIiIi0rGmEkroT/yJjYiIiEgDAxIRERGRBgYkIiIiIg0MSEREREQaGJCIiIiINDAgEREREWlgQCIiIiLSwIBEREREpIEBiYiIiEhDkwhIUVFRcHZ2hpGRETw9PXHy5Mka++/YsQOurq4wMjKCm5sbvv/+e7XpQggsXrwY9vb2MDY2hre3Ny5fvqzW5/79+wgICIC5uTksLCwwZcoUFBYW1vuyERER0fNH5wFp+/btCA4ORmhoKJKTk9GjRw/4+PggNze3yv7Hjx/HuHHjMGXKFJw5cwa+vr7w9fXF+fPnpT4rV67EunXrEB0djcTERJiYmMDHxwcPHz6U+gQEBODChQuIi4vDvn37cOTIEUybNq3Bl5eIiIiaPpkQQuiyAE9PT/Tp0wfr168HAKhUKjg6OmLmzJlYuHBhpf7+/v4oKirCvn37pLZ+/frB3d0d0dHREELAwcEB8+bNw3vvvQcAyM/Ph62tLbZs2YKxY8ciNTUVXbp0walTp+Dh4QEAiI2NxbBhw3Dz5k04ODjUWndBQQGUSiXy8/Nhbm5eH6tCwnvyEBHRX11D3ay2rt/fOr1ZbWlpKZKSkhASEiK16enpwdvbGwkJCVW+JiEhAcHBwWptPj4+2LNnDwDg6tWryM7Ohre3tzRdqVTC09MTCQkJGDt2LBISEmBhYSGFIwDw9vaGnp4eEhMTMWrUqErzLSkpQUlJifQ8Pz8fwKMVXd9UJcX1PiYREdHzpCG+X58ct7b9QzoNSHfv3kVFRQVsbW3V2m1tbZGWllbla7Kzs6vsn52dLU1/3FZTHxsbG7XpBgYGsLS0lPpoCgsLw9KlSyu1Ozo6Vrd4RERE9JSUkQ07/oMHD6BUKqudrtOA9DwJCQlR23OlUqlw//59WFlZQSaT6bCyhlNQUABHR0fcuHGj3n9GfF5xnVSN66UyrpPKuE6qxvVSWUOuEyEEHjx4UOvhNDoNSNbW1tDX10dOTo5ae05ODuzs7Kp8jZ2dXY39H/83JycH9vb2an3c3d2lPpoHgZeXl+P+/fvVzlehUEChUKi1WVhY1LyAzYS5uTk/tBq4TqrG9VIZ10llXCdV43qprKHWSU17jh7T6VlscrkcvXv3Rnx8vNSmUqkQHx8PLy+vKl/j5eWl1h8A4uLipP7t2rWDnZ2dWp+CggIkJiZKfby8vJCXl4ekpCSpz08//QSVSgVPT896Wz4iIiJ6Pun8J7bg4GAEBQXBw8MDffv2RWRkJIqKijBp0iQAQGBgIFq3bo2wsDAAwOzZszFo0CCsWbMGw4cPx7Zt23D69Gls3LgRACCTyTBnzhx89NFHcHFxQbt27fDhhx/CwcEBvr6+AIDOnTtj6NChmDp1KqKjo1FWVoYZM2Zg7NixdTqDjYiIiJo3nQckf39/3LlzB4sXL0Z2djbc3d0RGxsrHWSdmZkJPb0/d3T1798fMTExWLRoET744AO4uLhgz5496Natm9Tn/fffR1FREaZNm4a8vDy8+OKLiI2NhZGRkdRn69atmDFjBoYMGQI9PT34+flh3bp1jbfgzwGFQoHQ0NBKPy3+lXGdVI3rpTKuk8q4TqrG9VJZU1gnOr8OEhEREVFTo/MraRMRERE1NQxIRERERBoYkIiIiIg0MCARERERaWBAokrCwsLQp08fmJmZwcbGBr6+vkhPT9d1WU1KeHi4dEmJv7Jbt27hrbfegpWVFYyNjeHm5obTp0/ruiydqqiowIcffoh27drB2NgYHTp0wPLly2u971NzcuTIEbz++utwcHCATCaT7pX5mBACixcvhr29PYyNjeHt7Y3Lly/rpthGVNN6KSsrw4IFC+Dm5gYTExM4ODggMDAQt2/f1l3BjaC298qT3nnnHchkMkRGRjZKbQxIVMnhw4cxffp0nDhxAnFxcSgrK8Orr76KoqIiXZfWJJw6dQr//e9/0b17d12XolO///47BgwYAENDQ/zwww+4ePEi1qxZg5YtW+q6NJ2KiIjAhg0bsH79eqSmpiIiIgIrV67Ev//9b12X1miKiorQo0cPREVFVTl95cqVWLduHaKjo5GYmAgTExP4+Pjg4cOHjVxp46ppvRQXFyM5ORkffvghkpOTsWvXLqSnp2PEiBE6qLTx1PZeeWz37t04ceJE416rUBDVIjc3VwAQhw8f1nUpOvfgwQPh4uIi4uLixKBBg8Ts2bN1XZLOLFiwQLz44ou6LqPJGT58uJg8ebJa2+jRo0VAQICOKtItAGL37t3Sc5VKJezs7MSqVauktry8PKFQKMRXX32lgwp1Q3O9VOXkyZMCgLh+/XrjFKVj1a2TmzdvitatW4vz588LJycn8cknnzRKPdyDRLXKz88HAFhaWuq4Et2bPn06hg8fDm9vb12XonN79+6Fh4cH3njjDdjY2KBnz57YtGmTrsvSuf79+yM+Ph6XLl0CAPz666/45Zdf8Nprr+m4sqbh6tWryM7OVvsMKZVKeHp6IiEhQYeVNT35+fmQyWR/mft+VkWlUmHChAmYP38+unbt2qjz1vmVtKlpU6lUmDNnDgYMGKB2tfK/om3btiE5ORmnTp3SdSlNwm+//YYNGzYgODgYH3zwAU6dOoVZs2ZBLpcjKChI1+XpzMKFC1FQUABXV1fo6+ujoqICH3/8MQICAnRdWpOQnZ0NANLdEh6ztbWVphHw8OFDLFiwAOPGjftL38A2IiICBgYGmDVrVqPPmwGJajR9+nScP38ev/zyi65L0akbN25g9uzZiIuLU7tlzV+ZSqWCh4cHVqxYAQDo2bMnzp8/j+jo6L90QPr666+xdetWxMTEoGvXrkhJScGcOXPg4ODwl14vVHdlZWV48803IYTAhg0bdF2OziQlJeHTTz9FcnIyZDJZo8+fP7FRtWbMmIF9+/bh559/Rps2bXRdjk4lJSUhNzcXvXr1goGBAQwMDHD48GGsW7cOBgYGqKio0HWJjc7e3h5dunRRa+vcuTMyMzN1VFHTMH/+fCxcuBBjx46Fm5sbJkyYgLlz50o33P6rs7OzAwDk5OSotefk5EjT/soeh6Pr168jLi7uL7336OjRo8jNzUXbtm2l7e7169cxb948ODs7N/j8uQeJKhFCYObMmdi9ezcOHTqEdu3a6boknRsyZAjOnTun1jZp0iS4urpiwYIF0NfX11FlujNgwIBKl3+4dOkSnJycdFRR01BcXKx2g20A0NfXh0ql0lFFTUu7du1gZ2eH+Ph4uLu7AwAKCgqQmJiId999V7fF6djjcHT58mX8/PPPsLKy0nVJOjVhwoRKx3v6+PhgwoQJmDRpUoPPnwGJKpk+fTpiYmLw7bffwszMTDouQKlUwtjYWMfV6YaZmVmlY7BMTExgZWX1lz02a+7cuejfvz9WrFiBN998EydPnsTGjRuxceNGXZemU6+//jo+/vhjtG3bFl27dsWZM2ewdu1aTJ48WdelNZrCwkJcuXJFen716lWkpKTA0tISbdu2xZw5c/DRRx/BxcUF7dq1w4cffggHBwf4+vrqruhGUNN6sbe3x5gxY5CcnIx9+/ahoqJC2vZaWlpCLpfrquwGVdt7RTMkGhoaws7ODp06dWr44hrlXDl6rgCo8rF582Zdl9ak/NVP8xdCiO+++05069ZNKBQK4erqKjZu3KjrknSuoKBAzJ49W7Rt21YYGRmJ9u3bi3/961+ipKRE16U1mp9//rnKbUhQUJAQ4tGp/h9++KGwtbUVCoVCDBkyRKSnp+u26EZQ03q5evVqtdven3/+WdelN5ja3iuaGvM0f5kQf6HLuxIRERHVAQ/SJiIiItLAgERERESkgQGJiIiISAMDEhEREZEGBiQiIiIiDQxIRERERBoYkIiIiIg0MCARERERafjLBaRr165BJpMhJSVF16VI0tLS0K9fPxgZGUn3JqJnt2XLFlhYWOi6DJ2SyWTYs2fPM43RVNZjXT4nQghMmzYNlpaW0ud88ODBmDNnTqPW2lAmTpxY6+04Dh06BJlMhry8vAat5dixY3Bzc4OhoWGzv0VIQ9Lld1Jd3k+1KS4uhp+fH8zNzRvlfdeYGj0gTZw4ETKZDOHh4Wrte/bsgUwma+xymoTQ0FCYmJggPT0d8fHxui6nSWgqX8pA/YQMXcnKysJrr72m6zLqRV0+J7GxsdiyZQv27duHrKwsdOvWDbt27cLy5cufad5N5T3w6aefYsuWLdLzqsJf//79kZWVBaVS2aC1BAcHw93dHVevXlWr6XnTlLY1z6MvvvgCR48exfHjxxvlfdeYdLIHycjICBEREfj99991MfsGUVpa+tSvzcjIwIsvvggnJ6e//N2bqX7Z2dlBoVDouox6UZfPSUZGBuzt7dG/f3/Y2dnBwMAAlpaWMDMzq3bcZ/nsNjalUlnrl7lcLoednV2D/w9nRkYGXn75ZbRp0+apA8bztO6pahkZGejcuTO6devWKO+7RtUod3x7QlBQkPj73/8uXF1dxfz586X23bt3iyfLCQ0NFT169FB77SeffCKcnJzUxho5cqT4+OOPhY2NjVAqlWLp0qWirKxMvPfee6Jly5aidevW4vPPP5de8/iGgF999ZXw8vISCoVCdO3aVRw6dEhtXufOnRNDhw4VJiYmwsbGRrz11lvizp070vRBgwaJ6dOni9mzZwsrKysxePDgKpe3oqJCLF26VLRu3VrI5XLRo0cP8cMPP0jToXGDvtDQ0GrHiYiIEB06dBByuVw4OjqKjz76SJp+9uxZ8dJLLwkjIyNhaWkppk6dKh48eFAv62r79u3ixRdfFEZGRsLDw0Okp6eLkydPit69ewsTExMxdOhQkZubq1bvpk2bhKurq1AoFKJTp04iKiqq0rg7d+4UgwcPFsbGxqJ79+7i+PHjQoiqb174eL1ERUWJjh07CoVCIWxsbISfn1+V60sIITZv3iyUSqXYvXu39JpXX31VZGZmqvXbs2eP6Nmzp1AoFKJdu3ZiyZIloqysTAjx6MaIT9bh5OQk8vLyhJ6enjh16pT0b9OyZUvh6ekpjfn//t//E23atJGeZ2ZmijfeeEMolUrRsmVLMWLECHH16tV6W2fVASB2796t1RibN28Wjo6OwtjYWPj6+orVq1cLpVJZ53W2dOlSYW9vL+7evSv1HzZsmBg8eLCoqKioss76+JwEBQVV+rcSovJNhZ2cnMSyZcvEhAkThJmZmQgKChIlJSVi+vTpws7OTigUCtG2bVuxYsUKqX9V42qq67bl0KFDok+fPkIulws7OzuxYMECad0JIcSOHTtEt27dpM/ykCFDRGFhobSMI0eOrHJ5AYirV69Kn5/ff/9d5OfnCyMjI/H999+r1bBr1y5hamoqioqKhBB1e39qLueTj8c3sq5t2arbbta2va1t+/f+++8LFxcXYWxsLNq1aycWLVokSktLpekpKSli8ODBwtTUVJiZmYlevXqJU6dO1bit0XTlyhUxYsQIYWNjI0xMTISHh4eIi4tT6+Pk5CQ+/vhjMWnSJGFqaiocHR3Ff//7X7U+iYmJwt3dXSgUCtG7d2+xa9cuAUCcOXOmyvkKIcTDhw/FvHnzhIODg2jRooXo27ev2g1sH2/rYmNjhaurqzAxMRE+Pj7i9u3bUp/y8nIxd+5coVQqhaWlpZg/f74IDAyU3k/V+eabb0SXLl2EXC4XTk5OYvXq1dK0QYMGqa27QYMGVTvO3r17hYeHh1AoFMLKykr4+vpK0+7fvy8mTJggLCwshLGxsRg6dKi4dOlSnZfvwIEDQqFQiN9//11tnrNmzRIvvfSS9Pzo0aPSd1mbNm3EzJkzpc+WEJW3DToJSCNHjhS7du0SRkZG4saNG0KIpw9IZmZmYvr06SItLU189tlnAoDw8fERH3/8sbh06ZJYvny5MDQ0lObz+MPdpk0b8c0334iLFy+Kt99+W5iZmUkb9N9//120atVKhISEiNTUVJGcnCxeeeUVtRU9aNAgYWpqKubPny/S0tJEWlpalcu7du1aYW5uLr766iuRlpYm3n//fWFoaCj942dlZYmuXbuKefPmiaysLLVQ86T3339ftGzZUmzZskVcuXJFHD16VGzatEkIIURhYaGwt7cXo0ePFufOnRPx8fGiXbt2andDfpZ15erqKmJjY8XFixdFv379RO/evcXgwYPFL7/8IpKTk0XHjh3FO++8I83rf//7n7C3txc7d+4Uv/32m9i5c6ewtLQUW7ZsqTTuvn37RHp6uhgzZoxwcnISZWVloqSkRERGRgpzc3ORlZUlrZdTp04JfX19ERMTI65duyaSk5PFp59+WvUbTTz6UBkaGgoPDw9x/Phxcfr0adG3b1/Rv39/qc+RI0eEubm52LJli8jIyBA//vijcHZ2FkuWLBFCCJGbmyt9AWRlZUlBsFevXmLVqlVCiEcbX0tLSyGXy6V/v7ffflsEBAQIIYQoLS0VnTt3FpMnTxZnz54VFy9eFOPHjxedOnWS7vD+rOusOlUFpJrGOHHihNDT0xMREREiPT1dfPrpp8LCwkItINW2zsrLy4WXl5e0AVy/fr2wsLAQ169fr7bO+vic5OXliWXLlok2bdqo/VtVFZDMzc3F6tWrxZUrV8SVK1fEqlWrhKOjozhy5Ii4du2aOHr0qIiJianxPaCpLtuWmzdvihYtWoh//vOfIjU1VezevVtYW1tLX8q3b98WBgYGYu3ateLq1avi7NmzIioqSlreJwNSXl6e8PLyElOnTpU+J+Xl5WoBSQghxowZI9566y21Wv38/KS2urw/n1ReXi6ysrKEubm5iIyMFFlZWaK4uLjWZXv8b6G53azL9ram7Z8QQixfvlwcO3ZMXL16Vezdu1fY2tqKiIgIaXrXrl3FW2+9JVJTU8WlS5fE119/LVJSUqrd1lQlJSVFREdHi3PnzolLly6JRYsWCSMjI7X3tZOTk7C0tBRRUVHi8uXLIiwsTOjp6UnfDw8ePBCtWrUS48ePF+fPnxffffedaN++fa0B6e233xb9+/cXR44ckd6vCoVC+nw83tZ5e3uLU6dOiaSkJNG5c2cxfvx4aYyIiAjRsmVLsXPnTnHx4kUxZcoUYWZmVmNAOn36tNDT0xPLli0T6enpYvPmzcLY2FgKxPfu3RNTp04VXl5eIisrS9y7d6/Kcfbt2yf09fXF4sWLxcWLF0VKSor0PyBCCDFixAjRuXNnceTIEZGSkiJ8fHxEx44dpZBb2/KVl5cLW1tb8X//93/SmJptV65cESYmJuKTTz4Rly5dEseOHRM9e/YUEydOVPv3e3LboLOAJIQQ/fr1E5MnTxZCPH1AcnJyUvu/0k6dOom//e1v0vPy8nJhYmIivvrqKyHEnxux8PBwqU9ZWZlo06aN9IFavny5ePXVV9XmfePGDQFApKenCyEefdB79uxZ6/I6ODiIjz/+WK2tT58+4p///Kf0vEePHtX+X4sQQhQUFAiFQqG2QXjSxo0bRcuWLdWS8P79+4Wenp7Izs4WQjzbunryTffVV18JACI+Pl5qCwsLE506dZKed+jQQfpyeWz58uXCy8ur2nEvXLggAIjU1FQhxJ//x/CknTt3CnNzc1FQUFDtunrS5s2bBQBx4sQJqS01NVUAEImJiUIIIYYMGaL2QRXi0d4fe3t76fmTIeOx4OBgMXz4cCGEEJGRkcLf319tr0fHjh3Fxo0bpfE6deokVCqV9PqSkhJhbGwsDhw4IISon3VWlaoCUk1jjBs3TgwbNkxtDH9/f7V/i7qss4yMDGFmZiYWLFggjI2NxdatW6utUYj6+ZwIUXkbIUTVAenJ/3sVQoiZM2eKl19+We3f6ElVvQc01WXb8sEHH1R6L0RFRQlTU1NRUVEhkpKSBABx7dq1Kufx5PazqmUTQlQKSLt371bbW/R4r9Lj92pd3p9VUSqV0hdlXZbtcb2a283atre1bf+qsmrVKtG7d2/puZmZmfQ/G5qq2tbUVdeuXcW///1v6bmTk5NaGFWpVMLGxkZs2LBBCCHEf//7X2FlZSX++OMPqc+GDRtqDEjXr18X+vr64tatW2rtQ4YMESEhIdIyABBXrlyRpkdFRQlbW1vpub29vVi5cqX0/PF7s6aANH78ePHKK6+otc2fP1906dJFej579uwa9xwJIYSXl5f0P4yaLl26JACIY8eOSW13794VxsbG4uuvv67z8s2ePVu8/PLL0nPNvUpTpkwR06ZNU5v30aNHhZ6envTvoblt0OlZbBEREfjiiy+Qmpr61GN07doVenp/LoatrS3c3Nyk5/r6+rCyskJubq7a67y8vKS/DQwM4OHhIdXx66+/4ueff4apqan0cHV1BfDo99bHevfuXWNtBQUFuH37NgYMGKDWPmDAAK2WOTU1FSUlJRgyZEi103v06AETExO1eahUKqSnp0ttT7uuunfvrvYaAGqvs7W1lV5TVFSEjIwMTJkyRW39ffTRR2rrTnNce3t7AKg07ye98sorcHJyQvv27TFhwgRs3boVxcXF1fYHHv3b9unTR3ru6uoKCwsLtX/rZcuWqdU6depUZGVl1Tj2oEGD8Msvv6CiogKHDx/G4MGDMXjwYBw6dAi3b9/GlStXMHjwYGkeV65cgZmZmTQPS0tLPHz4EBkZGQ26zqpS0xipqanw9PRU6//kZ6Wu66x9+/ZYvXo1IiIiMGLECIwfP77aeurrc6INDw8PtecTJ05ESkoKOnXqhFmzZuHHH3986rFr2rakpqbCy8tL7TiNAQMGoLCwEDdv3kSPHj0wZMgQuLm54Y033sCmTZue+VjNYcOGwdDQEHv37gUA7Ny5E+bm5vD29gZQ+/uzrmpbtsc0t5u1bW9r2/4BwPbt2zFgwADY2dnB1NQUixYtQmZmpjQ9ODgYb7/9Nry9vREeHq7Vcj1WWFiI9957D507d4aFhQVMTU2RmpqqNh9A/fMlk8lgZ2en9vnq3r07jIyMpD6any9N586dQ0VFBV544QW1dXT48GG15WjRogU6dOggPbe3t5fmm5+fj6ysLLXP9uP3Zk1SU1Or/FxevnwZFRUVNb72SSkpKTV+fxkYGKjVZmVlhU6dOql9/mtaPgAICAiQtr8AsHXrVgwfPlw6Pu7XX3/Fli1b1Nahj48PVCoVrl69Ko3z5DoxqPMSNoCBAwfCx8cHISEhmDhxoto0PT09CCHU2srKyiqNYWhoqPZcJpNV2aZSqepcV2FhIV5//XVERERUmvb4CwWAWiBpSMbGxvUyztOuqyf7PN74abY9fk1hYSEAYNOmTZW+aPX19Wsdt6Z/JzMzMyQnJ+PQoUP48ccfsXjxYixZsgSnTp166oNECwsLsXTpUowePbrStCc3YpoGDhyIBw8eIDk5GUeOHMGKFStgZ2eH8PBw9OjRAw4ODnBxcZHm0bt3b2zdurXSOK1atWrQdVaVZx2jruvsyJEj0NfXx7Vr11BeXg4DA51ubtRofnZ79eqFq1ev4ocffsDBgwfx5ptvwtvbG998802j1qWvr4+4uDgcP34cP/74I/7973/jX//6FxITE9GuXbunGlMul2PMmDGIiYnB2LFjERMTA39/f+nfo7b3Z33TXPe1bW9/++23GsdLSEhAQEAAli5dCh8fHyiVSmzbtg1r1qyR+ixZsgTjx4/H/v378cMPPyA0NBTbtm3DqFGj6lz3e++9h7i4OKxevRodO3aEsbExxowZU+lA82f9/tFUWFgIfX19JCUlVdoemJqa1jhfze9QXamP77Dalq9Pnz7o0KEDtm3bhnfffRe7d+9WO7uysLAQ//jHPzBr1qxKY7dt21b6+8n3p86vgxQeHo7vvvsOCQkJau2tWrVCdna22gqoz+tEnDhxQvq7vLwcSUlJ6Ny5M4BHG8sLFy7A2dkZHTt2VHtoE4rMzc3h4OCAY8eOqbUfO3YMXbp0qfM4Li4uMDY2rvbU5s6dO+PXX39FUVGR2jz09PTQqVOnOs+nPtja2sLBwQG//fZbpXWnzQZeLpdX+X8oBgYG8Pb2xsqVK3H27Flcu3YNP/30U7XjlJeX4/Tp09Lz9PR05OXlqf1bp6enV6q1Y8eO0t42Q0PDSrVYWFige/fuWL9+PQwNDeHq6oqBAwfizJkz2LdvHwYNGiT17dWrFy5fvgwbG5tK81AqlfW2zupD586dkZiYqNb25GcFqNs62759O3bt2oVDhw4hMzOzxtPs6+tz8qzMzc3h7++PTZs2Yfv27di5cyfu378PoOr3QHVq2rZ07twZCQkJatu1Y8eOwczMDG3atAHwaMM/YMAALF26FGfOnIFcLsfu3burnFd1nxNNAQEBiI2NxYULF/DTTz8hICBAmlbb+7Ou6rJsValte1vb9u/48eNwcnLCv/71L3h4eMDFxQXXr1+v1O+FF17A3Llz8eOPP2L06NHYvHkzgLqvw2PHjmHixIkYNWoU3NzcYGdnh2vXrtX6uid17twZZ8+excOHD6U2zc+Xpp49e6KiogK5ubmV1o+dnV2d5qtUKmFvb6/22X783qyt3qo+ly+88EKlsFaT7t271/j9VV5erlbbvXv3kJ6ervXnPyAgAFu3bsV3330HPT09DB8+XJrWq1cvXLx4scrtllwur3I8nQckNzc3BAQEYN26dWrtgwcPxp07d7By5UpkZGQgKioKP/zwQ73NNyoqCrt370ZaWhqmT5+O33//HZMnTwYATJ8+Hffv38e4ceNw6tQpZGRk4MCBA5g0aZJWuxUBYP78+YiIiMD27duRnp6OhQsXIiUlBbNnz67zGEZGRliwYAHef/99fPnll8jIyMCJEyfw2WefAXj0pjAyMkJQUBDOnz+Pn3/+GTNnzsSECROkn8Qa09KlSxEWFoZ169bh0qVLOHfuHDZv3oy1a9fWeQxnZ2cUFhYiPj4ed+/eRXFxMfbt24d169YhJSUF169fx5dffgmVSlVjCDQ0NMTMmTORmJiIpKQkTJw4Ef369UPfvn0BAIsXL8aXX36JpUuX4sKFC0hNTcW2bduwaNEitVri4+ORnZ2t9nPH4MGDsXXrVikMWVpaonPnzti+fbtaQAoICIC1tTVGjhyJo0eP4urVqzh06BBmzZol/fRQH+usPsyaNQuxsbFYvXo1Ll++jPXr1yM2NlatT23r7ObNm3j33XcRERGBF198EZs3b8aKFStq/CKoj8/Js1i7di2++uorpKWl4dKlS9ixYwfs7OykPZPVvQeqUtO25Z///Cdu3LiBmTNnIi0tDd9++y1CQ0MRHBwMPT09JCYmYsWKFTh9+jQyMzOxa9cu3LlzRwpYmpydnZGYmIhr167h7t271e6pGDhwIOzs7BAQEIB27dqp7amsy/uzLmpbturUtr2tbfvn4uKCzMxMbNu2DRkZGVi3bp1aoPzjjz8wY8YMHDp0CNevX8exY8dw6tQpaZ1Wta2piouLC3bt2oWUlBT8+uuvGD9+vNZ7hsaPHw+ZTIapU6fi4sWL+P7777F69eoaX/PCCy8gICAAgYGB2LVrF65evYqTJ08iLCwM+/fvr/O8Z8+ejfDwcOzZswdpaWn45z//WetFHefNm4f4+HgsX74cly5dwhdffIH169fjvffeq/N8gUfXMPvqq68QGhqK1NRUnDt3Ttpj6OLigpEjR2Lq1Kn45Zdf8Ouvv+Ktt95C69atMXLkSK3mExAQgOTkZHz88ccYM2aM2iVOFixYgOPHj2PGjBlISUnB5cuX8e2332LGjBnVD1jjkVUNQPMgQyEeHdwol8uFZjkbNmwQjo6OwsTERAQGBoqPP/64ytP8n1TVQYtOTk7ik08+keYFQMTExIi+ffsKuVwuunTpIn766Se111y6dEmMGjVKOu3Q1dVVzJkzRzoAsar5VKWiokIsWbJEtG7dWhgaGlY6fVmIuh18WlFRIT766CPh5OQkDA0N1U5DFqLup/k/zbp68uBBzQNAhaj6IMetW7cKd3d3IZfLRcuWLcXAgQPFrl27qh33999/FwDUTl195513hJWVlXTq7dGjR8WgQYNEy5YtpVPUt2/fXu06e1zXzp07Rfv27YVCoRDe3t6VzqaKjY0V/fv3F8bGxsLc3Fz07dtXOsBaiEenp3bs2FEYGBiovf8en1jw+ABMIR4dKAig0lmNWVlZIjAwUFhbWwuFQiHat28vpk6dKvLz8+t1nWlCFQdp1zbGZ599Jtq0aSOMjY3F66+/XuVp/tWtM5VKJYYMGSJ8fHzUDtadOXOm6NChQ7VnCNXX56SuB2k/fo8/tnHjRuHu7i5MTEyEubm5GDJkiEhOTpamV/ceeFJdty01nQp/8eJF4ePjI1q1aiUUCoV44YUX1A4C1vwcp6eni379+gljY+MqT/N/0vvvvy8AiMWLF1eqvS7vT02aB2nXtmxCVL/drG17W9v2b/78+cLKykqYmpoKf39/8cknn0jv2ZKSEjF27Fjh6Ogo5HK5cHBwEDNmzFA7UFpzW1OVq1evipdeekkYGxsLR0dHsX79+jq9tzTftwkJCaJHjx5CLpcLd3d3sXPnzlrPYistLRWLFy8Wzs7OwtDQUNjb24tRo0aJs2fPCiGq3gZrnvhUVlYmZs+eLczNzYWFhYUIDg7W6jT/x+v98dm7j9XlIG0hHp1k83j7Zm1tLUaPHi1Ne3yav1KpFMbGxsLHx6fK0/xrWr7H+vbtKwBU+twJIcTJkyfFK6+8IkxNTYWJiYno3r272skhmv9+MiGayI+URETPsWvXrqFdu3Y4c+YMbxlE1Azo/Cc2IiIioqaGAYmIiIhIA39iIyIiItLAPUhEREREGhiQiIiIiDQwIBERERFpYEAiIiIi0sCARERERKSBAYmIiIhIAwMSERERkQYGJCIiIiIN/x8gtGi7Ha5XcAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.8922535211267606, Median = 2.0\n", + "Accuracy 0.704498\n", + "Precision 0.693021\n", + "Recall 0.73423\n", + "FPR 0.325233\n", + "F1 0.71303\n", + "Mean H 2.892254\n", + "Correct Adjustment 0.083247\n", + "Incorrect Adjustment 0.071355\n", + "Recovery 0.011892\n", + "Leaderboard String | MODEL_NAME | 70.4 | 69.3 | 73.4 | 71....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "fitting policy DeferralDecisionPolicy for seed 4\n", + "starting transformation.\n" + ] }, { - "cell_type": "code", - "execution_count": 1, - "id": "5e527737", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "pooled trigger_all current perf, best threshold per seed: 0.5532229185317815 (12359/22340)\n", - "pooled delayed_all best threshold per seed, k=7: 0.8353165159447882 (3510/4202)\n" - ] - } - ], - "source": [ - "import json\n", - "from pathlib import Path\n", - "from convokit import Corpus\n", - "\n", - "corpus_base = Path(\"/reef/lyk25/dynamic_training/game_analysis/corpi/test\")\n", - "config_base = Path(\"/reef/sqt2/FinalAAO/cga-cmv-large/google/gemma-2-9b-it\")\n", - "\n", - "corpus_dirs = sorted(\n", - " corpus_dir\n", - " for corpus_dir in corpus_base.rglob(\"*\")\n", - " if corpus_dir.is_dir() and (corpus_dir / \"index.json\").exists()\n", - ")\n", - "\n", - "if not corpus_dirs:\n", - " raise FileNotFoundError(f\"no convokit corpora found under {corpus_base}\")\n", - "\n", - "\n", - "def _test_seed_key(corpus_dir):\n", - " parent_name = corpus_dir.parent.name\n", - " if parent_name.startswith(\"test-seed-\"):\n", - " return parent_name\n", - " seed_idx = corpus_dir.name.rsplit(\"-\", 1)[-1]\n", - " return f\"test-seed-{seed_idx}\"\n", - "\n", - "\n", - "corpus_path_by_key = {}\n", - "for corpus_dir in corpus_dirs:\n", - " key = _test_seed_key(corpus_dir)\n", - " corpus_path_by_key[key] = corpus_dir\n", - "\n", - "\n", - "def is_calm_sim_forecast(forecast):\n", - " if isinstance(forecast, str):\n", - " forecast = forecast.strip().lower()\n", - " if forecast in {\"0\", \"false\", \"calm\"}:\n", - " return True\n", - " if forecast in {\"1\", \"true\", \"awry\"}:\n", - " return False\n", - " return int(forecast) == 0\n", - "\n", - "\n", - "def count_decreases_at_indices(corpus, get_indices):\n", - " total = 0\n", - " reduction = 0\n", - "\n", - " for convo in corpus.iter_conversations():\n", - " utts = convo.get_chronological_utterance_list()\n", - "\n", - " for i in get_indices(utts):\n", - " if i + 1 >= len(utts):\n", - " continue\n", - "\n", - " f1 = utts[i].meta[\"forecast_prob\"]\n", - " f2 = utts[i + 1].meta[\"forecast_prob\"]\n", - " total += 1\n", - "\n", - " if f1 > f2:\n", - " reduction += 1\n", - "\n", - " return reduction, total\n", - "\n", - "\n", - "def current_trigger_indices(utts, pred_threshold):\n", - " return [\n", - " i\n", - " for i, utt in enumerate(utts)\n", - " if utt.meta[\"forecast_prob\"] > pred_threshold\n", - " ]\n", - "\n", - "\n", - "def delayed_indices_from_sim_forecasts(utts, pred_threshold, k):\n", - " delayed = []\n", - "\n", - " for i, utt in enumerate(utts):\n", - " if utt.meta[\"forecast_prob\"] <= pred_threshold:\n", - " continue\n", - "\n", - " sim_forecasts = utt.meta[\"sim_replies_forecasts\"]\n", - " calm_sim_replies = sum(\n", - " 1 for forecast in sim_forecasts if is_calm_sim_forecast(forecast)\n", - " )\n", - "\n", - " if calm_sim_replies > k:\n", - " delayed.append(i)\n", - "\n", - " return delayed\n", - "\n", - "\n", - "current_reduction = 0\n", - "current_total = 0\n", - "delayed_reduction = 0\n", - "delayed_total = 0\n", - "\n", - "for seed in range(1, 6):\n", - " seed_key = f\"test-seed-{seed}\"\n", - " corpus = Corpus(filename=str(corpus_path_by_key[seed_key]))\n", - "\n", - " with open(config_base / f\"seed-{seed}\" / \"dev_config.json\") as f:\n", - " best_threshold = json.load(f)[\"best_threshold\"]\n", - "\n", - " r, t = count_decreases_at_indices(\n", - " corpus,\n", - " lambda utts: current_trigger_indices(utts, best_threshold),\n", - " )\n", - " current_reduction += r\n", - " current_total += t\n", - "\n", - " r, t = count_decreases_at_indices(\n", - " corpus,\n", - " lambda utts: delayed_indices_from_sim_forecasts(utts, best_threshold, k=7),\n", - " )\n", - " delayed_reduction += r\n", - " delayed_total += t\n", - "\n", - "pooled_trigger_all = current_reduction / current_total\n", - "pooled_delayed_all = delayed_reduction / delayed_total\n", - "\n", - "print(f\"pooled trigger_all current perf, best threshold per seed: {pooled_trigger_all} ({current_reduction}/{current_total})\")\n", - "print(f\"pooled delayed_all best threshold per seed, k=7: {pooled_delayed_all} ({delayed_reduction}/{delayed_total})\")" + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4268.73it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7035, p=0.7250, r=0.6556, fpr=0.2487, f1=0.6886\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.723186119873817, Median = 2.0\n", + "Accuracy 0.703464\n", + "Precision 0.724986\n", + "Recall 0.655636\n", + "FPR 0.248707\n", + "F1 0.688569\n", + "Mean H 2.723186\n", + "Correct Adjustment 0.06515\n", + "Incorrect Adjustment 0.073681\n", + "Recovery -0.008532\n", + "Leaderboard String | MODEL_NAME | 70.3 | 72.5 | 65.6 | 68....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "[info] summarize only: RandomDeferralDecisionPolicy seed 4\n" + ] }, { - "cell_type": "markdown", - "id": "cb154714", - "metadata": {}, - "source": [ - "## Calculating oracle threshold" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 9, - "id": "cba93b72", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] using 5 test-seed corpora: test-seed-1, test-seed-2, test-seed-3, test-seed-4, test-seed-5\n" - ] - } - ], - "source": [ - "# corpora comes from the decisionpolicy-demo download cell; use only test-seed- entries.\n", - "import re\n", - "\n", - "if \"corpora\" not in globals() or not corpora:\n", - " raise RuntimeError(\n", - " \"corpora is empty: run the download cell above first.\"\n", - " )\n", - "\n", - "_prev_keys = tuple(sorted(corpora))\n", - "_test_seed_re = re.compile(r\"^test-seed-(\\d+)$\")\n", - "\n", - "corpora = {\n", - " k: corpora[k]\n", - " for k in sorted(\n", - " (k for k in _prev_keys if _test_seed_re.match(k)),\n", - " key=lambda k: int(_test_seed_re.match(k).group(1)),\n", - " )\n", - "}\n", - "\n", - "if not corpora:\n", - " raise RuntimeError(\n", - " \"no test-seed- corpora after filter; had keys: \"\n", - " + \", \".join(_prev_keys)\n", - " )\n", - "\n", - "print(\n", - " f\"[info] using {len(corpora)} test-seed corpora: \"\n", - " + \", \".join(corpora)\n", - ")" + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.78343949044586, Median = 2.0\n", + "Accuracy 0.683299\n", + "Precision 0.696617\n", + "Recall 0.649431\n", + "FPR 0.282834\n", + "F1 0.672197\n", + "Mean H 2.783439\n", + "Correct Adjustment 0.081437\n", + "Incorrect Adjustment 0.109617\n", + "Recovery -0.02818\n", + "Leaderboard String | MODEL_NAME | 68.3 | 69.7 | 64.9 | 67....\n", + "dtype: object\n", + "---\n", + "fitting policy SimulationAverageDecisionPolicy for seed 4\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4302.66it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.6988, p=0.6855, r=0.7347, fpr=0.3371, f1=0.7093\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.9500351864883885, Median = 2.0\n", + "Accuracy 0.698811\n", + "Precision 0.68548\n", + "Recall 0.734747\n", + "FPR 0.337125\n", + "F1 0.709259\n", + "Mean H 2.950035\n", + "Correct Adjustment 0.088676\n", + "Incorrect Adjustment 0.10393\n", + "Recovery -0.015253\n", + "Leaderboard String | MODEL_NAME | 69.9 | 68.5 | 73.5 | 70....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "fitting policy SimulationMajorityDecisionPolicy for seed 4\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4286.36it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7006, p=0.6839, r=0.7461, fpr=0.3449, f1=0.7136\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] }, { - "cell_type": "code", - "execution_count": 10, - "id": "3be18b5d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] per-seed best thresholds: {'test-seed-1': 0.5926666259765625, 'test-seed-2': 0.622459352016449, 'test-seed-3': 0.6513549089431763, 'test-seed-4': 0.6513549089431763, 'test-seed-5': 0.6513549089431763}\n", - "[info] mean best threshold: 0.633838\n", - "[info] generating baseline roc curve with 400 thresholds in [0.483838, 0.783838]\n", - "[info] testing k values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import json\n", - "\n", - "seed_best_thresholds = {\n", - " \"test-seed-1\": 0.5926666259765625,\n", - " \"test-seed-2\": 0.622459352016449,\n", - " \"test-seed-3\": 0.6513549089431763,\n", - " \"test-seed-4\": 0.6513549089431763,\n", - " \"test-seed-5\": 0.6513549089431763,\n", - "}\n", - "\n", - "mean_best_threshold = float(np.mean(list(seed_best_thresholds.values())))\n", - "search_radius = 0.15\n", - "num_thresholds = 400\n", - "baseline_thresholds = np.linspace(\n", - " mean_best_threshold - search_radius,\n", - " mean_best_threshold + search_radius,\n", - " num_thresholds,\n", - ")\n", - "\n", - "print(f\"[info] per-seed best thresholds: {seed_best_thresholds}\")\n", - "print(f\"[info] mean best threshold: {mean_best_threshold:.6f}\")\n", - "print(f\"[info] generating baseline roc curve with {len(baseline_thresholds)} thresholds in [{baseline_thresholds[0]:.6f}, {baseline_thresholds[-1]:.6f}]\")\n", - "\n", - "# k values to test for our method\n", - "k_values = list(range(1, 11)) # 1 to 10\n", - "print(f\"[info] testing k values: {k_values}\")\n" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 10, - "id": "f6128fef", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] computing baseline roc curves for all seeds...\n", - "\n", - "[info] processing test-son-seed-1...\n", - "[info] test-son-seed-1 baseline progress: 1/400\n", - "[info] test-son-seed-1 baseline progress: 21/400\n", - "[info] test-son-seed-1 baseline progress: 41/400\n", - "[info] test-son-seed-1 baseline progress: 61/400\n", - "[info] test-son-seed-1 baseline progress: 81/400\n", - "[info] test-son-seed-1 baseline progress: 101/400\n", - "[info] test-son-seed-1 baseline progress: 121/400\n", - "[info] test-son-seed-1 baseline progress: 141/400\n", - "[info] test-son-seed-1 baseline progress: 161/400\n", - "[info] test-son-seed-1 baseline progress: 181/400\n", - "[info] test-son-seed-1 baseline progress: 201/400\n", - "[info] test-son-seed-1 baseline progress: 221/400\n", - "[info] test-son-seed-1 baseline progress: 241/400\n", - "[info] test-son-seed-1 baseline progress: 261/400\n", - "[info] test-son-seed-1 baseline progress: 281/400\n", - "[info] test-son-seed-1 baseline progress: 301/400\n", - "[info] test-son-seed-1 baseline progress: 321/400\n", - "[info] test-son-seed-1 baseline progress: 341/400\n", - "[info] test-son-seed-1 baseline progress: 361/400\n", - "[info] test-son-seed-1 baseline progress: 381/400\n", - "[pass] test-son-seed-1 baseline complete - 400 points\n", - "\n", - "[info] processing test-son-seed-2...\n", - "[info] test-son-seed-2 baseline progress: 1/400\n", - "[info] test-son-seed-2 baseline progress: 21/400\n", - "[info] test-son-seed-2 baseline progress: 41/400\n", - "[info] test-son-seed-2 baseline progress: 61/400\n", - "[info] test-son-seed-2 baseline progress: 81/400\n", - "[info] test-son-seed-2 baseline progress: 101/400\n", - "[info] test-son-seed-2 baseline progress: 121/400\n", - "[info] test-son-seed-2 baseline progress: 141/400\n", - "[info] test-son-seed-2 baseline progress: 161/400\n", - "[info] test-son-seed-2 baseline progress: 181/400\n", - "[info] test-son-seed-2 baseline progress: 201/400\n", - "[info] test-son-seed-2 baseline progress: 221/400\n", - "[info] test-son-seed-2 baseline progress: 241/400\n", - "[info] test-son-seed-2 baseline progress: 261/400\n", - "[info] test-son-seed-2 baseline progress: 281/400\n", - "[info] test-son-seed-2 baseline progress: 301/400\n", - "[info] test-son-seed-2 baseline progress: 321/400\n", - "[info] test-son-seed-2 baseline progress: 341/400\n", - "[info] test-son-seed-2 baseline progress: 361/400\n", - "[info] test-son-seed-2 baseline progress: 381/400\n", - "[pass] test-son-seed-2 baseline complete - 400 points\n", - "\n", - "[info] processing test-son-seed-3...\n", - "[info] test-son-seed-3 baseline progress: 1/400\n", - "[info] test-son-seed-3 baseline progress: 21/400\n", - "[info] test-son-seed-3 baseline progress: 41/400\n", - "[info] test-son-seed-3 baseline progress: 61/400\n", - "[info] test-son-seed-3 baseline progress: 81/400\n", - "[info] test-son-seed-3 baseline progress: 101/400\n", - "[info] test-son-seed-3 baseline progress: 121/400\n", - "[info] test-son-seed-3 baseline progress: 141/400\n", - "[info] test-son-seed-3 baseline progress: 161/400\n", - "[info] test-son-seed-3 baseline progress: 181/400\n", - "[info] test-son-seed-3 baseline progress: 201/400\n", - "[info] test-son-seed-3 baseline progress: 221/400\n", - "[info] test-son-seed-3 baseline progress: 241/400\n", - "[info] test-son-seed-3 baseline progress: 261/400\n", - "[info] test-son-seed-3 baseline progress: 281/400\n", - "[info] test-son-seed-3 baseline progress: 301/400\n", - "[info] test-son-seed-3 baseline progress: 321/400\n", - "[info] test-son-seed-3 baseline progress: 341/400\n", - "[info] test-son-seed-3 baseline progress: 361/400\n", - "[info] test-son-seed-3 baseline progress: 381/400\n", - "[pass] test-son-seed-3 baseline complete - 400 points\n", - "\n", - "[info] processing test-son-seed-4...\n", - "[info] test-son-seed-4 baseline progress: 1/400\n", - "[info] test-son-seed-4 baseline progress: 21/400\n", - "[info] test-son-seed-4 baseline progress: 41/400\n", - "[info] test-son-seed-4 baseline progress: 61/400\n", - "[info] test-son-seed-4 baseline progress: 81/400\n", - "[info] test-son-seed-4 baseline progress: 101/400\n", - "[info] test-son-seed-4 baseline progress: 121/400\n", - "[info] test-son-seed-4 baseline progress: 141/400\n", - "[info] test-son-seed-4 baseline progress: 161/400\n", - "[info] test-son-seed-4 baseline progress: 181/400\n", - "[info] test-son-seed-4 baseline progress: 201/400\n", - "[info] test-son-seed-4 baseline progress: 221/400\n", - "[info] test-son-seed-4 baseline progress: 241/400\n", - "[info] test-son-seed-4 baseline progress: 261/400\n", - "[info] test-son-seed-4 baseline progress: 281/400\n", - "[info] test-son-seed-4 baseline progress: 301/400\n", - "[info] test-son-seed-4 baseline progress: 321/400\n", - "[info] test-son-seed-4 baseline progress: 341/400\n", - "[info] test-son-seed-4 baseline progress: 361/400\n", - "[info] test-son-seed-4 baseline progress: 381/400\n", - "[pass] test-son-seed-4 baseline complete - 400 points\n", - "\n", - "[info] processing test-son-seed-5...\n", - "[info] test-son-seed-5 baseline progress: 1/400\n", - "[info] test-son-seed-5 baseline progress: 21/400\n", - "[info] test-son-seed-5 baseline progress: 41/400\n", - "[info] test-son-seed-5 baseline progress: 61/400\n", - "[info] test-son-seed-5 baseline progress: 81/400\n", - "[info] test-son-seed-5 baseline progress: 101/400\n", - "[info] test-son-seed-5 baseline progress: 121/400\n", - "[info] test-son-seed-5 baseline progress: 141/400\n", - "[info] test-son-seed-5 baseline progress: 161/400\n", - "[info] test-son-seed-5 baseline progress: 181/400\n", - "[info] test-son-seed-5 baseline progress: 201/400\n", - "[info] test-son-seed-5 baseline progress: 221/400\n", - "[info] test-son-seed-5 baseline progress: 241/400\n", - "[info] test-son-seed-5 baseline progress: 261/400\n", - "[info] test-son-seed-5 baseline progress: 281/400\n", - "[info] test-son-seed-5 baseline progress: 301/400\n", - "[info] test-son-seed-5 baseline progress: 321/400\n", - "[info] test-son-seed-5 baseline progress: 341/400\n", - "[info] test-son-seed-5 baseline progress: 361/400\n", - "[info] test-son-seed-5 baseline progress: 381/400\n", - "[pass] test-son-seed-5 baseline complete - 400 points\n", - "\n", - "[pass] all baseline roc curves computed for 5 seeds\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "from convokit.decisionpolicy import ThresholdDecisionPolicy\n", - "from convokit.forecaster.forecaster import ContextTuple\n", - "\n", - "\n", - "def _cached_forecast_score(context):\n", - " meta = getattr(context.current_utterance, \"meta\", {}) or {}\n", - " if \"forecast_prob\" not in meta:\n", - " raise KeyError(f\"missing forecast_prob for utterance {context.current_utterance.id}\")\n", - " return meta[\"forecast_prob\"]\n", - "\n", - "\n", - "def _threshold_policy_performance(corpus, policy):\n", - " tp = fp = tn = fn = 0\n", - " horizons = []\n", - "\n", - " for convo in corpus.iter_conversations():\n", - " utts = convo.get_chronological_utterance_list()\n", - " pred = 0\n", - " first_trigger_idx = None\n", - "\n", - " for utt_idx, utt in enumerate(utts):\n", - " context = ContextTuple(\n", - " context=utts[: utt_idx + 1],\n", - " current_utterance=utt,\n", - " future_context=utts[utt_idx + 1 :],\n", - " conversation_id=convo.id,\n", - " )\n", - " _, utt_pred = policy.decide(context, _cached_forecast_score)\n", - " if int(utt_pred) == 1:\n", - " pred = 1\n", - " first_trigger_idx = utt_idx\n", - " break\n", - "\n", - " truth = bool(convo.meta.get(\"has_removed_comment\", False))\n", - " if pred and truth:\n", - " tp += 1\n", - " horizons.append(len(utts) - first_trigger_idx)\n", - " elif pred and not truth:\n", - " fp += 1\n", - " elif not pred and not truth:\n", - " tn += 1\n", - " else:\n", - " fn += 1\n", - "\n", - " h = float(np.mean(horizons)) - 1 if horizons else float(\"nan\")\n", - " return {\n", - " \"confusion_matrix\": {\"TP\": tp, \"FP\": fp, \"TN\": tn, \"FN\": fn},\n", - " \"h\": h,\n", - " }\n", - "\n", - "\n", - "# step 1: compute baseline roc curve with ThresholdDecisionPolicy\n", - "print(\"[info] computing baseline roc curves for all seeds...\")\n", - "all_baseline_results = {}\n", - "\n", - "for seed_name, corpus in corpora.items():\n", - " print(f\"\\n[info] processing {seed_name}...\")\n", - " baseline_results = []\n", - "\n", - " for i, threshold in enumerate(baseline_thresholds):\n", - " if i % 20 == 0:\n", - " print(f\"[info] {seed_name} baseline progress: {i+1}/{len(baseline_thresholds)}\")\n", - "\n", - " policy = ThresholdDecisionPolicy(threshold=threshold)\n", - " results = _threshold_policy_performance(corpus, policy)\n", - " tp = results[\"confusion_matrix\"][\"TP\"]\n", - " fp = results[\"confusion_matrix\"][\"FP\"]\n", - " tn = results[\"confusion_matrix\"][\"TN\"]\n", - " fn = results[\"confusion_matrix\"][\"FN\"]\n", - "\n", - " # calculate tpr, fpr, accuracy, precision, recall, f1\n", - " # recall == tpr; kept as a separate field for downstream readability\n", - " tpr = tp / (tp + fn) if (tp + fn) > 0 else 0\n", - " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0\n", - " total = tp + fp + tn + fn\n", - " accuracy = (tp + tn) / total if total > 0 else 0\n", - " precision = tp / (tp + fp) if (tp + fp) > 0 else 0\n", - " recall = tpr\n", - " f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n", - "\n", - " baseline_results.append({\n", - " \"seed\": seed_name,\n", - " \"threshold\": threshold,\n", - " \"tpr\": tpr,\n", - " \"fpr\": fpr,\n", - " \"accuracy\": accuracy,\n", - " \"precision\": precision,\n", - " \"recall\": recall,\n", - " \"f1\": f1,\n", - " \"h\": results.get(\"h\", float(\"nan\")),\n", - " \"tp\": tp,\n", - " \"fp\": fp,\n", - " \"tn\": tn,\n", - " \"fn\": fn,\n", - " })\n", - "\n", - " all_baseline_results[seed_name] = pd.DataFrame(baseline_results)\n", - " print(f\"[pass] {seed_name} baseline complete - {len(all_baseline_results[seed_name])} points\")\n", - "\n", - "print(f\"\\n[pass] all baseline roc curves computed for {len(all_baseline_results)} seeds\")\n" + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.963270963270963, Median = 2.0\n", + "Accuracy 0.70062\n", + "Precision 0.683886\n", + "Recall 0.746122\n", + "FPR 0.344881\n", + "F1 0.71365\n", + "Mean H 2.963271\n", + "Correct Adjustment 0.089969\n", + "Incorrect Adjustment 0.111427\n", + "Recovery -0.021458\n", + "Leaderboard String | MODEL_NAME | 70.1 | 68.4 | 74.6 | 71....\n", + "dtype: object\n", + "summarization complete.\n", + "Unsloth: If you want to finetune Gemma 2, install flash-attn to make it faster!\n", + "To install flash-attn, do the below:\n", + "\n", + "pip install --no-deps --upgrade \"flash-attn>=2.6.3\"\n", + "==((====))== Unsloth 2025.7.11: Fast Gemma2 patching. Transformers: 4.53.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", + "---\n", + "fitting policy ThresholdDecisionPolicy for seed 5\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:00, 46248.29it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7063, p=0.6973, r=0.7291, fpr=0.3164, f1=0.7128\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.819858156028369, Median = 2.0\n", + "Accuracy 0.706308\n", + "Precision 0.697329\n", + "Recall 0.729059\n", + "FPR 0.316443\n", + "F1 0.712841\n", + "Mean H 2.819858\n", + "Correct Adjustment 0.08273\n", + "Incorrect Adjustment 0.067735\n", + "Recovery 0.014995\n", + "Leaderboard String | MODEL_NAME | 70.6 | 69.7 | 72.9 | 71....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "fitting policy DeferralDecisionPolicy for seed 5\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4299.92it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7027, p=0.7253, r=0.6525, fpr=0.2472, f1=0.6870\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] }, { - "cell_type": "code", - "execution_count": 11, - "id": "022d240f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] all_baseline_results has been pickled to all_baseline_results.pkl\n" - ] - } - ], - "source": [ - "import pickle\n", - "\n", - "with open('all_baseline_results.pkl', 'wb') as f:\n", - " pickle.dump(all_baseline_results, f)\n", - "print(\"[info] all_baseline_results has been pickled to all_baseline_results.pkl\")" + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAASstJREFUeJzt3XdUFPf+PvBn6UgTRZoSsBCxIHZEjZpIxOiNJTGxELHFfGOMDXuKaIwCxhjjlaPRe6Pmd21JLNfEBDVEjFGsiBWxBMRCsYJoBGXfvz88zHWlru6y6Dyvc/bIfnb2M++ZnZl9nJ2iEREBERERkYqYmboAIiIiosrGAERERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKpjYeoCqiKtVosrV67AwcEBGo3G1OUQERFRBYgIbt++DU9PT5iZlb2PhwGoBFeuXIGXl5epyyAiIqIncPHiRdSpU6fMYRiASuDg4ADg4Qx0dHQ0cTVERERUEbm5ufDy8lK+x8tSJQJQTEwMvvjiC2RmZiIgIAD//Oc/0bZt2xKHXb58Ob777jucOHECANCqVSvMnTtXZ/ihQ4di1apVOu8LCQlBbGxsheop+tnL0dGRAYiIiOgZU5HDV0x+EPT69esRHh6OiIgIJCYmIiAgACEhIcjOzi5x+Pj4eAwcOBA7d+5EQkICvLy80K1bN1y+fFlnuO7duyMjI0N5rF27tjImh4iIiJ4BGlPfDDUwMBBt2rTB4sWLATw8ANnLywtjxozBtGnTyn1/YWEhnJ2dsXjxYoSFhQF4uAfo1q1b2Lx58xPVlJubCycnJ+Tk5HAPEBER0TNCn+9vk+4BKigowOHDhxEcHKy0mZmZITg4GAkJCRXq4+7du7h//z5q1Kih0x4fHw9XV1c0bNgQo0aNwvXr10vtIz8/H7m5uToPIiIien6ZNABdu3YNhYWFcHNz02l3c3NDZmZmhfqYOnUqPD09dUJU9+7d8d133yEuLg7R0dHYtWsXXnvtNRQWFpbYR2RkJJycnJQHzwAjIiJ6vlWJg6CfVFRUFNatW4f4+HjY2Ngo7QMGDFD+9vf3R7NmzVC/fn3Ex8eja9euxfqZPn06wsPDledFR5ETERHR88mke4BcXFxgbm6OrKwsnfasrCy4u7uX+d758+cjKioK27dvR7Nmzcoctl69enBxccG5c+dKfN3a2lo544tnfhERET3/TBqArKys0KpVK8TFxSltWq0WcXFxCAoKKvV98+bNw+zZsxEbG4vWrVuXO55Lly7h+vXr8PDwMEjdRERE9Gwz+Wnw4eHhWL58OVatWoXk5GSMGjUKd+7cwbBhwwAAYWFhmD59ujJ8dHQ0Pv30U3z77bfw8fFBZmYmMjMzkZeXBwDIy8vD5MmTsW/fPqSlpSEuLg69e/dGgwYNEBISYpJpJCIioqrF5McA9e/fH1evXsWMGTOQmZmJ5s2bIzY2VjkwOj09Xed+HkuWLEFBQQH69eun009ERARmzpwJc3NzHDt2DKtWrcKtW7fg6emJbt26Yfbs2bC2tq7UaSMiIqKqyeTXAaqKeB0gIiKiZ88zcx0gIiIiIlNgACIiIiLVYQAiIiIi1WEAIiIiItVhACIiIiLVMflp8GQ6PtO2mroERVpUT1OXQEREKsI9QERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6FqYuQI18pm01dQlERESqxj1AREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOlUiAMXExMDHxwc2NjYIDAzEgQMHSh12+fLleOmll+Ds7AxnZ2cEBwcXG15EMGPGDHh4eMDW1hbBwcE4e/assSeDiIiInhEmD0Dr169HeHg4IiIikJiYiICAAISEhCA7O7vE4ePj4zFw4EDs3LkTCQkJ8PLyQrdu3XD58mVlmHnz5mHRokVYunQp9u/fDzs7O4SEhODevXuVNVlERERUhWlERExZQGBgINq0aYPFixcDALRaLby8vDBmzBhMmzat3PcXFhbC2dkZixcvRlhYGEQEnp6emDhxIiZNmgQAyMnJgZubG1auXIkBAwaU22dubi6cnJyQk5MDR0fHp5vAEvhM22rwPp91aVE9TV0CERE94/T5/jbpHqCCggIcPnwYwcHBSpuZmRmCg4ORkJBQoT7u3r2L+/fvo0aNGgCA1NRUZGZm6vTp5OSEwMDAUvvMz89Hbm6uzoOIiIieXyYNQNeuXUNhYSHc3Nx02t3c3JCZmVmhPqZOnQpPT08l8BS9T58+IyMj4eTkpDy8vLz0nRQiIiJ6hpj8GKCnERUVhXXr1mHTpk2wsbF54n6mT5+OnJwc5XHx4kUDVklERERVjYUpR+7i4gJzc3NkZWXptGdlZcHd3b3M986fPx9RUVH47bff0KxZM6W96H1ZWVnw8PDQ6bN58+Yl9mVtbQ1ra+snnAoiIiJ61ph0D5CVlRVatWqFuLg4pU2r1SIuLg5BQUGlvm/evHmYPXs2YmNj0bp1a53X6tatC3d3d50+c3NzsX///jL7JCIiIvUw6R4gAAgPD8eQIUPQunVrtG3bFgsXLsSdO3cwbNgwAEBYWBhq166NyMhIAEB0dDRmzJiBNWvWwMfHRzmux97eHvb29tBoNBg/fjw+//xz+Pr6om7duvj000/h6emJPn36mGoyiYiIqAoxeQDq378/rl69ihkzZiAzMxPNmzdHbGyschBzeno6zMz+t6NqyZIlKCgoQL9+/XT6iYiIwMyZMwEAU6ZMwZ07d/Dee+/h1q1b6NixI2JjY5/qOCEiIiJ6fpj8OkBVEa8DVPl4HSAiInpaz8x1gIiIiIhMgQGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUR+8AtGrVKmzdulV5PmXKFFSvXh3t27fHhQsXDFocERERkTHoHYDmzp0LW1tbAEBCQgJiYmIwb948uLi4YMKECQYvkIiIiMjQLPR9w8WLF9GgQQMAwObNm/Hmm2/ivffeQ4cOHdClSxdD10dERERkcHrvAbK3t8f169cBANu3b8err74KALCxscHff/9t2OqIiIiIjEDvPUCvvvoq3n33XbRo0QJnzpxBjx49AAAnT56Ej4+PoesjIiIiMji99wDFxMQgKCgIV69exYYNG1CzZk0AwOHDhzFw4ECDF0hERERkaHrvAapevToWL15crH3WrFkGKYiIiIjI2PQOQABw69YtHDhwANnZ2dBqtUq7RqPB4MGDDVYcERERkTHoHYB++uknhIaGIi8vD46OjtBoNMprDEBERET0LND7GKCJEydi+PDhyMvLw61bt3Dz5k3lcePGDWPUSERERGRQegegy5cvY+zYsahWrZox6iEiIiIyOr0DUEhICA4dOmSMWoiIiIgqhd7HAPXs2ROTJ0/GqVOn4O/vD0tLS53Xe/XqZbDiiIiIiIxB7wA0cuRIAMBnn31W7DWNRoPCwsKnr4qIiIjIiPQOQI+e9k5ERET0LNL7GCAiIiKiZ90TBaBdu3bh9ddfR4MGDdCgQQP06tULu3fvNnRtREREREahdwD6z3/+g+DgYFSrVg1jx47F2LFjYWtri65du2LNmjXGqJGIiIjIoDQiIvq8oVGjRnjvvfcwYcIEnfYFCxZg+fLlSE5ONmiBppCbmwsnJyfk5OTA0dHR4P37TNtq8D6fdWlRPU1dAhERPeP0+f7Wew/QX3/9hddff71Ye69evZCamqpvd0RERESVTu8A5OXlhbi4uGLtv/32G7y8vAxSFBEREZEx6X0a/MSJEzF27FgkJSWhffv2AIA9e/Zg5cqV+Prrrw1eIBEREZGh6R2ARo0aBXd3d3z55Zf4/vvvATw8Lmj9+vXo3bu3wQskIiIiMjS9AxAA9O3bF3379jV0LURERESVghdCJCIiItWp0B6gGjVq4MyZM3BxcYGzszM0Gk2pw964ccNgxREREREZQ4UC0FdffQUHBwfl77ICEBEREVFVV6EANGTIEOXvoUOHGqsWIiIiokqh9zFA5ubmyM7OLtZ+/fp1mJubG6QoIiIiImPSOwCVdueM/Px8WFlZPXVBRERERMZW4dPgFy1aBADQaDT417/+BXt7e+W1wsJC/PHHH/Dz8zN8hUREREQGVuEA9NVXXwF4uAdo6dKlOj93WVlZwcfHB0uXLjV8hUREREQGVuEAVHSj05dffhkbN26Es7Oz0YoiIiIiMia9rwS9c+dOY9RBREREVGme6FYYly5dwpYtW5Ceno6CggKd1xYsWGCQwoiIiIiMRe8AFBcXh169eqFevXo4ffo0mjZtirS0NIgIWrZsaYwaiYiIiAxK79Pgp0+fjkmTJuH48eOwsbHBhg0bcPHiRXTu3BlvvfWWMWokIiIiMii9A1BycjLCwsIAABYWFvj7779hb2+Pzz77DNHR0QYvkIiIiMjQ9A5AdnZ2ynE/Hh4eOH/+vPLatWvXDFcZERERkZHofQxQu3bt8Oeff6JRo0bo0aMHJk6ciOPHj2Pjxo1o166dMWokIiIiMii9A9CCBQuQl5cHAJg1axby8vKwfv16+Pr68gwwIiIieiboHYDq1aun/G1nZ8erPxMREdEzR+9jgC5evIhLly4pzw8cOIDx48dj2bJlBi2MiIiIyFj0DkCDBg1SrgadmZmJ4OBgHDhwAB9//DE+++wzvQuIiYmBj48PbGxsEBgYiAMHDpQ67MmTJ/Hmm2/Cx8cHGo0GCxcuLDbMzJkzodFodB68SSsRERE9Su8AdOLECbRt2xYA8P3338Pf3x979+7F6tWrsXLlSr36Wr9+PcLDwxEREYHExEQEBAQgJCQE2dnZJQ5/9+5d1KtXD1FRUXB3dy+13yZNmiAjI0N5/Pnnn3rVRURERM83vQPQ/fv3YW1tDQD47bff0KtXLwCAn58fMjIy9OprwYIFGDlyJIYNG4bGjRtj6dKlqFatGr799tsSh2/Tpg2++OILDBgwQKmhJBYWFnB3d1ceLi4uZdaRn5+P3NxcnQcRERE9v/QOQE2aNMHSpUuxe/du7NixA927dwcAXLlyBTVr1qxwPwUFBTh8+DCCg4P/V4yZGYKDg5GQkKBvWTrOnj0LT09P1KtXD6GhoUhPTy9z+MjISDg5OSkPLy+vpxo/ERERVW16B6Do6Gh888036NKlCwYOHIiAgAAAwJYtW5Sfxiri2rVrKCwshJubm067m5sbMjMz9S1LERgYiJUrVyI2NhZLlixBamoqXnrpJdy+fbvU90yfPh05OTnK4+LFi088fiIiIqr69D4NvkuXLrh27Rpyc3Ph7OystL/33nuoVq2aQYt7Eq+99pryd7NmzRAYGAhvb298//33GDFiRInvsba2LvMnNSIiInq+6L0HCABEBIcPH8Y333yj7FmxsrLSKwC5uLjA3NwcWVlZOu1ZWVllHuCsr+rVq+PFF1/EuXPnDNYnERERPdv0DkAXLlyAv78/evfujdGjR+Pq1asAHv40NmnSpAr3Y2VlhVatWiEuLk5p02q1iIuLQ1BQkL5llSovLw/nz5+Hh4eHwfokIiKiZ5veAWjcuHFo3bo1bt68CVtbW6W9b9++OmGmIsLDw7F8+XKsWrUKycnJGDVqFO7cuYNhw4YBAMLCwjB9+nRl+IKCAiQlJSEpKQkFBQW4fPkykpKSdPbuTJo0Cbt27UJaWhr27t2Lvn37wtzcHAMHDtR3UomIiOg5pfcxQLt378bevXthZWWl0+7j44PLly/r1Vf//v1x9epVzJgxA5mZmWjevDliY2OVA6PT09NhZva/jHblyhW0aNFCeT5//nzMnz8fnTt3Rnx8PADg0qVLGDhwIK5fv45atWqhY8eO2LdvH2rVqqXvpBIREdFzSu8ApNVqUVhYWKz90qVLcHBw0LuADz/8EB9++GGJrxWFmiI+Pj4QkTL7W7dund41EBERkbro/RNYt27ddG5BodFokJeXh4iICPTo0cOQtREREREZhd57gL788kuEhISgcePGuHfvHgYNGoSzZ8/CxcUFa9euNUaNRERERAaldwCqU6cOjh49inXr1uHYsWPIy8vDiBEjEBoaqnNQNBEREVFVpXcAunfvHmxsbPDOO+8Yox4iIiIio9P7GCBXV1cMGTIEO3bsgFarNUZNREREREaldwBatWoV7t69i969e6N27doYP348Dh06ZIzaiIiIiIxC7wDUt29f/PDDD8jKysLcuXNx6tQptGvXDi+++CI+++wzY9RIREREZFBPdC8wAHBwcMCwYcOwfft2HDt2DHZ2dpg1a5YhayMiIiIyiicOQPfu3cP333+PPn36oGXLlrhx4wYmT55syNqIiIiIjELvs8C2bduGNWvWYPPmzbCwsEC/fv2wfft2dOrUyRj1ERERERmc3gGob9+++Mc//oHvvvsOPXr0gKWlpTHqIiIiIjIavQNQVlbWE93zi4iIiKiq0DsAOTg4QKvV4ty5c8jOzi52LSD+FEZERERVnd4BaN++fRg0aBAuXLhQ7M7sGo2mxDvFExEREVUlegeg999/H61bt8bWrVvh4eEBjUZjjLqIiIiIjEbvAHT27Fn8+OOPaNCggTHqISIiIjI6va8DFBgYiHPnzhmjFiIiIqJKofceoDFjxmDixInIzMyEv79/sdPgmzVrZrDiiIiIiIxB7wD05ptvAgCGDx+utGk0GogID4Km54LPtK2mLgEAkBbV09QlEBE9t/QOQKmpqcaog4iIiKjS6B2AvL29jVEHERERUaXROwABwPnz57Fw4UIkJycDABo3boxx48ahfv36Bi2OiIiIyBj0Pgts27ZtaNy4MQ4cOIBmzZqhWbNm2L9/P5o0aYIdO3YYo0YiIiIig9J7D9C0adMwYcIEREVFFWufOnUqXn31VYMVR0RERGQMeu8BSk5OxogRI4q1Dx8+HKdOnTJIUURERETGpHcAqlWrFpKSkoq1JyUlwdXV1RA1ERERERmV3j+BjRw5Eu+99x7++usvtG/fHgCwZ88eREdHIzw83OAFEhERERma3gHo008/hYODA7788ktMnz4dAODp6YmZM2di7NixBi+QiIiIyND0DkAajQYTJkzAhAkTcPv2bQCAg4ODwQsjIiIiMpYnuhL0gwcP4OvrqxN8zp49C0tLS/j4+BiyPiIiIiKD0/sg6KFDh2Lv3r3F2vfv34+hQ4caoiYiIiIio9I7AB05cgQdOnQo1t6uXbsSzw4jIiIiqmr0DkAajUY59udROTk5vBM8ERERPRP0DkCdOnVCZGSkTtgpLCxEZGQkOnbsaNDiiIiIiIxB74Ogo6Oj0alTJzRs2BAvvfQSAGD37t3Izc3F77//bvACiYiIiAxN7z1AjRs3xrFjx/D2228jOzsbt2/fRlhYGE6fPo2mTZsao0YiIiIig9J7DxDw8MKHc+fONXQtRERERJVC7z1ARERERM86BiAiIiJSHQYgIiIiUp0KBaAtW7bg/v37xq6FiIiIqFJU6CDovn37IjMzE7Vq1YK5uTkyMjLg6upq7NpIRXymbTV1CUREpCIV2gNUq1Yt7Nu3DwAgItBoNEYtioiIiMiYKrQH6P3330fv3r2h0Wig0Wjg7u5e6rC8HQYRERFVdRUKQDNnzsSAAQNw7tw59OrVCytWrED16tWNXBoRERGRcVT4Qoh+fn7w8/NDREQE3nrrLVSrVs2YdREREREZjd5Xgo6IiAAAXL16FSkpKQCAhg0bolatWoatjIiIiMhI9L4O0N27dzF8+HB4enqiU6dO6NSpEzw9PTFixAjcvXvXGDUSERERGZTeAWjChAnYtWsXtmzZglu3buHWrVv473//i127dmHixInGqJGIiIjIoPT+CWzDhg348ccf0aVLF6WtR48esLW1xdtvv40lS5YYsj4iIiIig3uin8Dc3NyKtbu6uvInMCIiInom6B2AgoKCEBERgXv37iltf//9N2bNmoWgoCCDFkdERERkDHr/BPb1118jJCQEderUQUBAAADg6NGjsLGxwbZt2wxeIBEREZGh6R2AmjZtirNnz2L16tU4ffo0AGDgwIEIDQ2Fra2twQskIiIiMjS9AxAAVKtWDSNHjjR0LURERESVQu9jgIiIiIiedQxAREREpDoMQERERKQ6DEBERESkOnoHoHr16uH69evF2m/duoV69eoZpCgiIiIiY9I7AKWlpaGwsLBYe35+Pi5fvmyQooiIiIiMqcKnwW/ZskX5e9u2bXByclKeFxYWIi4uDj4+PgYtjoiIiMgYKrwHqE+fPujTpw80Gg2GDBmiPO/Tpw8GDBiAHTt24Msvv9S7gJiYGPj4+MDGxgaBgYE4cOBAqcOePHkSb775Jnx8fKDRaLBw4cKn7pOIiIjUp8IBSKvVQqvV4oUXXkB2drbyXKvVIj8/HykpKfjHP/6h18jXr1+P8PBwREREIDExEQEBAQgJCUF2dnaJw9+9exf16tVDVFQU3N3dDdInERERqY9GRMRUIw8MDESbNm2wePFiAA9DlpeXF8aMGYNp06aV+V4fHx+MHz8e48ePf+o+8/PzkZ+frzzPzc2Fl5cXcnJy4Ojo+BRTWErt07YavE96/qRF9TR1CUREz5Tc3Fw4OTlV6Pv7iW6FERcXh7i4OGVP0KO+/fbbCvVRUFCAw4cPY/r06UqbmZkZgoODkZCQ8CRlPXGfkZGRmDVr1hONk4iIiJ49ep8FNmvWLHTr1g1xcXG4du0abt68qfOoqGvXrqGwsBBubm467W5ubsjMzNS3rKfqc/r06cjJyVEeFy9efKLxExER0bNB7z1AS5cuxcqVKzF48GBj1GMS1tbWsLa2NnUZREREVEn03gNUUFCA9u3bP/WIXVxcYG5ujqysLJ32rKysUg9wNkWfRERE9PzROwC9++67WLNmzVOP2MrKCq1atUJcXJzSptVqERcXh6CgoCrTJxERET1/9P4J7N69e1i2bBl+++03NGvWDJaWljqvL1iwoMJ9hYeHY8iQIWjdujXatm2LhQsX4s6dOxg2bBgAICwsDLVr10ZkZCSAh3ufTp06pfx9+fJlJCUlwd7eHg0aNKhQn0RERER6B6Bjx46hefPmAIATJ07ovKbRaPTqq3///rh69SpmzJiBzMxMNG/eHLGxscpBzOnp6TAz+99OqitXrqBFixbK8/nz52P+/Pno3Lkz4uPjK9QnERERkUmvA1RV6XMdgSfB6wBRRfA6QERE+tHn+1vvY4CKnDt3Dtu2bcPff/8NAGCOIiIiomeF3gHo+vXr6Nq1K1588UX06NEDGRkZAIARI0Zg4sSJBi+QiIiIyND0DkATJkyApaUl0tPTUa1aNaW9f//+iI2NNWhxRERERMag90HQ27dvx7Zt21CnTh2ddl9fX1y4cMFghREREREZi957gO7cuaOz56fIjRs3eDVlIiIieiboHYBeeuklfPfdd8pzjUYDrVaLefPm4eWXXzZocURERETGoPdPYPPmzUPXrl1x6NAhFBQUYMqUKTh58iRu3LiBPXv2GKNGIiIiIoPSew9Q06ZNcebMGXTs2BG9e/fGnTt38MYbb+DIkSOoX7++MWokIiIiMii99wABgJOTEz7++GND10JERERUKfTeA7RixQr88MMPxdp/+OEHrFq1yiBFERERERmT3gEoMjISLi4uxdpdXV0xd+5cgxRFREREZEx6B6D09HTUrVu3WLu3tzfS09MNUhQRERGRMekdgFxdXXHs2LFi7UePHkXNmjUNUhQRERGRMekdgAYOHIixY8di586dKCwsRGFhIX7//XeMGzcOAwYMMEaNRERERAal91lgs2fPRlpaGrp27QoLi4dv12q1CAsL4zFARERE9EzQKwCJCDIzM7Fy5Up8/vnnSEpKgq2tLfz9/eHt7W2sGomIiIgMSu8A1KBBA5w8eRK+vr7w9fU1Vl1ERERERqPXMUBmZmbw9fXF9evXjVUPERERkdHpfRB0VFQUJk+ejBMnThijHiIiIiKj0/sg6LCwMNy9excBAQGwsrKCra2tzus3btwwWHFERERExqB3AFq4cKERyiAiIiKqPHoHoCFDhhijDiIiIqJKo/cxQABw/vx5fPLJJxg4cCCys7MBAL/++itOnjxp0OKIiIiIjEHvALRr1y74+/tj//792LhxI/Ly8gA8vBVGRESEwQskIiIiMjS9A9C0adPw+eefY8eOHbCyslLaX3nlFezbt8+gxREREREZg94B6Pjx4+jbt2+xdldXV1y7ds0gRREREREZk94BqHr16sjIyCjWfuTIEdSuXdsgRREREREZk94BaMCAAZg6dSoyMzOh0Wig1WqxZ88eTJo0CWFhYcaokYiIiMig9A5Ac+fOhZ+fH7y8vJCXl4fGjRujU6dOaN++PT755BNj1EhERERkUHpfB8jKygrLly/HjBkzcPz4ceTl5aFFixa8MSoRERE9MyocgLRaLb744gts2bIFBQUF6Nq1KyIiIordCoOIiIioqqvwT2Bz5szBRx99BHt7e9SuXRtff/01Ro8ebczaiIiIiIxCIyJSkQF9fX0xadIk/N///R8A4LfffkPPnj3x999/w8zsiS4oXWXl5ubCyckJOTk5cHR0NHj/PtO2GrxPImNKi+pp6hKIiMqlz/d3hZNLeno6evTooTwPDg6GRqPBlStXnrxSIiIiIhOocAB68OABbGxsdNosLS1x//59gxdFREREZEwVPghaRDB06FBYW1srbffu3cP7778POzs7pW3jxo2GrZCIiIjIwCocgIYMGVKs7Z133jFoMURERESVocIBaMWKFcasg4iIiKjSPF+nbxERERFVAAMQERERqQ4DEBEREamO3vcCIyL1qUoX7+RFGYnIELgHiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVIcBiIiIiFSHAYiIiIhUhwGIiIiIVMfC1AUQEenDZ9pWU5cAAEiL6mnqEojoKXAPEBEREakOAxARERGpDgMQERERqU6VCEAxMTHw8fGBjY0NAgMDceDAgTKH/+GHH+Dn5wcbGxv4+/vjl19+0Xl96NCh0Gg0Oo/u3bsbcxKIiIjoGWLyALR+/XqEh4cjIiICiYmJCAgIQEhICLKzs0scfu/evRg4cCBGjBiBI0eOoE+fPujTpw9OnDihM1z37t2RkZGhPNauXVsZk0NERETPAJMHoAULFmDkyJEYNmwYGjdujKVLl6JatWr49ttvSxz+66+/Rvfu3TF58mQ0atQIs2fPRsuWLbF48WKd4aytreHu7q48nJ2dK2NyiIiI6Blg0gBUUFCAw4cPIzg4WGkzMzNDcHAwEhISSnxPQkKCzvAAEBISUmz4+Ph4uLq6omHDhhg1ahSuX79eah35+fnIzc3VeRAREdHzy6QB6Nq1aygsLISbm5tOu5ubGzIzM0t8T2ZmZrnDd+/eHd999x3i4uIQHR2NXbt24bXXXkNhYWGJfUZGRsLJyUl5eHl5PeWUERERUVX2XF4IccCAAcrf/v7+aNasGerXr4/4+Hh07dq12PDTp09HeHi48jw3N5chiIiI6Dlm0j1ALi4uMDc3R1ZWlk57VlYW3N3dS3yPu7u7XsMDQL169eDi4oJz586V+Lq1tTUcHR11HkRERPT8MmkAsrKyQqtWrRAXF6e0abVaxMXFISgoqMT3BAUF6QwPADt27Ch1eAC4dOkSrl+/Dg8PD8MUTkRERM80k58FFh4ejuXLl2PVqlVITk7GqFGjcOfOHQwbNgwAEBYWhunTpyvDjxs3DrGxsfjyyy9x+vRpzJw5E4cOHcKHH34IAMjLy8PkyZOxb98+pKWlIS4uDr1790aDBg0QEhJikmkkIiKiqsXkxwD1798fV69exYwZM5CZmYnmzZsjNjZWOdA5PT0dZmb/y2nt27fHmjVr8Mknn+Cjjz6Cr68vNm/ejKZNmwIAzM3NcezYMaxatQq3bt2Cp6cnunXrhtmzZ8Pa2tok00hERERVi0ZExNRFVDW5ublwcnJCTk6OUY4Hqip3syaiJ8e7wRNVPfp8f5v8JzAiIiKiysYARERERKrDAERERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKrDAERERESqwwBEREREqsMARERERKrDAERERESqY2HqAoiInkU+07aaugRFWlRPU5dA9MzhHiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdngZPRPSM4yn5RPrjHiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdBiAiIiJSHQYgIiIiUh0GICIiIlIdC1MXQEREZGg+07aaugRFWlRPU5dAJeAeICIiIlId7gEiIiKDqUp7XojKwj1AREREpDoMQERERKQ6DEBERESkOgxAREREpDoMQERERKQ6DEBERESkOgxAREREpDq8DhAREZERVaVrI/Gq1P/DAERERKQSVSWMVYUgxp/AiIiISHUYgIiIiEh1GICIiIhIdRiAiIiISHUYgIiIiEh1GICIiIhIdapEAIqJiYGPjw9sbGwQGBiIAwcOlDn8Dz/8AD8/P9jY2MDf3x+//PKLzusighkzZsDDwwO2trYIDg7G2bNnjTkJRERE9AwxeQBav349wsPDERERgcTERAQEBCAkJATZ2dklDr93714MHDgQI0aMwJEjR9CnTx/06dMHJ06cUIaZN28eFi1ahKVLl2L//v2ws7NDSEgI7t27V1mTRURERFWYRkTElAUEBgaiTZs2WLx4MQBAq9XCy8sLY8aMwbRp04oN379/f9y5cwc///yz0tauXTs0b94cS5cuhYjA09MTEydOxKRJkwAAOTk5cHNzw8qVKzFgwIBya8rNzYWTkxNycnLg6OhooCn9n6pyISoiIiJTMNaFEPX5/jbplaALCgpw+PBhTJ8+XWkzMzNDcHAwEhISSnxPQkICwsPDddpCQkKwefNmAEBqaioyMzMRHBysvO7k5ITAwEAkJCSUGIDy8/ORn5+vPM/JyQHwcEYagzb/rlH6JSIiehYY6/u1qN+K7NsxaQC6du0aCgsL4ebmptPu5uaG06dPl/iezMzMEofPzMxUXi9qK22Yx0VGRmLWrFnF2r28vCo2IURERFRhTguN2//t27fh5ORU5jC8FxiA6dOn6+xV0mq1uHHjBmrWrAmNRmPCyownNzcXXl5euHjxolF+5ntWcb4Ux3lSHOdJyThfiuM8Kc6Y80REcPv2bXh6epY7rEkDkIuLC8zNzZGVlaXTnpWVBXd39xLf4+7uXubwRf9mZWXBw8NDZ5jmzZuX2Ke1tTWsra112qpXr67PpDyzHB0duVKWgPOlOM6T4jhPSsb5UhznSXHGmifl7fkpYtKzwKysrNCqVSvExcUpbVqtFnFxcQgKCirxPUFBQTrDA8COHTuU4evWrQt3d3edYXJzc7F///5S+yQiIiJ1MflPYOHh4RgyZAhat26Ntm3bYuHChbhz5w6GDRsGAAgLC0Pt2rURGRkJABg3bhw6d+6ML7/8Ej179sS6detw6NAhLFu2DACg0Wgwfvx4fP755/D19UXdunXx6aefwtPTE3369DHVZBIREVEVYvIA1L9/f1y9ehUzZsxAZmYmmjdvjtjYWOUg5vT0dJiZ/W9HVfv27bFmzRp88skn+Oijj+Dr64vNmzejadOmyjBTpkzBnTt38N577+HWrVvo2LEjYmNjYWNjU+nTV1VZW1sjIiKi2E9/asf5UhznSXGcJyXjfCmO86S4qjJPTH4dICIiIqLKZvIrQRMRERFVNgYgIiIiUh0GICIiIlIdBiAiIiJSHQYglYmMjESbNm3g4OAAV1dX9OnTBykpKaYuq0qJiopSLqegdpcvX8Y777yDmjVrwtbWFv7+/jh06JCpyzKZwsJCfPrpp6hbty5sbW1Rv359zJ49u0L3HXpe/PHHH3j99dfh6ekJjUaj3IexiIhgxowZ8PDwgK2tLYKDg3H27FnTFFuJypov9+/fx9SpU+Hv7w87Ozt4enoiLCwMV65cMV3BlaC8ZeVR77//PjQaDRYuXFhp9TEAqcyuXbswevRo7Nu3Dzt27MD9+/fRrVs33Llzx9SlVQkHDx7EN998g2bNmpm6FJO7efMmOnToAEtLS/z66684deoUvvzySzg7O5u6NJOJjo7GkiVLsHjxYiQnJyM6Ohrz5s3DP//5T1OXVmnu3LmDgIAAxMTElPj6vHnzsGjRIixduhT79++HnZ0dQkJCcO/evUqutHKVNV/u3r2LxMREfPrpp0hMTMTGjRuRkpKCXr16maDSylPeslJk06ZN2LdvX4VuX2FQQqqWnZ0tAGTXrl2mLsXkbt++Lb6+vrJjxw7p3LmzjBs3ztQlmdTUqVOlY8eOpi6jSunZs6cMHz5cp+2NN96Q0NBQE1VkWgBk06ZNynOtVivu7u7yxRdfKG23bt0Sa2trWbt2rQkqNI3H50tJDhw4IADkwoULlVOUiZU2Ty5duiS1a9eWEydOiLe3t3z11VeVVhP3AKlcTk4OAKBGjRomrsT0Ro8ejZ49eyI4ONjUpVQJW7ZsQevWrfHWW2/B1dUVLVq0wPLly01dlkm1b98ecXFxOHPmDADg6NGj+PPPP/Haa6+ZuLKqITU1FZmZmTrrkJOTEwIDA5GQkGDCyqqenJwcaDQa1dx3siRarRaDBw/G5MmT0aRJk0ofv8mvBE2mo9VqMX78eHTo0EHnStpqtG7dOiQmJuLgwYOmLqXK+Ouvv7BkyRKEh4fjo48+wsGDBzF27FhYWVlhyJAhpi7PJKZNm4bc3Fz4+fnB3NwchYWFmDNnDkJDQ01dWpWQmZkJAMqV/Iu4ubkprxFw7949TJ06FQMHDlT1DVKjo6NhYWGBsWPHmmT8DEAqNnr0aJw4cQJ//vmnqUsxqYsXL2LcuHHYsWMHb5fyCK1Wi9atW2Pu3LkAgBYtWuDEiRNYunSpagPQ999/j9WrV2PNmjVo0qQJkpKSMH78eHh6eqp2npB+7t+/j7fffhsigiVLlpi6HJM5fPgwvv76ayQmJkKj0ZikBv4EplIffvghfv75Z+zcuRN16tQxdTkmdfjwYWRnZ6Nly5awsLCAhYUFdu3ahUWLFsHCwgKFhYWmLtEkPDw80LhxY522Ro0aIT093UQVmd7kyZMxbdo0DBgwAP7+/hg8eDAmTJig3KxZ7dzd3QEAWVlZOu1ZWVnKa2pWFH4uXLiAHTt2qHrvz+7du5GdnY0XXnhB2e5euHABEydOhI+PT6XUwD1AKiMiGDNmDDZt2oT4+HjUrVvX1CWZXNeuXXH8+HGdtmHDhsHPzw9Tp06Fubm5iSozrQ4dOhS7RMKZM2fg7e1toopM7+7duzo3ZwYAc3NzaLVaE1VUtdStWxfu7u6Ii4tD8+bNAQC5ubnYv38/Ro0aZdriTKwo/Jw9exY7d+5EzZo1TV2SSQ0ePLjY8ZYhISEYPHgwhg0bVik1MACpzOjRo7FmzRr897//hYODg/K7vJOTE2xtbU1cnWk4ODgUOwbKzs4ONWvWVPWxURMmTED79u0xd+5cvP322zhw4ACWLVuGZcuWmbo0k3n99dcxZ84cvPDCC2jSpAmOHDmCBQsWYPjw4aYurdLk5eXh3LlzyvPU1FQkJSWhRo0aeOGFFzB+/Hh8/vnn8PX1Rd26dfHpp5/C09MTffr0MV3RlaCs+eLh4YF+/fohMTERP//8MwoLC5Vtb40aNWBlZWWqso2qvGXl8RBoaWkJd3d3NGzYsHIKrLTzzahKAFDiY8WKFaYurUrhafAP/fTTT9K0aVOxtrYWPz8/WbZsmalLMqnc3FwZN26cvPDCC2JjYyP16tWTjz/+WPLz801dWqXZuXNniduQIUOGiMjDU+E//fRTcXNzE2tra+nataukpKSYtuhKUNZ8SU1NLXXbu3PnTlOXbjTlLSuPq+zT4DUiKrqEKRERERF4EDQRERGpEAMQERERqQ4DEBEREakOAxARERGpDgMQERERqQ4DEBEREakOAxARERGpDgMQERERqc5zFYDS0tKg0WiQlJRk6lIUp0+fRrt27WBjY6PcG4ee3sqVK1G9enVTl2FSGo0Gmzdvfqo+qsp8rMh6IiJ47733UKNGDWU979KlC8aPH1+ptRrL0KFDy71dRHx8PDQaDW7dumXUWvbs2QN/f39YWlo+97ewMCZTfidVZHkqz927d/Hmm2/C0dGxUpa7ymbQADR06FBoNBpERUXptG/evNlkt7s3tYiICNjZ2SElJQVxcXGmLqdKqCpfuoBhQoSpZGRk4LXXXjN1GQZRkfUkNjYWK1euxM8//4yMjAw0bdoUGzduxOzZs59q3FVlGfj666+xcuVK5XlJ4a59+/bIyMiAk5OTUWsJDw9H8+bNkZqaqlPTs6YqbWueRatWrcLu3buxd+/eSlnuKpvB9wDZ2NggOjoaN2/eNHTXJlNQUPDE7z1//jw6duwIb29v1d/9lwzL3d0d1tbWpi7DICqynpw/fx4eHh5o37493N3dYWFhgRo1asDBwaHUfp9m3a1sTk5O5X5ZW1lZwd3d3ej/oTx//jxeeeUV1KlT54kDxLM076lk58+fR6NGjdC0adNKWe4qU0FBgWFvhjpkyBD5xz/+IX5+fjJ58mSlfdOmTYJHRhURESEBAQE67/3qq6/E29tbp6/evXvLnDlzxNXVVZycnGTWrFly//59mTRpkjg7O0vt2rXl22+/Vd5TdMO5tWvXSlBQkFhbW0uTJk0kPj5eZ1zHjx+X7t27i52dnbi6uso777wjV69eVV7v3LmzjB49WsaNGyc1a9aULl26lDi9hYWFMmvWLKldu7ZYWVlJQECA/Prrr8rreOwGcBEREaX2Ex0dLfXr1xcrKyvx8vKSzz//XHn92LFj8vLLL4uNjY3UqFFDRo4cKbdv3zbIvFq/fr107NhRbGxspHXr1pKSkiIHDhyQVq1aiZ2dnXTv3l2ys7N16l2+fLn4+fmJtbW1NGzYUGJiYor1u2HDBunSpYvY2tpKs2bNZO/evSJS8s3xiuZLTEyMNGjQQKytrcXV1VXefPPNEueXiMiKFSvEyclJNm3apLynW7dukp6erjPc5s2bpUWLFmJtbS1169aVmTNnyv3790Xk4Y33Hq3D29tbbt26JWZmZnLw4EHls3F2dpbAwEClz//3//6f1KlTR3menp4ub731ljg5OYmzs7P06tVLUlNTDTbPSgNANm3apFcfK1asEC8vL7G1tZU+ffrI/PnzxcnJqcLzbNasWeLh4SHXrl1Thu/Ro4d06dJFCgsLS6zTEOvJkCFDin1WIsVvWuvt7S2fffaZDB48WBwcHGTIkCGSn58vo0ePFnd3d7G2tpYXXnhB5s6dqwxfUr+Pq+i2JT4+Xtq0aSNWVlbi7u4uU6dOVeadiMgPP/wgTZs2Vdblrl27Sl5enjKNvXv3LnF6AUhqaqqy/ty8eVNycnLExsZGfvnlF50aNm7cKPb29nLnzh0Rqdjy+fh0PvooulFyedNW2nazvO1tedu/KVOmiK+vr9ja2krdunXlk08+kYKCAuX1pKQk6dKli9jb24uDg4O0bNlSDh48WOa25nHnzp2TXr16iaurq9jZ2Unr1q1lx44dOsN4e3vLnDlzZNiwYWJvby9eXl7yzTff6Ayzf/9+ad68uVhbW0urVq1k48aNAkCOHDlS4nhFRO7duycTJ04UT09PqVatmrRt21bnBqlF27rY2Fjx8/MTOzs7CQkJkStXrijDPHjwQCZMmCBOTk5So0YNmTx5soSFhSnLU2l+/PFHady4sVhZWYm3t7fMnz9fea1z5846865z586l9rNlyxZp3bq1WFtbS82aNaVPnz7Kazdu3JDBgwdL9erVxdbWVrp37y5nzpyp8PRt27ZNrK2t5ebNmzrjHDt2rLz88svK8927dyvfZXXq1JExY8Yo65ZIydsGgweg3r17y8aNG8XGxkYuXrwoIk8egBwcHGT06NFy+vRp+fe//y0AJCQkRObMmSNnzpyR2bNni6WlpTKeopW3Tp068uOPP8qpU6fk3XffFQcHB2WDffPmTalVq5ZMnz5dkpOTJTExUV599VWdGdm5c2ext7eXyZMny+nTp+X06dMlTu+CBQvE0dFR1q5dK6dPn5YpU6aIpaWl8uFmZGRIkyZNZOLEiZKRkaETWh41ZcoUcXZ2lpUrV8q5c+dk9+7dsnz5chERycvLEw8PD3njjTfk+PHjEhcXJ3Xr1tW5m+7TzCs/Pz+JjY2VU6dOSbt27aRVq1bSpUsX+fPPPyUxMVEaNGgg77//vjKu//znP+Lh4SEbNmyQv/76SzZs2CA1atSQlStXFuv3559/lpSUFOnXr594e3vL/fv3JT8/XxYuXCiOjo6SkZGhzJeDBw+Kubm5rFmzRtLS0iQxMVG+/vrrkhc0ebjSWFpaSuvWrWXv3r1y6NAhadu2rbRv314Z5o8//hBHR0dZuXKlnD9/XrZv3y4+Pj4yc+ZMERHJzs5WNvAZGRlK0GvZsqV88cUXIvJw41qjRg2xsrJSPr93331XQkNDRUSkoKBAGjVqJMOHD5djx47JqVOnZNCgQdKwYUPlDuFPO89KU1IAKquPffv2iZmZmURHR0tKSop8/fXXUr16dZ0AVN48e/DggQQFBSkbuMWLF0v16tXlwoULpdZpiPXk1q1b8tlnn0mdOnV0PquSApCjo6PMnz9fzp07J+fOnZMvvvhCvLy85I8//pC0tDTZvXu3rFmzpsxl4HEV2bZcunRJqlWrJh988IEkJyfLpk2bxMXFRfnSvXLlilhYWMiCBQskNTVVjh07JjExMcr0PhqAbt26JUFBQTJy5EhlPXnw4IFOABIR6devn7zzzjs6tb755ptKW0WWz0c9ePBAMjIyxNHRURYuXCgZGRly9+7dcqet6LN4fLtZke1tWds/EZHZs2fLnj17JDU1VbZs2SJubm4SHR2tvN6kSRN55513JDk5Wc6cOSPff/+9JCUllbqtKUlSUpIsXbpUjh8/LmfOnJFPPvlEbGxsdJZrb29vqVGjhsTExMjZs2clMjJSzMzMlO+H27dvS61atWTQoEFy4sQJ+emnn6RevXrlBqB3331X2rdvL3/88YeyvFpbWyvrR9G2Ljg4WA4ePCiHDx+WRo0ayaBBg5Q+oqOjxdnZWTZs2CCnTp2SESNGiIODQ5kB6NChQ2JmZiafffaZpKSkyIoVK8TW1lYJvNevX5eRI0dKUFCQZGRkyPXr10vs5+effxZzc3OZMWOGnDp1SpKSkpT/YIiI9OrVSxo1aiR//PGHJCUlSUhIiDRo0EAJseVN34MHD8TNzU3+9a9/KX0+3nbu3Dmxs7OTr776Ss6cOSN79uyRFi1ayNChQ3U+v8e3DUYJQCIi7dq1k+HDh4vIkwcgb29vnf9VNmzYUF566SXl+YMHD8TOzk7Wrl0rIv/bSEVFRSnD3L9/X+rUqaOsMLNnz5Zu3brpjPvixYsCQFJSUkTk4YrcokWLcqfX09NT5syZo9PWpk0b+eCDD5TnAQEBpf6vQ0QkNzdXrK2tdVb4Ry1btkycnZ11kuzWrVvFzMxMMjMzReTp5tWjC9XatWsFgMTFxSltkZGR0rBhQ+V5/fr1lS+PIrNnz5agoKBS+z158qQAkOTkZBH5X+J/1IYNG8TR0VFyc3NLnVePWrFihQCQffv2KW3JyckCQPbv3y8iIl27dtVZEUUe7r3x8PBQnj8aIoqEh4dLz549RURk4cKF0r9/f529Fg0aNJBly5Yp/TVs2FC0Wq3y/vz8fLG1tZVt27aJiGHmWUlKCkBl9TFw4EDp0aOHTh/9+/fX+SwqMs/Onz8vDg4OMnXqVLG1tZXVq1eXWqOIYdYTkeLbCJGSA9Cj//sUERkzZoy88sorOp/Ro0paBh5XkW3LRx99VGxZiImJEXt7eyksLJTDhw8LAElLSytxHI9uP0uaNhEpFoA2bdqks7enaK9Q0bJakeWzJE5OTsoXYUWmrajex7eb5W1vy9v+leSLL76QVq1aKc8dHByU/0w8rqRtTUU1adJE/vnPfyrPvb29dcKmVqsVV1dXWbJkiYiIfPPNN1KzZk35+++/lWGWLFlSZgC6cOGCmJuby+XLl3Xau3btKtOnT1emAYCcO3dOeT0mJkbc3NyU5x4eHjJv3jzledGyWVYAGjRokLz66qs6bZMnT5bGjRsrz8eNG1fmnh8RkaCgIOU/hI87c+aMAJA9e/YobdeuXRNbW1v5/vvvKzx948aNk1deeUV5/vheoREjRsh7772nM+7du3eLmZmZ8nmUtG0w2llg0dHRWLVqFZKTk5+4jyZNmsDM7H8lurm5wd/fX3lubm6OmjVrIjs7W+d9QUFByt8WFhZo3bq1UsfRo0exc+dO2NvbKw8/Pz8AD3/vLNKqVasya8vNzcWVK1fQoUMHnfYOHTroNc3JycnIz89H165dS309ICAAdnZ2OuPQarVISUlR2p50XjVr1kznPQB03ufm5qa8586dOzh//jxGjBihM/8+//xznXn3eL8eHh4AUGzcj3r11Vfh7e2NevXqYfDgwVi9ejXu3r1b6vDAw8+2TZs2ynM/Pz9Ur15d57P+7LPPdGodOXIkMjIyyuy7c+fO+PPPP1FYWIhdu3ahS5cu6NKlC+Lj43HlyhWcO3cOXbp0UcZx7tw5ODg4KOOoUaMG7t27h/Pnzxt1npWkrD6Sk5MRGBioM/yj60pF51m9evUwf/58REdHo1evXhg0aFCp9RhqPdFH69atdZ4PHToUSUlJaNiwIcaOHYvt27c/cd9lbVuSk5MRFBSkc5xEhw4dkJeXh0uXLiEgIABdu3aFv78/3nrrLSxfvvypj5Xs0aMHLC0tsWXLFgDAhg0b4OjoiODgYADlL58VVd60FXl8u1ne9ra87R8ArF+/Hh06dIC7uzvs7e3xySefID09XXk9PDwc7777LoKDgxEVFaXXdBXJy8vDpEmT0KhRI1SvXh329vZITk7WGQ+gu35pNBq4u7vrrF/NmjWDjY2NMszj69fjjh8/jsLCQrz44os682jXrl0601GtWjXUr19fee7h4aGMNycnBxkZGTrrdtGyWZbk5OQS18uzZ8+isLCwzPc+KikpqczvLwsLC53aatasiYYNG+qs/2VNHwCEhoYq218AWL16NXr27Kkcn3b06FGsXLlSZx6GhIRAq9UiNTVV6efxeWJR4anUU6dOnRASEoLp06dj6NChOq+ZmZlBRHTa7t+/X6wPS0tLnecajabENq1WW+G68vLy8PrrryM6OrrYa0VfGAB0Aocx2draGqSfJ51Xjw5TtHF7vK3oPXl5eQCA5cuXF/siNTc3L7ffsj4nBwcHJCYmIj4+Htu3b8eMGTMwc+ZMHDx48IkPwszLy8OsWbPwxhtvFHvt0Y3U4zp16oTbt28jMTERf/zxB+bOnQt3d3dERUUhICAAnp6e8PX1VcbRqlUrrF69ulg/tWrVMuo8K8nT9lHRefbHH3/A3NwcaWlpePDgASwsjLYp0dvj627Lli2RmpqKX3/9Fb/99hvefvttBAcH48cff6zUuszNzbFjxw7s3bsX27dvxz//+U98/PHH2L9/P+rWrftEfVpZWaFfv35Ys2YNBgwYgDVr1qB///7K51He8mloj8/78ra3f/31V5n9JSQkIDQ0FLNmzUJISAicnJywbt06fPnll8owM2fOxKBBg7B161b8+uuviIiIwLp169C3b98K1z1p0iTs2LED8+fPR4MGDWBra4t+/foVO5D7ab9/HpeXlwdzc3McPny42PbA3t6+zPE+/h1qKob4Ditv+tq0aYP69etj3bp1GDVqFDZt2qRzdmJeXh7+7//+D2PHji3W9wsvvKD8/fjyadTrAEVFReGnn35CQkKCTnutWrWQmZmpM4GGvE7Cvn37lL8fPHiAw4cPo1GjRgAebgxPnjwJHx8fNGjQQOehT+hxdHSEp6cn9uzZo9O+Z88eNG7cuML9+Pr6wtbWttRTfxs1aoSjR4/izp07OuMwMzNDw4YNKzweQ3Bzc4Onpyf++uuvYvNOnw24lZVVif/DsLCwQHBwMObNm4djx44hLS0Nv//+e6n9PHjwAIcOHVKep6Sk4NatWzqfdUpKSrFaGzRooOwts7S0LFZL9erV0axZMyxevBiWlpbw8/NDp06dcOTIEfz888/o3LmzMmzLli1x9uxZuLq6FhuHk5OTweaZITRq1Aj79+/XaXt0XQEqNs/Wr1+PjRs3Ij4+Hunp6WWehm6o9eRpOTo6on///li+fDnWr1+PDRs24MaNGwBKXgZKU9a2pVGjRkhISNDZru3ZswcODg6oU6cOgIcb9g4dOmDWrFk4cuQIrKyssGnTphLHVdp68rjQ0FDExsbi5MmT+P333xEaGqq8Vt7yWVEVmbaSlLe9LW/7t3fvXnh7e+Pjjz9G69at4evriwsXLhQb7sUXX8SECROwfft2vPHGG1ixYgWAis/DPXv2YOjQoejbty/8/f3h7u6OtLS0ct/3qEaNGuHYsWO4d++e0vb4+vW4Fi1aoLCwENnZ2cXmj7u7e4XG6+TkBA8PD511u2jZLK/ektbLF198sVgYK0uzZs3K/P568OCBTm3Xr19HSkqK3ut/aGgoVq9ejZ9++glmZmbo2bOn8lrLli1x6tSpErdbVlZWpfZp1ADk7++P0NBQLFq0SKe9S5cuuHr1KubNm4fz588jJiYGv/76q8HGGxMTg02bNuH06dMYPXo0bt68ieHDhwMARo8ejRs3bmDgwIE4ePAgzp8/j23btmHYsGF67fYDgMmTJyM6Ohrr169HSkoKpk2bhqSkJIwbN67CfdjY2GDq1KmYMmUKvvvuO5w/fx779u3Dv//9bwAPP3QbGxsMGTIEJ06cwM6dOzFmzBgMHjxY+cmqMs2aNQuRkZFYtGgRzpw5g+PHj2PFihVYsGBBhfvw8fFBXl4e4uLicO3aNdy9exc///wzFi1ahKSkJFy4cAHfffcdtFptmSHP0tISY8aMwf79+3H48GEMHToU7dq1Q9u2bQEAM2bMwHfffYdZs2bh5MmTSE5Oxrp16/DJJ5/o1BIXF4fMzEydnyO6dOmC1atXK2GnRo0aaNSoEdavX68TgEJDQ+Hi4oLevXtj9+7dSE1NRXx8PMaOHav8NGCIeWYIY8eORWxsLObPn4+zZ89i8eLFiI2N1RmmvHl26dIljBo1CtHR0ejYsSNWrFiBuXPnlrmhN8R68jQWLFiAtWvX4vTp0zhz5gx++OEHuLu7K3sWS1sGSlLWtuWDDz7AxYsXMWbMGJw+fRr//e9/ERERgfDwcJiZmWH//v2YO3cuDh06hPT0dGzcuBFXr15VAtTjfHx8sH//fqSlpeHatWul7mno1KkT3N3dERoairp16+rsaazI8lkR5U1bacrb3pa3/fP19UV6ejrWrVuH8+fPY9GiRTqB8e+//8aHH36I+Ph4XLhwAXv27MHBgweVeVrStqYkvr6+2LhxI5KSknD06FEMGjRI7z07gwYNgkajwciRI3Hq1Cn88ssvmD9/fpnvefHFFxEaGoqwsDBs3LgRqampOHDgACIjI7F169YKj3vcuHGIiorC5s2bcfr0aXzwwQflXrRw4sSJiIuLw+zZs3HmzBmsWrUKixcvxqRJkyo8XuDhNbzWrl2LiIgIJCcn4/jx48oeP19fX/Tu3RsjR47En3/+iaNHj+Kdd95B7dq10bt3b73GExoaisTERMyZMwf9+vXTuQTI1KlTsXfvXnz44YdISkrC2bNn8d///hcffvhh2Z2WeXSTnh4/iE/k4cGDVlZW8violixZIl5eXmJnZydhYWEyZ86cEk+Df1RJBwV6e3vLV199pYwLgKxZs0batm0rVlZW0rhxY/n999913nPmzBnp27evclqen5+fjB8/XjnAr6TxlKSwsFBmzpwptWvXFktLy2Kn94pU7ODOwsJC+fzzz8Xb21ssLS11TtMVqfhp8E8yrx49OO/xAyxFSj6IcPXq1dK8eXOxsrISZ2dn6dSpk2zcuLHUfm/evCkAdE7tfP/996VmzZrKqam7d++Wzp07i7Ozs3IK9/r160udZ0V1bdiwQerVqyfW1tYSHBxc7Gyk2NhYad++vdja2oqjo6O0bdtWOYBZ5OHpmw0aNBALCwud5a/owP2iAxxFHh6IB6DYWYEZGRkSFhYmLi4uYm1tLfXq1ZORI0dKTk6OQefZ41DCQdDl9fHvf/9b6tSpI7a2tvL666+XeBp8afNMq9VK165dJSQkROdg2DFjxkj9+vVLPcPGUOtJRQ+CLlrGiyxbtkyaN28udnZ24ujoKF27dpXExETl9dKWgUdVdNtS1qnip06dkpCQEKlVq5ZYW1vLiy++qHOQ7ePrcUpKirRr105sbW1LPA3+UVOmTBEAMmPGjGK1V2T5fNzjB0GXN20ipW83y9velrf9mzx5stSsWVPs7e2lf//+8tVXXynLbH5+vgwYMEC8vLzEyspKPD095cMPP9Q5EPnxbU1JUlNT5eWXXxZbW1vx8vKSxYsXV2jZeny5TUhIkICAALGyspLmzZvLhg0byj0LrKCgQGbMmCE+Pj5iaWkpHh4e0rdvXzl27JiIlLwNfvzEovv378u4cePE0dFRqlevLuHh4XqdBl8034vOfi1SkYOgRR6exFK0fXNxcZE33nhDea3oNHgnJyextbWVkJCQEk+DL2v6irRt21YAFFvvREQOHDggr776qtjb24udnZ00a9ZM5+SLkj4/jUgV+SGRiKiKSktLQ926dXHkyBHe0oboOfFc3QuMiIiIqCIYgIiIiEh1+BMYERERqQ73ABEREZHqMAARERGR6jAAERERkeowABEREZHqMAARERGR6jAAERERkeowABEREZHqMAARERGR6vx/kSph76nkLV8AAAAASUVORK5CYII=", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 8, - "id": "aa6450a5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "[info] processing test-son-seed-1...\n", - "[info] config seed: seed-1\n", - "[info] k method threshold 0.5926666259765625\n", - "[info] test-son-seed-1 computing k=1...\n", - "[info] test-son-seed-1 computing k=2...\n", - "[info] test-son-seed-1 computing k=3...\n", - "[info] test-son-seed-1 computing k=4...\n", - "[info] test-son-seed-1 computing k=5...\n", - "[info] test-son-seed-1 computing k=6...\n", - "[info] test-son-seed-1 computing k=7...\n", - "[info] test-son-seed-1 computing k=8...\n", - "[info] test-son-seed-1 computing k=9...\n", - "[info] test-son-seed-1 computing k=10...\n", - "[pass] test-son-seed-1 k-method complete - 10 points\n", - "\n", - "[info] processing test-son-seed-2...\n", - "[info] config seed: seed-2\n", - "[info] k method threshold 0.622459352016449\n", - "[info] test-son-seed-2 computing k=1...\n", - "[info] test-son-seed-2 computing k=2...\n", - "[info] test-son-seed-2 computing k=3...\n", - "[info] test-son-seed-2 computing k=4...\n", - "[info] test-son-seed-2 computing k=5...\n", - "[info] test-son-seed-2 computing k=6...\n", - "[info] test-son-seed-2 computing k=7...\n", - "[info] test-son-seed-2 computing k=8...\n", - "[info] test-son-seed-2 computing k=9...\n", - "[info] test-son-seed-2 computing k=10...\n", - "[pass] test-son-seed-2 k-method complete - 10 points\n", - "\n", - "[info] processing test-son-seed-3...\n", - "[info] config seed: seed-3\n", - "[info] k method threshold 0.6513549089431763\n", - "[info] test-son-seed-3 computing k=1...\n", - "[info] test-son-seed-3 computing k=2...\n", - "[info] test-son-seed-3 computing k=3...\n", - "[info] test-son-seed-3 computing k=4...\n", - "[info] test-son-seed-3 computing k=5...\n", - "[info] test-son-seed-3 computing k=6...\n", - "[info] test-son-seed-3 computing k=7...\n", - "[info] test-son-seed-3 computing k=8...\n", - "[info] test-son-seed-3 computing k=9...\n", - "[info] test-son-seed-3 computing k=10...\n", - "[pass] test-son-seed-3 k-method complete - 10 points\n", - "\n", - "[info] processing test-son-seed-4...\n", - "[info] config seed: seed-4\n", - "[info] k method threshold 0.6513549089431763\n", - "[info] test-son-seed-4 computing k=1...\n", - "[info] test-son-seed-4 computing k=2...\n", - "[info] test-son-seed-4 computing k=3...\n", - "[info] test-son-seed-4 computing k=4...\n", - "[info] test-son-seed-4 computing k=5...\n", - "[info] test-son-seed-4 computing k=6...\n", - "[info] test-son-seed-4 computing k=7...\n", - "[info] test-son-seed-4 computing k=8...\n", - "[info] test-son-seed-4 computing k=9...\n", - "[info] test-son-seed-4 computing k=10...\n", - "[pass] test-son-seed-4 k-method complete - 10 points\n", - "\n", - "[info] processing test-son-seed-5...\n", - "[info] config seed: seed-5\n", - "[info] k method threshold 0.6513549089431763\n", - "[info] test-son-seed-5 computing k=1...\n", - "[info] test-son-seed-5 computing k=2...\n", - "[info] test-son-seed-5 computing k=3...\n", - "[info] test-son-seed-5 computing k=4...\n", - "[info] test-son-seed-5 computing k=5...\n", - "[info] test-son-seed-5 computing k=6...\n", - "[info] test-son-seed-5 computing k=7...\n", - "[info] test-son-seed-5 computing k=8...\n", - "[info] test-son-seed-5 computing k=9...\n", - "[info] test-son-seed-5 computing k=10...\n", - "[pass] test-son-seed-5 k-method complete - 10 points\n", - "\n", - "[pass] all k-method results computed for 5 seeds\n" - ] - } - ], - "source": [ - "import json\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "from convokit.decisionpolicy import DeferralDecisionPolicy\n", - "from convokit.forecaster.forecaster import ContextTuple\n", - "\n", - "\n", - "def _cached_forecast_score(context):\n", - " meta = getattr(context.current_utterance, \"meta\", {}) or {}\n", - " if \"forecast_prob\" not in meta:\n", - " raise KeyError(f\"missing forecast_prob for utterance {context.current_utterance.id}\")\n", - " return meta[\"forecast_prob\"]\n", - "\n", - "\n", - "def _deferral_policy_performance(corpus, policy):\n", - " tp = fp = tn = fn = 0\n", - " horizons = []\n", - "\n", - " for convo in corpus.iter_conversations():\n", - " utts = convo.get_chronological_utterance_list()\n", - " pred = 0\n", - " first_trigger_idx = None\n", - "\n", - " for utt_idx, utt in enumerate(utts):\n", - " context = ContextTuple(\n", - " context=utts[: utt_idx + 1],\n", - " current_utterance=utt,\n", - " future_context=utts[utt_idx + 1 :],\n", - " conversation_id=convo.id,\n", - " )\n", - " result = policy.decide(context, _cached_forecast_score)\n", - " utt_pred = int(result[1])\n", - " if utt_pred == 1:\n", - " pred = 1\n", - " first_trigger_idx = utt_idx\n", - " break\n", - "\n", - " truth = bool(convo.meta.get(\"has_removed_comment\", False))\n", - " if pred and truth:\n", - " tp += 1\n", - " horizons.append(len(utts) - first_trigger_idx)\n", - " elif pred and not truth:\n", - " fp += 1\n", - " elif not pred and not truth:\n", - " tn += 1\n", - " else:\n", - " fn += 1\n", - "\n", - " h = float(np.mean(horizons)) - 1 if horizons else float(\"nan\")\n", - " return {\n", - " \"confusion_matrix\": {\"TP\": tp, \"FP\": fp, \"TN\": tn, \"FN\": fn},\n", - " \"h\": h,\n", - " }\n", - "\n", - "\n", - "all_k_results = {}\n", - "\n", - "for seed_name, corpus in corpora.items():\n", - " print(f\"\\n[info] processing {seed_name}...\")\n", - " k_results = []\n", - "\n", - " pruned_seed_name = seed_name[len(seed_name) - 6 :]\n", - " print(f\"[info] config seed: {pruned_seed_name}\")\n", - "\n", - " with open(f\"/reef/sqt2/FinalAAO/cga-cmv-large/google/gemma-2-9b-it/{pruned_seed_name}/dev_config.json\", \"r\") as f:\n", - " dev_config = json.load(f)\n", - "\n", - " k_method_threshold = dev_config[\"best_threshold\"]\n", - " print(\"[info] k method threshold\", k_method_threshold)\n", - "\n", - " for k in k_values:\n", - " print(f\"[info] {seed_name} computing k={k}...\")\n", - " policy = DeferralDecisionPolicy(\n", - " simulator=None,\n", - " threshold=k_method_threshold,\n", - " tau=k,\n", - " num_simulations=10,\n", - " store_simulations=False,\n", - " simulated_reply_attribute_name=\"sim_replies\",\n", - " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", - " reuse_cached_simulations=True,\n", - " )\n", - " results = _deferral_policy_performance(corpus, policy)\n", - " tp = results[\"confusion_matrix\"][\"TP\"]\n", - " fp = results[\"confusion_matrix\"][\"FP\"]\n", - " tn = results[\"confusion_matrix\"][\"TN\"]\n", - " fn = results[\"confusion_matrix\"][\"FN\"]\n", - "\n", - " # calculate tpr, fpr, accuracy, precision, recall, f1\n", - " # recall == tpr; kept as a separate field for downstream readability\n", - " tpr = tp / (tp + fn) if (tp + fn) > 0 else 0\n", - " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0\n", - " total = tp + fp + tn + fn\n", - " accuracy = (tp + tn) / total if total > 0 else 0\n", - " precision = tp / (tp + fp) if (tp + fp) > 0 else 0\n", - " recall = tpr\n", - " f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n", - "\n", - " k_results.append({\n", - " \"seed\": seed_name,\n", - " \"k\": k,\n", - " \"threshold\": k_method_threshold,\n", - " \"tpr\": tpr,\n", - " \"fpr\": fpr,\n", - " \"accuracy\": accuracy,\n", - " \"precision\": precision,\n", - " \"recall\": recall,\n", - " \"f1\": f1,\n", - " \"h\": results.get(\"h\", float(\"nan\")),\n", - " \"tp\": tp,\n", - " \"fp\": fp,\n", - " \"tn\": tn,\n", - " \"fn\": fn,\n", - " })\n", - "\n", - " all_k_results[seed_name] = pd.DataFrame(k_results)\n", - " print(f\"[pass] {seed_name} k-method complete - {len(all_k_results[seed_name])} points\")\n", - "\n", - "print(f\"\\n[pass] all k-method results computed for {len(all_k_results)} seeds\")\n" + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.713153724247227, Median = 2.0\n", + "Accuracy 0.702689\n", + "Precision 0.725287\n", + "Recall 0.652534\n", + "FPR 0.247156\n", + "F1 0.68699\n", + "Mean H 2.713154\n", + "Correct Adjustment 0.067994\n", + "Incorrect Adjustment 0.074974\n", + "Recovery -0.00698\n", + "Leaderboard String | MODEL_NAME | 70.3 | 72.5 | 65.3 | 68....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "[info] summarize only: RandomDeferralDecisionPolicy seed 5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.6946386946386944, Median = 2.0\n", + "Accuracy 0.690021\n", + "Precision 0.699837\n", + "Recall 0.66546\n", + "FPR 0.285419\n", + "F1 0.682216\n", + "Mean H 2.694639\n", + "Correct Adjustment 0.085315\n", + "Incorrect Adjustment 0.109359\n", + "Recovery -0.024043\n", + "Leaderboard String | MODEL_NAME | 69.0 | 70.0 | 66.5 | 68....\n", + "dtype: object\n", + "---\n", + "fitting policy SimulationAverageDecisionPolicy for seed 5\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4304.83it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": 13, - "id": "bba8d667", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] matching fprs for all seeds...\n", - "\n", - "[info] matching fprs for test-son-seed-1...\n", - "[PASS] test-son-seed-1 matched 10 fpr points\n", - "\n", - "[info] matching fprs for test-son-seed-2...\n", - "[PASS] test-son-seed-2 matched 10 fpr points\n", - "\n", - "[info] matching fprs for test-son-seed-3...\n", - "[PASS] test-son-seed-3 matched 10 fpr points\n", - "\n", - "[info] matching fprs for test-son-seed-4...\n", - "[PASS] test-son-seed-4 matched 10 fpr points\n", - "\n", - "[info] matching fprs for test-son-seed-5...\n", - "[PASS] test-son-seed-5 matched 10 fpr points\n", - "\n", - "[PASS] all matching complete for 5 seeds\n" - ] - } - ], - "source": [ - "# step 3: for each k's FPR, find the closest baseline FPR (per seed)\n", - "print(\"[info] matching fprs for all seeds...\")\n", - "all_matched_results = {}\n", - "\n", - "for seed_name in corpora.keys():\n", - " print(f\"\\n[info] matching fprs for {seed_name}...\")\n", - " matched_results = []\n", - " \n", - " k_df = all_k_results[seed_name]\n", - " baseline_df = all_baseline_results[seed_name]\n", - " \n", - " for _, k_row in k_df.iterrows():\n", - " k_fpr = k_row['fpr']\n", - " k_tpr = k_row['tpr']\n", - " k_val = k_row['k']\n", - " \n", - " # find closest baseline fpr\n", - " fpr_diffs = np.abs(baseline_df['fpr'] - k_fpr)\n", - " closest_idx = fpr_diffs.idxmin()\n", - " baseline_match = baseline_df.iloc[closest_idx]\n", - " \n", - " matched_results.append({\n", - " 'seed': seed_name,\n", - " 'k': k_val,\n", - " 'k_fpr': k_fpr,\n", - " 'k_tpr': k_tpr,\n", - " 'baseline_fpr': baseline_match['fpr'],\n", - " 'baseline_tpr': baseline_match['tpr'],\n", - " 'baseline_accuracy': baseline_match['accuracy'],\n", - " 'baseline_precision': baseline_match['precision'],\n", - " 'baseline_recall': baseline_match['recall'],\n", - " 'baseline_f1': baseline_match['f1'],\n", - " 'baseline_h': baseline_match['h'],\n", - " 'baseline_threshold': baseline_match['threshold'],\n", - " 'fpr_diff': abs(k_fpr - baseline_match['fpr']),\n", - " 'tpr_improvement': k_tpr - baseline_match['tpr']\n", - " })\n", - " \n", - " all_matched_results[seed_name] = pd.DataFrame(matched_results)\n", - " print(f\"[PASS] {seed_name} matched {len(all_matched_results[seed_name])} fpr points\")\n", - "\n", - "print(f\"\\n[PASS] all matching complete for {len(all_matched_results)} seeds\")\n" + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.7042, p=0.6934, r=0.7322, fpr=0.3237, f1=0.7123\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.9491525423728815, Median = 2.0\n", + "Accuracy 0.70424\n", + "Precision 0.693438\n", + "Recall 0.732161\n", + "FPR 0.323681\n", + "F1 0.712274\n", + "Mean H 2.949153\n", + "Correct Adjustment 0.088159\n", + "Incorrect Adjustment 0.111427\n", + "Recovery -0.023268\n", + "Leaderboard String | MODEL_NAME | 70.4 | 69.3 | 73.2 | 71....\n", + "dtype: object\n", + "summarization complete.\n", + "---\n", + "fitting policy SimulationMajorityDecisionPolicy for seed 5\n", + "starting transformation.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "22864it [00:05, 4225.02it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": 18, - "id": "95588d73", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] matched fpr-oracle metrics for tau=7 (mean ± std over seeds, n=5):\n", - " tau baseline_accuracy_mean baseline_accuracy_std baseline_precision_mean baseline_precision_std baseline_recall_mean baseline_recall_std baseline_f1_mean baseline_f1_std baseline_h_mean baseline_h_std fpr_diff_mean fpr_diff_std tpr_improvement_mean tpr_improvement_std baseline_threshold_mean baseline_threshold_std baseline_fpr_mean baseline_fpr_std baseline_tpr_mean baseline_tpr_std\n", - " 7 0.7002 0.0088 0.7152 0.0100 0.6677 0.0494 0.6896 0.0218 2.6965 0.1029 0.0036 0.0028 0.0155 0.0055 0.6900 0.0245 0.2674 0.0331 0.6677 0.0494\n" - ] - } - ], - "source": [ - "# average matched-baseline (oracle) metrics for tau=7, across all seeds\n", - "target_tau = 7\n", - "matched_long = pd.concat(\n", - " [df.assign(seed=seed_name) for seed_name, df in all_matched_results.items()],\n", - " ignore_index=True,\n", - ")\n", - "matched_long = matched_long[matched_long[\"k\"] == target_tau].copy()\n", - "\n", - "if matched_long.empty:\n", - " raise ValueError(f\"no matched results found for tau={target_tau}\")\n", - "\n", - "oracle_cols = [\n", - " \"baseline_accuracy\",\n", - " \"baseline_precision\",\n", - " \"baseline_recall\",\n", - " \"baseline_f1\",\n", - " \"baseline_h\",\n", - " \"fpr_diff\",\n", - " \"tpr_improvement\",\n", - " \"baseline_threshold\",\n", - " \"baseline_fpr\",\n", - " \"baseline_tpr\",\n", - "]\n", - "\n", - "oracle_stats_per_tau = (\n", - " matched_long.groupby(\"k\")[oracle_cols]\n", - " .agg([\"mean\", \"std\"])\n", - " .reset_index()\n", - " .rename(columns={\"k\": \"tau\"})\n", - ")\n", - "\n", - "# reformat columns to single-level, e.g. baseline_fpr_mean\n", - "oracle_stats_per_tau.columns = [\"tau\"] + [\n", - " f\"{col}_{stat}\" for col in oracle_cols for stat in [\"mean\", \"std\"]\n", - "]\n", - "\n", - "with pd.option_context(\n", - " \"display.float_format\",\n", - " \"{:.4f}\".format,\n", - " \"display.max_columns\",\n", - " None,\n", - " \"display.width\",\n", - " 200,\n", - "):\n", - " print(\"[info] matched fpr-oracle metrics for tau=7 \"\n", - " f\"(mean ± std over seeds, n={matched_long['seed'].nunique()}):\")\n", - " print(oracle_stats_per_tau.to_string(index=False))" + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] final transform metrics: processed_contexts=22864, conversations=3868, acc=0.6996, p=0.6883, r=0.7296, fpr=0.3304, f1=0.7083\n", + "transformation complete.\n", + "corpus dumped.\n", + "starting summarization.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 2.966690290574061, Median = 2.0\n", + "Accuracy 0.699586\n", + "Precision 0.688293\n", + "Recall 0.729576\n", + "FPR 0.330403\n", + "F1 0.708333\n", + "Mean H 2.96669\n", + "Correct Adjustment 0.090486\n", + "Incorrect Adjustment 0.112203\n", + "Recovery -0.021717\n", + "Leaderboard String | MODEL_NAME | 70.0 | 68.8 | 73.0 | 70....\n", + "dtype: object\n", + "summarization complete.\n" + ] + } + ], + "source": [ + "for seed_idx in SEEDS:\n", + " config = TransformerForecasterConfig(\n", + " output_dir=f\"outputs/{OUTPUT_DIR}/forecaster_{seed_idx}\",\n", + " per_device_batch_size=16,\n", + " gradient_accumulation_steps=1,\n", + " num_train_epochs=1,\n", + " learning_rate=1e-5,\n", + " random_seed=seed_idx,\n", + " context_mode=\"normal\",\n", + " device=\"cuda\",\n", + " )\n", + "\n", + " # TODO this will have to be edited\n", + " forecaster_model = TransformerDecoderModel(\n", + " model_name_or_path=\"google/gemma-2-9b-it\",\n", + " config=config,\n", + " )\n", + "\n", + " forecaster = Forecaster(\n", + " forecaster_model=forecaster_model,\n", + " labeler='has_removed_comment',\n", + " )\n", + "\n", + " # remove training---we can instead use the cached forecast probabilities.\n", + "\n", + " # ---\n", + " cfg_path = os.path.join(repo_root, \"saves\", f\"seed-{seed_idx}\", \"dev_config.json\")\n", + " if seed_idx == 1:\n", + " best_threshold = 0.5926666259765625\n", + " elif seed_idx == 2:\n", + " best_threshold = 0.622459352016449\n", + " elif seed_idx == 3:\n", + " best_threshold = 0.6513549089431763\n", + " elif seed_idx == 4:\n", + " best_threshold = 0.6513549089431763\n", + " elif seed_idx == 5:\n", + " best_threshold = 0.6513549089431763\n", + " \n", + " for policy_trial in [ThresholdDecisionPolicy, DeferralDecisionPolicy, RandomDeferralDecisionPolicy, SimulationAverageDecisionPolicy, SimulationMajorityDecisionPolicy]:\n", + " corpus_name = f\"seed-{seed_idx}-{policy_trial.__name__}\"\n", + " if corpus_name in corpora_all:\n", + " corpus = corpora_all[corpus_name]\n", + " else:\n", + " raise KeyError(f\"missing corpus {corpus_name}\")\n", + "\n", + " if policy_trial == RandomDeferralDecisionPolicy:\n", + " # bundled corpus already has forecast/forecast_prob; re-transform would redraw np.random.\n", + " print('---')\n", + " print(f\"[info] summarize only: {policy_trial.__name__} seed {seed_idx}\")\n", + " def summarize_selector(convo):\n", + " return convo.meta.get(\"split\") == \"test\"\n", + " conversational_forecasts_df, metrics = forecaster.summarize(\n", + " corpus=corpus,\n", + " selector=summarize_selector,\n", + " )\n", + " seed_folder = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + " os.makedirs(seed_folder, exist_ok=True)\n", + " conversational_forecasts_df.to_csv(\n", + " os.path.join(seed_folder, \"conversational_forecasts.csv\"), index=False\n", + " )\n", + " with open(os.path.join(seed_folder, \"metrics.json\"), \"w\") as f:\n", + " json.dump(metrics, f, indent=2)\n", + " continue\n", + "\n", + " print('---')\n", + " print(f\"fitting policy {policy_trial.__name__} for seed {seed_idx}\")\n", + " if policy_trial == ThresholdDecisionPolicy:\n", + " policy = ThresholdDecisionPolicy(\n", + " threshold=best_threshold,\n", + " )\n", + " elif policy_trial == DeferralDecisionPolicy:\n", + " policy = DeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " tau=TAU,\n", + " )\n", + " elif policy_trial == SimulationAverageDecisionPolicy:\n", + " policy = SimulationAverageDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " num_simulations=NUM_SIMULATIONS,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " )\n", + " elif policy_trial == SimulationMajorityDecisionPolicy:\n", + " policy = SimulationMajorityDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " tau=5,\n", + " num_simulations=NUM_SIMULATIONS,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " )\n", + " \n", + " # attach the decision policy to the underlying forecaster model;\n", + " # Forecaster itself does not accept decision_policy in its constructor.\n", + " forecaster_model.decision_policy = policy\n", + "\n", + " forecaster = Forecaster(\n", + " forecaster_model=forecaster_model,\n", + " labeler='has_removed_comment',\n", + " )\n", + "\n", + " print('starting transformation.')\n", + " # evaluate the forecaster on the test set\n", + " forecaster.transform(\n", + " corpus=corpus,\n", + " context_selector=make_data_selector('test'),\n", + " verbose=False,\n", + " )\n", + " print('transformation complete.')\n", + "\n", + " output_dir = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + " os.makedirs(output_dir, exist_ok=True)\n", + " corpus.dump(name=f\"{policy_trial.__name__}\", base_path=output_dir)\n", + " print('corpus dumped.')\n", + "\n", + " print('starting summarization.')\n", + " # forecaster.summarize expects a conversation-level selector (Callable[[Conversation], bool]),\n", + " # unlike the context-tuple selectors used in fit/transform.\n", + " def summarize_selector(convo):\n", + " return convo.meta.get(\"split\") == \"test\"\n", + " conversational_forecasts_df, metrics = forecaster.summarize(\n", + " corpus=corpus,\n", + " selector=summarize_selector,\n", + " )\n", + " print('summarization complete.')\n", + " \n", + " # path to the seed output directory\n", + " seed_folder = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + "\n", + " # ensure the directory exists\n", + " os.makedirs(seed_folder, exist_ok=True)\n", + "\n", + " # save conversational_forecasts_df as CSV\n", + " conversational_forecasts_df.to_csv(os.path.join(seed_folder, \"conversational_forecasts.csv\"), index=False)\n", + "\n", + " # save metrics as JSON\n", + " with open(os.path.join(seed_folder, \"metrics.json\"), \"w\") as f:\n", + " json.dump(metrics, f, indent=2)\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "46fb43be", + "metadata": {}, + "source": [ + "Below is a script to retrain forecasters and regenerating simulations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dde130ed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset already exists at /reef/lyk25/ConvoKit/examples/forecaster/conversations-gone-awry-cmv-corpus-large\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[14], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m seed_idx \u001b[38;5;129;01min\u001b[39;00m SEEDS:\n\u001b[0;32m----> 2\u001b[0m train_corpus \u001b[38;5;241m=\u001b[39m \u001b[43mCorpus\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdownload\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mconversations-gone-awry-cmv-corpus-large\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# corpus = Corpus(filename=f'/reef/lyk25/theres-a-way-out-ACL26-internal/outputs/benchmark_preannotated/seed-{seed_idx}-ThresholdDecisionPolicy/ThresholdDecisionPolicy')\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# corpus = Corpus(filename=f'/reef/lyk25/dynamic_training/game_analysis/corpi/test/test-son-seed-{seed_idx}')\u001b[39;00m\n\u001b[1;32m 5\u001b[0m corpus \u001b[38;5;241m=\u001b[39m Corpus(filename\u001b[38;5;241m=\u001b[39mdownload(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mconversations-gone-awry-cmv-corpus-large\u001b[39m\u001b[38;5;124m'\u001b[39m))\n", + "File \u001b[0;32m/reef/lyk25/ConvoKit/convokit/model/corpus.py:206\u001b[0m, in \u001b[0;36mCorpus.__init__\u001b[0;34m(self, filename, utterances, db_collection_prefix, db_host, preload_vectors, utterance_start_index, utterance_end_index, merge_lines, exclude_utterance_meta, exclude_conversation_meta, exclude_speaker_meta, exclude_overall_meta, disable_type_check, backend, backend_mapper)\u001b[0m\n\u001b[1;32m 203\u001b[0m \u001b[38;5;66;03m# if corpus is nonempty (check for self.utterances), construct the conversation\u001b[39;00m\n\u001b[1;32m 204\u001b[0m \u001b[38;5;66;03m# data from the utterance list\u001b[39;00m\n\u001b[1;32m 205\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutterances\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m--> 206\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconversations \u001b[38;5;241m=\u001b[39m \u001b[43minitialize_conversations\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 207\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconvos_data\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfill_missing_convo_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\n\u001b[1;32m 208\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmeta_index\u001b[38;5;241m.\u001b[39menable_type_check()\n\u001b[1;32m 210\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mupdate_speakers_data()\n", + "File \u001b[0;32m/reef/lyk25/ConvoKit/convokit/model/corpus_helpers.py:485\u001b[0m, in \u001b[0;36minitialize_conversations\u001b[0;34m(corpus, convos_data, convo_to_utts, fill_missing_convo_ids)\u001b[0m\n\u001b[1;32m 477\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 478\u001b[0m \u001b[38;5;124;03mInitialize Conversation objects from utterances and conversations data.\u001b[39;00m\n\u001b[1;32m 479\u001b[0m \u001b[38;5;124;03mIf a mapping from Conversation IDs to their constituent Utterance IDs is\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 482\u001b[0m \u001b[38;5;124;03mwill be computed by iteration over the Utterances in utt_dict.\u001b[39;00m\n\u001b[1;32m 483\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 484\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m fill_missing_convo_ids:\n\u001b[0;32m--> 485\u001b[0m \u001b[43mfill_missing_conversation_ids\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcorpus\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mutterances\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 487\u001b[0m \u001b[38;5;66;03m# organize utterances by conversation\u001b[39;00m\n\u001b[1;32m 488\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m convo_to_utts \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m/reef/lyk25/ConvoKit/convokit/model/corpus_helpers.py:439\u001b[0m, in \u001b[0;36mfill_missing_conversation_ids\u001b[0;34m(utterances_dict)\u001b[0m\n\u001b[1;32m 437\u001b[0m convo_roots_with_convo_ids\u001b[38;5;241m.\u001b[39mappend(utt\u001b[38;5;241m.\u001b[39mid)\n\u001b[1;32m 438\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 439\u001b[0m utt_ids_to_replier_ids[utt\u001b[38;5;241m.\u001b[39mreply_to]\u001b[38;5;241m.\u001b[39mappend(\u001b[43mutt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mid\u001b[49m)\n\u001b[1;32m 441\u001b[0m \u001b[38;5;66;03m# connect the reply-to edges for convo roots without convo ids\u001b[39;00m\n\u001b[1;32m 442\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m root_utt_id \u001b[38;5;129;01min\u001b[39;00m convo_roots_without_convo_ids:\n", + "File \u001b[0;32m/reef/lyk25/ConvoKit/convokit/model/corpusComponent.py:87\u001b[0m, in \u001b[0;36mCorpusComponent.get_id\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 84\u001b[0m ck_meta[key] \u001b[38;5;241m=\u001b[39m value\n\u001b[1;32m 85\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ck_meta\n\u001b[0;32m---> 87\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mget_id\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 88\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_id\n\u001b[1;32m 90\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mset_id\u001b[39m(\u001b[38;5;28mself\u001b[39m, value):\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "for seed_idx in SEEDS:\n", + " train_corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", + " # corpus = Corpus(filename=f'/reef/lyk25/theres-a-way-out-ACL26-internal/outputs/benchmark_preannotated/seed-{seed_idx}-ThresholdDecisionPolicy/ThresholdDecisionPolicy')\n", + " # corpus = Corpus(filename=f'/reef/lyk25/dynamic_training/game_analysis/corpi/test/test-son-seed-{seed_idx}')\n", + " corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", + " corpus.filter_conversations_by(lambda convo: convo.meta['split'] == 'test')\n", + "\n", + " config = TransformerForecasterConfig(\n", + " output_dir=f\"outputs/{OUTPUT_DIR}/forecaster_{seed_idx}\",\n", + " per_device_batch_size=16,\n", + " gradient_accumulation_steps=1,\n", + " num_train_epochs=1,\n", + " learning_rate=1e-5,\n", + " random_seed=seed_idx,\n", + " context_mode=\"normal\",\n", + " device=\"cuda\",\n", + " )\n", + "\n", + " # TODO this will have to be edited\n", + " forecaster_model = TransformerDecoderModel(\n", + " model_name_or_path=\"google/gemma-2-9b-it\",\n", + " config=config,\n", + " )\n", + "\n", + " forecaster = Forecaster(\n", + " forecaster_model=forecaster_model,\n", + " labeler='has_removed_comment',\n", + " )\n", + "\n", + " forecaster.fit_belief_estimator(\n", + " corpus=train_corpus,\n", + " context_selector=train_context_selector,\n", + " val_context_selector=val_context_selector,\n", + " )\n", + "\n", + " # ---\n", + " cfg_path = os.path.join(repo_root, \"saves\", f\"seed-{seed_idx}\", \"dev_config.json\")\n", + " with open(cfg_path) as f:\n", + " cfg = json.load(f)\n", + " best_threshold = cfg['best_threshold']\n", + "\n", + " for policy_trial in [ThresholdDecisionPolicy, DeferralDecisionPolicy, RandomDeferralDecisionPolicy, SimulationAverageDecisionPolicy, SimulationMajorityDecisionPolicy]:\n", + " print('---')\n", + " print(f\"Fitting policy {policy_trial.__name__} for seed {seed_idx}\")\n", + " if policy_trial == ThresholdDecisionPolicy:\n", + " policy = ThresholdDecisionPolicy(\n", + " threshold=best_threshold,\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == DeferralDecisionPolicy:\n", + " policy = DeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " tau=TAU,\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == RandomDeferralDecisionPolicy:\n", + " policy = RandomDeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " deferral_probability=DEFERRAL_PROBABILITY_THRESHOLD,\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == SimulationAverageDecisionPolicy:\n", + " policy = SimulationAverageDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " num_simulations=NUM_SIMULATIONS,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " elif policy_trial == SimulationMajorityDecisionPolicy:\n", + " policy = SimulationMajorityDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=best_threshold,\n", + " tau=5,\n", + " num_simulations=NUM_SIMULATIONS,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " reuse_cached_forecast_probs=False,\n", + " )\n", + " \n", + " # attach the decision policy to the underlying forecaster model;\n", + " # Forecaster itself does not accept decision_policy in its constructor.\n", + " forecaster_model.decision_policy = policy\n", + "\n", + " forecaster = Forecaster(\n", + " forecaster_model=forecaster_model,\n", + " labeler='has_removed_comment',\n", + " )\n", + "\n", + " print('starting transformation.')\n", + " # evaluate the forecaster on the test set\n", + " forecaster.transform(\n", + " corpus=corpus,\n", + " context_selector=make_data_selector('test'),\n", + " verbose=True,\n", + " )\n", + " print('transformation complete.')\n", + "\n", + " output_dir = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + " os.makedirs(output_dir, exist_ok=True)\n", + " corpus.dump(name=f\"{policy_trial.__name__}\", base_path=output_dir)\n", + " print('corpus dumped.')\n", + "\n", + " print('starting summarization.')\n", + " # forecaster.summarize expects a conversation-level selector (Callable[[Conversation], bool]),\n", + " # unlike the context-tuple selectors used in fit/transform.\n", + " def summarize_selector(convo):\n", + " return convo.meta.get(\"split\") == \"test\"\n", + " conversational_forecasts_df, metrics = forecaster.summarize(\n", + " corpus=corpus,\n", + " selector=summarize_selector,\n", + " )\n", + " print('summarization complete.')\n", + " \n", + " # path to the seed output directory\n", + " seed_folder = f\"outputs/{OUTPUT_DIR}/seed-{seed_idx}-{policy_trial.__name__}\"\n", + "\n", + " # ensure the directory exists\n", + " os.makedirs(seed_folder, exist_ok=True)\n", + "\n", + " # save conversational_forecasts_df as CSV\n", + " conversational_forecasts_df.to_csv(os.path.join(seed_folder, \"conversational_forecasts.csv\"), index=False)\n", + "\n", + " # save metrics as JSON\n", + " with open(os.path.join(seed_folder, \"metrics.json\"), \"w\") as f:\n", + " json.dump(metrics, f, indent=2)" + ] + }, + { + "cell_type": "markdown", + "id": "9e1c332f", + "metadata": {}, + "source": [ + "To view our results:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f45efc60", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "ThresholdDecisionPolicy (seeds=[1, 2, 3, 4, 5], n=5)\n", + " Accuracy: 0.7090\n", + " Precision: 0.6905\n", + " Recall: 0.7606\n", + " FPR: 0.3428\n", + " F1: 0.7231\n", + " Mean H: 2.9110\n", + " Correct Adjustment: 0.0864\n", + " Incorrect Adjustment: 0.0671\n", + " Recovery: 0.0193\n", + "\n", + "DeferralDecisionPolicy (seeds=[1, 2, 3, 4, 5], n=5)\n", + " Accuracy: 0.7085\n", + " Precision: 0.7205\n", + " Recall: 0.6839\n", + " FPR: 0.2668\n", + " F1: 0.7008\n", + " Mean H: 2.7688\n", + " Correct Adjustment: 0.0702\n", + " Incorrect Adjustment: 0.0710\n", + " Recovery: -0.0008\n", + "\n", + "RandomDeferralDecisionPolicy (seeds=[1, 2, 3, 4, 5], n=5)\n", + " Accuracy: 0.6939\n", + " Precision: 0.6967\n", + " Recall: 0.6899\n", + " FPR: 0.3021\n", + " F1: 0.6923\n", + " Mean H: 2.8083\n", + " Correct Adjustment: 0.0874\n", + " Incorrect Adjustment: 0.1126\n", + " Recovery: -0.0252\n", + "\n", + "SimulationAverageDecisionPolicy (seeds=[1, 2, 3, 4, 5], n=5)\n", + " Accuracy: 0.7021\n", + " Precision: 0.6809\n", + " Recall: 0.7656\n", + " FPR: 0.3615\n", + " F1: 0.7196\n", + " Mean H: 3.0251\n", + " Correct Adjustment: 0.0932\n", + " Incorrect Adjustment: 0.1048\n", + " Recovery: -0.0117\n", + "\n", + "SimulationMajorityDecisionPolicy (seeds=[1, 2, 3, 4, 5], n=5)\n", + " Accuracy: 0.6991\n", + " Precision: 0.6769\n", + " Recall: 0.7668\n", + " FPR: 0.3688\n", + " F1: 0.7180\n", + " Mean H: 3.0427\n", + " Correct Adjustment: 0.0977\n", + " Incorrect Adjustment: 0.1095\n", + " Recovery: -0.0118\n" + ] + } + ], + "source": [ + "import os\n", + "import json\n", + "from collections import defaultdict\n", + "\n", + "def fmt_mean(values):\n", + " # sample std dev requires n>=2; show 0 std for single-seed runs so output stays readable.\n", + " mean_val = sum(values) / len(values)\n", + " return f\"{mean_val:.4f}\"\n", + "\n", + "benchmark_dir = \"outputs/\" + OUTPUT_DIR\n", + "\n", + "SEEDS = list(range(1, 6))\n", + "POLICIES = [\n", + " \"ThresholdDecisionPolicy\",\n", + " \"DeferralDecisionPolicy\",\n", + " \"RandomDeferralDecisionPolicy\",\n", + " \"SimulationAverageDecisionPolicy\",\n", + " \"SimulationMajorityDecisionPolicy\",\n", + "]\n", + "\n", + "\n", + "def _resolve_metrics_path(benchmark_dir, seed_idx, policy):\n", + " # summarize-only reads frozen bundle corpora; full runs write seed--/ after transform.\n", + " # check summarize_only first: for RandomDeferral, a stale seed-/ from an old transform can\n", + " # disagree with the bundled corpus, and mixing primary for some seeds with summarize_only for\n", + " # others skews per-policy means.\n", + " summarize = os.path.join(\n", + " benchmark_dir, f\"summarize_only-seed-{seed_idx}-{policy}\", \"metrics.json\"\n", + " )\n", + " full_run = os.path.join(benchmark_dir, f\"seed-{seed_idx}-{policy}\", \"metrics.json\")\n", + " if os.path.exists(summarize):\n", + " return summarize\n", + " if os.path.exists(full_run):\n", + " return full_run\n", + " return None\n", + "\n", + "\n", + "# metrics_by_policy[policy][metric_name] -> list of per-seed values\n", + "metrics_by_policy = defaultdict(lambda: defaultdict(list))\n", + "seeds_found_by_policy = defaultdict(list)\n", + "\n", + "for policy in POLICIES:\n", + " for seed_idx in SEEDS:\n", + " metrics_path = _resolve_metrics_path(benchmark_dir, seed_idx, policy)\n", + " if metrics_path is None:\n", + " print(\n", + " f\"warn: missing metrics for seed {seed_idx} {policy} \"\n", + " f\"(looked for summarize_only-seed-{seed_idx}-{policy}/ and seed-{seed_idx}-{policy}/), skipping\"\n", + " )\n", + " continue\n", + " with open(metrics_path) as f:\n", + " m = json.load(f)\n", + " seeds_found_by_policy[policy].append(seed_idx)\n", + " for k, v in m.items():\n", + " # only average numeric metrics; skip strings like \"leaderboard string\"\n", + " if isinstance(v, (int, float)):\n", + " metrics_by_policy[policy][k].append(v)\n", + "\n", + "# print means per policy\n", + "for policy in POLICIES:\n", + " seeds_found = seeds_found_by_policy.get(policy, [])\n", + " if not seeds_found:\n", + " print(f\"\\n{policy}: no seeds found\")\n", + " continue\n", + " print(f\"\\n{policy} (seeds={seeds_found}, n={len(seeds_found)})\")\n", + " for metric_name, values in metrics_by_policy[policy].items():\n", + " print(f\" {metric_name}: {fmt_mean(values)}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "29a0cdc1", + "metadata": {}, + "source": [ + "## 4. Human benchmark analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2830d45f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] reading download config from /reef/lyk25/ConvoKit/download_config.json\n", + "[info] downloading human-benchmark from https://zissou.infosci.cornell.edu/convokit/datasets/human-benchmark/human-benchmark.zip\n", + "[info] extracting /home/lyk25/.convokit/saved-corpora/human-benchmark.zip to /home/lyk25/.convokit/saved-corpora\n" + ] + } + ], + "source": [ + "# TODO replace with actual download\n", + "\n", + "human_base = download_dataset(dataset_name=\"human-benchmark\")\n", + "\n", + "if (human_base / \"index.json\").exists():\n", + " corpus = Corpus(filename=str(human_base))\n", + "else:\n", + " human_corpus_dirs = sorted(\n", + " path\n", + " for path in human_base.rglob(\"*\")\n", + " if path.is_dir() and (path / \"index.json\").exists()\n", + " )\n", + "\n", + " if len(human_corpus_dirs) != 1:\n", + " raise ValueError(f\"expected 1 corpus, found {len(human_corpus_dirs)}: {human_corpus_dirs}\")\n", + "\n", + " corpus = Corpus(filename=str(human_corpus_dirs[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e22fafd2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "human horizon (round 1, tps only, mean - 1):\n", + " player 1: n=2, h=1.5000\n", + " player 2: n=1, h=2.0000\n", + " player 3: n=2, h=2.5000\n", + " player 4: n=4, h=1.5000\n", + " player 5: n=4, h=2.5000\n", + " player 6: n=2, h=0.5000\n", + " player 7: n=4, h=2.2500\n", + " player 8: n=2, h=5.0000\n", + " player 9: n=1, h=6.0000\n", + " mean over players: h=2.6389\n", + " pooled: n=22, h=2.3636\n", + "human horizon (round 2, tps only, mean - 1):\n", + " player 1: n=4, h=3.2500\n", + " player 2: n=2, h=0.5000\n", + " player 3: n=1, h=3.0000\n", + " player 4: n=2, h=0.5000\n", + " player 5: n=4, h=3.0000\n", + " player 6: n=2, h=4.0000\n", + " player 7: n=4, h=1.2500\n", + " player 8: n=3, h=2.0000\n", + " player 9: n=3, h=1.6667\n", + " mean over players: h=2.1296\n", + " pooled: n=25, h=2.1600\n", + "\n", + "round 1 - per-player metrics:\n", + " player accuracy precision recall f1 fpr specificity fnr n_convos\n", + " 1 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", + " 2 0.4000 0.3333 0.2000 0.2500 0.4000 0.6000 0.8000 10\n", + " 3 0.7000 1.0000 0.4000 0.5714 0.0000 1.0000 0.6000 10\n", + " 4 0.8000 0.8000 0.8000 0.8000 0.2000 0.8000 0.2000 10\n", + " 5 0.7000 0.6667 0.8000 0.7273 0.4000 0.6000 0.2000 10\n", + " 6 0.7000 1.0000 0.4000 0.5714 0.0000 1.0000 0.6000 10\n", + " 7 0.8000 0.8000 0.8000 0.8000 0.2000 0.8000 0.2000 10\n", + " 8 0.5000 0.5000 0.4000 0.4444 0.4000 0.6000 0.6000 10\n", + " 9 0.4000 0.3333 0.2000 0.2500 0.4000 0.6000 0.8000 10\n", + "\n", + "round 2 - per-player metrics:\n", + " player accuracy precision recall f1 fpr specificity fnr n_convos\n", + " 1 0.9000 1.0000 0.8000 0.8889 0.0000 1.0000 0.2000 10\n", + " 2 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", + " 3 0.4000 0.3333 0.2000 0.2500 0.4000 0.6000 0.8000 10\n", + " 4 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", + " 5 0.9000 1.0000 0.8000 0.8889 0.0000 1.0000 0.2000 10\n", + " 6 0.6000 0.6667 0.4000 0.5000 0.2000 0.8000 0.6000 10\n", + " 7 0.9000 1.0000 0.8000 0.8889 0.0000 1.0000 0.2000 10\n", + " 8 0.7000 0.7500 0.6000 0.6667 0.2000 0.8000 0.4000 10\n", + " 9 0.7000 0.7500 0.6000 0.6667 0.2000 0.8000 0.4000 10\n", + "\n", + "aggregate benchmark (gemma: mean+/-std over 5 seeds; humans: mean over players)\n", + "group accuracy precision recall f1 fpr specificity fnr\n", + "gemma (mean+/-std over seeds) 0.700+/-0.018 0.679+/-0.026 0.762+/-0.029 0.718+/-0.012 0.362+/-0.052 0.638+/-0.052 0.238+/-0.029\n", + "round1 humans (mean over players) 0.6222 0.6778 0.4889 0.5461 0.2444 0.7556 0.5111\n", + "round2 humans (mean over players) 0.7000 0.7593 0.5556 0.6389 0.1556 0.8444 0.4444\n", + "\n", + "round 1 unique convos: 84\n", + "round 2 unique convos: 84\n" + ] + } + ], + "source": [ + "from collections import defaultdict\n", + "import numpy as np\n", + "\n", + "def _truth(convo):\n", + " return bool(convo.meta.get(\"has_removed_comment\", False))\n", + "\n", + "def _round_seen(convo, round_label):\n", + " seen_by_round = convo.meta.get(\"human_seen_by_round\", {})\n", + " return list(seen_by_round.get(round_label, []))\n", + "\n", + "def _round_guesses(utt, round_label):\n", + " guesses_by_round = utt.meta.get(\"human_guesses_by_round\", {})\n", + " return list(guesses_by_round.get(round_label, []))\n", + "\n", + "def _compute_metrics(tp, fp, tn, fn):\n", + " total = tp + fp + tn + fn\n", + " accuracy = (tp + tn) / total if total > 0 else 0.0\n", + " precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0\n", + " recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0\n", + " f1 = (2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0.0\n", + " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0.0\n", + " specificity = tn / (tn + fp) if (tn + fp) > 0 else 0.0\n", + " fnr = fn / (fn + tp) if (fn + tp) > 0 else 0.0\n", + " return {\n", + " \"tp\": tp, \"fp\": fp, \"tn\": tn, \"fn\": fn,\n", + " \"accuracy\": accuracy, \"precision\": precision, \"recall\": recall,\n", + " \"f1\": f1, \"fpr\": fpr, \"specificity\": specificity, \"fnr\": fnr,\n", + " }\n", + "\n", + "def _horizon_mean(horizons):\n", + " if len(horizons) == 0:\n", + " return float(\"nan\"), 0\n", + " return float(np.mean(horizons)) - 1, len(horizons)\n", + "\n", + "def _human_per_player_preds(corpus, round_label):\n", + " preds = defaultdict(dict)\n", + "\n", + " for convo in corpus.iter_conversations():\n", + " seen_players = _round_seen(convo, round_label)\n", + " if not seen_players:\n", + " continue\n", + "\n", + " utts = convo.get_chronological_utterance_list()\n", + " guessed_players = {\n", + " player\n", + " for utt in utts\n", + " for player in _round_guesses(utt, round_label)\n", + " }\n", + "\n", + " for player in seen_players:\n", + " preds[player][convo.id] = int(player in guessed_players)\n", + "\n", + " return preds\n", + "\n", + "def _human_horizons(corpus, round_label):\n", + " by_player = defaultdict(list)\n", + "\n", + " for convo in corpus.iter_conversations():\n", + " if not _truth(convo):\n", + " continue\n", + "\n", + " utts = convo.get_chronological_utterance_list()\n", + " seen_players = set()\n", + "\n", + " for i, utt in enumerate(utts):\n", + " for player in _round_guesses(utt, round_label):\n", + " if player in seen_players:\n", + " continue\n", + " by_player[player].append(len(utts) - i)\n", + " seen_players.add(player)\n", + "\n", + " return by_player\n", + "\n", + "def _per_player_metrics(corpus, preds):\n", + " rows = {}\n", + "\n", + " for player, convo_preds in preds.items():\n", + " tp = fp = tn = fn = 0\n", + "\n", + " for cid, pred in convo_preds.items():\n", + " convo = corpus.get_conversation(cid)\n", + " truth = int(_truth(convo))\n", + "\n", + " if pred and truth:\n", + " tp += 1\n", + " elif pred and not truth:\n", + " fp += 1\n", + " elif not pred and not truth:\n", + " tn += 1\n", + " else:\n", + " fn += 1\n", + "\n", + " rows[player] = _compute_metrics(tp, fp, tn, fn)\n", + "\n", + " return rows\n", + "\n", + "def _mean_over_players(per_player):\n", + " keys = [\"accuracy\", \"precision\", \"recall\", \"f1\", \"fpr\", \"specificity\", \"fnr\"]\n", + " if not per_player:\n", + " return {k: float(\"nan\") for k in keys}\n", + " return {k: float(np.mean([m[k] for m in per_player.values()])) for k in keys}\n", + "\n", + "def _gemma_metrics(corpus):\n", + " gemma_per_seed = []\n", + "\n", + " for seed_num in range(1, 6):\n", + " tp = fp = tn = fn = 0\n", + "\n", + " for convo in corpus.iter_conversations():\n", + " utts = convo.get_chronological_utterance_list()\n", + " pred = any(\n", + " utt.meta.get(\"model_forecasts\", {}).get(f\"seed_{seed_num}\") == 1\n", + " for utt in utts\n", + " )\n", + " truth = _truth(convo)\n", + "\n", + " if pred and truth:\n", + " tp += 1\n", + " elif pred and not truth:\n", + " fp += 1\n", + " elif not pred and not truth:\n", + " tn += 1\n", + " else:\n", + " fn += 1\n", + "\n", + " gemma_per_seed.append(_compute_metrics(tp, fp, tn, fn))\n", + "\n", + " gemma_mean = {k: float(np.mean([m[k] for m in gemma_per_seed])) for k in gemma_per_seed[0]}\n", + " gemma_std = {k: float(np.std([m[k] for m in gemma_per_seed], ddof=1)) for k in gemma_per_seed[0]}\n", + " return gemma_mean, gemma_std\n", + "\n", + "def _print_horizons(label, by_player):\n", + " print(f\"human horizon ({label}, tps only, mean - 1):\")\n", + "\n", + " player_h = []\n", + " for player in sorted(by_player):\n", + " h, n = _horizon_mean(by_player[player])\n", + " player_h.append(h)\n", + " print(f\" player {player}: n={n}, h={h:.4f}\")\n", + "\n", + " all_vals = [v for vs in by_player.values() for v in vs]\n", + " mean_over_players = float(np.mean(player_h)) if player_h else float(\"nan\")\n", + " pooled_h, pooled_n = _horizon_mean(all_vals)\n", + "\n", + " print(f\" mean over players: h={mean_over_players:.4f}\")\n", + " print(f\" pooled: n={pooled_n}, h={pooled_h:.4f}\")\n", + " return mean_over_players, pooled_h\n", + "\n", + "metric_order = [\"accuracy\", \"precision\", \"recall\", \"f1\", \"fpr\", \"specificity\", \"fnr\"]\n", + "\n", + "def _print_per_player(label, per_player):\n", + " print(f\"{label} - per-player metrics:\")\n", + " header = f\" {'player':<10}\" + \"\".join(f\"{m:>12}\" for m in metric_order) + f\"{'n_convos':>10}\"\n", + " print(header)\n", + "\n", + " for player in sorted(per_player):\n", + " m = per_player[player]\n", + " n = m[\"tp\"] + m[\"fp\"] + m[\"tn\"] + m[\"fn\"]\n", + " row = f\" {player:<10}\" + \"\".join(f\"{m[k]:>12.4f}\" for k in metric_order) + f\"{n:>10d}\"\n", + " print(row)\n", + "\n", + "round1_h = _human_horizons(corpus, \"round_1\")\n", + "round2_h = _human_horizons(corpus, \"round_2\")\n", + "r1_mean, r1_pooled = _print_horizons(\"round 1\", round1_h)\n", + "r2_mean, r2_pooled = _print_horizons(\"round 2\", round2_h)\n", + "\n", + "round1_preds = _human_per_player_preds(corpus, \"round_1\")\n", + "round2_preds = _human_per_player_preds(corpus, \"round_2\")\n", + "\n", + "round1_per_player = _per_player_metrics(corpus, round1_preds)\n", + "round2_per_player = _per_player_metrics(corpus, round2_preds)\n", + "\n", + "round1_mean_over_players = _mean_over_players(round1_per_player)\n", + "round2_mean_over_players = _mean_over_players(round2_per_player)\n", + "\n", + "gemma_mean, gemma_std = _gemma_metrics(corpus)\n", + "\n", + "print()\n", + "_print_per_player(\"round 1\", round1_per_player)\n", + "print()\n", + "_print_per_player(\"round 2\", round2_per_player)\n", + "\n", + "print()\n", + "print(\"aggregate benchmark (gemma: mean+/-std over 5 seeds; humans: mean over players)\")\n", + "header = f\"{'group':<36}\" + \"\".join(f\"{m:>14}\" for m in metric_order)\n", + "print(header)\n", + "\n", + "def _fmt_mean_std(mean_dict, std_dict):\n", + " return \"\".join(f\"{mean_dict[k]:>7.3f}+/-{std_dict[k]:<5.3f}\" for k in metric_order)\n", + "\n", + "def _fmt_mean(mean_dict):\n", + " return \"\".join(f\"{mean_dict[k]:>14.4f}\" for k in metric_order)\n", + "\n", + "print(f\"{'gemma (mean+/-std over seeds)':<36}\" + _fmt_mean_std(gemma_mean, gemma_std))\n", + "print(f\"{'round1 humans (mean over players)':<36}\" + _fmt_mean(round1_mean_over_players))\n", + "print(f\"{'round2 humans (mean over players)':<36}\" + _fmt_mean(round2_mean_over_players))\n", + "\n", + "round1_unique_convos = {cid for preds in round1_preds.values() for cid in preds}\n", + "round2_unique_convos = {cid for preds in round2_preds.values() for cid in preds}\n", + "\n", + "print()\n", + "print(f\"round 1 unique convos: {len(round1_unique_convos)}\")\n", + "print(f\"round 2 unique convos: {len(round2_unique_convos)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9c68d1bd", + "metadata": {}, + "source": [ + "## 5. Validation of forecast probability decrease" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "383d61a9", + "metadata": {}, + "outputs": [], + "source": [ + "seed_best_thresholds = {\n", + " \"test-seed-1\": 0.5926666259765625,\n", + " \"test-seed-2\": 0.622459352016449,\n", + " \"test-seed-3\": 0.6513549089431763,\n", + " \"test-seed-4\": 0.6513549089431763,\n", + " \"test-seed-5\": 0.6513549089431763,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5e527737", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pooled trigger_all current perf, best threshold per seed: 0.5532229185317815 (12359/22340)\n", + "pooled delayed_all best threshold per seed, k=7: 0.8353165159447882 (3510/4202)\n" + ] + } + ], + "source": [ + "import json\n", + "from pathlib import Path\n", + "from convokit import Corpus\n", + "\n", + "corpus_base = Path(\"/reef/lyk25/dynamic_training/game_analysis/corpi/test\")\n", + "# config_base = Path(\"\")\n", + "# replace here with your own base path with multiple seeds\n", + "\n", + "corpus_dirs = sorted(\n", + " corpus_dir\n", + " for corpus_dir in corpus_base.rglob(\"*\")\n", + " if corpus_dir.is_dir() and (corpus_dir / \"index.json\").exists()\n", + ")\n", + "\n", + "if not corpus_dirs:\n", + " raise FileNotFoundError(f\"no convokit corpora found under {corpus_base}\")\n", + "\n", + "\n", + "def _test_seed_key(corpus_dir):\n", + " parent_name = corpus_dir.parent.name\n", + " if parent_name.startswith(\"test-seed-\"):\n", + " return parent_name\n", + " seed_idx = corpus_dir.name.rsplit(\"-\", 1)[-1]\n", + " return f\"test-seed-{seed_idx}\"\n", + "\n", + "\n", + "corpus_path_by_key = {}\n", + "for corpus_dir in corpus_dirs:\n", + " key = _test_seed_key(corpus_dir)\n", + " corpus_path_by_key[key] = corpus_dir\n", + "\n", + "\n", + "def is_calm_sim_forecast(forecast):\n", + " if isinstance(forecast, str):\n", + " forecast = forecast.strip().lower()\n", + " if forecast in {\"0\", \"false\", \"calm\"}:\n", + " return True\n", + " if forecast in {\"1\", \"true\", \"awry\"}:\n", + " return False\n", + " return int(forecast) == 0\n", + "\n", + "\n", + "def count_decreases_at_indices(corpus, get_indices):\n", + " total = 0\n", + " reduction = 0\n", + "\n", + " for convo in corpus.iter_conversations():\n", + " utts = convo.get_chronological_utterance_list()\n", + "\n", + " for i in get_indices(utts):\n", + " if i + 1 >= len(utts):\n", + " continue\n", + "\n", + " f1 = utts[i].meta[\"forecast_prob\"]\n", + " f2 = utts[i + 1].meta[\"forecast_prob\"]\n", + " total += 1\n", + "\n", + " if f1 > f2:\n", + " reduction += 1\n", + "\n", + " return reduction, total\n", + "\n", + "\n", + "def current_trigger_indices(utts, pred_threshold):\n", + " return [\n", + " i\n", + " for i, utt in enumerate(utts)\n", + " if utt.meta[\"forecast_prob\"] > pred_threshold\n", + " ]\n", + "\n", + "\n", + "def delayed_indices_from_sim_forecasts(utts, pred_threshold, k):\n", + " delayed = []\n", + "\n", + " for i, utt in enumerate(utts):\n", + " if utt.meta[\"forecast_prob\"] <= pred_threshold:\n", + " continue\n", + "\n", + " sim_forecasts = utt.meta[\"sim_replies_forecasts\"]\n", + " calm_sim_replies = sum(\n", + " 1 for forecast in sim_forecasts if is_calm_sim_forecast(forecast)\n", + " )\n", + "\n", + " if calm_sim_replies > k:\n", + " delayed.append(i)\n", + "\n", + " return delayed\n", + "\n", + "\n", + "current_reduction = 0\n", + "current_total = 0\n", + "delayed_reduction = 0\n", + "delayed_total = 0\n", + "\n", + "for seed in range(1, 6):\n", + " seed_key = f\"test-seed-{seed}\"\n", + " corpus = Corpus(filename=str(corpus_path_by_key[seed_key]))\n", + "\n", + " best_threshold = seed_best_thresholds[seed_key]\n", + " \n", + "\n", + " r, t = count_decreases_at_indices(\n", + " corpus,\n", + " lambda utts: current_trigger_indices(utts, best_threshold),\n", + " )\n", + " current_reduction += r\n", + " current_total += t\n", + "\n", + " r, t = count_decreases_at_indices(\n", + " corpus,\n", + " lambda utts: delayed_indices_from_sim_forecasts(utts, best_threshold, k=7),\n", + " )\n", + " delayed_reduction += r\n", + " delayed_total += t\n", + "\n", + "pooled_trigger_all = current_reduction / current_total\n", + "pooled_delayed_all = delayed_reduction / delayed_total\n", + "\n", + "print(f\"pooled trigger_all current perf, best threshold per seed: {pooled_trigger_all} ({current_reduction}/{current_total})\")\n", + "print(f\"pooled delayed_all best threshold per seed, k=7: {pooled_delayed_all} ({delayed_reduction}/{delayed_total})\")" + ] + }, + { + "cell_type": "markdown", + "id": "cb154714", + "metadata": {}, + "source": [ + "## 6. Calculating oracle threshold" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "cba93b72", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] using 5 test-seed corpora: test-seed-1, test-seed-2, test-seed-3, test-seed-4, test-seed-5\n" + ] + } + ], + "source": [ + "# corpora comes from the decisionpolicy-demo download cell; use only test-seed- entries.\n", + "import re\n", + "\n", + "_prev_keys = tuple(sorted(corpora))\n", + "_test_seed_re = re.compile(r\"^test-seed-(\\d+)$\")\n", + "\n", + "corpora = {\n", + " k: corpora[k]\n", + " for k in sorted(\n", + " (k for k in _prev_keys if _test_seed_re.match(k)),\n", + " key=lambda k: int(_test_seed_re.match(k).group(1)),\n", + " )\n", + "}\n", + "\n", + "if not corpora:\n", + " raise RuntimeError(\n", + " \"no test-seed- corpora after filter; had keys: \"\n", + " + \", \".join(_prev_keys)\n", + " )\n", + "\n", + "print(\n", + " f\"[info] using {len(corpora)} test-seed corpora: \"\n", + " + \", \".join(corpora)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3be18b5d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] per-seed best thresholds: {'test-seed-1': 0.5926666259765625, 'test-seed-2': 0.622459352016449, 'test-seed-3': 0.6513549089431763, 'test-seed-4': 0.6513549089431763, 'test-seed-5': 0.6513549089431763}\n", + "[info] mean best threshold: 0.633838\n", + "[info] generating baseline roc curve with 400 thresholds in [0.483838, 0.783838]\n", + "[info] testing k values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import json\n", + "\n", + "mean_best_threshold = float(np.mean(list(seed_best_thresholds.values())))\n", + "search_radius = 0.15\n", + "num_thresholds = 400\n", + "baseline_thresholds = np.linspace(\n", + " mean_best_threshold - search_radius,\n", + " mean_best_threshold + search_radius,\n", + " num_thresholds,\n", + ")\n", + "\n", + "print(f\"[info] per-seed best thresholds: {seed_best_thresholds}\")\n", + "print(f\"[info] mean best threshold: {mean_best_threshold:.6f}\")\n", + "print(f\"[info] generating baseline roc curve with {len(baseline_thresholds)} thresholds in [{baseline_thresholds[0]:.6f}, {baseline_thresholds[-1]:.6f}]\")\n", + "\n", + "# k values to test for our method\n", + "k_values = list(range(1, 11)) # 1 to 10\n", + "print(f\"[info] testing k values: {k_values}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "f6128fef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] computing baseline roc curves for all seeds...\n", + "\n", + "[info] processing test-seed-1...\n", + "[info] test-seed-1 baseline progress: 1/400\n", + "[info] test-seed-1 baseline progress: 21/400\n", + "[info] test-seed-1 baseline progress: 41/400\n", + "[info] test-seed-1 baseline progress: 61/400\n", + "[info] test-seed-1 baseline progress: 81/400\n", + "[info] test-seed-1 baseline progress: 101/400\n", + "[info] test-seed-1 baseline progress: 121/400\n", + "[info] test-seed-1 baseline progress: 141/400\n", + "[info] test-seed-1 baseline progress: 161/400\n", + "[info] test-seed-1 baseline progress: 181/400\n", + "[info] test-seed-1 baseline progress: 201/400\n", + "[info] test-seed-1 baseline progress: 221/400\n", + "[info] test-seed-1 baseline progress: 241/400\n", + "[info] test-seed-1 baseline progress: 261/400\n", + "[info] test-seed-1 baseline progress: 281/400\n", + "[info] test-seed-1 baseline progress: 301/400\n", + "[info] test-seed-1 baseline progress: 321/400\n", + "[info] test-seed-1 baseline progress: 341/400\n", + "[info] test-seed-1 baseline progress: 361/400\n", + "[info] test-seed-1 baseline progress: 381/400\n", + "[pass] test-seed-1 baseline complete - 400 points\n", + "\n", + "[info] processing test-seed-2...\n", + "[info] test-seed-2 baseline progress: 1/400\n", + "[info] test-seed-2 baseline progress: 21/400\n", + "[info] test-seed-2 baseline progress: 41/400\n", + "[info] test-seed-2 baseline progress: 61/400\n", + "[info] test-seed-2 baseline progress: 81/400\n", + "[info] test-seed-2 baseline progress: 101/400\n", + "[info] test-seed-2 baseline progress: 121/400\n", + "[info] test-seed-2 baseline progress: 141/400\n", + "[info] test-seed-2 baseline progress: 161/400\n", + "[info] test-seed-2 baseline progress: 181/400\n", + "[info] test-seed-2 baseline progress: 201/400\n", + "[info] test-seed-2 baseline progress: 221/400\n", + "[info] test-seed-2 baseline progress: 241/400\n", + "[info] test-seed-2 baseline progress: 261/400\n", + "[info] test-seed-2 baseline progress: 281/400\n", + "[info] test-seed-2 baseline progress: 301/400\n", + "[info] test-seed-2 baseline progress: 321/400\n", + "[info] test-seed-2 baseline progress: 341/400\n", + "[info] test-seed-2 baseline progress: 361/400\n", + "[info] test-seed-2 baseline progress: 381/400\n", + "[pass] test-seed-2 baseline complete - 400 points\n", + "\n", + "[info] processing test-seed-3...\n", + "[info] test-seed-3 baseline progress: 1/400\n", + "[info] test-seed-3 baseline progress: 21/400\n", + "[info] test-seed-3 baseline progress: 41/400\n", + "[info] test-seed-3 baseline progress: 61/400\n", + "[info] test-seed-3 baseline progress: 81/400\n", + "[info] test-seed-3 baseline progress: 101/400\n", + "[info] test-seed-3 baseline progress: 121/400\n", + "[info] test-seed-3 baseline progress: 141/400\n", + "[info] test-seed-3 baseline progress: 161/400\n", + "[info] test-seed-3 baseline progress: 181/400\n", + "[info] test-seed-3 baseline progress: 201/400\n", + "[info] test-seed-3 baseline progress: 221/400\n", + "[info] test-seed-3 baseline progress: 241/400\n", + "[info] test-seed-3 baseline progress: 261/400\n", + "[info] test-seed-3 baseline progress: 281/400\n", + "[info] test-seed-3 baseline progress: 301/400\n", + "[info] test-seed-3 baseline progress: 321/400\n", + "[info] test-seed-3 baseline progress: 341/400\n", + "[info] test-seed-3 baseline progress: 361/400\n", + "[info] test-seed-3 baseline progress: 381/400\n", + "[pass] test-seed-3 baseline complete - 400 points\n", + "\n", + "[info] processing test-seed-4...\n", + "[info] test-seed-4 baseline progress: 1/400\n", + "[info] test-seed-4 baseline progress: 21/400\n", + "[info] test-seed-4 baseline progress: 41/400\n", + "[info] test-seed-4 baseline progress: 61/400\n", + "[info] test-seed-4 baseline progress: 81/400\n", + "[info] test-seed-4 baseline progress: 101/400\n", + "[info] test-seed-4 baseline progress: 121/400\n", + "[info] test-seed-4 baseline progress: 141/400\n", + "[info] test-seed-4 baseline progress: 161/400\n", + "[info] test-seed-4 baseline progress: 181/400\n", + "[info] test-seed-4 baseline progress: 201/400\n", + "[info] test-seed-4 baseline progress: 221/400\n", + "[info] test-seed-4 baseline progress: 241/400\n", + "[info] test-seed-4 baseline progress: 261/400\n", + "[info] test-seed-4 baseline progress: 281/400\n", + "[info] test-seed-4 baseline progress: 301/400\n", + "[info] test-seed-4 baseline progress: 321/400\n", + "[info] test-seed-4 baseline progress: 341/400\n", + "[info] test-seed-4 baseline progress: 361/400\n", + "[info] test-seed-4 baseline progress: 381/400\n", + "[pass] test-seed-4 baseline complete - 400 points\n", + "\n", + "[info] processing test-seed-5...\n", + "[info] test-seed-5 baseline progress: 1/400\n", + "[info] test-seed-5 baseline progress: 21/400\n", + "[info] test-seed-5 baseline progress: 41/400\n", + "[info] test-seed-5 baseline progress: 61/400\n", + "[info] test-seed-5 baseline progress: 81/400\n", + "[info] test-seed-5 baseline progress: 101/400\n", + "[info] test-seed-5 baseline progress: 121/400\n", + "[info] test-seed-5 baseline progress: 141/400\n", + "[info] test-seed-5 baseline progress: 161/400\n", + "[info] test-seed-5 baseline progress: 181/400\n", + "[info] test-seed-5 baseline progress: 201/400\n", + "[info] test-seed-5 baseline progress: 221/400\n", + "[info] test-seed-5 baseline progress: 241/400\n", + "[info] test-seed-5 baseline progress: 261/400\n", + "[info] test-seed-5 baseline progress: 281/400\n", + "[info] test-seed-5 baseline progress: 301/400\n", + "[info] test-seed-5 baseline progress: 321/400\n", + "[info] test-seed-5 baseline progress: 341/400\n", + "[info] test-seed-5 baseline progress: 361/400\n", + "[info] test-seed-5 baseline progress: 381/400\n", + "[pass] test-seed-5 baseline complete - 400 points\n", + "\n", + "[pass] all baseline roc curves computed for 5 seeds\n" + ] } - ], - "metadata": { - "kernelspec": { - "display_name": "lyk25-env", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.11" + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from convokit.decisionpolicy import ThresholdDecisionPolicy\n", + "from convokit.forecaster.forecaster import ContextTuple\n", + "\n", + "\n", + "def _cached_forecast_score(context):\n", + " meta = getattr(context.current_utterance, \"meta\", {}) or {}\n", + " if \"forecast_prob\" not in meta:\n", + " raise KeyError(f\"missing forecast_prob for utterance {context.current_utterance.id}\")\n", + " return meta[\"forecast_prob\"]\n", + "\n", + "\n", + "def _threshold_policy_performance(corpus, policy):\n", + " tp = fp = tn = fn = 0\n", + " horizons = []\n", + "\n", + " for convo in corpus.iter_conversations():\n", + " utts = convo.get_chronological_utterance_list()\n", + " pred = 0\n", + " first_trigger_idx = None\n", + "\n", + " for utt_idx, utt in enumerate(utts):\n", + " context = ContextTuple(\n", + " context=utts[: utt_idx + 1],\n", + " current_utterance=utt,\n", + " future_context=utts[utt_idx + 1 :],\n", + " conversation_id=convo.id,\n", + " )\n", + " _, utt_pred = policy.decide(context, _cached_forecast_score)\n", + " if int(utt_pred) == 1:\n", + " pred = 1\n", + " first_trigger_idx = utt_idx\n", + " break\n", + "\n", + " truth = bool(convo.meta.get(\"has_removed_comment\", False))\n", + " if pred and truth:\n", + " tp += 1\n", + " horizons.append(len(utts) - first_trigger_idx)\n", + " elif pred and not truth:\n", + " fp += 1\n", + " elif not pred and not truth:\n", + " tn += 1\n", + " else:\n", + " fn += 1\n", + "\n", + " h = float(np.mean(horizons)) - 1 if horizons else float(\"nan\")\n", + " return {\n", + " \"confusion_matrix\": {\"TP\": tp, \"FP\": fp, \"TN\": tn, \"FN\": fn},\n", + " \"h\": h,\n", + " }\n", + "\n", + "\n", + "# step 1: compute baseline roc curve with ThresholdDecisionPolicy\n", + "print(\"[info] computing baseline roc curves for all seeds...\")\n", + "all_baseline_results = {}\n", + "\n", + "for seed_name, corpus in corpora.items():\n", + " print(f\"\\n[info] processing {seed_name}...\")\n", + " baseline_results = []\n", + "\n", + " for i, threshold in enumerate(baseline_thresholds):\n", + " if i % 20 == 0:\n", + " print(f\"[info] {seed_name} baseline progress: {i+1}/{len(baseline_thresholds)}\")\n", + "\n", + " policy = ThresholdDecisionPolicy(threshold=threshold)\n", + " results = _threshold_policy_performance(corpus, policy)\n", + " tp = results[\"confusion_matrix\"][\"TP\"]\n", + " fp = results[\"confusion_matrix\"][\"FP\"]\n", + " tn = results[\"confusion_matrix\"][\"TN\"]\n", + " fn = results[\"confusion_matrix\"][\"FN\"]\n", + "\n", + " # calculate tpr, fpr, accuracy, precision, recall, f1\n", + " # recall == tpr; kept as a separate field for downstream readability\n", + " tpr = tp / (tp + fn) if (tp + fn) > 0 else 0\n", + " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0\n", + " total = tp + fp + tn + fn\n", + " accuracy = (tp + tn) / total if total > 0 else 0\n", + " precision = tp / (tp + fp) if (tp + fp) > 0 else 0\n", + " recall = tpr\n", + " f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n", + "\n", + " baseline_results.append({\n", + " \"seed\": seed_name,\n", + " \"threshold\": threshold,\n", + " \"tpr\": tpr,\n", + " \"fpr\": fpr,\n", + " \"accuracy\": accuracy,\n", + " \"precision\": precision,\n", + " \"recall\": recall,\n", + " \"f1\": f1,\n", + " \"h\": results.get(\"h\", float(\"nan\")),\n", + " \"tp\": tp,\n", + " \"fp\": fp,\n", + " \"tn\": tn,\n", + " \"fn\": fn,\n", + " })\n", + "\n", + " all_baseline_results[seed_name] = pd.DataFrame(baseline_results)\n", + " print(f\"[pass] {seed_name} baseline complete - {len(all_baseline_results[seed_name])} points\")\n", + "\n", + "print(f\"\\n[pass] all baseline roc curves computed for {len(all_baseline_results)} seeds\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "022d240f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] all_baseline_results has been pickled to all_baseline_results.pkl\n" + ] + } + ], + "source": [ + "import pickle\n", + "\n", + "with open('all_baseline_results.pkl', 'wb') as f:\n", + " pickle.dump(all_baseline_results, f)\n", + "print(\"[info] all_baseline_results has been pickled to all_baseline_results.pkl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "aa6450a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[info] processing test-seed-1...\n", + "[info] config seed: seed-1\n", + "[info] k method threshold 0.5926666259765625\n", + "[info] test-seed-1 computing k=1...\n", + "[info] test-seed-1 computing k=2...\n", + "[info] test-seed-1 computing k=3...\n", + "[info] test-seed-1 computing k=4...\n", + "[info] test-seed-1 computing k=5...\n", + "[info] test-seed-1 computing k=6...\n", + "[info] test-seed-1 computing k=7...\n", + "[info] test-seed-1 computing k=8...\n", + "[info] test-seed-1 computing k=9...\n", + "[info] test-seed-1 computing k=10...\n", + "[pass] test-seed-1 k-method complete - 10 points\n", + "\n", + "[info] processing test-seed-2...\n", + "[info] config seed: seed-2\n", + "[info] k method threshold 0.622459352016449\n", + "[info] test-seed-2 computing k=1...\n", + "[info] test-seed-2 computing k=2...\n", + "[info] test-seed-2 computing k=3...\n", + "[info] test-seed-2 computing k=4...\n", + "[info] test-seed-2 computing k=5...\n", + "[info] test-seed-2 computing k=6...\n", + "[info] test-seed-2 computing k=7...\n", + "[info] test-seed-2 computing k=8...\n", + "[info] test-seed-2 computing k=9...\n", + "[info] test-seed-2 computing k=10...\n", + "[pass] test-seed-2 k-method complete - 10 points\n", + "\n", + "[info] processing test-seed-3...\n", + "[info] config seed: seed-3\n", + "[info] k method threshold 0.6513549089431763\n", + "[info] test-seed-3 computing k=1...\n", + "[info] test-seed-3 computing k=2...\n", + "[info] test-seed-3 computing k=3...\n", + "[info] test-seed-3 computing k=4...\n", + "[info] test-seed-3 computing k=5...\n", + "[info] test-seed-3 computing k=6...\n", + "[info] test-seed-3 computing k=7...\n", + "[info] test-seed-3 computing k=8...\n", + "[info] test-seed-3 computing k=9...\n", + "[info] test-seed-3 computing k=10...\n", + "[pass] test-seed-3 k-method complete - 10 points\n", + "\n", + "[info] processing test-seed-4...\n", + "[info] config seed: seed-4\n", + "[info] k method threshold 0.6513549089431763\n", + "[info] test-seed-4 computing k=1...\n", + "[info] test-seed-4 computing k=2...\n", + "[info] test-seed-4 computing k=3...\n", + "[info] test-seed-4 computing k=4...\n", + "[info] test-seed-4 computing k=5...\n", + "[info] test-seed-4 computing k=6...\n", + "[info] test-seed-4 computing k=7...\n", + "[info] test-seed-4 computing k=8...\n", + "[info] test-seed-4 computing k=9...\n", + "[info] test-seed-4 computing k=10...\n", + "[pass] test-seed-4 k-method complete - 10 points\n", + "\n", + "[info] processing test-seed-5...\n", + "[info] config seed: seed-5\n", + "[info] k method threshold 0.6513549089431763\n", + "[info] test-seed-5 computing k=1...\n", + "[info] test-seed-5 computing k=2...\n", + "[info] test-seed-5 computing k=3...\n", + "[info] test-seed-5 computing k=4...\n", + "[info] test-seed-5 computing k=5...\n", + "[info] test-seed-5 computing k=6...\n", + "[info] test-seed-5 computing k=7...\n", + "[info] test-seed-5 computing k=8...\n", + "[info] test-seed-5 computing k=9...\n", + "[info] test-seed-5 computing k=10...\n", + "[pass] test-seed-5 k-method complete - 10 points\n", + "\n", + "[pass] all k-method results computed for 5 seeds\n" + ] + } + ], + "source": [ + "import json\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from convokit.decisionpolicy import DeferralDecisionPolicy\n", + "from convokit.forecaster.forecaster import ContextTuple\n", + "\n", + "\n", + "def _cached_forecast_score(context):\n", + " meta = getattr(context.current_utterance, \"meta\", {}) or {}\n", + " if \"forecast_prob\" not in meta:\n", + " raise KeyError(f\"missing forecast_prob for utterance {context.current_utterance.id}\")\n", + " return meta[\"forecast_prob\"]\n", + "\n", + "\n", + "def _deferral_policy_performance(corpus, policy):\n", + " tp = fp = tn = fn = 0\n", + " horizons = []\n", + "\n", + " for convo in corpus.iter_conversations():\n", + " utts = convo.get_chronological_utterance_list()\n", + " pred = 0\n", + " first_trigger_idx = None\n", + "\n", + " for utt_idx, utt in enumerate(utts):\n", + " context = ContextTuple(\n", + " context=utts[: utt_idx + 1],\n", + " current_utterance=utt,\n", + " future_context=utts[utt_idx + 1 :],\n", + " conversation_id=convo.id,\n", + " )\n", + " result = policy.decide(context, _cached_forecast_score)\n", + " utt_pred = int(result[1])\n", + " if utt_pred == 1:\n", + " pred = 1\n", + " first_trigger_idx = utt_idx\n", + " break\n", + "\n", + " truth = bool(convo.meta.get(\"has_removed_comment\", False))\n", + " if pred and truth:\n", + " tp += 1\n", + " horizons.append(len(utts) - first_trigger_idx)\n", + " elif pred and not truth:\n", + " fp += 1\n", + " elif not pred and not truth:\n", + " tn += 1\n", + " else:\n", + " fn += 1\n", + "\n", + " h = float(np.mean(horizons)) - 1 if horizons else float(\"nan\")\n", + " return {\n", + " \"confusion_matrix\": {\"TP\": tp, \"FP\": fp, \"TN\": tn, \"FN\": fn},\n", + " \"h\": h,\n", + " }\n", + "\n", + "\n", + "all_k_results = {}\n", + "\n", + "for seed_name, corpus in corpora.items():\n", + " print(f\"\\n[info] processing {seed_name}...\")\n", + " k_results = []\n", + "\n", + " pruned_seed_name = seed_name[len(seed_name) - 6 :]\n", + " print(f\"[info] config seed: {pruned_seed_name}\")\n", + "\n", + " with open(f\"/reef/sqt2/FinalAAO/cga-cmv-large/google/gemma-2-9b-it/{pruned_seed_name}/dev_config.json\", \"r\") as f:\n", + " dev_config = json.load(f)\n", + "\n", + " k_method_threshold = dev_config[\"best_threshold\"]\n", + " print(\"[info] k method threshold\", k_method_threshold)\n", + "\n", + " for k in k_values:\n", + " print(f\"[info] {seed_name} computing k={k}...\")\n", + " policy = DeferralDecisionPolicy(\n", + " simulator=None,\n", + " threshold=k_method_threshold,\n", + " tau=k,\n", + " num_simulations=10,\n", + " store_simulations=False,\n", + " simulated_reply_attribute_name=\"sim_replies\",\n", + " sim_replies_forecast_probs_attribute_name=\"sim_replies_forecast_probs\",\n", + " reuse_cached_simulations=True,\n", + " )\n", + " results = _deferral_policy_performance(corpus, policy)\n", + " tp = results[\"confusion_matrix\"][\"TP\"]\n", + " fp = results[\"confusion_matrix\"][\"FP\"]\n", + " tn = results[\"confusion_matrix\"][\"TN\"]\n", + " fn = results[\"confusion_matrix\"][\"FN\"]\n", + "\n", + " # calculate tpr, fpr, accuracy, precision, recall, f1\n", + " # recall == tpr; kept as a separate field for downstream readability\n", + " tpr = tp / (tp + fn) if (tp + fn) > 0 else 0\n", + " fpr = fp / (fp + tn) if (fp + tn) > 0 else 0\n", + " total = tp + fp + tn + fn\n", + " accuracy = (tp + tn) / total if total > 0 else 0\n", + " precision = tp / (tp + fp) if (tp + fp) > 0 else 0\n", + " recall = tpr\n", + " f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n", + "\n", + " k_results.append({\n", + " \"seed\": seed_name,\n", + " \"k\": k,\n", + " \"threshold\": k_method_threshold,\n", + " \"tpr\": tpr,\n", + " \"fpr\": fpr,\n", + " \"accuracy\": accuracy,\n", + " \"precision\": precision,\n", + " \"recall\": recall,\n", + " \"f1\": f1,\n", + " \"h\": results.get(\"h\", float(\"nan\")),\n", + " \"tp\": tp,\n", + " \"fp\": fp,\n", + " \"tn\": tn,\n", + " \"fn\": fn,\n", + " })\n", + "\n", + " all_k_results[seed_name] = pd.DataFrame(k_results)\n", + " print(f\"[pass] {seed_name} k-method complete - {len(all_k_results[seed_name])} points\")\n", + "\n", + "print(f\"\\n[pass] all k-method results computed for {len(all_k_results)} seeds\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "bba8d667", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] matching fprs for all seeds...\n", + "\n", + "[info] matching fprs for test-seed-1...\n", + "[PASS] test-seed-1 matched 10 fpr points\n", + "\n", + "[info] matching fprs for test-seed-2...\n", + "[PASS] test-seed-2 matched 10 fpr points\n", + "\n", + "[info] matching fprs for test-seed-3...\n", + "[PASS] test-seed-3 matched 10 fpr points\n", + "\n", + "[info] matching fprs for test-seed-4...\n", + "[PASS] test-seed-4 matched 10 fpr points\n", + "\n", + "[info] matching fprs for test-seed-5...\n", + "[PASS] test-seed-5 matched 10 fpr points\n", + "\n", + "[PASS] all matching complete for 5 seeds\n" + ] + } + ], + "source": [ + "# step 3: for each k's FPR, find the closest baseline FPR (per seed)\n", + "print(\"[info] matching fprs for all seeds...\")\n", + "all_matched_results = {}\n", + "\n", + "for seed_name in corpora.keys():\n", + " print(f\"\\n[info] matching fprs for {seed_name}...\")\n", + " matched_results = []\n", + " \n", + " k_df = all_k_results[seed_name]\n", + " baseline_df = all_baseline_results[seed_name]\n", + " \n", + " for _, k_row in k_df.iterrows():\n", + " k_fpr = k_row['fpr']\n", + " k_tpr = k_row['tpr']\n", + " k_val = k_row['k']\n", + " \n", + " # find closest baseline fpr\n", + " fpr_diffs = np.abs(baseline_df['fpr'] - k_fpr)\n", + " closest_idx = fpr_diffs.idxmin()\n", + " baseline_match = baseline_df.iloc[closest_idx]\n", + " \n", + " matched_results.append({\n", + " 'seed': seed_name,\n", + " 'k': k_val,\n", + " 'k_fpr': k_fpr,\n", + " 'k_tpr': k_tpr,\n", + " 'baseline_fpr': baseline_match['fpr'],\n", + " 'baseline_tpr': baseline_match['tpr'],\n", + " 'baseline_accuracy': baseline_match['accuracy'],\n", + " 'baseline_precision': baseline_match['precision'],\n", + " 'baseline_recall': baseline_match['recall'],\n", + " 'baseline_f1': baseline_match['f1'],\n", + " 'baseline_h': baseline_match['h'],\n", + " 'baseline_threshold': baseline_match['threshold'],\n", + " 'fpr_diff': abs(k_fpr - baseline_match['fpr']),\n", + " 'tpr_improvement': k_tpr - baseline_match['tpr']\n", + " })\n", + " \n", + " all_matched_results[seed_name] = pd.DataFrame(matched_results)\n", + " print(f\"[PASS] {seed_name} matched {len(all_matched_results[seed_name])} fpr points\")\n", + "\n", + "print(f\"\\n[PASS] all matching complete for {len(all_matched_results)} seeds\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "95588d73", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[info] matched fpr-oracle metrics for tau=7 (mean over seeds, n=5):\n", + " tau baseline_accuracy_mean baseline_precision_mean baseline_recall_mean baseline_f1_mean baseline_h_mean fpr_diff_mean tpr_improvement_mean baseline_threshold_mean baseline_fpr_mean baseline_tpr_mean\n", + " 7 0.7002 0.7152 0.6677 0.6896 2.6965 0.0036 0.0155 0.6900 0.2674 0.6677\n" + ] } + ], + "source": [ + "# average matched-baseline (oracle) metrics for tau=7, across all seeds\n", + "target_tau = 7\n", + "matched_long = pd.concat(\n", + " [df.assign(seed=seed_name) for seed_name, df in all_matched_results.items()],\n", + " ignore_index=True,\n", + ")\n", + "matched_long = matched_long[matched_long[\"k\"] == target_tau].copy()\n", + "\n", + "if matched_long.empty:\n", + " raise ValueError(f\"no matched results found for tau={target_tau}\")\n", + "\n", + "oracle_cols = [\n", + " \"baseline_accuracy\",\n", + " \"baseline_precision\",\n", + " \"baseline_recall\",\n", + " \"baseline_f1\",\n", + " \"baseline_h\",\n", + " \"fpr_diff\",\n", + " \"tpr_improvement\",\n", + " \"baseline_threshold\",\n", + " \"baseline_fpr\",\n", + " \"baseline_tpr\",\n", + "]\n", + "\n", + "oracle_stats_per_tau = (\n", + " matched_long.groupby(\"k\")[oracle_cols]\n", + " .agg(\"mean\")\n", + " .reset_index()\n", + " .rename(columns={\"k\": \"tau\"})\n", + ")\n", + "\n", + "# reformat columns to single-level, e.g. baseline_fpr_mean\n", + "oracle_stats_per_tau.columns = [\"tau\"] + [\n", + " f\"{col}_mean\" for col in oracle_cols\n", + "]\n", + "\n", + "with pd.option_context(\n", + " \"display.float_format\",\n", + " \"{:.4f}\".format,\n", + " \"display.max_columns\",\n", + " None,\n", + " \"display.width\",\n", + " 200,\n", + "):\n", + " print(\"[info] matched fpr-oracle metrics for tau=7 \"\n", + " f\"(mean over seeds, n={matched_long['seed'].nunique()}):\")\n", + " print(oracle_stats_per_tau.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b655fd20", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "lyk25-env", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 5 + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "undefined.undefined.undefined" + } + }, + "nbformat": 4, + "nbformat_minor": 5 } From 431d6932714c244e5b613d382767a9b32360a0df Mon Sep 17 00:00:00 2001 From: asungii Date: Mon, 8 Jun 2026 12:35:55 -0500 Subject: [PATCH 09/21] fixes for imports on new Decision Policies, rst add, cleaned TransformerDecoder TODOs --- convokit/decisionpolicy/__init__.py | 3 + .../forecaster/TransformerDecoderModel.py | 58 ++++++++++--------- docs/source/decisionpolicy.rst | 54 +++++++++++++++-- 3 files changed, 84 insertions(+), 31 deletions(-) diff --git a/convokit/decisionpolicy/__init__.py b/convokit/decisionpolicy/__init__.py index 43e3ab9bc..c9eb6b04b 100644 --- a/convokit/decisionpolicy/__init__.py +++ b/convokit/decisionpolicy/__init__.py @@ -1,3 +1,6 @@ from .decisionPolicy import * from .thresholdDecisionPolicy import * from .deferralDecisionPolicy import * +from .simulationAverageDecisionPolicy import * +from .simulationMajorityDecisionPolicy import * +from .randomDeferralDecisionPolicy import * \ No newline at end of file diff --git a/convokit/forecaster/TransformerDecoderModel.py b/convokit/forecaster/TransformerDecoderModel.py index 9dd14a1d5..510bf62ed 100644 --- a/convokit/forecaster/TransformerDecoderModel.py +++ b/convokit/forecaster/TransformerDecoderModel.py @@ -390,15 +390,16 @@ def transform( preds = [] scores = [] metadatas = defaultdict(list) - # TODO(metrics): temporary running metric logging during transform; remove before merge. + # verbose-only diagnostics: running conversation-level metrics and an + # incremental predictions.csv dump. skipped entirely in the default path. report_every_n = 250 prediction_file = os.path.join(self.config.output_dir, "predictions.csv") - if os.path.exists(prediction_file): - os.remove(prediction_file) next_flush_start = 0 csv_header_written = False convo_forecasts = {} convo_labels = {} + if verbose and os.path.exists(prediction_file): + os.remove(prediction_file) def _compute_conversation_metrics(): common_convo_ids = [cid for cid in convo_forecasts if cid in convo_labels] @@ -459,6 +460,9 @@ def _compute_conversation_metrics(): metadatas[key] = [None] * current_idx metadatas[key].append(value) + if not verbose: + continue + convo_id = getattr(context, "conversation_id", None) try: convo = context.current_utterance.get_conversation() @@ -491,22 +495,21 @@ def _compute_conversation_metrics(): next_flush_start = idx running_metrics = _compute_conversation_metrics() - if verbose: - if running_metrics is not None: - tqdm.write( - f"[info] transform metrics running: " - f"processed_contexts={idx}, conversations={running_metrics['n']}, " - f"acc={running_metrics['acc']:.4f}, p={running_metrics['p']:.4f}, " - f"r={running_metrics['r']:.4f}, fpr={running_metrics['fpr']:.4f}, " - f"f1={running_metrics['f1']:.4f}" - ) - else: - tqdm.write( - f"[info] transform metrics running: " - f"processed_contexts={idx}, conversations=0" - ) + if running_metrics is not None: + tqdm.write( + f"[info] transform metrics running: " + f"processed_contexts={idx}, conversations={running_metrics['n']}, " + f"acc={running_metrics['acc']:.4f}, p={running_metrics['p']:.4f}, " + f"r={running_metrics['r']:.4f}, fpr={running_metrics['fpr']:.4f}, " + f"f1={running_metrics['f1']:.4f}" + ) + else: + tqdm.write( + f"[info] transform metrics running: " + f"processed_contexts={idx}, conversations=0" + ) total_processed = len(preds) - if total_processed > next_flush_start: + if verbose and total_processed > next_flush_start: batch_cols = { forecast_attribute_name: preds[next_flush_start:total_processed], forecast_prob_attribute_name: scores[next_flush_start:total_processed], @@ -524,15 +527,16 @@ def _compute_conversation_metrics(): forecast_attribute_name: preds, forecast_prob_attribute_name: scores, } - final_metrics = _compute_conversation_metrics() - if final_metrics is not None: - tqdm.write( - f"[info] final transform metrics: " - f"processed_contexts={len(preds)}, conversations={final_metrics['n']}, " - f"acc={final_metrics['acc']:.4f}, p={final_metrics['p']:.4f}, " - f"r={final_metrics['r']:.4f}, fpr={final_metrics['fpr']:.4f}, " - f"f1={final_metrics['f1']:.4f}" - ) + if verbose: + final_metrics = _compute_conversation_metrics() + if final_metrics is not None: + tqdm.write( + f"[info] final transform metrics: " + f"processed_contexts={len(preds)}, conversations={final_metrics['n']}, " + f"acc={final_metrics['acc']:.4f}, p={final_metrics['p']:.4f}, " + f"r={final_metrics['r']:.4f}, fpr={final_metrics['fpr']:.4f}, " + f"f1={final_metrics['f1']:.4f}" + ) for key, series in metadatas.items(): assert len(series) == len( preds diff --git a/docs/source/decisionpolicy.rst b/docs/source/decisionpolicy.rst index 48eebd1a7..2ecd53abf 100644 --- a/docs/source/decisionpolicy.rst +++ b/docs/source/decisionpolicy.rst @@ -1,9 +1,55 @@ Decision Policy =============== -The decision policy API separates belief estimation (continuous scores) from -intervention decisions (discrete actions). This keeps ``Forecaster`` unchanged -while allowing flexible action logic in ``ForecasterModel``. +A decision policy converts the continuous score produced by a ForecasterModel's belief estimator into a +discrete intervention decision. Separating belief estimation (the score) from the action (intervene or not) +lets you swap decision logic, ranging from simple thresholding to look-ahead deferral and simulation-based +voting, without retraining or modifying the underlying forecaster. -.. automodule:: convokit.decisionpolicy +Every policy implements two methods: + +* ``decide(context, score_fn)``: returns a ``(score, action, metadata)`` tuple, where ``action`` is the binary + intervention decision and ``metadata`` is an optional dict of extra per-utterance information (e.g. the + simulated replies used by deferral policies). +* ``fit(contexts, val_contexts, score_fn)``: tunes policy-specific parameters (such as the decision threshold) + on a held-out validation set. + +A ForecasterModel owns a single decision policy, defaulting to ``ThresholdDecisionPolicy``, and exposes it via +its ``decision_policy`` property. The policy receives the model's ``score`` function as ``score_fn`` and shares +the model's labeler and ``forecast_prob`` cache key so it can reuse already-computed forecast probabilities. + +Base Class +---------- + +.. automodule:: convokit.decisionpolicy.decisionPolicy + :members: + +Threshold Decision Policy +------------------------- + +.. automodule:: convokit.decisionpolicy.thresholdDecisionPolicy + :members: + +Deferral Decision Policy +------------------------ + +.. automodule:: convokit.decisionpolicy.deferralDecisionPolicy + :members: + +Random Deferral Decision Policy +------------------------------- + +.. automodule:: convokit.decisionpolicy.randomDeferralDecisionPolicy + :members: + +Simulation Average Decision Policy +---------------------------------- + +.. automodule:: convokit.decisionpolicy.simulationAverageDecisionPolicy + :members: + +Simulation Majority Decision Policy +----------------------------------- + +.. automodule:: convokit.decisionpolicy.simulationMajorityDecisionPolicy :members: From 760403cdad572e98ce02d33394fd2bb6dcdeccee Mon Sep 17 00:00:00 2001 From: asungii Date: Mon, 8 Jun 2026 13:23:19 -0500 Subject: [PATCH 10/21] black reformat --- convokit/decisionpolicy/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/convokit/decisionpolicy/__init__.py b/convokit/decisionpolicy/__init__.py index c9eb6b04b..7f1a970ce 100644 --- a/convokit/decisionpolicy/__init__.py +++ b/convokit/decisionpolicy/__init__.py @@ -3,4 +3,4 @@ from .deferralDecisionPolicy import * from .simulationAverageDecisionPolicy import * from .simulationMajorityDecisionPolicy import * -from .randomDeferralDecisionPolicy import * \ No newline at end of file +from .randomDeferralDecisionPolicy import * From 87fc7f3cfeff31625f316bd23ba082a16c954119 Mon Sep 17 00:00:00 2001 From: laerdon Date: Tue, 9 Jun 2026 02:58:17 +0000 Subject: [PATCH 11/21] updated download config with human benchmark entry, downloader fixes to decisionpolicy_demo --- download_config.json | 6 +- .../decisionpolicy/decisionpolicy_demo.ipynb | 89 ++----------------- 2 files changed, 9 insertions(+), 86 deletions(-) diff --git a/download_config.json b/download_config.json index 3027a0d28..03c774312 100644 --- a/download_config.json +++ b/download_config.json @@ -42,7 +42,8 @@ "contextual-abuse": 0, "news-interview": 0, "emotional-support": 0, - "decisionpolicy-demo": 0 + "decisionpolicy-demo": 0, + "human-benchmark": 0 }, "DatasetURLs": { "chromium-corpus": "http://zissou.infosci.cornell.edu/convokit/datasets/chromium-corpus/chromium-corpus.zip", @@ -117,7 +118,8 @@ "contextual-abuse": "https://zissou.infosci.cornell.edu/convokit/datasets/contextual-abuse/contextual-abuse.zip", "news-interview": "https://zissou.infosci.cornell.edu/convokit/datasets/news-interview/news-interview.zip", "emotional-support": "https://zissou.infosci.cornell.edu/convokit/datasets/emotional-support/emotional-support.zip", - "decisionpolicy-demo": "https://zissou.infosci.cornell.edu/convokit/datasets/decisionpolicy-demo/decisionpolicy-demo.zip" + "decisionpolicy-demo": "https://zissou.infosci.cornell.edu/convokit/datasets/decisionpolicy-demo/decisionpolicy-demo.zip", + "human-benchmark": "https://zissou.infosci.cornell.edu/convokit/datasets/human-benchmark/human-benchmark.zip" }, "ModelURLS": { "craft-wiki-pretrained": [ diff --git a/examples/decisionpolicy/decisionpolicy_demo.ipynb b/examples/decisionpolicy/decisionpolicy_demo.ipynb index 50a4ffca7..8fa14b0cf 100644 --- a/examples/decisionpolicy/decisionpolicy_demo.ipynb +++ b/examples/decisionpolicy/decisionpolicy_demo.ipynb @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "18f2375b", "metadata": {}, "outputs": [ @@ -117,49 +117,9 @@ } ], "source": [ - "# TODO temporary pre-merge downloader for decisionpolicy-demo\n", "from pathlib import Path\n", - "import json\n", - "import urllib.request\n", - "import zipfile\n", - "\n", - "from convokit import Corpus\n", - "\n", - "DOWNLOAD_CONFIG_PATH = Path(\"/reef/lyk25/ConvoKit/download_config.json\")\n", - "\n", - "\n", - "def get_dataset_url(config_path=DOWNLOAD_CONFIG_PATH, dataset=\"decisionpolicy-demo\"):\n", - " print(f\"[info] reading download config from {config_path}\")\n", - " with open(config_path) as infile:\n", - " dataset_config = json.load(infile)\n", - " try:\n", - " return dataset_config[\"DatasetURLs\"][dataset]\n", - " except KeyError as exc:\n", - " raise KeyError(f\"{dataset} is missing from local download_config.json\") from exc\n", - "\n", - "def download_dataset(data_dir=None, dataset_name=\"decisionpolicy-demo\"):\n", - " data_root = Path(data_dir or \"~/.convokit/saved-corpora\").expanduser()\n", - " dataset_dir = data_root / dataset_name\n", - " zip_path = data_root / f\"{dataset_name}.zip\"\n", "\n", - " if any(path.is_dir() and (path / \"index.json\").exists() for path in dataset_dir.rglob(\"*\")):\n", - " print(f\"[info] using cached {dataset_name} at {dataset_dir}\")\n", - " return dataset_dir\n", - "\n", - " url = get_dataset_url(dataset=dataset_name)\n", - " data_root.mkdir(parents=True, exist_ok=True)\n", - " print(f\"[info] downloading {dataset_name} from {url}\")\n", - " urllib.request.urlretrieve(url, zip_path)\n", - "\n", - " print(f\"[info] extracting {zip_path} to {data_root}\")\n", - " with zipfile.ZipFile(zip_path, \"r\") as zipf:\n", - " zipf.extractall(data_root)\n", - "\n", - " if not dataset_dir.exists():\n", - " raise FileNotFoundError(f\"expected extracted folder missing: {dataset_dir}\")\n", - " return dataset_dir\n", - "\n", - "base = download_dataset()" + "base = Path(download(\"decisionpolicy-demo\"))\n" ] }, { @@ -1795,30 +1755,7 @@ "execution_count": null, "id": "dde130ed", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset already exists at /reef/lyk25/ConvoKit/examples/forecaster/conversations-gone-awry-cmv-corpus-large\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[14], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m seed_idx \u001b[38;5;129;01min\u001b[39;00m SEEDS:\n\u001b[0;32m----> 2\u001b[0m train_corpus \u001b[38;5;241m=\u001b[39m \u001b[43mCorpus\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdownload\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mconversations-gone-awry-cmv-corpus-large\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# corpus = Corpus(filename=f'/reef/lyk25/theres-a-way-out-ACL26-internal/outputs/benchmark_preannotated/seed-{seed_idx}-ThresholdDecisionPolicy/ThresholdDecisionPolicy')\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# corpus = Corpus(filename=f'/reef/lyk25/dynamic_training/game_analysis/corpi/test/test-son-seed-{seed_idx}')\u001b[39;00m\n\u001b[1;32m 5\u001b[0m corpus \u001b[38;5;241m=\u001b[39m Corpus(filename\u001b[38;5;241m=\u001b[39mdownload(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mconversations-gone-awry-cmv-corpus-large\u001b[39m\u001b[38;5;124m'\u001b[39m))\n", - "File \u001b[0;32m/reef/lyk25/ConvoKit/convokit/model/corpus.py:206\u001b[0m, in \u001b[0;36mCorpus.__init__\u001b[0;34m(self, filename, utterances, db_collection_prefix, db_host, preload_vectors, utterance_start_index, utterance_end_index, merge_lines, exclude_utterance_meta, exclude_conversation_meta, exclude_speaker_meta, exclude_overall_meta, disable_type_check, backend, backend_mapper)\u001b[0m\n\u001b[1;32m 203\u001b[0m \u001b[38;5;66;03m# if corpus is nonempty (check for self.utterances), construct the conversation\u001b[39;00m\n\u001b[1;32m 204\u001b[0m \u001b[38;5;66;03m# data from the utterance list\u001b[39;00m\n\u001b[1;32m 205\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutterances\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m--> 206\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconversations \u001b[38;5;241m=\u001b[39m \u001b[43minitialize_conversations\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 207\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconvos_data\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfill_missing_convo_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\n\u001b[1;32m 208\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmeta_index\u001b[38;5;241m.\u001b[39menable_type_check()\n\u001b[1;32m 210\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mupdate_speakers_data()\n", - "File \u001b[0;32m/reef/lyk25/ConvoKit/convokit/model/corpus_helpers.py:485\u001b[0m, in \u001b[0;36minitialize_conversations\u001b[0;34m(corpus, convos_data, convo_to_utts, fill_missing_convo_ids)\u001b[0m\n\u001b[1;32m 477\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 478\u001b[0m \u001b[38;5;124;03mInitialize Conversation objects from utterances and conversations data.\u001b[39;00m\n\u001b[1;32m 479\u001b[0m \u001b[38;5;124;03mIf a mapping from Conversation IDs to their constituent Utterance IDs is\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 482\u001b[0m \u001b[38;5;124;03mwill be computed by iteration over the Utterances in utt_dict.\u001b[39;00m\n\u001b[1;32m 483\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 484\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m fill_missing_convo_ids:\n\u001b[0;32m--> 485\u001b[0m \u001b[43mfill_missing_conversation_ids\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcorpus\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mutterances\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 487\u001b[0m \u001b[38;5;66;03m# organize utterances by conversation\u001b[39;00m\n\u001b[1;32m 488\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m convo_to_utts \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m/reef/lyk25/ConvoKit/convokit/model/corpus_helpers.py:439\u001b[0m, in \u001b[0;36mfill_missing_conversation_ids\u001b[0;34m(utterances_dict)\u001b[0m\n\u001b[1;32m 437\u001b[0m convo_roots_with_convo_ids\u001b[38;5;241m.\u001b[39mappend(utt\u001b[38;5;241m.\u001b[39mid)\n\u001b[1;32m 438\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 439\u001b[0m utt_ids_to_replier_ids[utt\u001b[38;5;241m.\u001b[39mreply_to]\u001b[38;5;241m.\u001b[39mappend(\u001b[43mutt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mid\u001b[49m)\n\u001b[1;32m 441\u001b[0m \u001b[38;5;66;03m# connect the reply-to edges for convo roots without convo ids\u001b[39;00m\n\u001b[1;32m 442\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m root_utt_id \u001b[38;5;129;01min\u001b[39;00m convo_roots_without_convo_ids:\n", - "File \u001b[0;32m/reef/lyk25/ConvoKit/convokit/model/corpusComponent.py:87\u001b[0m, in \u001b[0;36mCorpusComponent.get_id\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 84\u001b[0m ck_meta[key] \u001b[38;5;241m=\u001b[39m value\n\u001b[1;32m 85\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ck_meta\n\u001b[0;32m---> 87\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mget_id\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 88\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_id\n\u001b[1;32m 90\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mset_id\u001b[39m(\u001b[38;5;28mself\u001b[39m, value):\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "for seed_idx in SEEDS:\n", " train_corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", @@ -2124,23 +2061,7 @@ } ], "source": [ - "# TODO replace with actual download\n", - "\n", - "human_base = download_dataset(dataset_name=\"human-benchmark\")\n", - "\n", - "if (human_base / \"index.json\").exists():\n", - " corpus = Corpus(filename=str(human_base))\n", - "else:\n", - " human_corpus_dirs = sorted(\n", - " path\n", - " for path in human_base.rglob(\"*\")\n", - " if path.is_dir() and (path / \"index.json\").exists()\n", - " )\n", - "\n", - " if len(human_corpus_dirs) != 1:\n", - " raise ValueError(f\"expected 1 corpus, found {len(human_corpus_dirs)}: {human_corpus_dirs}\")\n", - "\n", - " corpus = Corpus(filename=str(human_corpus_dirs[0]))" + "corpus = Corpus(filename=download(\"human-benchmark\"))" ] }, { @@ -3309,7 +3230,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "undefined.undefined.undefined" + "version": "3.11.11" } }, "nbformat": 4, From 184408f524ac1ce8bd5aa4739a11b7881225b95c Mon Sep 17 00:00:00 2001 From: laerdon Date: Fri, 12 Jun 2026 15:35:37 +0000 Subject: [PATCH 12/21] updated decision rst to add arxiv --- docs/source/decisionpolicy.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/source/decisionpolicy.rst b/docs/source/decisionpolicy.rst index 2ecd53abf..f69518ca6 100644 --- a/docs/source/decisionpolicy.rst +++ b/docs/source/decisionpolicy.rst @@ -18,6 +18,8 @@ A ForecasterModel owns a single decision policy, defaulting to ``ThresholdDecisi its ``decision_policy`` property. The policy receives the model's ``score`` function as ``score_fn`` and shares the model's labeler and ``forecast_prob`` cache key so it can reuse already-computed forecast probabilities. +This mechanism is introduced in ["Wait! There’s a Way Out"](https://arxiv.org/abs/2605.29243). + Base Class ---------- From 90e4ab285f21bff69cf43cc7fd63c2d15d9735b8 Mon Sep 17 00:00:00 2001 From: laerdon Date: Sat, 27 Jun 2026 14:47:57 +0000 Subject: [PATCH 13/21] updates to docs, added decisionpolicy demo to Run Transformer Finetuned Models, version bump --- README.md | 2 +- convokit/pivotal_framework/pivotal_demo.ipynb | 474 +++- docs/source/conf.py | 2 +- docs/source/decisionpolicy.rst | 2 +- docs/source/forecaster.rst | 85 +- docs/source/index.rst | 2 +- docs/source/transformerforecastertraining.rst | 88 + .../decisionpolicy/decisionpolicy_demo.ipynb | 112 +- .../Run Transformer Fine-tuned Models.ipynb | 2169 +++++++++++------ setup.py | 3 +- website/docs/source/conf.py | 2 +- website/docs/source/index.rst | 2 +- 12 files changed, 2058 insertions(+), 885 deletions(-) diff --git a/README.md b/README.md index 62a3f4118..973c1dd76 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ [![license](https://img.shields.io/badge/license-MIT-green)](https://github.com/CornellNLP/ConvoKit/blob/master/LICENSE.md) [![Discord Community](https://img.shields.io/static/v1?logo=discord&style=flat&color=red&label=discord&message=community)](https://discord.gg/WMFqMWgz6P) -This toolkit contains tools to extract conversational features and analyze social phenomena in conversations, using a [single unified interface](https://convokit.cornell.edu/documentation/architecture.html) inspired by (and compatible with) scikit-learn. Several large [conversational datasets](https://github.com/CornellNLP/ConvoKit#datasets) are included together with scripts exemplifying the use of the toolkit on these datasets. The latest version is [4.1.1](https://github.com/CornellNLP/ConvoKit/releases/tag/v4.1.1) (released May 1, 2026); follow the [project on GitHub](https://github.com/CornellNLP/ConvoKit) to keep track of updates. +This toolkit contains tools to extract conversational features and analyze social phenomena in conversations, using a [single unified interface](https://convokit.cornell.edu/documentation/architecture.html) inspired by (and compatible with) scikit-learn. Several large [conversational datasets](https://github.com/CornellNLP/ConvoKit#datasets) are included together with scripts exemplifying the use of the toolkit on these datasets. The latest version is [4.1.2](https://github.com/CornellNLP/ConvoKit/releases/tag/v4.1.2) (released June 26, 2026); follow the [project on GitHub](https://github.com/CornellNLP/ConvoKit) to keep track of updates. Join our [Discord community](https://discord.gg/WMFqMWgz6P) to stay informed, connect with fellow developers, and be part of an engaging space where we share progress, discuss features, and tackle issues together. diff --git a/convokit/pivotal_framework/pivotal_demo.ipynb b/convokit/pivotal_framework/pivotal_demo.ipynb index a6cfab064..56c02ac99 100644 --- a/convokit/pivotal_framework/pivotal_demo.ipynb +++ b/convokit/pivotal_framework/pivotal_demo.ipynb @@ -18,14 +18,16 @@ "metadata": {}, "outputs": [], "source": [ - "!pip install git+https://github.com/CornellNLP/ConvoKit.git\n", + "# !pip install git+https://github.com/CornellNLP/ConvoKit.git\n", "# !pip install -q convokit\n", "\n", "# Do this only in Colab notebooks!\n", "# !pip install --no-deps bitsandbytes accelerate xformers==0.0.29.post3 peft trl==0.15.2 triton cut_cross_entropy unsloth_zoo\n", "# !pip install sentencepiece protobuf \"datasets>=3.4.1\" huggingface_hub hf_transfer\n", "# !pip install transformers==4.51.3\n", - "# !pip install --no-deps unsloth" + "# !pip install --no-deps unsloth\n", + "\n", + "!pip install -e /reef/lyk25/ConvoKit" ] }, { @@ -38,13 +40,45 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "603194f5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-06-08 20:00:34.731372: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2026-06-08 20:00:34.750975: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1780948834.774631 1186876 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1780948834.782324 1186876 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1780948834.801417 1186876 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1780948834.801440 1186876 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1780948834.801443 1186876 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1780948834.801445 1186876 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "2026-06-08 20:00:34.806924: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🦥 Unsloth Zoo will now patch everything to make training faster!\n" + ] + } + ], "source": [ "import os\n", - "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"3\"\n", "\n", "from convokit import Corpus, download\n", "from convokit.pivotal_framework.pivotal import PivotalMomentMeasure\n", @@ -67,10 +101,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "c02abbe6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset already exists at /reef/lyk25/ConvoKit/examples/forecaster/YOUR_DATA_DIRECTORY/conversations-gone-awry-cmv-corpus\n", + "Number of Speakers: 9548\n", + "Number of Utterances: 42964\n", + "Number of Conversations: 6842\n" + ] + } + ], "source": [ "corpus = Corpus(filename=download(\"conversations-gone-awry-cmv-corpus\"))\n", "# If you have the corpus saved locally, load it as follows:\n", @@ -90,10 +135,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "1d2c6e07", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3421\n" + ] + } + ], "source": [ "pair_ids = set()\n", "for i, convo in enumerate(corpus.iter_conversations()):\n", @@ -124,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "d9fe6cea", "metadata": {}, "outputs": [], @@ -159,10 +212,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "3561ff02", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Forecaster (train, val, test)\n", + "800 100 100\n", + "Simulator (train, val)\n", + "900 100\n", + "Analysis\n", + "20\n" + ] + } + ], "source": [ "def get_paired_sample(sample):\n", " result = []\n", @@ -202,7 +268,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "ff4dada0", "metadata": {}, "outputs": [], @@ -233,7 +299,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "a6012350", "metadata": {}, "outputs": [], @@ -252,7 +318,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "e580a2fe", "metadata": {}, "outputs": [], @@ -305,10 +371,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "641bacb9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nDEFAULT_NUM_SIMULATIONS = 10\\n\\nDEFAULT_LLAMA_CHAT_TEMPLATE = \"llama3\"\\nDEFAULT_LLAMA_CHAT_TEMPLATE_MAPPING = {\\n \"role\": \"from\",\\n \"content\": \"value\",\\n \"user\": \"human\",\\n \"assistant\": \"gpt\",\\n}\\n\\nDEFAULT_MODEL_CONFIG = {\\n \"load_in_4bit\": True,\\n \"max_seq_length\": 2048,\\n \"dtype\": None,\\n \"target_modules\": [\\n \"q_proj\",\\n \"k_proj\",\\n \"v_proj\",\\n \"o_proj\",\\n \"gate_proj\",\\n \"up_proj\",\\n \"down_proj\",\\n \"embed_tokens\",\\n \"lm_head\",\\n ],\\n \"r\": 16,\\n \"lora_alpha\": 16,\\n \"lora_dropout\": 0,\\n \"bias\": \"none\",\\n \"use_gradient_checkpointing\": \"unsloth\",\\n \"use_rslora\": False,\\n \"loftq_config\": None,\\n}\\n\\nDEFAULT_TRAIN_CONFIG = {\\n \"per_device_train_batch_size\": 16,\\n \"per_device_eval_batch_size\": 16,\\n \"eval_strategy\": \"steps\",\\n \"save_strategy\": \"steps\",\\n \"save_steps\": 30,\\n \"gradient_accumulation_steps\": 4,\\n \"warmup_steps\": 5,\\n \"num_train_epochs\": 1,\\n \"eval_steps\": 30,\\n \"learning_rate\": 2e-4,\\n \"logging_steps\": 5,\\n \"optim\": \"adamw_8bit\",\\n \"weight_decay\": 0.01,\\n \"lr_scheduler_type\": \"linear\",\\n \"output_dir\": \"outputs\",\\n \"logging_dir\": \"logs\",\\n \"load_best_model_at_end\": True,\\n}\\n'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "DEFAULT_NUM_SIMULATIONS = 10\n", @@ -369,10 +446,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "cba48afa", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==((====))== Unsloth 2025.7.11: Fast Llama patching. Transformers: 4.53.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", + "Unsloth: Offloading input_embeddings to disk to save VRAM\n", + "Unsloth: Offloading output_embeddings to disk to save VRAM\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Unsloth 2025.7.11 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unsloth: Training embed_tokens in mixed precision to save VRAM\n", + "Unsloth: Training lm_head in mixed precision to save VRAM\n" + ] + } + ], "source": [ "DEVICE = \"cuda\"\n", "simulator_model = UnslothUtteranceSimulatorModel(\n", @@ -399,10 +506,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "aa81a2fe", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + } + ], "source": [ "model_name_or_path = 'roberta-large'\n", "config_dict = TransformerForecasterConfig(\n", @@ -427,7 +543,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "d8c53ac7", "metadata": {}, "outputs": [], @@ -457,10 +573,195 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "556a16e0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:accelerate.utils.other:Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n", + "==((====))== Unsloth - 2x faster free finetuning | Num GPUs used = 1\n", + " \\\\ /| Num examples = 800 | Num Epochs = 4 | Total steps = 800\n", + "O^O/ \\_/ \\ Batch size per device = 4 | Gradient accumulation steps = 1\n", + "\\ / Data Parallel GPUs = 1 | Total batch size (4 x 1 x 1) = 4\n", + " \"-____-\" Trainable parameters = 355,361,794 of 355,361,794 (100.00% trained)\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: \u001b[33mWARNING\u001b[0m The `run_name` is currently set to the same value as `TrainingArguments.output_dir`. If this was not intended, please specify a different run name by setting the `TrainingArguments.run_name` parameter.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mkim-laerdon\u001b[0m (\u001b[33mkim-laerdon-cornell-university\u001b[0m) to \u001b[32mhttps://api.wandb.ai\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.20.1" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /reef/lyk25/ConvoKit/convokit/pivotal_framework/wandb/run-20260608_200320-i09ahqpa" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run YOUR_SAVING_DIRECTORY to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://wandb.ai/kim-laerdon-cornell-university/huggingface" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://wandb.ai/kim-laerdon-cornell-university/huggingface/runs/i09ahqpa" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [800/800 04:35, Epoch 4/4]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
2000.702200
4000.627000
6000.577500
8000.438700

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:03<00:00, 32.62it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy: checkpoint-200 0.68\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:03<00:00, 32.37it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy: checkpoint-400 0.71\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:03<00:00, 31.90it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy: checkpoint-600 0.69\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:03<00:00, 32.04it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "accuracy: checkpoint-800 0.69\n", + "deleting: YOUR_SAVING_DIRECTORY/checkpoint-200\n", + "deleting: YOUR_SAVING_DIRECTORY/checkpoint-600\n", + "deleting: YOUR_SAVING_DIRECTORY/checkpoint-800\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:02<00:00, 35.98it/s]\n", + "701it [00:42, 16.48it/s]\n" + ] + } + ], "source": [ "piv_transformer.fit_forecaster(\n", " corpus=corpus,\n", @@ -475,7 +776,118 @@ "execution_count": null, "id": "34db603f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "229a5bbf69e8407faced4dd7da11fcce", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Map: 0%| | 0/4730 [00:00\n", + " \n", + " \n", + " [39/74 42:55 < 40:35, 0.01 it/s, Epoch 0.51/1]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining LossValidation Loss
300.6384000.659977

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Unsloth: Not an error, but LlamaForCausalLM does not accept `num_items_in_batch`.\n", + "Using gradient accumulation will be very slightly less accurate.\n", + "Read more on gradient accumulation issues here: https://unsloth.ai/blog/gradient\n" + ] + } + ], "source": [ "piv_transformer.fit_simulator(\n", " corpus=corpus,\n", @@ -538,11 +950,19 @@ "source": [ "print_random_convo(analysis)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "170c7d9f", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "lyk25-env", "language": "python", "name": "python3" }, @@ -556,7 +976,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.4" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/docs/source/conf.py b/docs/source/conf.py index 9db0c116f..43e4733a4 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -66,7 +66,7 @@ # The short X.Y version. version = "4.1" # The full version, including alpha/beta/rc tags. -release = "4.1.1" +release = "4.1.2" # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/docs/source/decisionpolicy.rst b/docs/source/decisionpolicy.rst index f69518ca6..2df99c964 100644 --- a/docs/source/decisionpolicy.rst +++ b/docs/source/decisionpolicy.rst @@ -18,7 +18,7 @@ A ForecasterModel owns a single decision policy, defaulting to ``ThresholdDecisi its ``decision_policy`` property. The policy receives the model's ``score`` function as ``score_fn`` and shares the model's labeler and ``forecast_prob`` cache key so it can reuse already-computed forecast probabilities. -This mechanism is introduced in ["Wait! There’s a Way Out"](https://arxiv.org/abs/2605.29243). +This mechanism is introduced in `Wait! There's a Way Out `_. Base Class ---------- diff --git a/docs/source/forecaster.rst b/docs/source/forecaster.rst index cd0fe35b0..26e9548e2 100644 --- a/docs/source/forecaster.rst +++ b/docs/source/forecaster.rst @@ -27,6 +27,19 @@ Illustrative example, a conversation containing utterances ``[a, b, c, d]`` (in #. ``(context=[a,b,c], current_utterance=c, future_context=[d])`` #. ``(context=[a,b,c,d], current_utterance=d, future_context=[])`` +Belief estimation and decision policies +--------------------------------------- + +ConvoKit splits conversational forecasting into two steps: + +* **Belief estimation** — the forecaster model assigns a continuous score to each conversational context (typically a probability that a target event will occur). This is implemented by ``ForecasterModel.score()``. +* **Decision policy** — a separate component converts that score into a binary **intervention decision** (intervene now, or wait). This is implemented by ``DecisionPolicy.decide()``. + +Separating belief from action lets you change *when* to intervene—for example simple thresholding, look-ahead deferral, or simulation-based voting—without retraining or modifying the underlying forecaster. Each ``ForecasterModel`` owns one decision policy (default: ``ThresholdDecisionPolicy``), exposed via the ``decision_policy`` property. + +At inference time, the model scores the current context, then the policy decides whether to act. During training, ``fit()`` can train both components; you can also call ``fit_belief_estimator()`` and ``fit_decision_policy()`` separately. + +For policy types, API details, and implementation notes, see :doc:`decisionpolicy`. .. automodule:: convokit.forecaster.forecaster :members: @@ -34,6 +47,8 @@ Illustrative example, a conversation containing utterances ``[a, b, c, d]`` (in .. automodule:: convokit.forecaster.forecasterModel :members: +This two-stage design is introduced in `Wait! There's a Way Out `_. + Forecaster Model ================ These are subclasses of ForecasterModel, each implementing forecasting models using different model architectures or families. @@ -49,35 +64,45 @@ These are subclasses of ForecasterModel, each implementing forecasting models us The following table is the current leaderboard comparing the performance of different forecaster models following a uniform evaluation framework described in `Tran et al., 2025 `_. If you want to include the performance of another model in this leaderboard, make a pull request with the respective ForecasterModel class and with the version of this `demo `_ that generates the respective new leaderboard line. -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| Model | Acc ↑ | P ↑ | R ↑ | F1 ↑ | FPR ↓| Mean H ↑ | Recovery ↑ | -+================+=======+======+=======+=======+======+==========+=========================+ -| Gemma2 9B | 71.0 | 69.1 | 76.1 | 72.3 | 34.2 | 3.9 | +1.8 (8.4 - 6.6) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| Mistral 7B | 70.7 | 68.8 | 76.0 | 72.1 | 34.6 | 4.0 | +2.9 (8.1 - 5.2) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| Phi4 14B | 70.5 | 67.7 | 78.4 | 72.6 | 37.5 | 4.0 | +2.0 (7.7 - 5.7) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| LlaMa3.1 8B | 70.0 | 68.8 | 73.2 | 70.9 | 33.2 | 4.0 | +1.7 (7.3 - 5.6) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| DeBERTaV3-large| 68.9 | 67.3 | 73.7 | 70.3 | 36.0 | 4.2 | +1.1 (7.6 - 6.5) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| RoBERTa-large | 68.6 | 67.1 | 73.4 | 70.0 | 36.1 | 4.2 | +1.6 (7.5 - 5.9) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| RoBERTa-base | 68.1 | 67.3 | 70.6 | 68.8 | 34.4 | 4.2 | +0.7 (7.4 - 6.7) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| DeBERTaV3-base | 67.9 | 66.7 | 71.4 | 69.0 | 35.7 | 4.2 | +1.5 (7.2 - 5.7) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| SpanBERT-large | 67.0 | 65.8 | 70.5 | 68.1 | 36.6 | 4.2 | +1.3 (8.3 - 7.0) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| SpanBERT-base | 66.4 | 64.7 | 72.0 | 68.2 | 39.3 | 4.4 | +1.7 (9.6 - 8.0) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| BERT-large | 65.7 | 66.0 | 65.4 | 65.5 | 34.1 | 4.2 | +0.4 (7.8 - 7.3) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| BERT-base | 65.3 | 64.1 | 70.1 | 66.9 | 39.5 | 4.4 | +1.9 (9.7 - 7.8) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| CRAFT | 62.8 | 59.4 | 81.1 | 68.5 | 55.5 | 4.7 | +4.9 (12.0 - 7.1) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ +Unless otherwise specified, the performance is reported using the ThresholdDecisionPolicy. + ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Model | Acc ↑ | P ↑ | R ↑ | F1 ↑ | FPR ↓| Mean H ↑ | Recovery ↑ | ++=============================================+=======+======+=======+=======+======+==========+=========================+ +| Gemma2 9B (ThresholdDecisionPolicy) | 70.9 | 69.0 | 76.1 | 72.3 | 34.3 | 2.91 | +1.9 (8.6 - 6.7) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Gemma2 9B (DeferralDecisionPolicy) | 70.9 | 72.0 | 68.4 | 70.1 | 26.7 | 2.77 | -0.1 (7.0 - 7.1) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Gemma2 9B (RandomDeferralDecisionPolicy) | 69.4 | 69.7 | 69.0 | 69.2 | 30.2 | 2.81 | -2.5 (8.7 - 11.3) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Gemma2 9B (SimulationAverageDecisionPolicy) | 70.2 | 68.1 | 76.6 | 72.0 | 36.1 | 3.03 | -1.2 (9.3 - 10.5) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Gemma2 9B (SimulationMajorityDecisionPolicy)| 69.9 | 67.7 | 76.7 | 71.8 | 36.9 | 3.04 | -1.2 (9.8 - 10.9) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Mistral 7B | 70.7 | 68.8 | 76.0 | 72.1 | 34.6 | 4.0 | +2.9 (8.1 - 5.2) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Phi4 14B | 70.5 | 67.7 | 78.4 | 72.6 | 37.5 | 4.0 | +2.0 (7.7 - 5.7) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| LlaMa3.1 8B | 70.0 | 68.8 | 73.2 | 70.9 | 33.2 | 4.0 | +1.7 (7.3 - 5.6) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| DeBERTaV3-large | 68.9 | 67.3 | 73.7 | 70.3 | 36.0 | 4.2 | +1.1 (7.6 - 6.5) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| RoBERTa-large | 68.6 | 67.1 | 73.4 | 70.0 | 36.1 | 4.2 | +1.6 (7.5 - 5.9) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| RoBERTa-base | 68.1 | 67.3 | 70.6 | 68.8 | 34.4 | 4.2 | +0.7 (7.4 - 6.7) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| DeBERTaV3-base | 67.9 | 66.7 | 71.4 | 69.0 | 35.7 | 4.2 | +1.5 (7.2 - 5.7) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| SpanBERT-large | 67.0 | 65.8 | 70.5 | 68.1 | 36.6 | 4.2 | +1.3 (8.3 - 7.0) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| SpanBERT-base | 66.4 | 64.7 | 72.0 | 68.2 | 39.3 | 4.4 | +1.7 (9.6 - 8.0) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| BERT-large | 65.7 | 66.0 | 65.4 | 65.5 | 34.1 | 4.2 | +0.4 (7.8 - 7.3) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| BERT-base | 65.3 | 64.1 | 70.1 | 66.9 | 39.5 | 4.4 | +1.9 (9.7 - 7.8) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| CRAFT | 62.8 | 59.4 | 81.1 | 68.5 | 55.5 | 4.7 | +4.9 (12.0 - 7.1) | ++---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ **Table 1: Forecasting derailment on CGA-CMV-large conversations.** The performance is measured in accuracy (Acc), precision (P), recall (R), F1, false positive rate (FPR), mean horizon (Mean H), and Forecast Recovery (Recovery) along with the correct and incorrect recovery rates. Results are reported as averages over five runs with @@ -117,4 +142,4 @@ different random seeds. The performance is measured in accuracy (Acc), precision (P), recall (R), F1, false positive rate (FPR), mean horizon (Mean H), and Forecast Recovery (Recovery) along with the correct and incorrect recovery rates. Results are reported as averages over five runs with different random seeds. -For more information on how to produce a leaderboard string here, see the `Run Transformer Fine-tuned Models.ipynb `_ notebook. If you would like to include your model in the leaderboard, please make a pull request adding the respective ForecasterModel and the version of the demo generating the leaderboard line. Please contact us on `Discord `_ for assistance. +For more information on how to produce a leaderboard string here, see the `Run Transformer Fine-tuned Models.ipynb `_ notebook. ``Forecaster.evaluate()`` prints a ``Leaderboard String`` via ``format_leaderboard_row()``; paste that row into table 1 above (model names up to 44 characters). If a name is longer, widen the first column separator in every row of table 1 to match. If you would like to include your model in the leaderboard, please make a pull request adding the respective ForecasterModel and the version of the demo generating the leaderboard line. Please contact us on `Discord `_ for assistance. diff --git a/docs/source/index.rst b/docs/source/index.rst index bf3293bf6..971a6d6a7 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -9,7 +9,7 @@ Cornell Conversational Analysis Toolkit (ConvoKit) Documentation This toolkit contains tools to extract conversational features and analyze social phenomena in conversations, using a `single unified interface `_ inspired by (and compatible with) scikit-learn. Several large `conversational datasets `_ are included together with scripts exemplifying the use of the toolkit on these datasets. -More information can be found at our `website `_. The latest version is `4.1.1 `_ (released May 1, 2026). +More information can be found at our `website `_. The latest version is `4.1.2 `_ (released June 26, 2026). Contents -------- diff --git a/docs/source/transformerforecastertraining.rst b/docs/source/transformerforecastertraining.rst index 68970930c..51ea1be32 100644 --- a/docs/source/transformerforecastertraining.rst +++ b/docs/source/transformerforecastertraining.rst @@ -1,5 +1,93 @@ Transformer Forecaster Configuration ======================================== +``TransformerForecasterConfig`` is a dataclass that holds training and runtime settings for transformer-based +``ForecasterModel`` implementations, including :doc:`transformerencodermodel` and :doc:`transformerdecodermodel`. +Pass a config when constructing the model; the model stores it on ``self.config`` and uses it during ``fit()``, +``transform()``, checkpoint loading, and inference. + +Install LLM dependencies first: ``pip install convokit[llm]``. + +Usage +----- + +``output_dir`` is the only required field. Other hyperparameters have defaults: + +.. code-block:: python + + from convokit.forecaster import TransformerForecasterConfig, TransformerEncoderModel + + config = TransformerForecasterConfig( + output_dir="YOUR_SAVING_DIRECTORY", + per_device_batch_size=4, + gradient_accumulation_steps=1, + num_train_epochs=4, + learning_rate=6.7e-6, + random_seed=1, + context_mode="normal", + device="cuda", + ) + model = TransformerEncoderModel("bert-base-uncased", config=config) + +For inference-only runs (loading an existing checkpoint), you can pass a minimal config with ``output_dir``, +``context_mode``, and ``device``; training hyperparameters are ignored. + +Configuration fields +-------------------- + +``output_dir`` + Directory for checkpoints, prediction CSVs, and training logs. Created automatically if it does not exist. + Encoder models write ``test_predictions.csv`` and ``val_predictions.csv`` here; decoder models write + ``predictions.csv``. Checkpoints are subfolders named ``checkpoint-*``. + +``per_device_batch_size`` + Batch size per GPU during training. Effective batch size is + ``per_device_batch_size * gradient_accumulation_steps`` (times the number of GPUs if using distributed training). + +``gradient_accumulation_steps`` + Accumulate gradients over this many steps before an optimizer update. Useful when GPU memory limits batch size; + decoder models often use a larger value (e.g. 32) to simulate a larger batch. + +``num_train_epochs`` + Number of passes over the training data. + +``learning_rate`` + Optimizer learning rate. Encoder and decoder models ship with different class-level defaults (see below). + +``random_seed`` + Seed passed to the Hugging Face ``Trainer`` (encoder models). Improves reproducibility across runs. + +``device`` + Where tensors are placed at inference time, e.g. ``"cuda"``, ``"cuda:0"``, or ``"cpu"``. + +``context_mode`` + How conversational input is built for each context tuple: + + * ``"normal"`` — include prior utterances plus the current utterance (default). + * ``"no-context"`` — use only the current utterance, ablating conversational history. + + Must be one of these two values; anything else raises ``ValueError``. + +Model defaults +-------------- + +If you omit ``config``, each model class uses its own ``DEFAULT_CONFIG``: + +**TransformerEncoderModel** — ``per_device_batch_size=4``, ``gradient_accumulation_steps=1``, +``num_train_epochs=1``, ``learning_rate=6.7e-6``. + +**TransformerDecoderModel** — ``per_device_batch_size=2``, ``gradient_accumulation_steps=32``, +``num_train_epochs=1``, ``learning_rate=1e-4``. + +These defaults are starting points; demos and benchmarks often override them (see +`Transformer Forecaster demo `_). + +See also +-------- + +* :doc:`forecaster` — Forecaster wrapper and decision policies +* :doc:`transformerencodermodel` — BERT-style encoder forecasters +* :doc:`transformerdecodermodel` — LLM decoder forecasters (Llama, Gemma, etc.) + .. automodule:: convokit.forecaster.TransformerForecasterConfig :members: diff --git a/examples/decisionpolicy/decisionpolicy_demo.ipynb b/examples/decisionpolicy/decisionpolicy_demo.ipynb index 8fa14b0cf..7beda1c2a 100644 --- a/examples/decisionpolicy/decisionpolicy_demo.ipynb +++ b/examples/decisionpolicy/decisionpolicy_demo.ipynb @@ -25,15 +25,13 @@ "metadata": {}, "outputs": [], "source": [ - "# TODO\n", - "\n", "import os\n", - "os.environ['CUDA_VISIBLE_DEVICES'] = '2'" + "os.environ['CUDA_VISIBLE_DEVICES'] = '0'" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "fd8b87be", "metadata": {}, "outputs": [ @@ -48,16 +46,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-05-09 06:39:57.997129: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", - "2026-05-09 06:39:58.017604: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2026-06-27 02:07:23.753374: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2026-06-27 02:07:23.772991: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "E0000 00:00:1778308798.042093 1608381 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "E0000 00:00:1778308798.050215 1608381 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "W0000 00:00:1778308798.070817 1608381 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1778308798.070837 1608381 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1778308798.070840 1608381 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1778308798.070842 1608381 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "2026-05-09 06:39:58.076717: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "E0000 00:00:1782526043.796638 659512 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1782526043.804470 659512 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1782526043.824077 659512 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1782526043.824096 659512 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1782526043.824099 659512 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1782526043.824101 659512 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "2026-06-27 02:07:23.829785: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" ] }, @@ -65,11 +63,13 @@ "name": "stdout", "output_type": "stream", "text": [ + "INFO 06-27 02:07:32 [__init__.py:216] Automatically detected platform cuda.\n", "🦥 Unsloth Zoo will now patch everything to make training faster!\n" ] } ], "source": [ + "import unsloth\n", "import os\n", "import argparse\n", "import sys\n", @@ -81,7 +81,8 @@ "from convokit.forecaster.TransformerDecoderModel import TransformerDecoderModel\n", "from convokit.forecaster.TransformerForecasterConfig import TransformerForecasterConfig\n", "from convokit.decisionpolicy import DeferralDecisionPolicy, ThresholdDecisionPolicy, SimulationAverageDecisionPolicy, SimulationMajorityDecisionPolicy, RandomDeferralDecisionPolicy\n", - "from convokit.utterance_simulator.unslothUtteranceSimulatorModel import UnslothUtteranceSimulatorModel" + "from convokit.utterance_simulator.unslothUtteranceSimulatorModel import UnslothUtteranceSimulatorModel\n", + "from convokit.utterance_simulator.utteranceSimulator import UtteranceSimulator" ] }, { @@ -107,15 +108,7 @@ "execution_count": null, "id": "18f2375b", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[info] using cached decisionpolicy-demo at /home/lyk25/.convokit/saved-corpora/decisionpolicy-demo\n" - ] - } - ], + "outputs": [], "source": [ "from pathlib import Path\n", "\n", @@ -124,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "858a8431", "metadata": {}, "outputs": [ @@ -247,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 3, "id": "638fb31c", "metadata": {}, "outputs": [], @@ -275,7 +268,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 4, "id": "bf55d140", "metadata": {}, "outputs": [], @@ -297,7 +290,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "id": "a9502041", "metadata": {}, "outputs": [], @@ -330,7 +323,29 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, + "id": "68e6380e", + "metadata": {}, + "outputs": [], + "source": [ + "from unsloth import FastLanguageModel\n", + "\n", + "_orig_get_peft_model = FastLanguageModel.get_peft_model\n", + "\n", + "def _get_peft_model(model, *args, **kwargs):\n", + " kwargs[\"modules_to_save\"] = [\"embed_tokens\", \"lm_head\"]\n", + " kwargs[\"target_modules\"] = [\n", + " m for m in kwargs.get(\"target_modules\", [])\n", + " if m not in (\"embed_tokens\", \"lm_head\")\n", + " ]\n", + " return _orig_get_peft_model(model, *args, **kwargs)\n", + "\n", + "FastLanguageModel.get_peft_model = _get_peft_model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "id": "aedd02fe", "metadata": {}, "outputs": [ @@ -338,20 +353,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "==((====))== Unsloth 2025.7.11: Fast Llama patching. Transformers: 4.53.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.7.1+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.1.0+cf34004b8a\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.31.post1. FA2 = False]\n", + "==((====))== Unsloth 2026.6.9: Fast Llama patching. Transformers: 4.57.6. vLLM: 0.10.2.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.538 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.8.0+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.4.0\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.32.post1. FA2 = False]\n", " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", + "Unsloth: Offloading input_embeddings to disk to save VRAM\n", + "Unsloth: Offloading output_embeddings to disk to save VRAM\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Unsloth 2025.7.11 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n", - "Unsloth: Already have LoRA adapters! We shall skip this step.\n" + "/reef/conda-envs/lyk25-env/lib/python3.11/site-packages/peft/tuners/tuners_utils.py:1348: UserWarning: Model has `tie_word_embeddings=True` and a tied layer is part of the adapter, but `ensure_weight_tying` is not set to True. This can lead to complications, for example when merging the adapter or converting your model to formats other than safetensors. Check the discussion here: https://github.com/huggingface/peft/issues/2777\n", + " warnings.warn(msg)\n", + "Unsloth 2026.6.9 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n" ] }, { @@ -365,11 +383,29 @@ ], "source": [ "simulator_model = UnslothUtteranceSimulatorModel(\n", - " model_name=\"/reef/lyk25/dynamic_training/game_analysis/outputs/checkpoint-74\",\n", " train_config=SIMULATOR_TRAIN_CONFIG,\n", ")" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "021007c3", + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial\n", + "\n", + "corpus = Corpus(filename=download('conversations-gone-awry-cmv-corpus-large'))\n", + "\n", + "simulator = UtteranceSimulator(simulator_model)\n", + "simulator.fit(\n", + " corpus=corpus,\n", + " context_selector=train_context_selector,\n", + " val_context_selector=val_context_selector,\n", + ")" + ] + }, { "cell_type": "markdown", "id": "407b2444", @@ -380,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "2f4a29c2", "metadata": {}, "outputs": [ @@ -1609,7 +1645,6 @@ " device=\"cuda\",\n", " )\n", "\n", - " # TODO this will have to be edited\n", " forecaster_model = TransformerDecoderModel(\n", " model_name_or_path=\"google/gemma-2-9b-it\",\n", " config=config,\n", @@ -1775,7 +1810,6 @@ " device=\"cuda\",\n", " )\n", "\n", - " # TODO this will have to be edited\n", " forecaster_model = TransformerDecoderModel(\n", " model_name_or_path=\"google/gemma-2-9b-it\",\n", " config=config,\n", diff --git a/examples/forecaster/Run Transformer Fine-tuned Models.ipynb b/examples/forecaster/Run Transformer Fine-tuned Models.ipynb index f3d10280d..2bd1b1e2b 100644 --- a/examples/forecaster/Run Transformer Fine-tuned Models.ipynb +++ b/examples/forecaster/Run Transformer Fine-tuned Models.ipynb @@ -1,850 +1,1455 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This notebook is for reproducing all results reported in paper \"Conversations Gone Awry, But Then? Evaluating Conversational Forecasting Models\".\n", - "The results include:\n", - "1. Performance of TransformerEncoderModels (BERT-base, BERT-large, RoBERTa-base, RoBERTa-large, SpanBERT-base, SpanBERT-large, DeBERTaV3-base, and DeBERTaV3-large)\n", - "2. Performance of TransformerDecoderModels (Gemma2 9B, LlaMA3.1 8B, Mistral 7B, and Phi4 14B)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/reef/conda-envs/sqt-env/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n", - "/home/sqt2/ConvoKit/convokit/forecaster/TransformerDecoderModel.py:1: UserWarning: WARNING: Unsloth should be imported before transformers, peft to ensure all optimizations are applied. Your code may run slower or encounter memory issues without these optimizations.\n", - "\n", - "Please restructure your imports with 'import unsloth' at the top of your file.\n", - " from unsloth import FastLanguageModel, is_bfloat16_supported\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n", - "🦥 Unsloth Zoo will now patch everything to make training faster!\n" - ] - } - ], - "source": [ - "from convokit import (download,\n", - " Corpus,\n", - " Forecaster,\n", - " TransformerEncoderModel,\n", - " TransformerDecoderModel,\n", - " TransformerForecasterConfig,\n", - ")\n", - "import tarfile\n", - "import json, os, shutil\n", - "import re\n", - "import urllib.request\n", - "from urllib.parse import urljoin, urlparse" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define datasets and working directories " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# CPU mode (noting that it will be slower)\n", - "DEVICE = \"cuda\"\n", - "\n", - "corpus_name = \"cga-wikiconv\"\n", - "# corpus_name = \"cga-cmv-legacy\"\n", - "# corpus_name = \"cga-cmv-large\"\n", - "label_metadata = \"has_removed_comment\" if 'cmv' in corpus_name else 'conversation_has_personal_attack'\n", - "\n", - "YOUR_MODEL_DIRECTORY = \"YOUR_MODEL_DIRECTORY\"\n", - "YOUR_SAVING_DIRECTORY = \"YOUR_SAVING_DIRECTORY\"" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset already exists at /home/sqt2/.convokit/saved-corpora/conversations-gone-awry-corpus\n" - ] - } - ], - "source": [ - "if corpus_name == \"cga-wikiconv\":\n", - " corpus = Corpus(filename=download(\"conversations-gone-awry-corpus\"))\n", - "elif corpus_name == \"cga-cmv-legacy\":\n", - " corpus = Corpus(filename=download(\"conversations-gone-awry-cmv-corpus\"))\n", - "elif corpus_name == \"cga-cmv-large\":\n", - " raise ValueError(f\"The corpus {corpus_name} has not been published. This corpus is not available.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Download Fine-tuned Models" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "MODEL = \"bert-base-cased\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**List of Models**\n", - "\n", - "**TransformerEncoderModel**\n", - "- `bert-base-cased` — BERT-base \n", - "- `roberta-base` — RoBERTa-base \n", - "- `SpanBERT/spanbert-base-cased` — SpanBERT-base \n", - "- `microsoft/deberta-v3-base` — DeBERTaV3-base \n", - "- `bert-large-cased` — BERT-large \n", - "- `roberta-large` — RoBERTa-large \n", - "- `SpanBERT/spanbert-large-cased` — SpanBERT-large \n", - "- `microsoft/deberta-v3-large` — DeBERTaV3-large \n", - "\n", - "**TransformerDecoderModel**\n", - "- `google/gemma-2-9b-it` — Gemma2 9B \n", - "- `meta-llama/Llama-3.1-8B-Instruct` — LLaMA 3.1 8B \n", - "- `mistralai/Mistral-7B-Instruct-v0.3` — Mistral 7B \n", - "- `microsoft/phi-4` — Phi-4 14B" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "BASE_URL = f\"https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/{corpus_name}/{MODEL}/\"\n", - "DOWNLOAD_DIR = f\"{YOUR_MODEL_DIRECTORY}/{corpus_name}/{MODEL}\"\n", - "\n", - "def is_directory(href):\n", - " return href.endswith('/')\n", - "\n", - "def list_links(url):\n", - " \"\"\"List files and directories from an Apache-style directory listing.\"\"\"\n", - " response = urllib.request.urlopen(url)\n", - " html = response.read().decode('utf-8')\n", - " return re.findall(r'href=\"([^\"?][^\"]*)\"', html)\n", - "\n", - "def download_file(file_url, dest_path):\n", - " if os.path.exists(dest_path):\n", - " print(f\"Skipped existing: {dest_path}\")\n", - " return\n", - " urllib.request.urlretrieve(file_url, dest_path)\n", - "\n", - "def download_recursive(base_url, base_folder):\n", - " links = list_links(base_url)\n", - " for href in links:\n", - " if href in ('../',): # skip parent link\n", - " continue\n", - " full_url = urljoin(base_url, href)\n", - " parsed = urlparse(full_url)\n", - " relative_path = parsed.path.replace(urlparse(BASE_URL).path, '').lstrip('/')\n", - " local_path = os.path.join(base_folder, relative_path)\n", - "\n", - " if is_directory(href):\n", - " os.makedirs(local_path, exist_ok=True)\n", - " download_recursive(full_url, base_folder)\n", - " else:\n", - " os.makedirs(os.path.dirname(local_path), exist_ok=True)\n", - " download_file(full_url, local_path)\n", - "\n", - "os.makedirs(DOWNLOAD_DIR, exist_ok=True)\n", - "download_recursive(BASE_URL, DOWNLOAD_DIR)\n", - "forecasting_models_path = DOWNLOAD_DIR" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define selectors for the Forecaster\n", - "\n", - "Core to the flexibility of the `Forecaster` framework is the concept of *selectors*. \n", - "\n", - "To capture the temporal dimension of the conversational forecasting task, `Forecaster` iterates through conversations in chronological utterance order, at each step presenting to the backend forecasting model a \"context tuple\" containing both the comment itself and the full \"context\" preceding that comment. As a general framework, `Forecaster` on its own does not try to make any further assumptions about what \"context\" should contain or look like; it simply presents context as a chronologically ordered list of all utterances up to and including the current one. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def transform_selector(context_tuple):\n", - " \"\"\"\n", - " For transform we only need to check that the conversation is in the test split\n", - " \"\"\"\n", - " convo = context_tuple.current_utterance.get_conversation()\n", - " convo_length = len(convo.get_chronological_utterance_list())\n", - "\n", - " matches_split = (context_tuple.current_utterance.get_conversation().meta[\"split\"] == \"test\")\n", - " is_end = (len(context_tuple.context) == convo_length)\n", - "\n", - " return (matches_split and not is_end)\n", - "def update_metrics(all_results, cur_metrics):\n", - " for metric in cur_metrics:\n", - " all_results[metric] = all_results.get(metric, []) + [cur_metrics[metric]]\n", - " return all_results" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Transformer Encoder-based Forecaster" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Evaluating Random Seed 1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5131/5131 [00:47<00:00, 109.11it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "

" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook is for reproducing all results reported in paper \"Conversations Gone Awry, But Then? Evaluating Conversational Forecasting Models\".\n", + "The results include:\n", + "1. Performance of TransformerEncoderModels (BERT-base, BERT-large, RoBERTa-base, RoBERTa-large, SpanBERT-base, SpanBERT-large, DeBERTaV3-base, and DeBERTaV3-large)\n", + "2. Performance of TransformerDecoderModels (Gemma2 9B, LlaMA3.1 8B, Mistral 7B, and Phi4 14B)" ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.5899280575539567, Median = 3.0\n", - "Accuracy 0.661905\n", - "Precision 0.661905\n", - "Recall 0.661905\n", - "FPR 0.338095\n", - "F1 0.661905\n", - "Mean H 3.589928\n", - "Correct Adjustment 0.05\n", - "Incorrect Adjustment 0.066667\n", - "Recovery -0.016667\n", - "Leaderboard String | MODEL_NAME | 66.2 | 66.2 | 66.2 | 66....\n", - "dtype: object\n", - "Evaluating Random Seed 2\n" - ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5131/5131 [00:47<00:00, 108.70it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-06-27 02:36:22.140467: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2026-06-27 02:36:22.160162: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1782527782.183784 668601 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1782527782.191521 668601 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1782527782.210587 668601 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1782527782.210606 668601 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1782527782.210609 668601 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1782527782.210611 668601 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "2026-06-27 02:36:22.216822: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO 06-27 02:36:30 [__init__.py:216] Automatically detected platform cuda.\n", + "🦥 Unsloth Zoo will now patch everything to make training faster!\n" + ] + } + ], + "source": [ + "import unsloth\n", + "\n", + "from convokit.utterance_simulator.unslothUtteranceSimulatorModel import UnslothUtteranceSimulatorModel\n", + "from convokit.utterance_simulator.utteranceSimulator import UtteranceSimulator\n", + "\n", + "from convokit import (download,\n", + " Corpus,\n", + " Forecaster,\n", + " TransformerEncoderModel,\n", + " TransformerDecoderModel,\n", + " TransformerForecasterConfig,\n", + ")\n", + "import tarfile\n", + "import json, os, shutil\n", + "import re\n", + "import urllib.request\n", + "from urllib.parse import urljoin, urlparse" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.731182795698925, Median = 3.0\n", - "Accuracy 0.666667\n", - "Precision 0.667464\n", - "Recall 0.664286\n", - "FPR 0.330952\n", - "F1 0.665871\n", - "Mean H 3.731183\n", - "Correct Adjustment 0.054762\n", - "Incorrect Adjustment 0.07619\n", - "Recovery -0.021429\n", - "Leaderboard String | MODEL_NAME | 66.7 | 66.7 | 66.4 | 66....\n", - "dtype: object\n", - "Evaluating Random Seed 3\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define datasets and working directories " + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5131/5131 [00:47<00:00, 109.03it/s]\n" - ] + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# CPU mode (noting that it will be slower)\n", + "DEVICE = \"cuda\"\n", + "\n", + "# corpus_name = \"cga-wikiconv\"\n", + "# corpus_name = \"cga-cmv-legacy\"\n", + "corpus_name = \"cga-cmv-large\"\n", + "label_metadata = \"has_removed_comment\" if 'cmv' in corpus_name else 'conversation_has_personal_attack'\n", + "\n", + "YOUR_MODEL_DIRECTORY = \"YOUR_MODEL_DIRECTORY\"\n", + "YOUR_SAVING_DIRECTORY = \"YOUR_SAVING_DIRECTORY\"" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset already exists at /reef/lyk25/ConvoKit/examples/forecaster/conversations-gone-awry-cmv-corpus-large\n" + ] + } + ], + "source": [ + "if corpus_name == \"cga-wikiconv\":\n", + " corpus = Corpus(filename=download(\"conversations-gone-awry-corpus\"))\n", + "elif corpus_name == \"cga-cmv-legacy\":\n", + " corpus = Corpus(filename=download(\"conversations-gone-awry-cmv-corpus\"))\n", + "elif corpus_name == \"cga-cmv-large\":\n", + " corpus = Corpus(filename=download(\"conversations-gone-awry-cmv-corpus-large\"))" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.7491525423728813, Median = 3.0\n", - "Accuracy 0.672619\n", - "Precision 0.662921\n", - "Recall 0.702381\n", - "FPR 0.357143\n", - "F1 0.682081\n", - "Mean H 3.749153\n", - "Correct Adjustment 0.070238\n", - "Incorrect Adjustment 0.088095\n", - "Recovery -0.017857\n", - "Leaderboard String | MODEL_NAME | 67.3 | 66.3 | 70.2 | 68....\n", - "dtype: object\n", - "Evaluating Random Seed 4\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Download Fine-tuned Models" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5131/5131 [00:47<00:00, 108.49it/s]\n" - ] + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def is_directory(href):\n", + " return href.endswith('/')\n", + "\n", + "def list_links(url):\n", + " \"\"\"list files and directories from an apache-style directory listing.\"\"\"\n", + " response = urllib.request.urlopen(url)\n", + " html = response.read().decode('utf-8')\n", + " return re.findall(r'href=\"([^\"?][^\"]*)\"', html)\n", + "\n", + "def download_file(file_url, dest_path):\n", + " if os.path.exists(dest_path):\n", + " print(f\"skipped existing: {dest_path}\")\n", + " return\n", + " urllib.request.urlretrieve(file_url, dest_path)\n", + "\n", + "def download_recursive(base_url, base_folder, root_url=None):\n", + " if root_url is None:\n", + " root_url = base_url\n", + " links = list_links(base_url)\n", + " for href in links:\n", + " if href in ('../',): # skip parent link\n", + " continue\n", + " full_url = urljoin(base_url, href)\n", + " parsed = urlparse(full_url)\n", + " relative_path = parsed.path.replace(urlparse(root_url).path, '').lstrip('/')\n", + " local_path = os.path.join(base_folder, relative_path)\n", + "\n", + " if is_directory(href):\n", + " os.makedirs(local_path, exist_ok=True)\n", + " download_recursive(full_url, base_folder, root_url=root_url)\n", + " else:\n", + " os.makedirs(os.path.dirname(local_path), exist_ok=True)\n", + " download_file(full_url, local_path)\n" + ] }, { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAGwCAYAAABSN5pGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVxhJREFUeJzt3XlYVGX/P/D3sAwgq4BsSoBKgoqgooiWWlCYPrlE5YKBS/rU446aUgbuoKmRjzyafkvtl6SZS6aFKa4pooLkBqgE4gK4BQgmCHP//vDy5Azr6MAAvV/XNVfOfe5zn885zJx5d+acMzIhhAARERERSXS0XQARERFRQ8OARERERKSCAYmIiIhIBQMSERERkQoGJCIiIiIVDEhEREREKhiQiIiIiFToabuAxkqhUODmzZswNTWFTCbTdjlERERUC0II3L9/Hw4ODtDRqfo4EQPSM7p58yYcHR21XQYRERE9g2vXrqFVq1ZVTmdAekampqYAHm9gMzMzLVdDREREtVFYWAhHR0fpc7wqDEjP6MnXamZmZgxIREREjUxNp8fwJG0iIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISIWetgsg0ibn2Xu0XYLasqIGaLsEIqImj0eQiIiIiFQwIBERERGpYEAiIiIiUsGARERERKSCAYmIiIhIBQMSERERkQoGJCIiIiIVDEhEREREKhiQiIiIiFQwIBERERGpYEAiIiIiUsGARERERKSCAYmIiIhIBQMSERERkQoGJCIiIiIVDSIgxcTEwNnZGYaGhvDx8cHJkyer7Ltu3Tq8/PLLaN68OZo3bw5/f/8K/YUQCA8Ph729PYyMjODv74/Lly8r9bl37x6CgoJgZmYGCwsLjB07FkVFRXWyfkRERNS4aD0gbdmyBaGhoYiIiEBycjI8PT0REBCAW7duVdr/0KFDGD58OA4ePIiEhAQ4Ojri9ddfx40bN6Q+S5cuxcqVK7FmzRokJibC2NgYAQEBePjwodQnKCgIFy5cwL59+7B7924cOXIE48ePr/P1JSIiooZPJoQQ2izAx8cH3bp1w6pVqwAACoUCjo6OmDRpEmbPnl3j/OXl5WjevDlWrVqF4OBgCCHg4OCA6dOnY8aMGQCAgoIC2NraYsOGDRg2bBhSU1PRvn17nDp1Ct7e3gCAuLg49O/fH9evX4eDg0OF5ZSUlKCkpER6XlhYCEdHRxQUFMDMzEwTm4K0wHn2Hm2XoLasqAHaLoGIqNEqLCyEubl5jZ/fWj2CVFpaiqSkJPj7+0ttOjo68Pf3R0JCQq3GePDgAR49egRLS0sAQGZmJnJzc5XGNDc3h4+PjzRmQkICLCwspHAEAP7+/tDR0UFiYmKly4mMjIS5ubn0cHR0VHt9iYiIqHHQakC6c+cOysvLYWtrq9Rua2uL3NzcWo0xa9YsODg4SIHoyXzVjZmbmwsbGxul6Xp6erC0tKxyuWFhYSgoKJAe165dq1V9RERE1PjoabuA5xEVFYXNmzfj0KFDMDQ0rNNlGRgYwMDAoE6XQURERA2DVo8gWVtbQ1dXF3l5eUrteXl5sLOzq3beZcuWISoqCr/++is6deoktT+Zr7ox7ezsKpwEXlZWhnv37tW4XCIiImr6tBqQ5HI5unbtivj4eKlNoVAgPj4evr6+Vc63dOlSLFiwAHFxcUrnEQGAi4sL7OzslMYsLCxEYmKiNKavry/y8/ORlJQk9Tlw4AAUCgV8fHw0tXpERETUSGn9K7bQ0FCEhITA29sb3bt3R3R0NIqLizF69GgAQHBwMFq2bInIyEgAwJIlSxAeHo7Y2Fg4OztL5wyZmJjAxMQEMpkMU6dOxcKFC+Hq6goXFxd8+umncHBwwODBgwEA7u7u6NevH8aNG4c1a9bg0aNHmDhxIoYNG1bpFWxERET0z6L1gDR06FDcvn0b4eHhyM3NhZeXF+Li4qSTrLOzs6Gj8/eBrtWrV6O0tBRvv/220jgRERGYO3cuAOCjjz5CcXExxo8fj/z8fLz00kuIi4tTOk9p06ZNmDhxIvz8/KCjo4PAwECsXLmy7leYiIiIGjyt3wepsartfRSoYeN9kIiI/lkaxX2QiIiIiBoiBiQiIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCoYkIiIiIhU6Gm7AGoaGuOPvhIREVWFR5CIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFr2IjamQa4xWDWVEDtF0CEZFaeASJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFVoPSDExMXB2doahoSF8fHxw8uTJKvteuHABgYGBcHZ2hkwmQ3R0dIU+T6apPiZMmCD16du3b4XpH3zwQV2sHhERETVCWg1IW7ZsQWhoKCIiIpCcnAxPT08EBATg1q1blfZ/8OABWrdujaioKNjZ2VXa59SpU8jJyZEe+/btAwC88847Sv3GjRun1G/p0qWaXTkiIiJqtLQakFasWIFx48Zh9OjRaN++PdasWYNmzZrh66+/rrR/t27d8Nlnn2HYsGEwMDCotE+LFi1gZ2cnPXbv3o02bdqgT58+Sv2aNWum1M/MzEzj60dERESNk9YCUmlpKZKSkuDv7/93MTo68Pf3R0JCgsaW8e2332LMmDGQyWRK0zZt2gRra2t07NgRYWFhePDgQbVjlZSUoLCwUOlBRERETZOethZ8584dlJeXw9bWVqnd1tYWaWlpGlnGzp07kZ+fj1GjRim1jxgxAk5OTnBwcMDZs2cxa9YspKenY/v27VWOFRkZiXnz5mmkLiIiImrYtBaQ6sNXX32FN954Aw4ODkrt48ePl/7t4eEBe3t7+Pn5ISMjA23atKl0rLCwMISGhkrPCwsL4ejoWDeFExERkVZpLSBZW1tDV1cXeXl5Su15eXlVnoCtjqtXr2L//v3VHhV6wsfHBwBw5cqVKgOSgYFBlec9ERERUdOitXOQ5HI5unbtivj4eKlNoVAgPj4evr6+zz3++vXrYWNjgwEDBtTYNyUlBQBgb2//3MslIiKixk+rX7GFhoYiJCQE3t7e6N69O6Kjo1FcXIzRo0cDAIKDg9GyZUtERkYCeHzS9cWLF6V/37hxAykpKTAxMUHbtm2lcRUKBdavX4+QkBDo6SmvYkZGBmJjY9G/f39YWVnh7NmzmDZtGnr37o1OnTrV05oTERFRQ6bVgDR06FDcvn0b4eHhyM3NhZeXF+Li4qQTt7Ozs6Gj8/dBrps3b6Jz587S82XLlmHZsmXo06cPDh06JLXv378f2dnZGDNmTIVlyuVy7N+/Xwpjjo6OCAwMxJw5c+puRYmIiKhRkQkhhLaLaIwKCwthbm6OgoIC3kMJgPPsPdougRqwrKiav+omIqoPtf381vpPjRARERE1NAxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCoYkIiIiIhUqB2QNm7ciD179kjPP/roI1hYWKBnz564evWqRosjIiIi0ga1A9LixYthZGQEAEhISEBMTAyWLl0Ka2trTJs2TeMFEhEREdU3PXVnuHbtGtq2bQsA2LlzJwIDAzF+/Hj06tULffv21XR9RERERPVO7SNIJiYmuHv3LgDg119/xWuvvQYAMDQ0xF9//aXZ6oiIiIi0QO0jSK+99href/99dO7cGZcuXUL//v0BABcuXICzs7Om6yMiIiKqd2ofQYqJiYGvry9u376Nbdu2wcrKCgCQlJSE4cOHa7xAIiIiovqm9hEkCwsLrFq1qkL7vHnzNFIQERERkbapHZAAID8/HydPnsStW7egUCikdplMhvfee09jxRERERFpg9oB6aeffkJQUBCKiopgZmYGmUwmTWNAIiIioqZA7XOQpk+fjjFjxqCoqAj5+fn4888/pce9e/fqokYiIiKieqV2QLpx4wYmT56MZs2a1UU9RERERFqndkAKCAjA6dOn66IWIiIiogZB7YA0YMAAzJw5E3PnzsW2bduwa9cupYe6YmJi4OzsDENDQ/j4+ODkyZNV9r1w4QICAwPh7OwMmUyG6OjoCn3mzp0LmUym9HBzc1Pq8/DhQ0yYMAFWVlYwMTFBYGAg8vLy1K6diIiImia1T9IeN24cAGD+/PkVpslkMpSXl9d6rC1btiA0NBRr1qyBj48PoqOjERAQgPT0dNjY2FTo/+DBA7Ru3RrvvPNOtb/71qFDB+zfv196rqenvJrTpk3Dnj17sHXrVpibm2PixIl46623cOzYsVrXTkRERE2X2gHp6cv6n9eKFSswbtw4jB49GgCwZs0a7NmzB19//TVmz55doX+3bt3QrVs3AKh0+hN6enqws7OrdFpBQQG++uorxMbG4tVXXwUArF+/Hu7u7jhx4gR69OhR6XwlJSUoKSmRnhcWFtZuJYmIiKjRUfsrNk0pLS1FUlIS/P39/y5GRwf+/v5ISEh4rrEvX74MBwcHtG7dGkFBQcjOzpamJSUl4dGjR0rLdXNzwwsvvFDtciMjI2Fubi49HB0dn6tGIiIiarieKSAdPnwYb775Jtq2bYu2bdti4MCBOHr0qFpj3LlzB+Xl5bC1tVVqt7W1RW5u7rOUBQDw8fHBhg0bEBcXh9WrVyMzMxMvv/wy7t+/DwDIzc2FXC6HhYWFWssNCwtDQUGB9Lh27doz10hEREQNm9oB6dtvv4W/vz+aNWuGyZMnY/LkyTAyMoKfnx9iY2Proka1vPHGG3jnnXfQqVMnBAQE4Oeff0Z+fj6+//775xrXwMAAZmZmSg8iIiJqmtQ+B2nRokVYunSp0knSkydPxooVK7BgwQKMGDGiVuNYW1tDV1e3wtVjeXl5VZ4/9CwsLCzw4osv4sqVKwAAOzs7lJaWIj8/X+kokqaXS0RERI2X2keQ/vjjD7z55psV2gcOHIjMzMxajyOXy9G1a1fEx8dLbQqFAvHx8fD19VW3rCoVFRUhIyMD9vb2AICuXbtCX19fabnp6enIzs7W6HKJiIio8VL7CJKjoyPi4+PRtm1bpfb9+/erfeJyaGgoQkJC4O3tje7duyM6OhrFxcXSVW3BwcFo2bIlIiMjATw+sfvixYvSv2/cuIGUlBSYmJhI9cyYMQNvvvkmnJyccPPmTUREREBXVxfDhw8HAJibm2Ps2LEIDQ2FpaUlzMzMMGnSJPj6+lZ5BRsRERH9s6gdkKZPn47JkycjJSUFPXv2BAAcO3YMGzZswBdffKHWWEOHDsXt27cRHh6O3NxceHl5IS4uTjpxOzs7Gzo6fx/kunnzJjp37iw9X7ZsGZYtW4Y+ffrg0KFDAIDr169j+PDhuHv3Llq0aIGXXnoJJ06cQIsWLaT5Pv/8c+jo6CAwMBAlJSUICAjA//73P3U3BRERETVRMiGEUHemHTt2YPny5UhNTQUAuLu7Y+bMmRg0aJDGC2yoCgsLYW5ujoKCAp6wDcB59h5tl0ANWFbUAG2XQEQEoPaf32ofQQKAIUOGYMiQIc9cHBEREVFDprUbRRIRERE1VLU6gmRpaYlLly7B2toazZs3h0wmq7LvvXv3NFYcERERkTbUKiB9/vnnMDU1lf5dXUAiIiIiauxqFZBCQkKkf48aNaquaiEiIiJqENQ+B0lXVxe3bt2q0H737l3o6upqpCgiIiIibVI7IFV1V4CSkhLI5fLnLoiIiIhI22p9mf/KlSsBADKZDP/3f/8HExMTaVp5eTmOHDkCNzc3zVdIREREVM9qHZA+//xzAI+PIK1Zs0bp6zS5XA5nZ2esWbNG8xUSERER1bNaB6QnP0T7yiuvYPv27WjevHmdFUVERESkTWrfSfvgwYN1UQcRERFRg/FMPzVy/fp17Nq1C9nZ2SgtLVWatmLFCo0URkRERKQtagek+Ph4DBw4EK1bt0ZaWho6duyIrKwsCCHQpUuXuqiRiIiIqF6pfZl/WFgYZsyYgXPnzsHQ0BDbtm3DtWvX0KdPH7zzzjt1USMRERFRvVL7CFJqaiq+++67xzPr6eGvv/6CiYkJ5s+fj0GDBuHDDz/UeJFE1Lg5z96j7RLUlhU1QNslEJEWqX0EydjYWDrvyN7eHhkZGdK0O3fuaK4yIiIiIi1R+whSjx498Ntvv8Hd3R39+/fH9OnTce7cOWzfvh09evSoixqJiIiI6pXaAWnFihUoKioCAMybNw9FRUXYsmULXF1deQUbERERNQlqB6TWrVtL/zY2Nubds4mIiKjJUfscpGvXruH69evS85MnT2Lq1KlYu3atRgsjIiIi0ha1A9KIESOku2nn5ubC398fJ0+exCeffIL58+drvEAiIiKi+qZ2QDp//jy6d+8OAPj+++/h4eGB48ePY9OmTdiwYYOm6yMiIiKqd2oHpEePHsHAwAAAsH//fgwcOBAA4ObmhpycHM1WR0RERKQFagekDh06YM2aNTh69Cj27duHfv36AQBu3rwJKysrjRdIREREVN/UDkhLlizBl19+ib59+2L48OHw9PQEAOzatUv66o2IiIioMVP7Mv++ffvizp07KCwsRPPmzaX28ePHo1mzZhotjoiIiEgb1D6CBABCCCQlJeHLL7/E/fv3AQByuZwBiYiIiJoEtY8gXb16Ff369UN2djZKSkrw2muvwdTUFEuWLEFJSQlvHElERESNntpHkKZMmQJvb2/8+eefMDIyktqHDBmC+Ph4jRZHREREpA1qH0E6evQojh8/DrlcrtTu7OyMGzduaKwwIiIiIm1R+wiSQqFAeXl5hfbr16/D1NRU7QJiYmLg7OwMQ0ND+Pj44OTJk1X2vXDhAgIDA+Hs7AyZTIbo6OgKfSIjI9GtWzeYmprCxsYGgwcPRnp6ulKfvn37QiaTKT0++OADtWsnIiKipkntgPT6668rBROZTIaioiJERESgf//+ao21ZcsWhIaGIiIiAsnJyfD09ERAQABu3bpVaf8HDx6gdevWiIqKgp2dXaV9Dh8+jAkTJuDEiRPYt28fHj16hNdffx3FxcVK/caNG4ecnBzpsXTpUrVqJyIioqZLJoQQ6sxw/fp1BAQEQAiBy5cvw9vbG5cvX4a1tTWOHDkCGxubWo/l4+ODbt26YdWqVQAeH51ydHTEpEmTMHv27GrndXZ2xtSpUzF16tRq+92+fRs2NjY4fPgwevfuDeDxESQvL69Kj0DVVmFhIczNzVFQUAAzM7NnHqepcJ69R9slEGlUVtQAbZdARHWgtp/fah9BatWqFX7//Xd8/PHHmDZtGjp37oyoqCicOXNGrXBUWlqKpKQk+Pv7/12Mjg78/f2RkJCgbllVKigoAABYWloqtW/atAnW1tbo2LEjwsLC8ODBg2rHKSkpQWFhodKDiIiImia1T9J++PAhDA0NMXLkyOda8J07d1BeXg5bW1uldltbW6SlpT3X2E8oFApMnToVvXr1QseOHaX2ESNGwMnJCQ4ODjh79ixmzZqF9PR0bN++vcqxIiMjMW/ePI3URURERA2b2gHJxsYGQ4YMwciRI+Hn5wcdnWe612S9mDBhAs6fP4/ffvtNqX38+PHSvz08PGBvbw8/Pz9kZGSgTZs2lY4VFhaG0NBQ6XlhYSEcHR3rpnAiIiLSKrXTzcaNG/HgwQMMGjQILVu2xNSpU3H69Gm1F2xtbQ1dXV3k5eUptefl5VV5ArY6Jk6ciN27d+PgwYNo1apVtX19fHwAAFeuXKmyj4GBAczMzJQeRERE1DSpHZCGDBmCrVu3Ii8vD4sXL8bFixfRo0cPvPjii5g/f36tx5HL5ejatavSzSUVCgXi4+Ph6+urblkSIQQmTpyIHTt24MCBA3BxcalxnpSUFACAvb39My+XiIiImo5n/n7M1NQUo0ePxq+//oqzZ8/C2NhY7XN0QkNDsW7dOmzcuBGpqan48MMPUVxcjNGjRwMAgoODERYWJvUvLS1FSkoKUlJSUFpaihs3biAlJUXpyM+ECRPw7bffIjY2FqampsjNzUVubi7++usvAEBGRgYWLFiApKQkZGVlYdeuXQgODkbv3r3RqVOnZ90cRERE1ISofQ7SEw8fPsSuXbsQGxuLuLg42NraYubMmWqNMXToUNy+fRvh4eHIzc2Fl5eXNBYAZGdnK53jdPPmTXTu3Fl6vmzZMixbtgx9+vTBoUOHAACrV68G8PhS/qetX78eo0aNglwux/79+xEdHY3i4mI4OjoiMDAQc+bMeYatQERERE2R2vdB2rt3L2JjY7Fz507o6enh7bffRlBQkHSPoX8K3gdJGe+DRE0N74NE1DTV9vNb7SNIQ4YMwb/+9S9888036N+/P/T19Z+rUCIiIqKGRu2AlJeX90y/uUZERETUWKgdkExNTaFQKHDlyhXcunULCoVCafo/7as2IiIianrUDkgnTpzAiBEjcPXqVaieviSTyVBeXq6x4oiIiIi0Qe2A9MEHH8Db2xt79uyBvb09ZDJZXdRFREREpDVqB6TLly/jhx9+QNu2beuiHiIiIiKtU/tGkT4+PtX+JAcRERFRY6f2EaRJkyZh+vTpyM3NhYeHR4XL/Hk3aiIiImrs1A5IgYGBAIAxY8ZIbTKZDEIInqRNRERETYLaASkzM7Mu6iAiIiJqMNQOSE5OTnVRBxEREVGD8Uw/VpuRkYHo6GikpqYCANq3b48pU6agTZs2Gi2OiIiISBvUvopt7969aN++PU6ePIlOnTqhU6dOSExMRIcOHbBv3766qJGIiIioXql9BGn27NmYNm0aoqKiKrTPmjULr732msaKIyIiItIGtY8gpaamYuzYsRXax4wZg4sXL2qkKCIiIiJtUjsgtWjRAikpKRXaU1JSYGNjo4maiIiIiLRK7a/Yxo0bh/Hjx+OPP/5Az549AQDHjh3DkiVLEBoaqvECiYiIiOqb2gHp008/hampKZYvX46wsDAAgIODA+bOnYvJkydrvEAiIiKi+iYTQohnnfn+/fsAAFNTU40V1FgUFhbC3NwcBQUFMDMz03Y5Wuc8e4+2SyD6x8uKGqDtEogavNp+fj/TnbTLysrg6uqqFIwuX74MfX19ODs7P1PBRERERA2F2idpjxo1CsePH6/QnpiYiFGjRmmiJiIiIiKtUjsgnTlzBr169arQ3qNHj0qvbiMiIiJqbNQOSDKZTDr36GkFBQUoLy/XSFFERERE2qR2QOrduzciIyOVwlB5eTkiIyPx0ksvabQ4IiIiIm1Q+yTtJUuWoHfv3mjXrh1efvllAMDRo0dRWFiIAwcOaLxAIiIiovqm9hGk9u3b4+zZs3j33Xdx69Yt3L9/H8HBwUhLS0PHjh3rokYiIiKieqX2ESTg8Y0hFy9erOlaiIiIiBoEtY8gERERETV1DEhEREREKhiQiIiIiFTUKiDt2rULjx49qutaiIiIiBqEWgWkIUOGID8/HwCgq6uLW7duaayAmJgYODs7w9DQED4+Pjh58mSVfS9cuIDAwEA4OztDJpMhOjr6mcZ8+PAhJkyYACsrK5iYmCAwMBB5eXkaWyciIiJq3GoVkFq0aIETJ04AAIQQkMlkGln4li1bEBoaioiICCQnJ8PT0xMBAQFVBrAHDx6gdevWiIqKgp2d3TOPOW3aNPz000/YunUrDh8+jJs3b+Ktt97SyDoRERFR4ycTQoiaOs2dOxfz58+vVTBS5+dGfHx80K1bN6xatQoAoFAo4OjoiEmTJmH27NnVzuvs7IypU6di6tSpao1ZUFCAFi1aIDY2Fm+//TYAIC0tDe7u7khISECPHj1qVXthYSHMzc1RUFAAMzOzWq9zU+U8e4+2SyD6x8uKGqDtEogavNp+ftfqPkhz587FsGHDcOXKFQwcOBDr16+HhYXFcxVYWlqKpKQkhIWFSW06Ojrw9/dHQkJCnY2ZlJSER48ewd/fX+rj5uaGF154odqAVFJSgpKSEul5YWHhM9VIREREDV+tbxTp5uYGNzc3RERE4J133kGzZs2ea8F37txBeXk5bG1tldptbW2RlpZWZ2Pm5uZCLpdXCHi2trbIzc2tcuzIyEjMmzfvmeoiIiKixkXty/wjIiLQrFkz3L59G7/99ht+++033L59uy5qa1DCwsJQUFAgPa5du6btkoiIiKiOqB2QHjx4gDFjxsDBwQG9e/dG79694eDggLFjx+LBgwe1Hsfa2hq6uroVrh7Ly8ur8gRsTYxpZ2eH0tJS6aq82i7XwMAAZmZmSg8iIiJqmtQOSNOmTcPhw4exa9cu5OfnIz8/Hz/++CMOHz6M6dOn13ocuVyOrl27Ij4+XmpTKBSIj4+Hr6+vumXVesyuXbtCX19fqU96ejqys7OfeblERETUtKj9Y7Xbtm3DDz/8gL59+0pt/fv3h5GREd59912sXr261mOFhoYiJCQE3t7e6N69O6Kjo1FcXIzRo0cDAIKDg9GyZUtERkYCeHwS9sWLF6V/37hxAykpKTAxMUHbtm1rNaa5uTnGjh2L0NBQWFpawszMDJMmTYKvr2+tr2AjIiKipk3tgPTgwYMKJ0EDgI2NjVpfsQHA0KFDcfv2bYSHhyM3NxdeXl6Ii4uTxs/OzoaOzt8HuW7evInOnTtLz5ctW4Zly5ahT58+OHToUK3GBIDPP/8cOjo6CAwMRElJCQICAvC///1PrdqJiIio6arVfZCe5ufnBysrK3zzzTcwNDQEAPz1118ICQnBvXv3sH///joptKHhfZCU8T5IRNrH+yAR1Uyj90F62hdffIGAgAC0atUKnp6eAIDff/8dhoaG2Lt377NXTERERNRAqB2QOnbsiMuXL2PTpk3SvYWGDx+OoKAgGBkZabxAIiIiovqmdkACgGbNmmHcuHGaroWIiIioQVD7Mn8iIiKipo4BiYiIiEgFAxIRERGRCgYkIiIiIhVqB6TWrVvj7t27Fdrz8/PRunVrjRRFREREpE1qB6SsrCyUl5dXaC8pKcGNGzc0UhQRERGRNtX6Mv9du3ZJ/967dy/Mzc2l5+Xl5YiPj4ezs7NGiyMiIiLShloHpMGDBwMAZDIZQkJClKbp6+vD2dkZy5cv12hxRERERNpQ64CkUCgAAC4uLjh16hSsra3rrCgiIiIibVL7TtqZmZl1UQcRERFRg/FMPzUSHx+P+Ph43Lp1Szqy9MTXX3+tkcKIiIiItEXtgDRv3jzMnz8f3t7esLe3h0wmq4u6iIiIiLRG7YC0Zs0abNiwAe+9915d1ENERESkdWrfB6m0tBQ9e/asi1qIiIiIGgS1A9L777+P2NjYuqiFiIiIqEFQ+yu2hw8fYu3atdi/fz86deoEfX19pekrVqzQWHFERERE2qB2QDp79iy8vLwAAOfPn1eaxhO2iYiIqClQOyAdPHiwLuogIiIiajDUPgfpiStXrmDv3r3466+/AABCCI0VRURERKRNageku3fvws/PDy+++CL69++PnJwcAMDYsWMxffp0jRdIREREVN/UDkjTpk2Dvr4+srOz0axZM6l96NChiIuL02hxRERERNqg9jlIv/76K/bu3YtWrVoptbu6uuLq1asaK4yIiIhIW9Q+glRcXKx05OiJe/fuwcDAQCNFEREREWmT2gHp5ZdfxjfffCM9l8lkUCgUWLp0KV555RWNFkdERESkDWp/xbZ06VL4+fnh9OnTKC0txUcffYQLFy7g3r17OHbsWF3USERERFSv1D6C1LFjR1y6dAkvvfQSBg0ahOLiYrz11ls4c+YM2rRpUxc1EhEREdUrtY8gAYC5uTk++eQTTddCRERE1CCofQRp/fr12Lp1a4X2rVu3YuPGjc9URExMDJydnWFoaAgfHx+cPHmy2v5bt26Fm5sbDA0N4eHhgZ9//llpukwmq/Tx2WefSX2cnZ0rTI+Kinqm+omIiKhpUTsgRUZGwtraukK7jY0NFi9erHYBW7ZsQWhoKCIiIpCcnAxPT08EBATg1q1blfY/fvw4hg8fjrFjx+LMmTMYPHgwBg8erPS7cDk5OUqPr7/+GjKZDIGBgUpjzZ8/X6nfpEmT1K6fiIiImh61A1J2djZcXFwqtDs5OSE7O1vtAlasWIFx48Zh9OjRaN++PdasWYNmzZrh66+/rrT/F198gX79+mHmzJlwd3fHggUL0KVLF6xatUrqY2dnp/T48ccf8corr6B169ZKY5mamir1MzY2Vrt+IiIianrUDkg2NjY4e/Zshfbff/8dVlZWao1VWlqKpKQk+Pv7/12Qjg78/f2RkJBQ6TwJCQlK/QEgICCgyv55eXnYs2cPxo4dW2FaVFQUrKys0LlzZ3z22WcoKyurstaSkhIUFhYqPYiIiKhpUvsk7eHDh2Py5MkwNTVF7969AQCHDx/GlClTMGzYMLXGunPnDsrLy2Fra6vUbmtri7S0tErnyc3NrbR/bm5upf03btwIU1NTvPXWW0rtkydPRpcuXWBpaYnjx48jLCwMOTk5WLFiRaXjREZGYt68ebVdNSIiImrE1A5ICxYsQFZWFvz8/KCn93h2hUKB4ODgZzoHqa59/fXXCAoKgqGhoVJ7aGio9O9OnTpBLpfj3//+NyIjIyu9I3hYWJjSPIWFhXB0dKy7womIiEhr1ApIQgjk5uZiw4YNWLhwIVJSUmBkZAQPDw84OTmpvXBra2vo6uoiLy9PqT0vLw92dnaVzmNnZ1fr/kePHkV6ejq2bNlSYy0+Pj4oKytDVlYW2rVrV2G6gYEBf0qFiIjoH0Ktc5CEEGjbti2uX78OV1dXvPPOO/jXv/71TOEIAORyObp27Yr4+HipTaFQID4+Hr6+vpXO4+vrq9QfAPbt21dp/6+++gpdu3aFp6dnjbWkpKRAR0cHNjY2aq4FERERNTVqHUHS0dGBq6sr7t69C1dXV40UEBoaipCQEHh7e6N79+6Ijo5GcXExRo8eDQAIDg5Gy5YtERkZCQCYMmUK+vTpg+XLl2PAgAHYvHkzTp8+jbVr1yqNW1hYiK1bt2L58uUVlpmQkIDExES88sorMDU1RUJCAqZNm4aRI0eiefPmGlkvIiIiarzUPgcpKioKM2fOxOrVq9GxY8fnLmDo0KG4ffs2wsPDkZubCy8vL8TFxUknYmdnZ0NH5+8DXT179kRsbCzmzJmDjz/+GK6urti5c2eFWjZv3gwhBIYPH15hmQYGBti8eTPmzp2LkpISuLi4YNq0aUrnGBEREdE/l0wIIdSZoXnz5njw4AHKysogl8thZGSkNP3evXsaLbChKiwshLm5OQoKCmBmZqbtcrTOefYebZdA9I+XFTVA2yUQNXi1/fxW+whSdHT089RFRERE1OCpHZBCQkLqog4iIiKiBkPtO2kDQEZGBubMmYPhw4dLv5n2yy+/4MKFCxotjoiIiEgb1A5Ihw8fhoeHBxITE7F9+3YUFRUBePxTIxERERovkIiIiKi+qR2QZs+ejYULF2Lfvn2Qy+VS+6uvvooTJ05otDgiIiIibVA7IJ07dw5Dhgyp0G5jY4M7d+5opCgiIiIibVI7IFlYWCAnJ6dC+5kzZ9CyZUuNFEVERESkTWpfxTZs2DDMmjULW7duhUwmg0KhwLFjxzBjxgwEBwfXRY1ERFQLjfF+ZLx3EzVUah9BWrx4Mdzc3ODo6IiioiK0b98evXv3Rs+ePTFnzpy6qJGIiIioXql9BEkul2PdunUIDw/HuXPnUFRUhM6dO2vst9mIiIiItK3WAUmhUOCzzz7Drl27UFpaCj8/P0RERFT4qREiIiKixq7WX7EtWrQIH3/8MUxMTNCyZUt88cUXmDBhQl3WRkRERKQVtQ5I33zzDf73v/9h79692LlzJ3766Sds2rQJCoWiLusjIiIiqne1DkjZ2dno37+/9Nzf3x8ymQw3b96sk8KIiIiItKXWAamsrAyGhoZKbfr6+nj06JHGiyIiIiLSplqfpC2EwKhRo2BgYCC1PXz4EB988AGMjY2ltu3bt2u2QiIiIqJ6VuuAFBISUqFt5MiRGi2GiIiIqCGodUBav359XdZBRERE1GCofSdtIiIioqaOAYmIiIhIBQMSERERkQoGJCIiIiIVDEhEREREKhiQiIiIiFQwIBERERGpYEAiIiIiUsGARERERKSCAYmIiIhIBQMSERERkQoGJCIiIiIVDEhEREREKhpEQIqJiYGzszMMDQ3h4+ODkydPVtt/69atcHNzg6GhITw8PPDzzz8rTR81ahRkMpnSo1+/fkp97t27h6CgIJiZmcHCwgJjx45FUVGRxteNiIiIGh+tB6QtW7YgNDQUERERSE5OhqenJwICAnDr1q1K+x8/fhzDhw/H2LFjcebMGQwePBiDBw/G+fPnlfr169cPOTk50uO7775Tmh4UFIQLFy5g37592L17N44cOYLx48fX2XoSERFR4yETQghtFuDj44Nu3bph1apVAACFQgFHR0dMmjQJs2fPrtB/6NChKC4uxu7du6W2Hj16wMvLC2vWrAHw+AhSfn4+du7cWekyU1NT0b59e5w6dQre3t4AgLi4OPTv3x/Xr1+Hg4NDjXUXFhbC3NwcBQUFMDMzU3e1mxzn2Xu0XQIRUb3Iihqg7RLoOdT281urR5BKS0uRlJQEf39/qU1HRwf+/v5ISEiodJ6EhASl/gAQEBBQof+hQ4dgY2ODdu3a4cMPP8Tdu3eVxrCwsJDCEQD4+/tDR0cHiYmJlS63pKQEhYWFSg8iIiJqmrQakO7cuYPy8nLY2toqtdva2iI3N7fSeXJzc2vs369fP3zzzTeIj4/HkiVLcPjwYbzxxhsoLy+XxrCxsVEaQ09PD5aWllUuNzIyEubm5tLD0dFR7fUlIiKixkFP2wXUhWHDhkn/9vDwQKdOndCmTRscOnQIfn5+zzRmWFgYQkNDpeeFhYUMSURERE2UVo8gWVtbQ1dXF3l5eUrteXl5sLOzq3QeOzs7tfoDQOvWrWFtbY0rV65IY6ieBF5WVoZ79+5VOY6BgQHMzMyUHkRERNQ0aTUgyeVydO3aFfHx8VKbQqFAfHw8fH19K53H19dXqT8A7Nu3r8r+AHD9+nXcvXsX9vb20hj5+flISkqS+hw4cAAKhQI+Pj7Ps0pERETUBGj9Mv/Q0FCsW7cOGzduRGpqKj788EMUFxdj9OjRAIDg4GCEhYVJ/adMmYK4uDgsX74caWlpmDt3Lk6fPo2JEycCAIqKijBz5kycOHECWVlZiI+Px6BBg9C2bVsEBAQAANzd3dGvXz+MGzcOJ0+exLFjxzBx4kQMGzasVlewERERUdOm9XOQhg4ditu3byM8PBy5ubnw8vJCXFycdCJ2dnY2dHT+znE9e/ZEbGws5syZg48//hiurq7YuXMnOnbsCADQ1dXF2bNnsXHjRuTn58PBwQGvv/46FixYAAMDA2mcTZs2YeLEifDz84OOjg4CAwOxcuXK+l15IiIiapC0fh+kxor3QVLG+yAR0T8F74PUuDWK+yARERERNUQMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpEJP2wUQERE1Js6z92i7BLVlRQ3QdgmNToM4ghQTEwNnZ2cYGhrCx8cHJ0+erLb/1q1b4ebmBkNDQ3h4eODnn3+Wpj169AizZs2Ch4cHjI2N4eDggODgYNy8eVNpDGdnZ8hkMqVHVFRUnawfERERNS5aD0hbtmxBaGgoIiIikJycDE9PTwQEBODWrVuV9j9+/DiGDx+OsWPH4syZMxg8eDAGDx6M8+fPAwAePHiA5ORkfPrpp0hOTsb27duRnp6OgQMHVhhr/vz5yMnJkR6TJk2q03UlIiKixkEmhBDaLMDHxwfdunXDqlWrAAAKhQKOjo6YNGkSZs+eXaH/0KFDUVxcjN27d0ttPXr0gJeXF9asWVPpMk6dOoXu3bvj6tWreOGFFwA8PoI0depUTJ06tVZ1lpSUoKSkRHpeWFgIR0dHFBQUwMzMrLar22Q1xkPORET/FPyK7W+FhYUwNzev8fNbq0eQSktLkZSUBH9/f6lNR0cH/v7+SEhIqHSehIQEpf4AEBAQUGV/ACgoKIBMJoOFhYVSe1RUFKysrNC5c2d89tlnKCsrq3KMyMhImJubSw9HR8darCERERE1Rlo9SfvOnTsoLy+Hra2tUrutrS3S0tIqnSc3N7fS/rm5uZX2f/jwIWbNmoXhw4crJcXJkyejS5cusLS0xPHjxxEWFoacnBysWLGi0nHCwsIQGhoqPX9yBImIiIianiZ9FdujR4/w7rvvQgiB1atXK017Oux06tQJcrkc//73vxEZGQkDA4MKYxkYGFTaTkRERE2PVgOStbU1dHV1kZeXp9Sel5cHOzu7Suexs7OrVf8n4ejq1as4cOBAjecJ+fj4oKysDFlZWWjXrt0zrA0REVHD1BjPE9X2eVNaPQdJLpeja9euiI+Pl9oUCgXi4+Ph6+tb6Ty+vr5K/QFg3759Sv2fhKPLly9j//79sLKyqrGWlJQU6OjowMbG5hnXhoiIiJoKrX/FFhoaipCQEHh7e6N79+6Ijo5GcXExRo8eDQAIDg5Gy5YtERkZCQCYMmUK+vTpg+XLl2PAgAHYvHkzTp8+jbVr1wJ4HI7efvttJCcnY/fu3SgvL5fOT7K0tIRcLkdCQgISExPxyiuvwNTUFAkJCZg2bRpGjhyJ5s2ba2dDEBERUYOh9YA0dOhQ3L59G+Hh4cjNzYWXlxfi4uKkE7Gzs7Oho/P3ga6ePXsiNjYWc+bMwccffwxXV1fs3LkTHTt2BADcuHEDu3btAgB4eXkpLevgwYPo27cvDAwMsHnzZsydOxclJSVwcXHBtGnTlM5LIiIion8urd8HqbGq7X0U/ika4/fbRETUcNXVOUiN4j5IRERERA0RAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREaloEAEpJiYGzs7OMDQ0hI+PD06ePFlt/61bt8LNzQ2Ghobw8PDAzz//rDRdCIHw8HDY29vDyMgI/v7+uHz5slKfe/fuISgoCGZmZrCwsMDYsWNRVFSk8XUjIiKixkfrAWnLli0IDQ1FREQEkpOT4enpiYCAANy6davS/sePH8fw4cMxduxYnDlzBoMHD8bgwYNx/vx5qc/SpUuxcuVKrFmzBomJiTA2NkZAQAAePnwo9QkKCsKFCxewb98+7N69G0eOHMH48ePrfH2JiIio4ZMJIYQ2C/Dx8UG3bt2watUqAIBCoYCjoyMmTZqE2bNnV+g/dOhQFBcXY/fu3VJbjx494OXlhTVr1kAIAQcHB0yfPh0zZswAABQUFMDW1hYbNmzAsGHDkJqaivbt2+PUqVPw9vYGAMTFxaF///64fv06HBwcaqy7sLAQ5ubmKCgogJmZmSY2RaPmPHuPtksgIqImJCtqQJ2MW9vPb706WXotlZaWIikpCWFhYVKbjo4O/P39kZCQUOk8CQkJCA0NVWoLCAjAzp07AQCZmZnIzc2Fv7+/NN3c3Bw+Pj5ISEjAsGHDkJCQAAsLCykcAYC/vz90dHSQmJiIIUOGVFhuSUkJSkpKpOcFBQUAHm9oAhQlD7RdAhERNSF19fn6ZNyajg9pNSDduXMH5eXlsLW1VWq3tbVFWlpapfPk5uZW2j83N1ea/qStuj42NjZK0/X09GBpaSn1URUZGYl58+ZVaHd0dKxq9YiIiOgZmUfX7fj379+Hubl5ldO1GpAak7CwMKUjVwqFAvfu3YOVlRVkMpkWK9O+wsJCODo64tq1a/y6sY5xW9cPbuf6we1cP7idlQkhcP/+/RpPp9FqQLK2toauri7y8vKU2vPy8mBnZ1fpPHZ2dtX2f/LfvLw82NvbK/Xx8vKS+qieBF5WVoZ79+5VuVwDAwMYGBgotVlYWFS/gv8wZmZmfPPVE27r+sHtXD+4nesHt/Pfqjty9IRWr2KTy+Xo2rUr4uPjpTaFQoH4+Hj4+vpWOo+vr69SfwDYt2+f1N/FxQV2dnZKfQoLC5GYmCj18fX1RX5+PpKSkqQ+Bw4cgEKhgI+Pj8bWj4iIiBonrX/FFhoaipCQEHh7e6N79+6Ijo5GcXExRo8eDQAIDg5Gy5YtERkZCQCYMmUK+vTpg+XLl2PAgAHYvHkzTp8+jbVr1wIAZDIZpk6dioULF8LV1RUuLi749NNP4eDggMGDBwMA3N3d0a9fP4wbNw5r1qzBo0ePMHHiRAwbNqxWV7ARERFR06b1gDR06FDcvn0b4eHhyM3NhZeXF+Li4qSTrLOzs6Gj8/eBrp49eyI2NhZz5szBxx9/DFdXV+zcuRMdO3aU+nz00UcoLi7G+PHjkZ+fj5deeglxcXEwNDSU+mzatAkTJ06En58fdHR0EBgYiJUrV9bfijchBgYGiIiIqPAVJGket3X94HauH9zO9YPb+dlo/T5IRERERA2N1u+kTURERNTQMCARERERqWBAIiIiIlLBgERERESkggGJnllkZCS6desGU1NT2NjYYPDgwUhPT9d2WU1eVFSUdDsL0qwbN25g5MiRsLKygpGRETw8PHD69Gltl9XklJeX49NPP4WLiwuMjIzQpk0bLFiwoMbfxqLqHTlyBG+++SYcHBwgk8mk3yh9QgiB8PBw2Nvbw8jICP7+/rh8+bJ2im0EGJDomR0+fBgTJkzAiRMnsG/fPjx69Aivv/46iouLtV1ak3Xq1Cl8+eWX6NSpk7ZLaXL+/PNP9OrVC/r6+vjll19w8eJFLF++HM2bN9d2aU3OkiVLsHr1aqxatQqpqalYsmQJli5div/+97/aLq1RKy4uhqenJ2JiYiqdvnTpUqxcuRJr1qxBYmIijI2NERAQgIcPH9ZzpY0DL/Mnjbl9+zZsbGxw+PBh9O7dW9vlNDlFRUXo0qUL/ve//2HhwoXw8vJCdHS0tstqMmbPno1jx47h6NGj2i6lyfvXv/4FW1tbfPXVV1JbYGAgjIyM8O2332qxsqZDJpNhx44d0g2ShRBwcHDA9OnTMWPGDABAQUEBbG1tsWHDBgwbNkyL1TZMPIJEGlNQUAAAsLS01HIlTdOECRMwYMAA+Pv7a7uUJmnXrl3w9vbGO++8AxsbG3Tu3Bnr1q3TdllNUs+ePREfH49Lly4BAH7//Xf89ttveOONN7RcWdOVmZmJ3Nxcpf2Hubk5fHx8kJCQoMXKGi6t30mbmgaFQoGpU6eiV69eSnc1J83YvHkzkpOTcerUKW2X0mT98ccfWL16NUJDQ/Hxxx/j1KlTmDx5MuRyOUJCQrRdXpMye/ZsFBYWws3NDbq6uigvL8eiRYsQFBSk7dKarNzcXACQfqXiCVtbW2kaKWNAIo2YMGECzp8/j99++03bpTQ5165dw5QpU7Bv3z6ln8shzVIoFPD29sbixYsBAJ07d8b58+exZs0aBiQN+/7777Fp0ybExsaiQ4cOSElJwdSpU+Hg4MBtTQ0Gv2Kj5zZx4kTs3r0bBw8eRKtWrbRdTpOTlJSEW7duoUuXLtDT04Oenh4OHz6MlStXQk9PD+Xl5dousUmwt7dH+/btldrc3d2RnZ2tpYqarpkzZ2L27NkYNmwYPDw88N5772HatGnSj5KT5tnZ2QEA8vLylNrz8vKkaaSMAYmemRACEydOxI4dO3DgwAG4uLhou6Qmyc/PD+fOnUNKSor08Pb2RlBQEFJSUqCrq6vtEpuEXr16VbhNxaVLl+Dk5KSlipquBw8eKP0IOQDo6upCoVBoqaKmz8XFBXZ2doiPj5faCgsLkZiYCF9fXy1W1nDxKzZ6ZhMmTEBsbCx+/PFHmJqaSt9jm5ubw8jISMvVNR2mpqYVzusyNjaGlZUVz/fSoGnTpqFnz55YvHgx3n33XZw8eRJr167F2rVrtV1ak/Pmm29i0aJFeOGFF9ChQwecOXMGK1aswJgxY7RdWqNWVFSEK1euSM8zMzORkpICS0tLvPDCC5g6dSoWLlwIV1dXuLi44NNPP4WDg4N0pRupEETPCEClj/Xr12u7tCavT58+YsqUKdouo8n56aefRMeOHYWBgYFwc3MTa9eu1XZJTVJhYaGYMmWKeOGFF4ShoaFo3bq1+OSTT0RJSYm2S2vUDh48WOk+OSQkRAghhEKhEJ9++qmwtbUVBgYGws/PT6Snp2u36AaM90EiIiIiUsFzkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCr+cQEpKysLMpkMKSkp2i5FkpaWhh49esDQ0BBeXl7aLqfJ2LBhAywsLLRdhlbJZDLs3LnzucZoKNuxNu8TIQTGjx8PS0tL6X3et29fTJ06tV5rrSujRo2q8WchDh06BJlMhvz8/Dqt5dixY/Dw8IC+vj5/quI5aPMzqTavp5o8ePAAgYGBMDMzq5fXXX2q94A0atQoyGQyREVFKbXv3LkTMpmsvstpECIiImBsbIz09HSlHxL8J2soH8qAZkKGtuTk5OCNN97QdhkaUZv3SVxcHDZs2IDdu3cjJycHHTt2xPbt27FgwYLnWnZDeQ188cUX2LBhg/S8svDXs2dP5OTkwNzcvE5rCQ0NhZeXFzIzM5Vqamwa0r6mMdq4cSOOHj2K48eP18vrrj5p5QiSoaEhlixZgj///FMbi68TpaWlzzxvRkYGXnrpJTg5OcHKykqDVdE/nZ2dHQwMDLRdhkbU5n2SkZEBe3t79OzZE3Z2dtDT04OlpSVMTU2rHPd53rv1zdzcvMYPc7lcDjs7uzr/H86MjAy8+uqraNWq1TMHjMa07alyGRkZcHd3R8eOHevldVev6vvH30JCQsS//vUv4ebmJmbOnCm179ixQzxdTkREhPD09FSa9/PPPxdOTk5KYw0aNEgsWrRI2NjYCHNzczFv3jzx6NEjMWPGDNG8eXPRsmVL8fXXX0vzZGZmCgDiu+++E76+vsLAwEB06NBBHDp0SGlZ586dE/369RPGxsbCxsZGjBw5Uty+fVua3qdPHzFhwgQxZcoUYWVlJfr27Vvp+paXl4t58+aJli1bCrlcLjw9PcUvv/wiTYfKjwpGRERUOc6SJUtEmzZthFwuF46OjmLhwoXS9LNnz4pXXnlFGBoaCktLSzFu3Dhx//59jWyrLVu2iJdeekkYGhoKb29vkZ6eLk6ePCm6du0qjI2NRb9+/cStW7eU6l23bp1wc3MTBgYGol27diImJqbCuNu2bRN9+/YVRkZGolOnTuL48eNCiMp/cPHJdomJiRFt27YVBgYGwsbGRgQGBla6vYQQYv369cLc3Fzs2LFDmuf1118X2dnZSv127twpOnfuLAwMDISLi4uYO3euePTokRBCCCcnJ6U6nJycRH5+vtDR0RGnTp2S/jbNmzcXPj4+0pj/7//9P9GqVSvpeXZ2tnjnnXeEubm5aN68uRg4cKDIzMzU2DarCgCxY8cOtcZYv369cHR0FEZGRmLw4MFi2bJlwtzcvNbbbN68ecLe3l7cuXNH6t+/f3/Rt29fUV5eXmmdmnifhISEVPhbCVHxh32dnJzE/PnzxXvvvSdMTU1FSEiIKCkpERMmTBB2dnbCwMBAvPDCC2Lx4sVS/8rGVVXbfcuhQ4dEt27dhFwuF3Z2dmLWrFnSthNCiK1bt4qOHTtK72U/Pz9RVFQkreOgQYMqXV8AIjMzU3r//Pnnn6KgoEAYGhqKn3/+WamG7du3CxMTE1FcXCyEqN3rU3U9n348+YHqmtatqv1mTfvbmvZ/H330kXB1dRVGRkbCxcVFzJkzR5SWlkrTU1JSRN++fYWJiYkwNTUVXbp0EadOnap2X6PqypUrYuDAgcLGxkYYGxsLb29vsW/fPqU+Tk5OYtGiRWL06NHCxMREODo6ii+//FKpT2JiovDy8hIGBgaia9euYvv27QKAOHPmTKXLFUKIhw8fiunTpwsHBwfRrFkz0b17d3Hw4EFp+pN9XVxcnHBzcxPGxsYiICBA3Lx5U+pTVlYmpk2bJszNzYWlpaWYOXOmCA4Oll5PVfnhhx9E+/bthVwuF05OTmLZsmXStD59+ihtuz59+lQ5zq5du4S3t7cwMDAQVlZWYvDgwdK0e/fuiffee09YWFgIIyMj0a9fP3Hp0qVar9/evXuFgYGB+PPPP5WWOXnyZPHKK69Iz48ePSp9lrVq1UpMmjRJem8JUXHfoJWANGjQILF9+3ZhaGgorl27JoR49oBkamoqJkyYINLS0sRXX30lAIiAgACxaNEicenSJbFgwQKhr68vLefJm7tVq1bihx9+EBcvXhTvv/++MDU1lXbof/75p2jRooUICwsTqampIjk5Wbz22mtKG7pPnz7CxMREzJw5U6SlpYm0tLRK13fFihXCzMxMfPfddyItLU189NFHQl9fX/rj5+TkiA4dOojp06eLnJwcpVDztI8++kg0b95cbNiwQVy5ckUcPXpUrFu3TgghRFFRkbC3txdvvfWWOHfunIiPjxcuLi7SLzg/77Zyc3MTcXFx4uLFi6JHjx6ia9euom/fvuK3334TycnJom3btuKDDz6QlvXtt98Ke3t7sW3bNvHHH3+Ibdu2CUtLS7Fhw4YK4+7evVukp6eLt99+Wzg5OYlHjx6JkpISER0dLczMzEROTo60XU6dOiV0dXVFbGysyMrKEsnJyeKLL76o/IUmHr+p9PX1hbe3tzh+/Lg4ffq06N69u+jZs6fU58iRI8LMzExs2LBBZGRkiF9//VU4OzuLuXPnCiGEuHXrlvQBkJOTIwXBLl26iM8++0wI8Xjna2lpKeRyufT3e//990VQUJAQQojS0lLh7u4uxowZI86ePSsuXrwoRowYIdq1ayf9evnzbrOqVBaQqhvjxIkTQkdHRyxZskSkp6eLL774QlhYWCgFpJq2WVlZmfD19ZV2gKtWrRIWFhbi6tWrVdapifdJfn6+mD9/vmjVqpXS36qygGRmZiaWLVsmrly5Iq5cuSI+++wz4ejoKI4cOSKysrLE0aNHRWxsbLWvAVW12bdcv35dNGvWTPznP/8RqampYseOHcLa2lr6UL5586bQ09MTK1asEJmZmeLs2bMiJiZGWt+nA1J+fr7w9fUV48aNk94nZWVlSgFJCCHefvttMXLkSKVaAwMDpbbavD6fVlZWJnJycoSZmZmIjo4WOTk54sGDBzWu25O/hep+szb72+r2f0IIsWDBAnHs2DGRmZkpdu3aJWxtbcWSJUuk6R06dBAjR44Uqamp4tKlS+L7778XKSkpVe5rKpOSkiLWrFkjzp07Jy5duiTmzJkjDA0NlV7XTk5OwtLSUsTExIjLly+LyMhIoaOjI30+3L9/X7Ro0UKMGDFCnD9/Xvz000+idevWNQak999/X/Ts2VMcOXJEer0aGBhI748n+zp/f39x6tQpkZSUJNzd3cWIESOkMZYsWSKaN28utm3bJi5evCjGjh0rTE1Nqw1Ip0+fFjo6OmL+/PkiPT1drF+/XhgZGUmB+O7du2LcuHHC19dX5OTkiLt371Y6zu7du4Wurq4IDw8XFy9eFCkpKdL/gAghxMCBA4W7u7s4cuSISElJEQEBAaJt27ZSyK1p/crKyoStra34v//7P2lM1bYrV64IY2Nj8fnnn4tLly6JY8eOic6dO4tRo0Yp/f2e3jdoLSAJIUSPHj3EmDFjhBDPHpCcnJyU/q+0Xbt24uWXX5ael5WVCWNjY/Hdd98JIf7eiUVFRUl9Hj16JFq1aiW9oRYsWCBef/11pWVfu3ZNABDp6elCiMdv9M6dO9e4vg4ODmLRokVKbd26dRP/+c9/pOeenp5V/l+LEEIUFhYKAwMDpR3C09auXSuaN2+ulIT37NkjdHR0RG5urhDi+bbV0y+67777TgAQ8fHxUltkZKRo166d9LxNmzbSh8sTCxYsEL6+vlWOe+HCBQFApKamCiH+/j+Gp23btk2YmZmJwsLCKrfV09avXy8AiBMnTkhtqampAoBITEwUQgjh5+en9EYV4vHRH3t7e+n50yHjidDQUDFgwAAhhBDR0dFi6NChSkc92rZtK9auXSuN165dO6FQKKT5S0pKhJGRkdi7d68QQjPbrDKVBaTqxhg+fLjo37+/0hhDhw5V+lvUZptlZGQIU1NTMWvWLGFkZCQ2bdpUZY1CaOZ9IkTFfYQQlQekp//vVQghJk2aJF599VWlv9HTKnsNqKrNvuXjjz+u8FqIiYkRJiYmory8XCQlJQkAIisrq9JlPL3/rGzdhBAVAtKOHTuUjhY9Oar05LVam9dnZczNzaUPytqs25N6VfebNe1va9r/Veazzz4TXbt2lZ6bmppK/7OhqrJ9TW116NBB/Pe//5WeOzk5KYVRhUIhbGxsxOrVq4UQQnz55ZfCyspK/PXXX1Kf1atXVxuQrl69KnR1dcWNGzeU2v38/ERYWJi0DgDElStXpOkxMTHC1tZWem5vby+WLl0qPX/y2qwuII0YMUK89tprSm0zZ84U7du3l55PmTKl2iNHQgjh6+sr/Q+jqkuXLgkA4tixY1LbnTt3hJGRkfj+++9rvX5TpkwRr776qvRc9ajS2LFjxfjx45WWffToUaGjoyP9PVT3DVq9im3JkiXYuHEjUlNTn3mMDh06QEfn79WwtbWFh4eH9FxXVxdWVla4deuW0ny+vr7Sv/X09ODt7S3V8fvvv+PgwYMwMTGRHm5ubgAef9/6RNeuXautrbCwEDdv3kSvXr2U2nv16qXWOqempqKkpAR+fn5VTvf09ISxsbHSMhQKBdLT06W2Z91WnTp1UpoHgNJ8tra20jzFxcXIyMjA2LFjlbbfwoULlbad6rj29vYAUGHZT3vttdfg5OSE1q1b47333sOmTZvw4MGDKvsDj/+23bp1k567ubnBwsJC6W89f/58pVrHjRuHnJycasfu06cPfvvtN5SXl+Pw4cPo27cv+vbti0OHDuHmzZu4cuUK+vbtKy3jypUrMDU1lZZhaWmJhw8fIiMjo063WWWqGyM1NRU+Pj5K/Z9+r9R2m7Vu3RrLli3DkiVLMHDgQIwYMaLKejT1PlGHt7e30vNRo0YhJSUF7dq1w+TJk/Hrr78+89jV7VtSU1Ph6+urdJ5Gr169UFRUhOvXr8PT0xN+fn7w8PDAO++8g3Xr1j33uZr9+/eHvr4+du3aBQDYtm0bzMzM4O/vD6Dm12dt1bRuT6juN2va39a0/wOALVu2oFevXrCzs4OJiQnmzJmD7OxsaXpoaCjef/99+Pv7IyoqSq31eqKoqAgzZsyAu7s7LCwsYGJigtTUVKXlAMrvL5lMBjs7O6X3V6dOnWBoaCj1UX1/qTp37hzKy8vx4osvKm2jw4cPK61Hs2bN0KZNG+m5vb29tNyCggLk5OQovbefvDark5qaWun78vLlyygvL6923qelpKRU+/mlp6enVJuVlRXatWun9P6vbv0AICgoSNr/AsCmTZswYMAA6fy433//HRs2bFDahgEBAVAoFMjMzJTGeXqb6NV6DetA7969ERAQgLCwMIwaNUppmo6ODoQQSm2PHj2qMIa+vr7Sc5lMVmmbQqGodV1FRUV48803sWTJkgrTnnygAFAKJHXJyMhII+M867Z6us+TnZ9q25N5ioqKAADr1q2r8EGrq6tb47jV/Z1MTU2RnJyMQ4cO4ddff0V4eDjmzp2LU6dOPfNJokVFRZg3bx7eeuutCtOe3omp6t27N+7fv4/k5GQcOXIEixcvhp2dHaKiouDp6QkHBwe4urpKy+jatSs2bdpUYZwWLVrU6TarzPOOUdttduTIEejq6iIrKwtlZWXQ09Pq7kaJ6nu3S5cuyMzMxC+//IL9+/fj3Xffhb+/P3744Yd6rUtXVxf79u3D8ePH8euvv+K///0vPvnkEyQmJsLFxeWZxpTL5Xj77bcRGxuLYcOGITY2FkOHDpX+HjW9PjVNddvXtL/9448/qh0vISEBQUFBmDdvHgICAmBubo7Nmzdj+fLlUp+5c+dixIgR2LNnD3755RdERERg8+bNGDJkSK3rnjFjBvbt24dly5ahbdu2MDIywttvv13hRPPn/fxRVVRUBF1dXSQlJVXYH5iYmFS7XNXPUG3RxGdYTevXrVs3tGnTBps3b8aHH36IHTt2KF1dWVRUhH//+9+YPHlyhbFfeOEF6d9Pvz61fh+kqKgo/PTTT0hISFBqb9GiBXJzc5U2gCbvE3HixAnp32VlZUhKSoK7uzuAxzvLCxcuwNnZGW3btlV6qBOKzMzM4ODggGPHjim1Hzt2DO3bt6/1OK6urjAyMqry0mZ3d3f8/vvvKC4uVlqGjo4O2rVrV+vlaIKtrS0cHBzwxx9/VNh26uzg5XJ5pf+HoqenB39/fyxduhRnz55FVlYWDhw4UOU4ZWVlOH36tPQ8PT0d+fn5Sn/r9PT0CrW2bdtWOtqmr69foRYLCwt06tQJq1atgr6+Ptzc3NC7d2+cOXMGu3fvRp8+faS+Xbp0weXLl2FjY1NhGebm5hrbZprg7u6OxMREpban3ytA7bbZli1bsH37dhw6dAjZ2dnVXmavqffJ8zIzM8PQoUOxbt06bNmyBdu2bcO9e/cAVP4aqEp1+xZ3d3ckJCQo7deOHTsGU1NTtGrVCsDjHX+vXr0wb948nDlzBnK5HDt27Kh0WVW9T1QFBQUhLi4OFy5cwIEDBxAUFCRNq+n1WVu1WbfK1LS/rWn/d/z4cTg5OeGTTz6Bt7c3XF1dcfXq1Qr9XnzxRUybNg2//vor3nrrLaxfvx5A7bfhsWPHMGrUKAwZMgQeHh6ws7NDVlZWjfM9zd3dHWfPnsXDhw+lNtX3l6rOnTujvLwct27dqrB97OzsarVcc3Nz2NvbK723n7w2a6q3svfliy++WCGsVadTp07Vfn6VlZUp1Xb37l2kp6er/f4PCgrCpk2b8NNPP0FHRwcDBgyQpnXp0gUXL16sdL8ll8srHU/rAcnDwwNBQUFYuXKlUnvfvn1x+/ZtLF26FBkZGYiJicEvv/yiseXGxMRgx44dSEtLw4QJE/Dnn39izJgxAIAJEybg3r17GD58OE6dOoWMjAzs3bsXo0ePVuuwIgDMnDkTS5YswZYtW5Ceno7Zs2cjJSUFU6ZMqfUYhoaGmDVrFj766CN88803yMjIwIkTJ/DVV18BePyiMDQ0REhICM6fP4+DBw9i0qRJeO+996SvxOrTvHnzEBkZiZUrV+LSpUs4d+4c1q9fjxUrVtR6DGdnZxQVFSE+Ph537tzBgwcPsHv3bqxcuRIpKSm4evUqvvnmGygUimpDoL6+PiZNmoTExEQkJSVh1KhR6NGjB7p37w4ACA8PxzfffIN58+bhwoULSE1NxebNmzFnzhylWuLj45Gbm6v0dUffvn2xadMmKQxZWlrC3d0dW7ZsUQpIQUFBsLa2xqBBg3D06FFkZmbi0KFDmDx5svTVgya2mSZMnjwZcXFxWLZsGS5fvoxVq1YhLi5OqU9N2+z69ev48MMPsWTJErz00ktYv349Fi9eXO0HgSbeJ89jxYoV+O6775CWloZLly5h69atsLOzk45MVvUaqEx1+5b//Oc/uHbtGiZNmoS0tDT8+OOPiIiIQGhoKHR0dJCYmIjFixfj9OnTyM7Oxvbt23H79m0pYKlydnZGYmIisrKycOfOnSqPVPTu3Rt2dnYICgqCi4uL0pHK2rw+a6OmdatKTfvbmvZ/rq6uyM7OxubNm5GRkYGVK1cqBcq//voLEydOxKFDh3D16lUcO3YMp06dkrZpZfuayri6umL79u1ISUnB77//jhEjRqh9ZGjEiBGQyWQYN24cLl68iJ9//hnLli2rdp4XX3wRQUFBCA4Oxvbt25GZmYmTJ08iMjISe/bsqfWyp0yZgqioKOzcuRNpaWn4z3/+U+NNHadPn474+HgsWLAAly5dwsaNG7Fq1SrMmDGj1ssFHt/D7LvvvkNERARSU1Nx7tw56Yihq6srBg0ahHHjxuG3337D77//jpEjR6Jly5YYNGiQWssJCgpCcnIyFi1ahLffflvpFiezZs3C8ePHMXHiRKSkpODy5cv48ccfMXHixKoHrPbMqjqgepKhEI9PbpTL5UK1nNWrVwtHR0dhbGwsgoODxaJFiyq9zP9plZ206OTkJD7//HNpWQBEbGys6N69u5DL5aJ9+/biwIEDSvNcunRJDBkyRLrs0M3NTUydOlU6AbGy5VSmvLxczJ07V7Rs2VLo6+tXuHxZiNqdfFpeXi4WLlwonJychL6+vtJlyELU/jL/Z9lWT588qHoCqBCVn+S4adMm4eXlJeRyuWjevLno3bu32L59e5Xj/vnnnwKA0qWrH3zwgbCyspIuvT169Kjo06ePaN68uXSJ+pYtW6rcZk/q2rZtm2jdurUwMDAQ/v7+Fa6miouLEz179hRGRkbCzMxMdO/eXTrBWojHl6e2bdtW6OnpKb3+nlxY8OQETCEenygIoMJVjTk5OSI4OFhYW1sLAwMD0bp1azFu3DhRUFCg0W2mCpWcpF3TGF999ZVo1aqVMDIyEm+++Wall/lXtc0UCoXw8/MTAQEBSifrTpo0SbRp06bKK4Q09T6p7UnaT17jT6xdu1Z4eXkJY2NjYWZmJvz8/ERycrI0varXwNNqu2+p7lL4ixcvioCAANGiRQthYGAgXnzxRaWTgFXfx+np6aJHjx7CyMio0sv8n/bRRx8JACI8PLxC7bV5fapSPUm7pnUTour9Zk3725r2fzNnzhRWVlbCxMREDB06VHz++efSa7akpEQMGzZMODo6CrlcLhwcHMTEiROVTpRW3ddUJjMzU7zyyivCyMhIODo6ilWrVtXqtaX6uk1ISBCenp5CLpcLLy8vsW3bthqvYistLRXh4eHC2dlZ6OvrC3t7ezFkyBBx9uxZIUTl+2DVC58ePXokpkyZIszMzISFhYUIDQ1V6zL/J9v9ydW7T9TmJG0hHl9k82T/Zm1tLd566y1p2pPL/M3NzYWRkZEICAio9DL/6tbvie7duwsAFd53Qghx8uRJ8dprrwkTExNhbGwsOnXqpHRxiOrfTyZEA/mSkoioEcvKyoKLiwvOnDnDnwwiagK0/hUbERERUUPDgERERESkgl+xEREREangESQiIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZGK/w/14lNq7GZmewAAAABJRU5ErkJggg==", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "MODEL = \"bert-base-cased\"" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.484375, Median = 3.0\n", - "Accuracy 0.642857\n", - "Precision 0.653061\n", - "Recall 0.609524\n", - "FPR 0.32381\n", - "F1 0.630542\n", - "Mean H 3.484375\n", - "Correct Adjustment 0.055952\n", - "Incorrect Adjustment 0.060714\n", - "Recovery -0.004762\n", - "Leaderboard String | MODEL_NAME | 64.3 | 65.3 | 61.0 | 63....\n", - "dtype: object\n", - "Evaluating Random Seed 5\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**List of Models**\n", + "\n", + "**TransformerEncoderModel**\n", + "- `bert-base-cased` — BERT-base \n", + "- `roberta-base` — RoBERTa-base \n", + "- `SpanBERT/spanbert-base-cased` — SpanBERT-base \n", + "- `microsoft/deberta-v3-base` — DeBERTaV3-base \n", + "- `bert-large-cased` — BERT-large \n", + "- `roberta-large` — RoBERTa-large \n", + "- `SpanBERT/spanbert-large-cased` — SpanBERT-large \n", + "- `microsoft/deberta-v3-large` — DeBERTaV3-large \n", + "\n", + "**TransformerDecoderModel**\n", + "- `google/gemma-2-9b-it` — Gemma2 9B \n", + "- `meta-llama/Llama-3.1-8B-Instruct` — LLaMA 3.1 8B \n", + "- `mistralai/Mistral-7B-Instruct-v0.3` — Mistral 7B \n", + "- `microsoft/phi-4` — Phi-4 14B" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5131/5131 [00:47<00:00, 108.92it/s]\n" - ] + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "BASE_URL = f\"https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/{corpus_name}/{MODEL}/\"\n", + "DOWNLOAD_DIR = f\"{YOUR_MODEL_DIRECTORY}/{corpus_name}/{MODEL}\"\n", + "\n", + "os.makedirs(DOWNLOAD_DIR, exist_ok=True)\n", + "download_recursive(BASE_URL, DOWNLOAD_DIR)\n", + "forecasting_models_path = DOWNLOAD_DIR\n" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define selectors for the Forecaster\n", + "\n", + "Core to the flexibility of the `Forecaster` framework is the concept of *selectors*. \n", + "\n", + "To capture the temporal dimension of the conversational forecasting task, `Forecaster` iterates through conversations in chronological utterance order, at each step presenting to the backend forecasting model a \"context tuple\" containing both the comment itself and the full \"context\" preceding that comment. As a general framework, `Forecaster` on its own does not try to make any further assumptions about what \"context\" should contain or look like; it simply presents context as a chronologically ordered list of all utterances up to and including the current one. " ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.605633802816901, Median = 3.0\n", - "Accuracy 0.678571\n", - "Precision 0.679426\n", - "Recall 0.67619\n", - "FPR 0.319048\n", - "F1 0.677804\n", - "Mean H 3.605634\n", - "Correct Adjustment 0.05\n", - "Incorrect Adjustment 0.070238\n", - "Recovery -0.020238\n", - "Leaderboard String | MODEL_NAME | 67.9 | 67.9 | 67.6 | 67....\n", - "dtype: object\n", - "{'Accuracy': np.float64(0.6645238095238095), 'Precision': np.float64(0.6649554573724549), 'Recall': np.float64(0.6628571428571428), 'FPR': np.float64(0.33380952380952383), 'F1': np.float64(0.6636405952685067), 'Mean H': np.float64(3.6320544396885324), 'Correct Adjustment': np.float64(0.05619047619047619), 'Incorrect Adjustment': np.float64(0.07238095238095239), 'Recovery': np.float64(-0.016190476190476193), 'Leaderboard String': ['| MODEL_NAME | 66.2 | 66.2 | 66.2 | 66.2 | 33.8 | 3.59 | -1.7 (5.0 - 6.7) |', '| MODEL_NAME | 66.7 | 66.7 | 66.4 | 66.6 | 33.1 | 3.73 | -2.1 (5.5 - 7.6) |', '| MODEL_NAME | 67.3 | 66.3 | 70.2 | 68.2 | 35.7 | 3.75 | -1.8 (7.0 - 8.8) |', '| MODEL_NAME | 64.3 | 65.3 | 61.0 | 63.1 | 32.4 | 3.48 | -0.5 (5.6 - 6.1) |', '| MODEL_NAME | 67.9 | 67.9 | 67.6 | 67.8 | 31.9 | 3.61 | -2.0 (5.0 - 7.0) |']}\n" - ] - } - ], - "source": [ - "all_results = {}\n", - "for seed in range(1,6):\n", - " print(f\"Evaluating Random Seed {seed}\")\n", - " config_dict = TransformerForecasterConfig(\n", - " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", - " context_mode=\"normal\", # set to normal by default\n", - " device=DEVICE\n", - " )\n", - " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", - "\n", - " #Load pre-tuned config\n", - " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", - " with open(tuned_config_file, 'r') as file:\n", - " tuned_config = json.load(file)\n", - "\n", - " encoder_model = TransformerEncoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", - " encoder_model.best_threshold = tuned_config['best_threshold']\n", - " encoder_forecaster = Forecaster(encoder_model, label_metadata)\n", - "\n", - " # corpus = copy.deepcopy(corpus)\n", - " corpus = encoder_forecaster.transform(corpus, transform_selector)\n", - " _, cur_metrics= encoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", - "\n", - " update_metrics(all_results, cur_metrics)\n", - "\n", - "for metric in all_results:\n", - " if metric == \"Leaderboard String\":\n", - " continue\n", - " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n", - "\n", - "print(all_results)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " \"Accuracy\": 0.6645238095238095,\n", - " \"Precision\": 0.6649554573724549,\n", - " \"Recall\": 0.6628571428571428,\n", - " \"FPR\": 0.33380952380952383,\n", - " \"F1\": 0.6636405952685067,\n", - " \"Mean H\": 3.6320544396885324,\n", - " \"Correct Adjustment\": 0.05619047619047619,\n", - " \"Incorrect Adjustment\": 0.07238095238095239,\n", - " \"Recovery\": -0.016190476190476193,\n", - " \"Leaderboard String\": \"| BERT-base | 66.5 | 66.5 | 66.3 | 66.4 | 33.4 | 3.63 | -1.6 (5.6 - 7.2) |\"\n", - "}\n" - ] - } - ], - "source": [ - "leaderboard_string = (f\"| BERT-base | \"\n", - " f\"{all_results['Accuracy']*100:.1f} | \"\n", - " f\"{all_results['Precision']*100:.1f} | \"\n", - " f\"{all_results['Recall']*100:.1f} | \"\n", - " f\"{all_results['F1']*100:.1f} | \"\n", - " f\"{all_results['FPR']*100:.1f} | \"\n", - " f\"{all_results['Mean H']:.2f} | \"\n", - " f\"{(all_results['Correct Adjustment']-all_results['Incorrect Adjustment'])*100:.1f} \"\n", - " f\"({all_results['Correct Adjustment']*100:.1f} - {all_results['Incorrect Adjustment']*100:.1f}) |\")\n", - "all_results['Leaderboard String'] = leaderboard_string\n", - "print(json.dumps(all_results, indent=4))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Transformer Decoder-based Forecaster" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "MODEL = \"google/gemma-2-9b-it\"\n", - "BASE_URL = f\"https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/{corpus_name}/{MODEL}/\"\n", - "DOWNLOAD_DIR = f\"{YOUR_MODEL_DIRECTORY}/{corpus_name}/{MODEL}\"\n", - "\n", - "os.makedirs(DOWNLOAD_DIR, exist_ok=True)\n", - "download_recursive(BASE_URL, DOWNLOAD_DIR)\n", - "forecasting_models_path = DOWNLOAD_DIR" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Evaluating Random Seed 1\n", - "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def transform_selector(context_tuple):\n", + " \"\"\"\n", + " For transform we only need to check that the conversation is in the test split\n", + " \"\"\"\n", + " convo = context_tuple.current_utterance.get_conversation()\n", + " convo_length = len(convo.get_chronological_utterance_list())\n", + "\n", + " matches_split = (context_tuple.current_utterance.get_conversation().meta[\"split\"] == \"test\")\n", + " is_end = (len(context_tuple.context) == convo_length)\n", + "\n", + " return (matches_split and not is_end)\n", + "def update_metrics(all_results, cur_metrics):\n", + " for metric in cur_metrics:\n", + " all_results[metric] = all_results.get(metric, []) + [cur_metrics[metric]]\n", + " return all_results" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Unsloth 2025.3.19 patched 42 layers with 42 QKV layers, 42 O layers and 42 MLP layers.\n", - "Unsloth: Will map to EOS = .\n", - "0it [00:00, ?it/s]The attention mask is not set and cannot be inferred from input because pad token is same as eos token. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n", - "5131it [15:38, 5.47it/s]\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Transformer Encoder-based Forecaster" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluating Random Seed 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:47<00:00, 109.11it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.5899280575539567, Median = 3.0\n", + "Accuracy 0.661905\n", + "Precision 0.661905\n", + "Recall 0.661905\n", + "FPR 0.338095\n", + "F1 0.661905\n", + "Mean H 3.589928\n", + "Correct Adjustment 0.05\n", + "Incorrect Adjustment 0.066667\n", + "Recovery -0.016667\n", + "Leaderboard String | MODEL_NAME | 66.2 | 66.2 | 66.2 | 66....\n", + "dtype: object\n", + "Evaluating Random Seed 2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:47<00:00, 108.70it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.731182795698925, Median = 3.0\n", + "Accuracy 0.666667\n", + "Precision 0.667464\n", + "Recall 0.664286\n", + "FPR 0.330952\n", + "F1 0.665871\n", + "Mean H 3.731183\n", + "Correct Adjustment 0.054762\n", + "Incorrect Adjustment 0.07619\n", + "Recovery -0.021429\n", + "Leaderboard String | MODEL_NAME | 66.7 | 66.7 | 66.4 | 66....\n", + "dtype: object\n", + "Evaluating Random Seed 3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:47<00:00, 109.03it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.7491525423728813, Median = 3.0\n", + "Accuracy 0.672619\n", + "Precision 0.662921\n", + "Recall 0.702381\n", + "FPR 0.357143\n", + "F1 0.682081\n", + "Mean H 3.749153\n", + "Correct Adjustment 0.070238\n", + "Incorrect Adjustment 0.088095\n", + "Recovery -0.017857\n", + "Leaderboard String | MODEL_NAME | 67.3 | 66.3 | 70.2 | 68....\n", + "dtype: object\n", + "Evaluating Random Seed 4\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:47<00:00, 108.49it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.484375, Median = 3.0\n", + "Accuracy 0.642857\n", + "Precision 0.653061\n", + "Recall 0.609524\n", + "FPR 0.32381\n", + "F1 0.630542\n", + "Mean H 3.484375\n", + "Correct Adjustment 0.055952\n", + "Incorrect Adjustment 0.060714\n", + "Recovery -0.004762\n", + "Leaderboard String | MODEL_NAME | 64.3 | 65.3 | 61.0 | 63....\n", + "dtype: object\n", + "Evaluating Random Seed 5\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:47<00:00, 108.92it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.605633802816901, Median = 3.0\n", + "Accuracy 0.678571\n", + "Precision 0.679426\n", + "Recall 0.67619\n", + "FPR 0.319048\n", + "F1 0.677804\n", + "Mean H 3.605634\n", + "Correct Adjustment 0.05\n", + "Incorrect Adjustment 0.070238\n", + "Recovery -0.020238\n", + "Leaderboard String | MODEL_NAME | 67.9 | 67.9 | 67.6 | 67....\n", + "dtype: object\n", + "{'Accuracy': np.float64(0.6645238095238095), 'Precision': np.float64(0.6649554573724549), 'Recall': np.float64(0.6628571428571428), 'FPR': np.float64(0.33380952380952383), 'F1': np.float64(0.6636405952685067), 'Mean H': np.float64(3.6320544396885324), 'Correct Adjustment': np.float64(0.05619047619047619), 'Incorrect Adjustment': np.float64(0.07238095238095239), 'Recovery': np.float64(-0.016190476190476193), 'Leaderboard String': ['| MODEL_NAME | 66.2 | 66.2 | 66.2 | 66.2 | 33.8 | 3.59 | -1.7 (5.0 - 6.7) |', '| MODEL_NAME | 66.7 | 66.7 | 66.4 | 66.6 | 33.1 | 3.73 | -2.1 (5.5 - 7.6) |', '| MODEL_NAME | 67.3 | 66.3 | 70.2 | 68.2 | 35.7 | 3.75 | -1.8 (7.0 - 8.8) |', '| MODEL_NAME | 64.3 | 65.3 | 61.0 | 63.1 | 32.4 | 3.48 | -0.5 (5.6 - 6.1) |', '| MODEL_NAME | 67.9 | 67.9 | 67.6 | 67.8 | 31.9 | 3.61 | -2.0 (5.0 - 7.0) |']}\n" + ] + } + ], + "source": [ + "all_results = {}\n", + "for seed in range(1,6):\n", + " print(f\"Evaluating Random Seed {seed}\")\n", + " config_dict = TransformerForecasterConfig(\n", + " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", + " context_mode=\"normal\", # set to normal by default\n", + " device=DEVICE\n", + " )\n", + " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", + "\n", + " #Load pre-tuned config\n", + " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", + " with open(tuned_config_file, 'r') as file:\n", + " tuned_config = json.load(file)\n", + "\n", + " encoder_model = TransformerEncoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", + " encoder_model.best_threshold = tuned_config['best_threshold']\n", + " encoder_forecaster = Forecaster(encoder_model, label_metadata)\n", + "\n", + " # corpus = copy.deepcopy(corpus)\n", + " corpus = encoder_forecaster.transform(corpus, transform_selector)\n", + " _, cur_metrics= encoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", + "\n", + " update_metrics(all_results, cur_metrics)\n", + "\n", + "for metric in all_results:\n", + " if metric == \"Leaderboard String\":\n", + " continue\n", + " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n", + "\n", + "print(all_results)" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.7551622418879056, Median = 3.0\n", - "Accuracy 0.688095\n", - "Precision 0.651923\n", - "Recall 0.807143\n", - "FPR 0.430952\n", - "F1 0.721277\n", - "Mean H 3.755162\n", - "Correct Adjustment 0.045238\n", - "Incorrect Adjustment 0.030952\n", - "Recovery 0.014286\n", - "Leaderboard String | MODEL_NAME | 68.8 | 65.2 | 80.7 | 72....\n", - "dtype: object\n", - "Evaluating Random Seed 2\n", - "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"Accuracy\": 0.6645238095238095,\n", + " \"Precision\": 0.6649554573724549,\n", + " \"Recall\": 0.6628571428571428,\n", + " \"FPR\": 0.33380952380952383,\n", + " \"F1\": 0.6636405952685067,\n", + " \"Mean H\": 3.6320544396885324,\n", + " \"Correct Adjustment\": 0.05619047619047619,\n", + " \"Incorrect Adjustment\": 0.07238095238095239,\n", + " \"Recovery\": -0.016190476190476193,\n", + " \"Leaderboard String\": \"| BERT-base | 66.5 | 66.5 | 66.3 | 66.4 | 33.4 | 3.63 | -1.6 (5.6 - 7.2) |\"\n", + "}\n" + ] + } + ], + "source": [ + "leaderboard_string = (f\"| BERT-base | \"\n", + " f\"{all_results['Accuracy']*100:.1f} | \"\n", + " f\"{all_results['Precision']*100:.1f} | \"\n", + " f\"{all_results['Recall']*100:.1f} | \"\n", + " f\"{all_results['F1']*100:.1f} | \"\n", + " f\"{all_results['FPR']*100:.1f} | \"\n", + " f\"{all_results['Mean H']:.2f} | \"\n", + " f\"{(all_results['Correct Adjustment']-all_results['Incorrect Adjustment'])*100:.1f} \"\n", + " f\"({all_results['Correct Adjustment']*100:.1f} - {all_results['Incorrect Adjustment']*100:.1f}) |\")\n", + "all_results['Leaderboard String'] = leaderboard_string\n", + "print(json.dumps(all_results, indent=4))\n" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "5131it [15:34, 5.49it/s]\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Transformer Decoder-based Forecaster" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/README.md\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_model.safetensors\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/optimizer.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/rng_state.pth\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/scheduler.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/special_tokens_map.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/trainer_state.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/training_args.bin\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/dev_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/test_result.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/README.md\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_model.safetensors\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/optimizer.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/rng_state.pth\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/scheduler.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/special_tokens_map.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/trainer_state.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/training_args.bin\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/dev_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/test_result.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/README.md\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_model.safetensors\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/optimizer.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/rng_state.pth\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/scheduler.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/special_tokens_map.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/trainer_state.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/training_args.bin\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/dev_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/test_result.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/README.md\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_model.safetensors\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/optimizer.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/rng_state.pth\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/scheduler.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/special_tokens_map.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/trainer_state.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/training_args.bin\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/dev_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/test_result.json\n" + ] + } + ], + "source": [ + "MODEL = \"google/gemma-2-9b-it\"\n", + "BASE_URL = f\"https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/{corpus_name}/{MODEL}/\"\n", + "DOWNLOAD_DIR = f\"{YOUR_MODEL_DIRECTORY}/{corpus_name}/{MODEL}\"\n", + "\n", + "os.makedirs(DOWNLOAD_DIR, exist_ok=True)\n", + "download_recursive(BASE_URL, DOWNLOAD_DIR)\n", + "forecasting_models_path = DOWNLOAD_DIR" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.7725947521865892, Median = 3.0\n", - "Accuracy 0.67381\n", - "Precision 0.635185\n", - "Recall 0.816667\n", - "FPR 0.469048\n", - "F1 0.714583\n", - "Mean H 3.772595\n", - "Correct Adjustment 0.035714\n", - "Incorrect Adjustment 0.021429\n", - "Recovery 0.014286\n", - "Leaderboard String | MODEL_NAME | 67.4 | 63.5 | 81.7 | 71....\n", - "dtype: object\n", - "Evaluating Random Seed 3\n", - "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluating Random Seed 1\n", + "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unsloth 2025.3.19 patched 42 layers with 42 QKV layers, 42 O layers and 42 MLP layers.\n", + "Unsloth: Will map to EOS = .\n", + "0it [00:00, ?it/s]The attention mask is not set and cannot be inferred from input because pad token is same as eos token. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n", + "5131it [15:38, 5.47it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.7551622418879056, Median = 3.0\n", + "Accuracy 0.688095\n", + "Precision 0.651923\n", + "Recall 0.807143\n", + "FPR 0.430952\n", + "F1 0.721277\n", + "Mean H 3.755162\n", + "Correct Adjustment 0.045238\n", + "Incorrect Adjustment 0.030952\n", + "Recovery 0.014286\n", + "Leaderboard String | MODEL_NAME | 68.8 | 65.2 | 80.7 | 72....\n", + "dtype: object\n", + "Evaluating Random Seed 2\n", + "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5131it [15:34, 5.49it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.7725947521865892, Median = 3.0\n", + "Accuracy 0.67381\n", + "Precision 0.635185\n", + "Recall 0.816667\n", + "FPR 0.469048\n", + "F1 0.714583\n", + "Mean H 3.772595\n", + "Correct Adjustment 0.035714\n", + "Incorrect Adjustment 0.021429\n", + "Recovery 0.014286\n", + "Leaderboard String | MODEL_NAME | 67.4 | 63.5 | 81.7 | 71....\n", + "dtype: object\n", + "Evaluating Random Seed 3\n", + "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5131it [15:35, 5.49it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.6523076923076925, Median = 3.0\n", + "Accuracy 0.692857\n", + "Precision 0.665984\n", + "Recall 0.77381\n", + "FPR 0.388095\n", + "F1 0.715859\n", + "Mean H 3.652308\n", + "Correct Adjustment 0.04881\n", + "Incorrect Adjustment 0.032143\n", + "Recovery 0.016667\n", + "Leaderboard String | MODEL_NAME | 69.3 | 66.6 | 77.4 | 71....\n", + "dtype: object\n", + "Evaluating Random Seed 4\n", + "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5131it [15:39, 5.46it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.300699300699301, Median = 3.0\n", + "Accuracy 0.704762\n", + "Precision 0.715\n", + "Recall 0.680952\n", + "FPR 0.271429\n", + "F1 0.697561\n", + "Mean H 3.300699\n", + "Correct Adjustment 0.035714\n", + "Incorrect Adjustment 0.038095\n", + "Recovery -0.002381\n", + "Leaderboard String | MODEL_NAME | 70.5 | 71.5 | 68.1 | 69....\n", + "dtype: object\n", + "Evaluating Random Seed 5\n", + "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5131it [15:40, 5.45it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.385416666666667, Median = 3.0\n", + "Accuracy 0.70119\n", + "Precision 0.707617\n", + "Recall 0.685714\n", + "FPR 0.283333\n", + "F1 0.696493\n", + "Mean H 3.385417\n", + "Correct Adjustment 0.039286\n", + "Incorrect Adjustment 0.038095\n", + "Recovery 0.00119\n", + "Leaderboard String | MODEL_NAME | 70.1 | 70.8 | 68.6 | 69....\n", + "dtype: object\n" + ] + } + ], + "source": [ + "# This cell takes around 80 mins on a single NVIDIA RTX A6000\n", + "all_results = {}\n", + "for seed in range(1,6):\n", + " print(f\"Evaluating Random Seed {seed}\")\n", + " config_dict = TransformerForecasterConfig(\n", + " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", + " context_mode=\"normal\", # set to normal by default\n", + " device=DEVICE\n", + " )\n", + " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", + "\n", + " #Load pre-tuned config\n", + " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", + " with open(tuned_config_file, 'r') as file:\n", + " tuned_config = json.load(file)\n", + "\n", + " decoder_model = TransformerDecoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", + " decoder_model.best_threshold = tuned_config['best_threshold']\n", + " decoder_forecaster = Forecaster(decoder_model, label_metadata)\n", + "\n", + " # corpus = copy.deepcopy(corpus)\n", + " corpus = decoder_forecaster.transform(corpus, transform_selector)\n", + " _, cur_metrics= decoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", + "\n", + " update_metrics(all_results, cur_metrics)\n", + "\n", + "for metric in all_results:\n", + " if metric == \"Leaderboard String\":\n", + " continue\n", + " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "5131it [15:35, 5.49it/s]\n" - ] + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"Accuracy\": 0.6921428571428571,\n", + " \"Precision\": 0.6751417152564694,\n", + " \"Recall\": 0.7528571428571429,\n", + " \"FPR\": 0.3685714285714286,\n", + " \"F1\": 0.7091546569961278,\n", + " \"Mean H\": 3.573236130749631,\n", + " \"Correct Adjustment\": 0.04095238095238095,\n", + " \"Incorrect Adjustment\": 0.03214285714285715,\n", + " \"Recovery\": 0.008809523809523807,\n", + " \"Leaderboard String\": \"| Gemma2-9B | 69.2 | 67.5 | 75.3 | 70.9 | 36.9 | 3.57 | 0.9 (4.1 - 3.2) |\"\n", + "}\n" + ] + } + ], + "source": [ + "leaderboard_string = (f\"| Gemma2-9B | \"\n", + " f\"{all_results['Accuracy']*100:.1f} | \"\n", + " f\"{all_results['Precision']*100:.1f} | \"\n", + " f\"{all_results['Recall']*100:.1f} | \"\n", + " f\"{all_results['F1']*100:.1f} | \"\n", + " f\"{all_results['FPR']*100:.1f} | \"\n", + " f\"{all_results['Mean H']:.2f} | \"\n", + " f\"{(all_results['Correct Adjustment']-all_results['Incorrect Adjustment'])*100:.1f} \"\n", + " f\"({all_results['Correct Adjustment']*100:.1f} - {all_results['Incorrect Adjustment']*100:.1f}) |\")\n", + "all_results['Leaderboard String'] = leaderboard_string\n", + "print(json.dumps(all_results, indent=4))" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## With DeferralDecisionPolicy\n", + "\n", + "We can also try attaching a DeferralDecisionPolicy to the same model." ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.6523076923076925, Median = 3.0\n", - "Accuracy 0.692857\n", - "Precision 0.665984\n", - "Recall 0.77381\n", - "FPR 0.388095\n", - "F1 0.715859\n", - "Mean H 3.652308\n", - "Correct Adjustment 0.04881\n", - "Incorrect Adjustment 0.032143\n", - "Recovery 0.016667\n", - "Leaderboard String | MODEL_NAME | 69.3 | 66.6 | 77.4 | 71....\n", - "dtype: object\n", - "Evaluating Random Seed 4\n", - "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "5131it [15:39, 5.46it/s]\n" - ] + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "SIMULATOR_TRAIN_CONFIG = {\n", + " \"per_device_train_batch_size\": 16,\n", + " \"per_device_eval_batch_size\": 16,\n", + " \"eval_strategy\": \"steps\",\n", + " \"save_strategy\": \"steps\",\n", + " \"save_steps\": 30,\n", + " \"gradient_accumulation_steps\": 4,\n", + " \"warmup_steps\": 5,\n", + " \"num_train_epochs\": 1,\n", + " \"eval_steps\": 30,\n", + " \"learning_rate\": 2e-4,\n", + " \"logging_steps\": 5,\n", + " \"optim\": \"adamw_8bit\",\n", + " \"weight_decay\": 0.01,\n", + " \"lr_scheduler_type\": \"linear\",\n", + " \"output_dir\": \"outputs/simulator_finetune\",\n", + " \"logging_dir\": \"logs\",\n", + " \"load_best_model_at_end\": True,\n", + "}" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "TAU = 7\n", + "DEFERRAL_PROBABILITY_THRESHOLD = 0.2518938553561718\n", + "NUM_SIMULATIONS = 10\n", + "OUTPUT_DIR = \"benchmark_preannotated\"\n", + "SEEDS = [1,2,3,4,5]" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.300699300699301, Median = 3.0\n", - "Accuracy 0.704762\n", - "Precision 0.715\n", - "Recall 0.680952\n", - "FPR 0.271429\n", - "F1 0.697561\n", - "Mean H 3.300699\n", - "Correct Adjustment 0.035714\n", - "Incorrect Adjustment 0.038095\n", - "Recovery -0.002381\n", - "Leaderboard String | MODEL_NAME | 70.5 | 71.5 | 68.1 | 69....\n", - "dtype: object\n", - "Evaluating Random Seed 5\n", - "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def context_selector(context_tuple, split):\n", + " \"\"\"\n", + " We use this generic function for both training and validation data.\n", + " In both cases, its job is to select only those contexts for which the\n", + " FUTURE context is not empty, so we have a next utterance to predict.\n", + " \"\"\"\n", + " matches_split = (context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split)\n", + " is_end = (len(context_tuple.future_context) == 0)\n", + " return matches_split and not is_end\n", + "\n", + "def make_data_selector(split):\n", + " return lambda context_tuple: context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split\n", + "\n", + "train_context_selector = partial(context_selector, split=\"train\")\n", + "val_context_selector = partial(context_selector, split=\"val\")\n", + "test_context_selector = partial(context_selector, split=\"test\")" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "5131it [15:40, 5.45it/s]\n" - ] + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==((====))== Unsloth 2026.6.9: Fast Llama patching. Transformers: 4.57.6. vLLM: 0.10.2.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.8.0+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.4.0\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.32.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", + "Unsloth: Offloading input_embeddings to disk to save VRAM\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/reef/conda-envs/lyk25-env/lib/python3.11/site-packages/peft/tuners/tuners_utils.py:1348: UserWarning: Model has `tie_word_embeddings=True` and a tied layer is part of the adapter, but `ensure_weight_tying` is not set to True. This can lead to complications, for example when merging the adapter or converting your model to formats other than safetensors. Check the discussion here: https://github.com/huggingface/peft/issues/2777\n", + " warnings.warn(msg)\n", + "Unsloth 2026.6.9 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unsloth: Training embed_tokens in mixed precision to save VRAM\n" + ] + } + ], + "source": [ + "simulator_model = UnslothUtteranceSimulatorModel(\n", + " train_config=SIMULATOR_TRAIN_CONFIG,\n", + ")" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluating Random Seed 1\n", + "Unsloth: If you want to finetune Gemma 2, install flash-attn to make it faster!\n", + "To install flash-attn, do the below:\n", + "\n", + "pip install --no-deps --upgrade \"flash-attn>=2.6.3\"\n", + "==((====))== Unsloth 2026.6.9: Fast Gemma2 patching. Transformers: 4.57.6. vLLM: 0.10.2.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.8.0+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.4.0\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.32.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "0it [00:00, ?it/s]The attention mask is not set and cannot be inferred from input because pad token is same as eos token. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n", + "AUTOTUNE bmm(16x530x256, 16x256x530)\n", + "strides: [s60*s67, s67, 1], [s60*s67, 1, s67]\n", + "dtypes: torch.bfloat16, torch.bfloat16\n", + " triton_bmm_14 0.0655 ms 100.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", + " triton_bmm_13 0.0676 ms 97.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", + " triton_bmm_5 0.0737 ms 88.9% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=16, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", + " triton_bmm_6 0.0737 ms 88.9% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", + " triton_bmm_9 0.0737 ms 88.9% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", + " triton_bmm_10 0.0748 ms 87.7% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", + " triton_bmm_18 0.0799 ms 82.1% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", + " triton_bmm_15 0.0860 ms 76.2% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=8\n", + " triton_bmm_3 0.0870 ms 75.3% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=32, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", + " bmm 0.0881 ms 74.4% \n", + "SingleProcess AUTOTUNE benchmarking takes 0.4082 seconds and 0.0098 seconds precompiling for 20 choices\n", + "AUTOTUNE bmm(16x530x530, 16x530x256)\n", + "strides: [s60**2, s60, 1], [s60*s67, s67, 1]\n", + "dtypes: torch.bfloat16, torch.bfloat16\n", + " triton_bmm_29 0.0584 ms 100.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", + " triton_bmm_35 0.0584 ms 100.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", + " triton_bmm_33 0.0594 ms 98.3% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", + " triton_bmm_28 0.0604 ms 96.6% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", + " triton_bmm_32 0.0604 ms 96.6% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", + " triton_bmm_25 0.0614 ms 95.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", + " triton_bmm_37 0.0614 ms 95.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", + " triton_bmm_34 0.0645 ms 90.5% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=8\n", + " triton_bmm_24 0.0707 ms 82.6% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=16, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", + " triton_bmm_26 0.0707 ms 82.6% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=8\n", + "SingleProcess AUTOTUNE benchmarking takes 0.3380 seconds and 0.1776 seconds precompiling for 20 choices\n", + "100%|██████████| 1/1 [00:14<00:00, 14.22s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.92s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.97s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.18s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.36s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.14s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.22s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.37s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.16s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.22s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.17s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.21s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.55s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.62s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.37s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.52s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.34s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.52s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.83s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.60s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.75s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.10s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.33s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.48s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.25s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.28s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.52s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.66s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.42s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.56s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.87s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.11s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.29s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.32s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.44s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.66s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.28s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.56s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.69s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.78s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.83s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.97s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.05s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.09s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.24s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.97s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.19s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.42s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.47s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.26s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.50s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.52s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.50s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.55s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.58s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.60s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.28s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.35s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.52s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.61s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.76s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.31s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.40s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.26s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.35s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.19s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.40s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.54s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.01s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.11s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.35s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.47s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.74s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.84s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.97s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.00s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.06s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.09s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.15s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.45s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.51s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.84s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.88s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.92s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.98s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.08s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.13s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.18s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.35s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.57s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.62s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.67s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.98s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.51s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.66s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.97s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.11s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.25s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.42s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.53s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.58s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.74s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.97s/it]\n", + "100%|██████████| 1/1 [00:15<00:00, 15.16s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.45s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.79s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.84s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.87s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.05s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.11s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.20s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.24s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.31s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.36s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.43s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.18s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.25s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.50s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.61s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.66s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.74s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.77s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.24s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.47s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.55s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.61s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.22s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.27s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.24s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.31s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.38s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.47s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.55s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.59s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.26s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.50s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.56s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.87s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.93s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.10s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.12s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.17s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.56s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.90s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.01s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.19s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.25s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.41s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.26s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.40s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.56s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.91s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.05s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.23s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.28s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.48s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.57s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.45s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.77s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.28s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.50s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.54s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.64s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.31s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.34s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.43s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.18s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.24s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.31s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.63s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.70s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.84s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.90s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.09s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.16s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.32s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.36s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.41s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.63s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.85s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.54s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.61s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.65s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.75s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.84s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.87s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.97s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.01s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.11s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.25s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.37s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.56s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.68s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.84s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.20s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.23s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.48s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.83s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.02s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.08s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.31s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.53s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.93s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.64s/it]\n", + "225it [1:00:13, 18.50s/it]Unsloth: Input IDs of shape torch.Size([10, 2175]) with length 2175 > the model's max sequence length of 2048.\n", + "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", + "100%|██████████| 1/1 [00:15<00:00, 15.41s/it]\n", + "226it [1:00:37, 20.02s/it]Unsloth: Input IDs of shape torch.Size([10, 3092]) with length 3092 > the model's max sequence length of 2048.\n", + "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", + "100%|██████████| 1/1 [00:15<00:00, 15.40s/it]\n", + "227it [1:01:04, 22.20s/it]AUTOTUNE bmm(16x4389x256, 16x256x4389)\n", + "strides: [s31*s67, s67, 1], [s31*s67, 1, s67]\n", + "dtypes: torch.bfloat16, torch.bfloat16\n", + " triton_bmm_51 3.1570 ms 100.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", + " triton_bmm_47 3.1857 ms 99.1% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", + " triton_bmm_56 3.4437 ms 91.7% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", + " triton_bmm_43 3.4898 ms 90.5% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=16, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", + " triton_bmm_52 3.5779 ms 88.2% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", + " triton_bmm_48 3.6372 ms 86.8% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", + " triton_bmm_44 4.0520 ms 77.9% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", + " bmm 4.1554 ms 76.0% \n", + " triton_bmm_53 4.2025 ms 75.1% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=8\n", + " triton_bmm_40 5.3750 ms 58.7% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=32, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", + "SingleProcess AUTOTUNE benchmarking takes 1.7333 seconds and 0.0006 seconds precompiling for 20 choices\n", + "AUTOTUNE bmm(16x4389x4389, 16x4389x256)\n", + "strides: [s31**2, s31, 1], [s31*s67, s67, 1]\n", + "dtypes: torch.bfloat16, torch.bfloat16\n", + " bmm 2.1832 ms 100.0% \n", + " triton_bmm_75 2.6081 ms 83.7% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", + " triton_bmm_66 2.7197 ms 80.3% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", + " triton_bmm_70 2.8170 ms 77.5% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", + " triton_bmm_73 2.9481 ms 74.1% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", + " triton_bmm_71 2.9747 ms 73.4% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", + " triton_bmm_67 3.2102 ms 68.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", + " triton_bmm_63 3.4335 ms 63.6% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", + " triton_bmm_72 3.4365 ms 63.5% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=8\n", + " triton_bmm_64 3.6792 ms 59.3% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=8\n", + "SingleProcess AUTOTUNE benchmarking takes 2.2529 seconds and 0.0011 seconds precompiling for 20 choices\n", + "Unsloth: Input IDs of shape torch.Size([10, 4044]) with length 4044 > the model's max sequence length of 2048.\n", + "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", + "100%|██████████| 1/1 [00:15<00:00, 15.38s/it]\n", + "228it [1:01:47, 28.28s/it]Unsloth: Input IDs of shape torch.Size([10, 4221]) with length 4221 > the model's max sequence length of 2048.\n", + "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", + "100%|██████████| 1/1 [00:15<00:00, 15.39s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.87s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.01s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.18s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.27s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.43s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.67s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.85s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.29s/it]\n", + "100%|██████████| 1/1 [00:15<00:00, 15.09s/it]\n", + "238it [1:04:59, 19.85s/it]Unsloth: Input IDs of shape torch.Size([10, 2259]) with length 2259 > the model's max sequence length of 2048.\n", + "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", + "100%|██████████| 1/1 [00:15<00:00, 15.40s/it]\n", + "239it [1:05:23, 21.05s/it]Unsloth: Input IDs of shape torch.Size([10, 2880]) with length 2880 > the model's max sequence length of 2048.\n", + "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", + "100%|██████████| 1/1 [00:15<00:00, 15.40s/it]\n", + "240it [1:05:49, 22.65s/it]Unsloth: Input IDs of shape torch.Size([10, 3299]) with length 3299 > the model's max sequence length of 2048.\n", + "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", + "100%|██████████| 1/1 [00:15<00:00, 15.40s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.83s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.97s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.33s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.61s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.76s/it]\n", + "100%|██████████| 1/1 [00:13<00:00, 13.96s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.07s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.14s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.37s/it]\n", + "100%|██████████| 1/1 [00:14<00:00, 14.41s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.27s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.34s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.55s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.65s/it]\n", + "100%|██████████| 1/1 [00:12<00:00, 12.84s/it]" + ] + } + ], + "source": [ + "from convokit.decisionpolicy import DeferralDecisionPolicy\n", + "\n", + "all_results = {}\n", + "for seed in range(1,6):\n", + " print(f\"Evaluating Random Seed {seed}\")\n", + " config_dict = TransformerForecasterConfig(\n", + " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", + " context_mode=\"normal\", # set to normal by default\n", + " device=DEVICE\n", + " )\n", + " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", + "\n", + " #Load pre-tuned config\n", + " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", + " with open(tuned_config_file, 'r') as file:\n", + " tuned_config = json.load(file)\n", + "\n", + " decoder_model = TransformerDecoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", + " decoder_model.decision_policy = DeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=tuned_config['best_threshold'],\n", + " tau=TAU,\n", + " )\n", + " decoder_model.best_threshold = tuned_config['best_threshold']\n", + " decoder_forecaster = Forecaster(decoder_model, label_metadata)\n", + "\n", + " # corpus = copy.deepcopy(corpus)\n", + " corpus = decoder_forecaster.transform(corpus, transform_selector)\n", + " _, cur_metrics= decoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", + "\n", + " update_metrics(all_results, cur_metrics)\n", + "\n", + "for metric in all_results:\n", + " if metric == \"Leaderboard String\":\n", + " continue\n", + " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n" ] - }, - "metadata": {}, - "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.385416666666667, Median = 3.0\n", - "Accuracy 0.70119\n", - "Precision 0.707617\n", - "Recall 0.685714\n", - "FPR 0.283333\n", - "F1 0.696493\n", - "Mean H 3.385417\n", - "Correct Adjustment 0.039286\n", - "Incorrect Adjustment 0.038095\n", - "Recovery 0.00119\n", - "Leaderboard String | MODEL_NAME | 70.1 | 70.8 | 68.6 | 69....\n", - "dtype: object\n" - ] + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } - ], - "source": [ - "# This cell takes around 80 mins on a single NVIDIA RTX A6000\n", - "all_results = {}\n", - "for seed in range(1,6):\n", - " print(f\"Evaluating Random Seed {seed}\")\n", - " config_dict = TransformerForecasterConfig(\n", - " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", - " context_mode=\"normal\", # set to normal by default\n", - " device=DEVICE\n", - " )\n", - " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", - "\n", - " #Load pre-tuned config\n", - " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", - " with open(tuned_config_file, 'r') as file:\n", - " tuned_config = json.load(file)\n", - "\n", - " decoder_model = TransformerDecoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", - " decoder_model.best_threshold = tuned_config['best_threshold']\n", - " decoder_forecaster = Forecaster(decoder_model, label_metadata)\n", - "\n", - " # corpus = copy.deepcopy(corpus)\n", - " corpus = decoder_forecaster.transform(corpus, transform_selector)\n", - " _, cur_metrics= decoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", - "\n", - " update_metrics(all_results, cur_metrics)\n", - "\n", - "for metric in all_results:\n", - " if metric == \"Leaderboard String\":\n", - " continue\n", - " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " \"Accuracy\": 0.6921428571428571,\n", - " \"Precision\": 0.6751417152564694,\n", - " \"Recall\": 0.7528571428571429,\n", - " \"FPR\": 0.3685714285714286,\n", - " \"F1\": 0.7091546569961278,\n", - " \"Mean H\": 3.573236130749631,\n", - " \"Correct Adjustment\": 0.04095238095238095,\n", - " \"Incorrect Adjustment\": 0.03214285714285715,\n", - " \"Recovery\": 0.008809523809523807,\n", - " \"Leaderboard String\": \"| Gemma2-9B | 69.2 | 67.5 | 75.3 | 70.9 | 36.9 | 3.57 | 0.9 (4.1 - 3.2) |\"\n", - "}\n" - ] + ], + "metadata": { + "kernelspec": { + "display_name": "lyk25-env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" } - ], - "source": [ - "leaderboard_string = (f\"| Gemma2-9B | \"\n", - " f\"{all_results['Accuracy']*100:.1f} | \"\n", - " f\"{all_results['Precision']*100:.1f} | \"\n", - " f\"{all_results['Recall']*100:.1f} | \"\n", - " f\"{all_results['F1']*100:.1f} | \"\n", - " f\"{all_results['FPR']*100:.1f} | \"\n", - " f\"{all_results['Mean H']:.2f} | \"\n", - " f\"{(all_results['Correct Adjustment']-all_results['Incorrect Adjustment'])*100:.1f} \"\n", - " f\"({all_results['Correct Adjustment']*100:.1f} - {all_results['Incorrect Adjustment']*100:.1f}) |\")\n", - "all_results['Leaderboard String'] = leaderboard_string\n", - "print(json.dumps(all_results, indent=4))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "lyk25-env", - "language": "python", - "name": "python3" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.11" - } - }, - "nbformat": 4, - "nbformat_minor": 2 + "nbformat": 4, + "nbformat_minor": 2 } diff --git a/setup.py b/setup.py index c38c90c94..2d7ce8faa 100644 --- a/setup.py +++ b/setup.py @@ -6,12 +6,13 @@ author_email="cristian@cs.cornell.edu", url="https://github.com/CornellNLP/ConvoKit", description="ConvoKit", - version="4.1.1", + version="4.1.2", packages=[ "convokit", "convokit.bag_of_words", "convokit.classifier", "convokit.coordination", + "convokit.decisionpolicy", "convokit.fighting_words", "convokit.forecaster", "convokit.forecaster.CRAFT", diff --git a/website/docs/source/conf.py b/website/docs/source/conf.py index 717b6badf..69dfdb92a 100644 --- a/website/docs/source/conf.py +++ b/website/docs/source/conf.py @@ -10,7 +10,7 @@ project = "ConvoKit" copyright = "2026, Cornell NLP" author = "Cornell NLP" -release = "4.1.1" +release = "4.1.2" # -- General configuration --------------------------------------------------- extensions = [ diff --git a/website/docs/source/index.rst b/website/docs/source/index.rst index d23144623..7cc70730f 100644 --- a/website/docs/source/index.rst +++ b/website/docs/source/index.rst @@ -17,7 +17,7 @@ ConvoKit: Conversational Analysis Toolkit :target: https://github.com/CornellNLP/ConvoKit/blob/master/LICENSE.md :alt: License -This toolkit contains tools to extract conversational features and analyze social phenomena in conversations, using a `single unified interface `_ inspired by (and compatible with) scikit-learn. Several large conversational datasets are included together with scripts exemplifying the use of the toolkit on these datasets. The latest version is `4.1.1 `_ (released May 1, 2026); follow the project on GitHub to keep track of updates. +This toolkit contains tools to extract conversational features and analyze social phenomena in conversations, using a `single unified interface `_ inspired by (and compatible with) scikit-learn. Several large conversational datasets are included together with scripts exemplifying the use of the toolkit on these datasets. The latest version is `4.1.2 `_ (released June 26, 2026); follow the project on GitHub to keep track of updates. Quick Links ----------- From 764be2c53fa32ffa7b3bb025accb1172c160f188 Mon Sep 17 00:00:00 2001 From: laerdon Date: Sat, 27 Jun 2026 15:10:19 +0000 Subject: [PATCH 14/21] removed extraneous from table --- docs/source/forecaster.rst | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/docs/source/forecaster.rst b/docs/source/forecaster.rst index 26e9548e2..8379745f3 100644 --- a/docs/source/forecaster.rst +++ b/docs/source/forecaster.rst @@ -69,16 +69,12 @@ Unless otherwise specified, the performance is reported using the ThresholdDecis +---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ | Model | Acc ↑ | P ↑ | R ↑ | F1 ↑ | FPR ↓| Mean H ↑ | Recovery ↑ | +=============================================+=======+======+=======+=======+======+==========+=========================+ -| Gemma2 9B (ThresholdDecisionPolicy) | 70.9 | 69.0 | 76.1 | 72.3 | 34.3 | 2.91 | +1.9 (8.6 - 6.7) | +| Gemma2 9B (ThresholdDecisionPolicy) | 71.0 | 69.1 | 76.1 | 72.3 | 34.2 | 3.9 | +1.8 (8.4 - 6.6) | +---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ | Gemma2 9B (DeferralDecisionPolicy) | 70.9 | 72.0 | 68.4 | 70.1 | 26.7 | 2.77 | -0.1 (7.0 - 7.1) | +---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Gemma2 9B (RandomDeferralDecisionPolicy) | 69.4 | 69.7 | 69.0 | 69.2 | 30.2 | 2.81 | -2.5 (8.7 - 11.3) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ | Gemma2 9B (SimulationAverageDecisionPolicy) | 70.2 | 68.1 | 76.6 | 72.0 | 36.1 | 3.03 | -1.2 (9.3 - 10.5) | +---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Gemma2 9B (SimulationMajorityDecisionPolicy)| 69.9 | 67.7 | 76.7 | 71.8 | 36.9 | 3.04 | -1.2 (9.8 - 10.9) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ | Mistral 7B | 70.7 | 68.8 | 76.0 | 72.1 | 34.6 | 4.0 | +2.9 (8.1 - 5.2) | +---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ | Phi4 14B | 70.5 | 67.7 | 78.4 | 72.6 | 37.5 | 4.0 | +2.0 (7.7 - 5.7) | From 84ccf807126dc0d8b4b9d9ea466e6071830dedce Mon Sep 17 00:00:00 2001 From: laerdon Date: Sat, 27 Jun 2026 15:24:36 +0000 Subject: [PATCH 15/21] simulationavgdecisionpolicy citation --- docs/source/decisionpolicy.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/source/decisionpolicy.rst b/docs/source/decisionpolicy.rst index 2df99c964..3de1e255d 100644 --- a/docs/source/decisionpolicy.rst +++ b/docs/source/decisionpolicy.rst @@ -47,6 +47,8 @@ Random Deferral Decision Policy Simulation Average Decision Policy ---------------------------------- +This policy is based upon the forecasting approach described in `Simulation-based Decision Making for Dialogue Intervention `_ in the static forecasting task, and is adapted for the non-static forecasting task in `Wait! There's a Way Out `_ + .. automodule:: convokit.decisionpolicy.simulationAverageDecisionPolicy :members: From 89faaf96c450126526a01508fea3d70d474b268b Mon Sep 17 00:00:00 2001 From: laerdon Date: Sat, 27 Jun 2026 15:38:08 +0000 Subject: [PATCH 16/21] added citation forecaster rst --- docs/source/forecaster.rst | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/source/forecaster.rst b/docs/source/forecaster.rst index 8379745f3..91c61b3f2 100644 --- a/docs/source/forecaster.rst +++ b/docs/source/forecaster.rst @@ -64,6 +64,8 @@ These are subclasses of ForecasterModel, each implementing forecasting models us The following table is the current leaderboard comparing the performance of different forecaster models following a uniform evaluation framework described in `Tran et al., 2025 `_. If you want to include the performance of another model in this leaderboard, make a pull request with the respective ForecasterModel class and with the version of this `demo `_ that generates the respective new leaderboard line. +The DeferralDecisionPolicy is based upon the forecasting approach described in `Wait! There's a Way Out `_. The SimulationAverageDecisionPolicy is based upon the forecasting approach described in `Simulation-based Decision Making for Dialogue Intervention `_ in the static forecasting task, and is adapted for the non-static forecasting task in `Wait! There's a Way Out `_. + Unless otherwise specified, the performance is reported using the ThresholdDecisionPolicy. +---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ @@ -71,9 +73,9 @@ Unless otherwise specified, the performance is reported using the ThresholdDecis +=============================================+=======+======+=======+=======+======+==========+=========================+ | Gemma2 9B (ThresholdDecisionPolicy) | 71.0 | 69.1 | 76.1 | 72.3 | 34.2 | 3.9 | +1.8 (8.4 - 6.6) | +---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Gemma2 9B (DeferralDecisionPolicy) | 70.9 | 72.0 | 68.4 | 70.1 | 26.7 | 2.77 | -0.1 (7.0 - 7.1) | +| Gemma2 9B (DeferralDecisionPolicy) | 70.9 | 72.0 | 68.4 | 70.1 | 26.7 | 3.8 | -0.1 (7.0 - 7.1) | +---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Gemma2 9B (SimulationAverageDecisionPolicy) | 70.2 | 68.1 | 76.6 | 72.0 | 36.1 | 3.03 | -1.2 (9.3 - 10.5) | +| Gemma2 9B (SimulationAverageDecisionPolicy) | 70.2 | 68.1 | 76.6 | 72.0 | 36.1 | 4.0 | -1.2 (9.3 - 10.5) | +---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ | Mistral 7B | 70.7 | 68.8 | 76.0 | 72.1 | 34.6 | 4.0 | +2.9 (8.1 - 5.2) | +---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ From 717caaf5d75ba84d6d5b569e1aa791e1dec620ab Mon Sep 17 00:00:00 2001 From: laerdon Date: Sat, 27 Jun 2026 15:53:42 +0000 Subject: [PATCH 17/21] decisionpolicy demo os visible device fix --- examples/decisionpolicy/decisionpolicy_demo.ipynb | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/examples/decisionpolicy/decisionpolicy_demo.ipynb b/examples/decisionpolicy/decisionpolicy_demo.ipynb index 7beda1c2a..98d606e06 100644 --- a/examples/decisionpolicy/decisionpolicy_demo.ipynb +++ b/examples/decisionpolicy/decisionpolicy_demo.ipynb @@ -18,17 +18,6 @@ "## 1. Imports and downloads" ] }, - { - "cell_type": "code", - "execution_count": 1, - "id": "703021a8", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "os.environ['CUDA_VISIBLE_DEVICES'] = '0'" - ] - }, { "cell_type": "code", "execution_count": 2, From ca4a7e9efc766ae55181cdb65a55f62e839f334d Mon Sep 17 00:00:00 2001 From: laerdon Date: Sat, 27 Jun 2026 20:55:28 +0000 Subject: [PATCH 18/21] table update --- docs/source/conf.py | 1 + docs/source/forecaster.rst | 124 ++++++++++++++++++------------------- 2 files changed, 63 insertions(+), 62 deletions(-) diff --git a/docs/source/conf.py b/docs/source/conf.py index 43e4733a4..5c2944611 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -164,6 +164,7 @@ # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ["_static"] +html_css_files = ["custom.css"] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied diff --git a/docs/source/forecaster.rst b/docs/source/forecaster.rst index 91c61b3f2..6072d0f45 100644 --- a/docs/source/forecaster.rst +++ b/docs/source/forecaster.rst @@ -68,73 +68,73 @@ The DeferralDecisionPolicy is based upon the forecasting approach described in ` Unless otherwise specified, the performance is reported using the ThresholdDecisionPolicy. -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Model | Acc ↑ | P ↑ | R ↑ | F1 ↑ | FPR ↓| Mean H ↑ | Recovery ↑ | -+=============================================+=======+======+=======+=======+======+==========+=========================+ -| Gemma2 9B (ThresholdDecisionPolicy) | 71.0 | 69.1 | 76.1 | 72.3 | 34.2 | 3.9 | +1.8 (8.4 - 6.6) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Gemma2 9B (DeferralDecisionPolicy) | 70.9 | 72.0 | 68.4 | 70.1 | 26.7 | 3.8 | -0.1 (7.0 - 7.1) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Gemma2 9B (SimulationAverageDecisionPolicy) | 70.2 | 68.1 | 76.6 | 72.0 | 36.1 | 4.0 | -1.2 (9.3 - 10.5) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Mistral 7B | 70.7 | 68.8 | 76.0 | 72.1 | 34.6 | 4.0 | +2.9 (8.1 - 5.2) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Phi4 14B | 70.5 | 67.7 | 78.4 | 72.6 | 37.5 | 4.0 | +2.0 (7.7 - 5.7) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| LlaMa3.1 8B | 70.0 | 68.8 | 73.2 | 70.9 | 33.2 | 4.0 | +1.7 (7.3 - 5.6) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| DeBERTaV3-large | 68.9 | 67.3 | 73.7 | 70.3 | 36.0 | 4.2 | +1.1 (7.6 - 6.5) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| RoBERTa-large | 68.6 | 67.1 | 73.4 | 70.0 | 36.1 | 4.2 | +1.6 (7.5 - 5.9) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| RoBERTa-base | 68.1 | 67.3 | 70.6 | 68.8 | 34.4 | 4.2 | +0.7 (7.4 - 6.7) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| DeBERTaV3-base | 67.9 | 66.7 | 71.4 | 69.0 | 35.7 | 4.2 | +1.5 (7.2 - 5.7) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| SpanBERT-large | 67.0 | 65.8 | 70.5 | 68.1 | 36.6 | 4.2 | +1.3 (8.3 - 7.0) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| SpanBERT-base | 66.4 | 64.7 | 72.0 | 68.2 | 39.3 | 4.4 | +1.7 (9.6 - 8.0) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| BERT-large | 65.7 | 66.0 | 65.4 | 65.5 | 34.1 | 4.2 | +0.4 (7.8 - 7.3) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| BERT-base | 65.3 | 64.1 | 70.1 | 66.9 | 39.5 | 4.4 | +1.9 (9.7 - 7.8) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| CRAFT | 62.8 | 59.4 | 81.1 | 68.5 | 55.5 | 4.7 | +4.9 (12.0 - 7.1) | -+---------------------------------------------+-------+------+-------+-------+------+----------+-------------------------+ ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Model | Decision Policy | Acc ↑ | P ↑ | R ↑ | F1 ↑ | FPR ↓| Mean H ↑ | Recovery ↑ | ++=====================+===================================+=======+======+=======+=======+======+==========+=========================+ +| Gemma2 9B | ThresholdDecisionPolicy | 71.0 | 69.1 | 76.1 | 72.3 | 34.2 | 3.9 | +1.8 (8.4 - 6.6) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Gemma2 9B | DeferralDecisionPolicy | 70.9 | 72.0 | 68.4 | 70.1 | 26.7 | 3.8 | -0.1 (7.0 - 7.1) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Gemma2 9B | SimulationAverageDecisionPolicy | 70.2 | 68.1 | 76.6 | 72.0 | 36.1 | 4.0 | -1.2 (9.3 - 10.5) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Mistral 7B | ThresholdDecisionPolicy | 70.7 | 68.8 | 76.0 | 72.1 | 34.6 | 4.0 | +2.9 (8.1 - 5.2) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Phi4 14B | ThresholdDecisionPolicy | 70.5 | 67.7 | 78.4 | 72.6 | 37.5 | 4.0 | +2.0 (7.7 - 5.7) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| LlaMa3.1 8B | ThresholdDecisionPolicy | 70.0 | 68.8 | 73.2 | 70.9 | 33.2 | 4.0 | +1.7 (7.3 - 5.6) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| DeBERTaV3-large | ThresholdDecisionPolicy | 68.9 | 67.3 | 73.7 | 70.3 | 36.0 | 4.2 | +1.1 (7.6 - 6.5) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| RoBERTa-large | ThresholdDecisionPolicy | 68.6 | 67.1 | 73.4 | 70.0 | 36.1 | 4.2 | +1.6 (7.5 - 5.9) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| RoBERTa-base | ThresholdDecisionPolicy | 68.1 | 67.3 | 70.6 | 68.8 | 34.4 | 4.2 | +0.7 (7.4 - 6.7) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| DeBERTaV3-base | ThresholdDecisionPolicy | 67.9 | 66.7 | 71.4 | 69.0 | 35.7 | 4.2 | +1.5 (7.2 - 5.7) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| SpanBERT-large | ThresholdDecisionPolicy | 67.0 | 65.8 | 70.5 | 68.1 | 36.6 | 4.2 | +1.3 (8.3 - 7.0) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| SpanBERT-base | ThresholdDecisionPolicy | 66.4 | 64.7 | 72.0 | 68.2 | 39.3 | 4.4 | +1.7 (9.6 - 8.0) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| BERT-large | ThresholdDecisionPolicy | 65.7 | 66.0 | 65.4 | 65.5 | 34.1 | 4.2 | +0.4 (7.8 - 7.3) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| BERT-base | ThresholdDecisionPolicy | 65.3 | 64.1 | 70.1 | 66.9 | 39.5 | 4.4 | +1.9 (9.7 - 7.8) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| CRAFT | ThresholdDecisionPolicy | 62.8 | 59.4 | 81.1 | 68.5 | 55.5 | 4.7 | +4.9 (12.0 - 7.1) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ **Table 1: Forecasting derailment on CGA-CMV-large conversations.** The performance is measured in accuracy (Acc), precision (P), recall (R), F1, false positive rate (FPR), mean horizon (Mean H), and Forecast Recovery (Recovery) along with the correct and incorrect recovery rates. Results are reported as averages over five runs with different random seeds. -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| Model | Acc ↑ | P ↑ | R ↑ | F1 ↑ | FPR ↓| Mean H ↑ | Recovery ↑ | -+================+=======+======+=======+=======+======+==========+=========================+ -| Gemma2 9B | 69.2 | 67.5 | 75.3 | 70.9 | 36.9 | 3.6 | +0.9 (4.1 - 3.2) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| Phi4 14B | 68.8 | 69.5 | 67.1 | 68.2 | 29.6 | 3.3 | +0.8 (3.7 - 2.9) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| LlaMa3.1 8B | 68.5 | 66.3 | 75.6 | 70.5 | 38.7 | 3.6 | +1.8 (5.5 - 3.7) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| RoBERTa-large | 68.2 | 67.8 | 69.7 | 68.6 | 33.3 | 3.6 | +0.3 (3.9 - 3.5) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| SpanBERT-large | 67.9 | 66.5 | 72.6 | 69.3 | 36.7 | 3.6 | +0.1 (4.9 - 4.8) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| Mistral 7B | 67.8 | 65.9 | 74.4 | 69.8 | 38.8 | 3.8 | +1.1 (5.1 - 4.0) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| DeBERTaV3-large| 67.8 | 66.9 | 70.9 | 68.7 | 35.3 | 3.7 | +0.8 (3.8 - 3.0) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| RoBERTa-base | 67.6 | 65.7 | 73.9 | 69.5 | 38.6 | 3.6 | +0.5 (3.4 - 2.8) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| DeBERTaV3-base | 67.5 | 67.0 | 69.2 | 68.0 | 34.3 | 3.6 | +0.5 (2.7 - 2.3) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| SpanBERT-base | 66.7 | 66.1 | 68.7 | 67.3 | 35.2 | 3.3 | -0.7 (4.5 - 5.2) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| BERT-base | 66.5 | 66.5 | 66.3 | 66.4 | 33.4 | 3.6 | -1.6 (5.6 - 7.2) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| BERT-large | 65.7 | 65.6 | 67.0 | 66.0 | 35.6 | 3.6 | +0.0 (5.6 - 5.6) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ -| CRAFT | 64.8 | 63.4 | 70.1 | 66.5 | 40.5 | 3.5 | +0.4 (3.7 - 2.9) | -+----------------+-------+------+-------+-------+------+----------+-------------------------+ ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Model | Decision Policy | Acc ↑ | P ↑ | R ↑ | F1 ↑ | FPR ↓| Mean H ↑ | Recovery ↑ | ++=====================+===================================+=======+======+=======+=======+======+==========+=========================+ +| Gemma2 9B | ThresholdDecisionPolicy | 69.2 | 67.5 | 75.3 | 70.9 | 36.9 | 3.6 | +0.9 (4.1 - 3.2) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Phi4 14B | ThresholdDecisionPolicy | 68.8 | 69.5 | 67.1 | 68.2 | 29.6 | 3.3 | +0.8 (3.7 - 2.9) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| LlaMa3.1 8B | ThresholdDecisionPolicy | 68.5 | 66.3 | 75.6 | 70.5 | 38.7 | 3.6 | +1.8 (5.5 - 3.7) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| RoBERTa-large | ThresholdDecisionPolicy | 68.2 | 67.8 | 69.7 | 68.6 | 33.3 | 3.6 | +0.3 (3.9 - 3.5) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| SpanBERT-large | ThresholdDecisionPolicy | 67.9 | 66.5 | 72.6 | 69.3 | 36.7 | 3.6 | +0.1 (4.9 - 4.8) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| Mistral 7B | ThresholdDecisionPolicy | 67.8 | 65.9 | 74.4 | 69.8 | 38.8 | 3.8 | +1.1 (5.1 - 4.0) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| DeBERTaV3-large | ThresholdDecisionPolicy | 67.8 | 66.9 | 70.9 | 68.7 | 35.3 | 3.7 | +0.8 (3.8 - 3.0) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| RoBERTa-base | ThresholdDecisionPolicy | 67.6 | 65.7 | 73.9 | 69.5 | 38.6 | 3.6 | +0.5 (3.4 - 2.8) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| DeBERTaV3-base | ThresholdDecisionPolicy | 67.5 | 67.0 | 69.2 | 68.0 | 34.3 | 3.6 | +0.5 (2.7 - 2.3) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| SpanBERT-base | ThresholdDecisionPolicy | 66.7 | 66.1 | 68.7 | 67.3 | 35.2 | 3.3 | -0.7 (4.5 - 5.2) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| BERT-base | ThresholdDecisionPolicy | 66.5 | 66.5 | 66.3 | 66.4 | 33.4 | 3.6 | -1.6 (5.6 - 7.2) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| BERT-large | ThresholdDecisionPolicy | 65.7 | 65.6 | 67.0 | 66.0 | 35.6 | 3.6 | +0.0 (5.6 - 5.6) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ +| CRAFT | ThresholdDecisionPolicy | 64.8 | 63.4 | 70.1 | 66.5 | 40.5 | 3.5 | +0.4 (3.7 - 2.9) | ++---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ **Table 2: Forecasting derailment on CGA-Wikiconv conversations.** The performance is measured in accuracy (Acc), precision (P), recall (R), F1, false positive rate (FPR), mean horizon (Mean H), and Forecast Recovery (Recovery) along with the correct and incorrect recovery rates. Results are reported as averages over five runs with From 47bfa78b4139783f1c436385b82822c399cbe89b Mon Sep 17 00:00:00 2001 From: laerdon Date: Sun, 28 Jun 2026 01:59:40 +0000 Subject: [PATCH 19/21] selector fixes --- .../Run Transformer Fine-tuned Models.ipynb | 2212 ++++++----------- 1 file changed, 796 insertions(+), 1416 deletions(-) diff --git a/examples/forecaster/Run Transformer Fine-tuned Models.ipynb b/examples/forecaster/Run Transformer Fine-tuned Models.ipynb index 2bd1b1e2b..4f4e9c415 100644 --- a/examples/forecaster/Run Transformer Fine-tuned Models.ipynb +++ b/examples/forecaster/Run Transformer Fine-tuned Models.ipynb @@ -1,1455 +1,835 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This notebook is for reproducing all results reported in paper \"Conversations Gone Awry, But Then? Evaluating Conversational Forecasting Models\".\n", - "The results include:\n", - "1. Performance of TransformerEncoderModels (BERT-base, BERT-large, RoBERTa-base, RoBERTa-large, SpanBERT-base, SpanBERT-large, DeBERTaV3-base, and DeBERTaV3-large)\n", - "2. Performance of TransformerDecoderModels (Gemma2 9B, LlaMA3.1 8B, Mistral 7B, and Phi4 14B)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-06-27 02:36:22.140467: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", - "2026-06-27 02:36:22.160162: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "E0000 00:00:1782527782.183784 668601 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "E0000 00:00:1782527782.191521 668601 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "W0000 00:00:1782527782.210587 668601 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1782527782.210606 668601 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1782527782.210609 668601 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1782527782.210611 668601 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "2026-06-27 02:36:22.216822: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO 06-27 02:36:30 [__init__.py:216] Automatically detected platform cuda.\n", - "🦥 Unsloth Zoo will now patch everything to make training faster!\n" - ] - } - ], - "source": [ - "import unsloth\n", - "\n", - "from convokit.utterance_simulator.unslothUtteranceSimulatorModel import UnslothUtteranceSimulatorModel\n", - "from convokit.utterance_simulator.utteranceSimulator import UtteranceSimulator\n", - "\n", - "from convokit import (download,\n", - " Corpus,\n", - " Forecaster,\n", - " TransformerEncoderModel,\n", - " TransformerDecoderModel,\n", - " TransformerForecasterConfig,\n", - ")\n", - "import tarfile\n", - "import json, os, shutil\n", - "import re\n", - "import urllib.request\n", - "from urllib.parse import urljoin, urlparse" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define datasets and working directories " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# CPU mode (noting that it will be slower)\n", - "DEVICE = \"cuda\"\n", - "\n", - "# corpus_name = \"cga-wikiconv\"\n", - "# corpus_name = \"cga-cmv-legacy\"\n", - "corpus_name = \"cga-cmv-large\"\n", - "label_metadata = \"has_removed_comment\" if 'cmv' in corpus_name else 'conversation_has_personal_attack'\n", - "\n", - "YOUR_MODEL_DIRECTORY = \"YOUR_MODEL_DIRECTORY\"\n", - "YOUR_SAVING_DIRECTORY = \"YOUR_SAVING_DIRECTORY\"" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset already exists at /reef/lyk25/ConvoKit/examples/forecaster/conversations-gone-awry-cmv-corpus-large\n" - ] - } - ], - "source": [ - "if corpus_name == \"cga-wikiconv\":\n", - " corpus = Corpus(filename=download(\"conversations-gone-awry-corpus\"))\n", - "elif corpus_name == \"cga-cmv-legacy\":\n", - " corpus = Corpus(filename=download(\"conversations-gone-awry-cmv-corpus\"))\n", - "elif corpus_name == \"cga-cmv-large\":\n", - " corpus = Corpus(filename=download(\"conversations-gone-awry-cmv-corpus-large\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Download Fine-tuned Models" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "def is_directory(href):\n", - " return href.endswith('/')\n", - "\n", - "def list_links(url):\n", - " \"\"\"list files and directories from an apache-style directory listing.\"\"\"\n", - " response = urllib.request.urlopen(url)\n", - " html = response.read().decode('utf-8')\n", - " return re.findall(r'href=\"([^\"?][^\"]*)\"', html)\n", - "\n", - "def download_file(file_url, dest_path):\n", - " if os.path.exists(dest_path):\n", - " print(f\"skipped existing: {dest_path}\")\n", - " return\n", - " urllib.request.urlretrieve(file_url, dest_path)\n", - "\n", - "def download_recursive(base_url, base_folder, root_url=None):\n", - " if root_url is None:\n", - " root_url = base_url\n", - " links = list_links(base_url)\n", - " for href in links:\n", - " if href in ('../',): # skip parent link\n", - " continue\n", - " full_url = urljoin(base_url, href)\n", - " parsed = urlparse(full_url)\n", - " relative_path = parsed.path.replace(urlparse(root_url).path, '').lstrip('/')\n", - " local_path = os.path.join(base_folder, relative_path)\n", - "\n", - " if is_directory(href):\n", - " os.makedirs(local_path, exist_ok=True)\n", - " download_recursive(full_url, base_folder, root_url=root_url)\n", - " else:\n", - " os.makedirs(os.path.dirname(local_path), exist_ok=True)\n", - " download_file(full_url, local_path)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "MODEL = \"bert-base-cased\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**List of Models**\n", - "\n", - "**TransformerEncoderModel**\n", - "- `bert-base-cased` — BERT-base \n", - "- `roberta-base` — RoBERTa-base \n", - "- `SpanBERT/spanbert-base-cased` — SpanBERT-base \n", - "- `microsoft/deberta-v3-base` — DeBERTaV3-base \n", - "- `bert-large-cased` — BERT-large \n", - "- `roberta-large` — RoBERTa-large \n", - "- `SpanBERT/spanbert-large-cased` — SpanBERT-large \n", - "- `microsoft/deberta-v3-large` — DeBERTaV3-large \n", - "\n", - "**TransformerDecoderModel**\n", - "- `google/gemma-2-9b-it` — Gemma2 9B \n", - "- `meta-llama/Llama-3.1-8B-Instruct` — LLaMA 3.1 8B \n", - "- `mistralai/Mistral-7B-Instruct-v0.3` — Mistral 7B \n", - "- `microsoft/phi-4` — Phi-4 14B" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "BASE_URL = f\"https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/{corpus_name}/{MODEL}/\"\n", - "DOWNLOAD_DIR = f\"{YOUR_MODEL_DIRECTORY}/{corpus_name}/{MODEL}\"\n", - "\n", - "os.makedirs(DOWNLOAD_DIR, exist_ok=True)\n", - "download_recursive(BASE_URL, DOWNLOAD_DIR)\n", - "forecasting_models_path = DOWNLOAD_DIR\n" - ] - }, + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook is for reproducing all results reported in paper \"Conversations Gone Awry, But Then? Evaluating Conversational Forecasting Models\".\n", + "The results include:\n", + "1. Performance of TransformerEncoderModels (BERT-base, BERT-large, RoBERTa-base, RoBERTa-large, SpanBERT-base, SpanBERT-large, DeBERTaV3-base, and DeBERTaV3-large)\n", + "2. Performance of TransformerDecoderModels (Gemma2 9B, LlaMA3.1 8B, Mistral 7B, and Phi4 14B)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define selectors for the Forecaster\n", - "\n", - "Core to the flexibility of the `Forecaster` framework is the concept of *selectors*. \n", - "\n", - "To capture the temporal dimension of the conversational forecasting task, `Forecaster` iterates through conversations in chronological utterance order, at each step presenting to the backend forecasting model a \"context tuple\" containing both the comment itself and the full \"context\" preceding that comment. As a general framework, `Forecaster` on its own does not try to make any further assumptions about what \"context\" should contain or look like; it simply presents context as a chronologically ordered list of all utterances up to and including the current one. " - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n" + ] }, { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def transform_selector(context_tuple):\n", - " \"\"\"\n", - " For transform we only need to check that the conversation is in the test split\n", - " \"\"\"\n", - " convo = context_tuple.current_utterance.get_conversation()\n", - " convo_length = len(convo.get_chronological_utterance_list())\n", - "\n", - " matches_split = (context_tuple.current_utterance.get_conversation().meta[\"split\"] == \"test\")\n", - " is_end = (len(context_tuple.context) == convo_length)\n", - "\n", - " return (matches_split and not is_end)\n", - "def update_metrics(all_results, cur_metrics):\n", - " for metric in cur_metrics:\n", - " all_results[metric] = all_results.get(metric, []) + [cur_metrics[metric]]\n", - " return all_results" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-06-27 20:18:39.864582: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2026-06-27 20:18:39.887405: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1782591519.912052 859600 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1782591519.919822 859600 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1782591519.938735 859600 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1782591519.938755 859600 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1782591519.938757 859600 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1782591519.938760 859600 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "2026-06-27 20:18:39.944875: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] }, { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Transformer Encoder-based Forecaster" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO 06-27 20:18:48 [__init__.py:216] Automatically detected platform cuda.\n", + "🦥 Unsloth Zoo will now patch everything to make training faster!\n" + ] + } + ], + "source": [ + "import unsloth\n", + "\n", + "from convokit.utterance_simulator.unslothUtteranceSimulatorModel import UnslothUtteranceSimulatorModel\n", + "from convokit.utterance_simulator.utteranceSimulator import UtteranceSimulator\n", + "\n", + "from convokit import (download,\n", + " Corpus,\n", + " Forecaster,\n", + " TransformerEncoderModel,\n", + " TransformerDecoderModel,\n", + " TransformerForecasterConfig,\n", + ")\n", + "import tarfile\n", + "import json, os, shutil\n", + "import re\n", + "import urllib.request\n", + "from urllib.parse import urljoin, urlparse\n", + "import copy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define datasets and working directories " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# CPU mode (noting that it will be slower)\n", + "DEVICE = \"cuda\"\n", + "\n", + "corpus_name = \"cga-wikiconv\"\n", + "# corpus_name = \"cga-cmv-legacy\"\n", + "# corpus_name = \"cga-cmv-large\"\n", + "label_metadata = \"has_removed_comment\" if 'cmv' in corpus_name else 'conversation_has_personal_attack'\n", + "\n", + "YOUR_MODEL_DIRECTORY = \"YOUR_MODEL_DIRECTORY\"\n", + "YOUR_SAVING_DIRECTORY = \"YOUR_SAVING_DIRECTORY\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Evaluating Random Seed 1\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 5131/5131 [00:47<00:00, 109.11it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.5899280575539567, Median = 3.0\n", - "Accuracy 0.661905\n", - "Precision 0.661905\n", - "Recall 0.661905\n", - "FPR 0.338095\n", - "F1 0.661905\n", - "Mean H 3.589928\n", - "Correct Adjustment 0.05\n", - "Incorrect Adjustment 0.066667\n", - "Recovery -0.016667\n", - "Leaderboard String | MODEL_NAME | 66.2 | 66.2 | 66.2 | 66....\n", - "dtype: object\n", - "Evaluating Random Seed 2\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 5131/5131 [00:47<00:00, 108.70it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.731182795698925, Median = 3.0\n", - "Accuracy 0.666667\n", - "Precision 0.667464\n", - "Recall 0.664286\n", - "FPR 0.330952\n", - "F1 0.665871\n", - "Mean H 3.731183\n", - "Correct Adjustment 0.054762\n", - "Incorrect Adjustment 0.07619\n", - "Recovery -0.021429\n", - "Leaderboard String | MODEL_NAME | 66.7 | 66.7 | 66.4 | 66....\n", - "dtype: object\n", - "Evaluating Random Seed 3\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 5131/5131 [00:47<00:00, 109.03it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.7491525423728813, Median = 3.0\n", - "Accuracy 0.672619\n", - "Precision 0.662921\n", - "Recall 0.702381\n", - "FPR 0.357143\n", - "F1 0.682081\n", - "Mean H 3.749153\n", - "Correct Adjustment 0.070238\n", - "Incorrect Adjustment 0.088095\n", - "Recovery -0.017857\n", - "Leaderboard String | MODEL_NAME | 67.3 | 66.3 | 70.2 | 68....\n", - "dtype: object\n", - "Evaluating Random Seed 4\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 5131/5131 [00:47<00:00, 108.49it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.484375, Median = 3.0\n", - "Accuracy 0.642857\n", - "Precision 0.653061\n", - "Recall 0.609524\n", - "FPR 0.32381\n", - "F1 0.630542\n", - "Mean H 3.484375\n", - "Correct Adjustment 0.055952\n", - "Incorrect Adjustment 0.060714\n", - "Recovery -0.004762\n", - "Leaderboard String | MODEL_NAME | 64.3 | 65.3 | 61.0 | 63....\n", - "dtype: object\n", - "Evaluating Random Seed 5\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100%|██████████| 5131/5131 [00:47<00:00, 108.92it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.605633802816901, Median = 3.0\n", - "Accuracy 0.678571\n", - "Precision 0.679426\n", - "Recall 0.67619\n", - "FPR 0.319048\n", - "F1 0.677804\n", - "Mean H 3.605634\n", - "Correct Adjustment 0.05\n", - "Incorrect Adjustment 0.070238\n", - "Recovery -0.020238\n", - "Leaderboard String | MODEL_NAME | 67.9 | 67.9 | 67.6 | 67....\n", - "dtype: object\n", - "{'Accuracy': np.float64(0.6645238095238095), 'Precision': np.float64(0.6649554573724549), 'Recall': np.float64(0.6628571428571428), 'FPR': np.float64(0.33380952380952383), 'F1': np.float64(0.6636405952685067), 'Mean H': np.float64(3.6320544396885324), 'Correct Adjustment': np.float64(0.05619047619047619), 'Incorrect Adjustment': np.float64(0.07238095238095239), 'Recovery': np.float64(-0.016190476190476193), 'Leaderboard String': ['| MODEL_NAME | 66.2 | 66.2 | 66.2 | 66.2 | 33.8 | 3.59 | -1.7 (5.0 - 6.7) |', '| MODEL_NAME | 66.7 | 66.7 | 66.4 | 66.6 | 33.1 | 3.73 | -2.1 (5.5 - 7.6) |', '| MODEL_NAME | 67.3 | 66.3 | 70.2 | 68.2 | 35.7 | 3.75 | -1.8 (7.0 - 8.8) |', '| MODEL_NAME | 64.3 | 65.3 | 61.0 | 63.1 | 32.4 | 3.48 | -0.5 (5.6 - 6.1) |', '| MODEL_NAME | 67.9 | 67.9 | 67.6 | 67.8 | 31.9 | 3.61 | -2.0 (5.0 - 7.0) |']}\n" - ] - } - ], - "source": [ - "all_results = {}\n", - "for seed in range(1,6):\n", - " print(f\"Evaluating Random Seed {seed}\")\n", - " config_dict = TransformerForecasterConfig(\n", - " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", - " context_mode=\"normal\", # set to normal by default\n", - " device=DEVICE\n", - " )\n", - " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", - "\n", - " #Load pre-tuned config\n", - " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", - " with open(tuned_config_file, 'r') as file:\n", - " tuned_config = json.load(file)\n", - "\n", - " encoder_model = TransformerEncoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", - " encoder_model.best_threshold = tuned_config['best_threshold']\n", - " encoder_forecaster = Forecaster(encoder_model, label_metadata)\n", - "\n", - " # corpus = copy.deepcopy(corpus)\n", - " corpus = encoder_forecaster.transform(corpus, transform_selector)\n", - " _, cur_metrics= encoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", - "\n", - " update_metrics(all_results, cur_metrics)\n", - "\n", - "for metric in all_results:\n", - " if metric == \"Leaderboard String\":\n", - " continue\n", - " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n", - "\n", - "print(all_results)" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset already exists at /reef/lyk25/ConvoKit/examples/forecaster/conversations-gone-awry-cmv-corpus-large\n" + ] + } + ], + "source": [ + "if corpus_name == \"cga-wikiconv\":\n", + " corpus = Corpus(filename=download(\"conversations-gone-awry-corpus\"))\n", + "elif corpus_name == \"cga-cmv-legacy\":\n", + " corpus = Corpus(filename=download(\"conversations-gone-awry-cmv-corpus\"))\n", + "elif corpus_name == \"cga-cmv-large\":\n", + " corpus = Corpus(filename=download(\"conversations-gone-awry-cmv-corpus-large\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Download Fine-tuned Models" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def is_directory(href):\n", + " return href.endswith('/')\n", + "\n", + "def list_links(url):\n", + " \"\"\"list files and directories from an apache-style directory listing.\"\"\"\n", + " response = urllib.request.urlopen(url)\n", + " html = response.read().decode('utf-8')\n", + " return re.findall(r'href=\"([^\"?][^\"]*)\"', html)\n", + "\n", + "def download_file(file_url, dest_path):\n", + " if os.path.exists(dest_path):\n", + " print(f\"skipped existing: {dest_path}\")\n", + " return\n", + " urllib.request.urlretrieve(file_url, dest_path)\n", + "\n", + "def download_recursive(base_url, base_folder, root_url=None):\n", + " if root_url is None:\n", + " root_url = base_url\n", + " links = list_links(base_url)\n", + " for href in links:\n", + " if href in ('../',): # skip parent link\n", + " continue\n", + " full_url = urljoin(base_url, href)\n", + " parsed = urlparse(full_url)\n", + " relative_path = parsed.path.replace(urlparse(root_url).path, '').lstrip('/')\n", + " local_path = os.path.join(base_folder, relative_path)\n", + "\n", + " if is_directory(href):\n", + " os.makedirs(local_path, exist_ok=True)\n", + " download_recursive(full_url, base_folder, root_url=root_url)\n", + " else:\n", + " os.makedirs(os.path.dirname(local_path), exist_ok=True)\n", + " download_file(full_url, local_path)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "MODEL = \"bert-base-cased\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**List of Models**\n", + "\n", + "**TransformerEncoderModel**\n", + "- `bert-base-cased` — BERT-base \n", + "- `roberta-base` — RoBERTa-base \n", + "- `SpanBERT/spanbert-base-cased` — SpanBERT-base \n", + "- `microsoft/deberta-v3-base` — DeBERTaV3-base \n", + "- `bert-large-cased` — BERT-large \n", + "- `roberta-large` — RoBERTa-large \n", + "- `SpanBERT/spanbert-large-cased` — SpanBERT-large \n", + "- `microsoft/deberta-v3-large` — DeBERTaV3-large \n", + "\n", + "**TransformerDecoderModel**\n", + "- `google/gemma-2-9b-it` — Gemma2 9B \n", + "- `meta-llama/Llama-3.1-8B-Instruct` — LLaMA 3.1 8B \n", + "- `mistralai/Mistral-7B-Instruct-v0.3` — Mistral 7B \n", + "- `microsoft/phi-4` — Phi-4 14B" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "BASE_URL = f\"https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/{corpus_name}/{MODEL}/\"\n", + "DOWNLOAD_DIR = f\"{YOUR_MODEL_DIRECTORY}/{corpus_name}/{MODEL}\"\n", + "\n", + "os.makedirs(DOWNLOAD_DIR, exist_ok=True)\n", + "download_recursive(BASE_URL, DOWNLOAD_DIR)\n", + "forecasting_models_path = DOWNLOAD_DIR\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define selectors for the Forecaster\n", + "\n", + "Core to the flexibility of the `Forecaster` framework is the concept of *selectors*. \n", + "\n", + "To capture the temporal dimension of the conversational forecasting task, `Forecaster` iterates through conversations in chronological utterance order, at each step presenting to the backend forecasting model a \"context tuple\" containing both the comment itself and the full \"context\" preceding that comment. As a general framework, `Forecaster` on its own does not try to make any further assumptions about what \"context\" should contain or look like; it simply presents context as a chronologically ordered list of all utterances up to and including the current one. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def transform_selector(context_tuple, corpus_name):\n", + " \"\"\"\n", + " For transform we only need to check that the conversation is in the test split\n", + " \"\"\"\n", + " \n", + " convo = context_tuple.current_utterance.get_conversation()\n", + " convo_length = len(convo.get_chronological_utterance_list())\n", + "\n", + " matches_split = (context_tuple.current_utterance.get_conversation().meta[\"split\"] == \"test\")\n", + " is_end = (len(context_tuple.context) == convo_length)\n", + "\n", + " if corpus_name.contains(\"cmv\"):\n", + " return (matches_split)\n", + " else:\n", + " return (matches_split and not is_end)\n", + " \n", + "def update_metrics(all_results, cur_metrics):\n", + " for metric in cur_metrics:\n", + " all_results[metric] = all_results.get(metric, []) + [cur_metrics[metric]]\n", + " return all_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Transformer Encoder-based Forecaster" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " \"Accuracy\": 0.6645238095238095,\n", - " \"Precision\": 0.6649554573724549,\n", - " \"Recall\": 0.6628571428571428,\n", - " \"FPR\": 0.33380952380952383,\n", - " \"F1\": 0.6636405952685067,\n", - " \"Mean H\": 3.6320544396885324,\n", - " \"Correct Adjustment\": 0.05619047619047619,\n", - " \"Incorrect Adjustment\": 0.07238095238095239,\n", - " \"Recovery\": -0.016190476190476193,\n", - " \"Leaderboard String\": \"| BERT-base | 66.5 | 66.5 | 66.3 | 66.4 | 33.4 | 3.63 | -1.6 (5.6 - 7.2) |\"\n", - "}\n" - ] - } - ], - "source": [ - "leaderboard_string = (f\"| BERT-base | \"\n", - " f\"{all_results['Accuracy']*100:.1f} | \"\n", - " f\"{all_results['Precision']*100:.1f} | \"\n", - " f\"{all_results['Recall']*100:.1f} | \"\n", - " f\"{all_results['F1']*100:.1f} | \"\n", - " f\"{all_results['FPR']*100:.1f} | \"\n", - " f\"{all_results['Mean H']:.2f} | \"\n", - " f\"{(all_results['Correct Adjustment']-all_results['Incorrect Adjustment'])*100:.1f} \"\n", - " f\"({all_results['Correct Adjustment']*100:.1f} - {all_results['Incorrect Adjustment']*100:.1f}) |\")\n", - "all_results['Leaderboard String'] = leaderboard_string\n", - "print(json.dumps(all_results, indent=4))\n" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluating Random Seed 1\n", + "100%|██████████| 5131/5131 [00:47<00:00, 109.11it/s]\n" + ] }, { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Transformer Decoder-based Forecaster" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/README.md\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_model.safetensors\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/optimizer.pt\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/rng_state.pth\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/scheduler.pt\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/special_tokens_map.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/trainer_state.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/training_args.bin\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/dev_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/test_result.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/README.md\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_model.safetensors\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/optimizer.pt\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/rng_state.pth\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/scheduler.pt\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/special_tokens_map.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/trainer_state.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/training_args.bin\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/dev_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/test_result.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/README.md\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_model.safetensors\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/optimizer.pt\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/rng_state.pth\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/scheduler.pt\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/special_tokens_map.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/trainer_state.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/training_args.bin\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/dev_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/test_result.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/README.md\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/adapter_model.safetensors\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/optimizer.pt\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/rng_state.pth\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/scheduler.pt\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/special_tokens_map.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/tokenizer_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/trainer_state.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/training_args.bin\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/dev_config.json\n", - "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/test_result.json\n" - ] - } - ], - "source": [ - "MODEL = \"google/gemma-2-9b-it\"\n", - "BASE_URL = f\"https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/{corpus_name}/{MODEL}/\"\n", - "DOWNLOAD_DIR = f\"{YOUR_MODEL_DIRECTORY}/{corpus_name}/{MODEL}\"\n", - "\n", - "os.makedirs(DOWNLOAD_DIR, exist_ok=True)\n", - "download_recursive(BASE_URL, DOWNLOAD_DIR)\n", - "forecasting_models_path = DOWNLOAD_DIR" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.5899280575539567, Median = 3.0\n", + "Accuracy 0.661905\n", + "Precision 0.661905\n", + "Recall 0.661905\n", + "FPR 0.338095\n", + "F1 0.661905\n", + "Mean H 3.589928\n", + "Correct Adjustment 0.05\n", + "Incorrect Adjustment 0.066667\n", + "Recovery -0.016667\n", + "Leaderboard String | MODEL_NAME | 66.2 | 66.2 | 66.2 | 66....\n", + "dtype: object\n", + "Evaluating Random Seed 2\n", + "100%|██████████| 5131/5131 [00:47<00:00, 108.70it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Evaluating Random Seed 1\n", - "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Unsloth 2025.3.19 patched 42 layers with 42 QKV layers, 42 O layers and 42 MLP layers.\n", - "Unsloth: Will map to EOS = .\n", - "0it [00:00, ?it/s]The attention mask is not set and cannot be inferred from input because pad token is same as eos token. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n", - "5131it [15:38, 5.47it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.7551622418879056, Median = 3.0\n", - "Accuracy 0.688095\n", - "Precision 0.651923\n", - "Recall 0.807143\n", - "FPR 0.430952\n", - "F1 0.721277\n", - "Mean H 3.755162\n", - "Correct Adjustment 0.045238\n", - "Incorrect Adjustment 0.030952\n", - "Recovery 0.014286\n", - "Leaderboard String | MODEL_NAME | 68.8 | 65.2 | 80.7 | 72....\n", - "dtype: object\n", - "Evaluating Random Seed 2\n", - "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5131it [15:34, 5.49it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.7725947521865892, Median = 3.0\n", - "Accuracy 0.67381\n", - "Precision 0.635185\n", - "Recall 0.816667\n", - "FPR 0.469048\n", - "F1 0.714583\n", - "Mean H 3.772595\n", - "Correct Adjustment 0.035714\n", - "Incorrect Adjustment 0.021429\n", - "Recovery 0.014286\n", - "Leaderboard String | MODEL_NAME | 67.4 | 63.5 | 81.7 | 71....\n", - "dtype: object\n", - "Evaluating Random Seed 3\n", - "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5131it [15:35, 5.49it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.6523076923076925, Median = 3.0\n", - "Accuracy 0.692857\n", - "Precision 0.665984\n", - "Recall 0.77381\n", - "FPR 0.388095\n", - "F1 0.715859\n", - "Mean H 3.652308\n", - "Correct Adjustment 0.04881\n", - "Incorrect Adjustment 0.032143\n", - "Recovery 0.016667\n", - "Leaderboard String | MODEL_NAME | 69.3 | 66.6 | 77.4 | 71....\n", - "dtype: object\n", - "Evaluating Random Seed 4\n", - "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5131it [15:39, 5.46it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.300699300699301, Median = 3.0\n", - "Accuracy 0.704762\n", - "Precision 0.715\n", - "Recall 0.680952\n", - "FPR 0.271429\n", - "F1 0.697561\n", - "Mean H 3.300699\n", - "Correct Adjustment 0.035714\n", - "Incorrect Adjustment 0.038095\n", - "Recovery -0.002381\n", - "Leaderboard String | MODEL_NAME | 70.5 | 71.5 | 68.1 | 69....\n", - "dtype: object\n", - "Evaluating Random Seed 5\n", - "==((====))== Unsloth 2025.3.19: Fast Gemma2 patching. Transformers: 4.50.3.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.5.1+cu124. CUDA: 8.6. CUDA Toolkit: 12.4. Triton: 3.1.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.28.post3. FA2 = True]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5131it [15:40, 5.45it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Horizon statistics (# of comments between first positive forecast and conversation end):\n", - "Mean = 3.385416666666667, Median = 3.0\n", - "Accuracy 0.70119\n", - "Precision 0.707617\n", - "Recall 0.685714\n", - "FPR 0.283333\n", - "F1 0.696493\n", - "Mean H 3.385417\n", - "Correct Adjustment 0.039286\n", - "Incorrect Adjustment 0.038095\n", - "Recovery 0.00119\n", - "Leaderboard String | MODEL_NAME | 70.1 | 70.8 | 68.6 | 69....\n", - "dtype: object\n" - ] - } - ], - "source": [ - "# This cell takes around 80 mins on a single NVIDIA RTX A6000\n", - "all_results = {}\n", - "for seed in range(1,6):\n", - " print(f\"Evaluating Random Seed {seed}\")\n", - " config_dict = TransformerForecasterConfig(\n", - " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", - " context_mode=\"normal\", # set to normal by default\n", - " device=DEVICE\n", - " )\n", - " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", - "\n", - " #Load pre-tuned config\n", - " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", - " with open(tuned_config_file, 'r') as file:\n", - " tuned_config = json.load(file)\n", - "\n", - " decoder_model = TransformerDecoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", - " decoder_model.best_threshold = tuned_config['best_threshold']\n", - " decoder_forecaster = Forecaster(decoder_model, label_metadata)\n", - "\n", - " # corpus = copy.deepcopy(corpus)\n", - " corpus = decoder_forecaster.transform(corpus, transform_selector)\n", - " _, cur_metrics= decoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", - "\n", - " update_metrics(all_results, cur_metrics)\n", - "\n", - "for metric in all_results:\n", - " if metric == \"Leaderboard String\":\n", - " continue\n", - " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " \"Accuracy\": 0.6921428571428571,\n", - " \"Precision\": 0.6751417152564694,\n", - " \"Recall\": 0.7528571428571429,\n", - " \"FPR\": 0.3685714285714286,\n", - " \"F1\": 0.7091546569961278,\n", - " \"Mean H\": 3.573236130749631,\n", - " \"Correct Adjustment\": 0.04095238095238095,\n", - " \"Incorrect Adjustment\": 0.03214285714285715,\n", - " \"Recovery\": 0.008809523809523807,\n", - " \"Leaderboard String\": \"| Gemma2-9B | 69.2 | 67.5 | 75.3 | 70.9 | 36.9 | 3.57 | 0.9 (4.1 - 3.2) |\"\n", - "}\n" - ] - } - ], - "source": [ - "leaderboard_string = (f\"| Gemma2-9B | \"\n", - " f\"{all_results['Accuracy']*100:.1f} | \"\n", - " f\"{all_results['Precision']*100:.1f} | \"\n", - " f\"{all_results['Recall']*100:.1f} | \"\n", - " f\"{all_results['F1']*100:.1f} | \"\n", - " f\"{all_results['FPR']*100:.1f} | \"\n", - " f\"{all_results['Mean H']:.2f} | \"\n", - " f\"{(all_results['Correct Adjustment']-all_results['Incorrect Adjustment'])*100:.1f} \"\n", - " f\"({all_results['Correct Adjustment']*100:.1f} - {all_results['Incorrect Adjustment']*100:.1f}) |\")\n", - "all_results['Leaderboard String'] = leaderboard_string\n", - "print(json.dumps(all_results, indent=4))" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.731182795698925, Median = 3.0\n", + "Accuracy 0.666667\n", + "Precision 0.667464\n", + "Recall 0.664286\n", + "FPR 0.330952\n", + "F1 0.665871\n", + "Mean H 3.731183\n", + "Correct Adjustment 0.054762\n", + "Incorrect Adjustment 0.07619\n", + "Recovery -0.021429\n", + "Leaderboard String | MODEL_NAME | 66.7 | 66.7 | 66.4 | 66....\n", + "dtype: object\n", + "Evaluating Random Seed 3\n", + "100%|██████████| 5131/5131 [00:47<00:00, 109.03it/s]\n" + ] }, { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## With DeferralDecisionPolicy\n", - "\n", - "We can also try attaching a DeferralDecisionPolicy to the same model." + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "from functools import partial" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.7491525423728813, Median = 3.0\n", + "Accuracy 0.672619\n", + "Precision 0.662921\n", + "Recall 0.702381\n", + "FPR 0.357143\n", + "F1 0.682081\n", + "Mean H 3.749153\n", + "Correct Adjustment 0.070238\n", + "Incorrect Adjustment 0.088095\n", + "Recovery -0.017857\n", + "Leaderboard String | MODEL_NAME | 67.3 | 66.3 | 70.2 | 68....\n", + "dtype: object\n", + "Evaluating Random Seed 4\n", + "100%|██████████| 5131/5131 [00:47<00:00, 108.49it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "SIMULATOR_TRAIN_CONFIG = {\n", - " \"per_device_train_batch_size\": 16,\n", - " \"per_device_eval_batch_size\": 16,\n", - " \"eval_strategy\": \"steps\",\n", - " \"save_strategy\": \"steps\",\n", - " \"save_steps\": 30,\n", - " \"gradient_accumulation_steps\": 4,\n", - " \"warmup_steps\": 5,\n", - " \"num_train_epochs\": 1,\n", - " \"eval_steps\": 30,\n", - " \"learning_rate\": 2e-4,\n", - " \"logging_steps\": 5,\n", - " \"optim\": \"adamw_8bit\",\n", - " \"weight_decay\": 0.01,\n", - " \"lr_scheduler_type\": \"linear\",\n", - " \"output_dir\": \"outputs/simulator_finetune\",\n", - " \"logging_dir\": \"logs\",\n", - " \"load_best_model_at_end\": True,\n", - "}" + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAGwCAYAAABSN5pGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVxhJREFUeJzt3XlYVGX/P/D3sAwgq4BsSoBKgoqgooiWWlCYPrlE5YKBS/rU446aUgbuoKmRjzyafkvtl6SZS6aFKa4pooLkBqgE4gK4BQgmCHP//vDy5Azr6MAAvV/XNVfOfe5zn885zJx5d+acMzIhhAARERERSXS0XQARERFRQ8OARERERKSCAYmIiIhIBQMSERERkQoGJCIiIiIVDEhEREREKhiQiIiIiFToabuAxkqhUODmzZswNTWFTCbTdjlERERUC0II3L9/Hw4ODtDRqfo4EQPSM7p58yYcHR21XQYRERE9g2vXrqFVq1ZVTmdAekampqYAHm9gMzMzLVdDREREtVFYWAhHR0fpc7wqDEjP6MnXamZmZgxIREREjUxNp8fwJG0iIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISIWetgsg0ibn2Xu0XYLasqIGaLsEIqImj0eQiIiIiFQwIBERERGpYEAiIiIiUsGARERERKSCAYmIiIhIBQMSERERkQoGJCIiIiIVDEhEREREKhiQiIiIiFQwIBERERGpYEAiIiIiUsGARERERKSCAYmIiIhIBQMSERERkQoGJCIiIiIVDSIgxcTEwNnZGYaGhvDx8cHJkyer7Ltu3Tq8/PLLaN68OZo3bw5/f/8K/YUQCA8Ph729PYyMjODv74/Lly8r9bl37x6CgoJgZmYGCwsLjB07FkVFRXWyfkRERNS4aD0gbdmyBaGhoYiIiEBycjI8PT0REBCAW7duVdr/0KFDGD58OA4ePIiEhAQ4Ojri9ddfx40bN6Q+S5cuxcqVK7FmzRokJibC2NgYAQEBePjwodQnKCgIFy5cwL59+7B7924cOXIE48ePr/P1JSIiooZPJoQQ2izAx8cH3bp1w6pVqwAACoUCjo6OmDRpEmbPnl3j/OXl5WjevDlWrVqF4OBgCCHg4OCA6dOnY8aMGQCAgoIC2NraYsOGDRg2bBhSU1PRvn17nDp1Ct7e3gCAuLg49O/fH9evX4eDg0OF5ZSUlKCkpER6XlhYCEdHRxQUFMDMzEwTm4K0wHn2Hm2XoLasqAHaLoGIqNEqLCyEubl5jZ/fWj2CVFpaiqSkJPj7+0ttOjo68Pf3R0JCQq3GePDgAR49egRLS0sAQGZmJnJzc5XGNDc3h4+PjzRmQkICLCwspHAEAP7+/tDR0UFiYmKly4mMjIS5ubn0cHR0VHt9iYiIqHHQakC6c+cOysvLYWtrq9Rua2uL3NzcWo0xa9YsODg4SIHoyXzVjZmbmwsbGxul6Xp6erC0tKxyuWFhYSgoKJAe165dq1V9RERE1PjoabuA5xEVFYXNmzfj0KFDMDQ0rNNlGRgYwMDAoE6XQURERA2DVo8gWVtbQ1dXF3l5eUrteXl5sLOzq3beZcuWISoqCr/++is6deoktT+Zr7ox7ezsKpwEXlZWhnv37tW4XCIiImr6tBqQ5HI5unbtivj4eKlNoVAgPj4evr6+Vc63dOlSLFiwAHFxcUrnEQGAi4sL7OzslMYsLCxEYmKiNKavry/y8/ORlJQk9Tlw4AAUCgV8fHw0tXpERETUSGn9K7bQ0FCEhITA29sb3bt3R3R0NIqLizF69GgAQHBwMFq2bInIyEgAwJIlSxAeHo7Y2Fg4OztL5wyZmJjAxMQEMpkMU6dOxcKFC+Hq6goXFxd8+umncHBwwODBgwEA7u7u6NevH8aNG4c1a9bg0aNHmDhxIoYNG1bpFWxERET0z6L1gDR06FDcvn0b4eHhyM3NhZeXF+Li4qSTrLOzs6Gj8/eBrtWrV6O0tBRvv/220jgRERGYO3cuAOCjjz5CcXExxo8fj/z8fLz00kuIi4tTOk9p06ZNmDhxIvz8/KCjo4PAwECsXLmy7leYiIiIGjyt3wepsartfRSoYeN9kIiI/lkaxX2QiIiIiBoiBiQiIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCoYkIiIiIhU6Gm7AGoaGuOPvhIREVWFR5CIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFr2IjamQa4xWDWVEDtF0CEZFaeASJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFVoPSDExMXB2doahoSF8fHxw8uTJKvteuHABgYGBcHZ2hkwmQ3R0dIU+T6apPiZMmCD16du3b4XpH3zwQV2sHhERETVCWg1IW7ZsQWhoKCIiIpCcnAxPT08EBATg1q1blfZ/8OABWrdujaioKNjZ2VXa59SpU8jJyZEe+/btAwC88847Sv3GjRun1G/p0qWaXTkiIiJqtLQakFasWIFx48Zh9OjRaN++PdasWYNmzZrh66+/rrR/t27d8Nlnn2HYsGEwMDCotE+LFi1gZ2cnPXbv3o02bdqgT58+Sv2aNWum1M/MzEzj60dERESNk9YCUmlpKZKSkuDv7/93MTo68Pf3R0JCgsaW8e2332LMmDGQyWRK0zZt2gRra2t07NgRYWFhePDgQbVjlZSUoLCwUOlBRERETZOethZ8584dlJeXw9bWVqnd1tYWaWlpGlnGzp07kZ+fj1GjRim1jxgxAk5OTnBwcMDZs2cxa9YspKenY/v27VWOFRkZiXnz5mmkLiIiImrYtBaQ6sNXX32FN954Aw4ODkrt48ePl/7t4eEBe3t7+Pn5ISMjA23atKl0rLCwMISGhkrPCwsL4ejoWDeFExERkVZpLSBZW1tDV1cXeXl5Su15eXlVnoCtjqtXr2L//v3VHhV6wsfHBwBw5cqVKgOSgYFBlec9ERERUdOitXOQ5HI5unbtivj4eKlNoVAgPj4evr6+zz3++vXrYWNjgwEDBtTYNyUlBQBgb2//3MslIiKixk+rX7GFhoYiJCQE3t7e6N69O6Kjo1FcXIzRo0cDAIKDg9GyZUtERkYCeHzS9cWLF6V/37hxAykpKTAxMUHbtm2lcRUKBdavX4+QkBDo6SmvYkZGBmJjY9G/f39YWVnh7NmzmDZtGnr37o1OnTrV05oTERFRQ6bVgDR06FDcvn0b4eHhyM3NhZeXF+Li4qQTt7Ozs6Gj8/dBrps3b6Jz587S82XLlmHZsmXo06cPDh06JLXv378f2dnZGDNmTIVlyuVy7N+/Xwpjjo6OCAwMxJw5c+puRYmIiKhRkQkhhLaLaIwKCwthbm6OgoIC3kMJgPPsPdougRqwrKiav+omIqoPtf381vpPjRARERE1NAxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCoYkIiIiIhUqB2QNm7ciD179kjPP/roI1hYWKBnz564evWqRosjIiIi0ga1A9LixYthZGQEAEhISEBMTAyWLl0Ka2trTJs2TeMFEhEREdU3PXVnuHbtGtq2bQsA2LlzJwIDAzF+/Hj06tULffv21XR9RERERPVO7SNIJiYmuHv3LgDg119/xWuvvQYAMDQ0xF9//aXZ6oiIiIi0QO0jSK+99href/99dO7cGZcuXUL//v0BABcuXICzs7Om6yMiIiKqd2ofQYqJiYGvry9u376Nbdu2wcrKCgCQlJSE4cOHa7xAIiIiovqm9hEkCwsLrFq1qkL7vHnzNFIQERERkbapHZAAID8/HydPnsStW7egUCikdplMhvfee09jxRERERFpg9oB6aeffkJQUBCKiopgZmYGmUwmTWNAIiIioqZA7XOQpk+fjjFjxqCoqAj5+fn4888/pce9e/fqokYiIiKieqV2QLpx4wYmT56MZs2a1UU9RERERFqndkAKCAjA6dOn66IWIiIiogZB7YA0YMAAzJw5E3PnzsW2bduwa9cupYe6YmJi4OzsDENDQ/j4+ODkyZNV9r1w4QICAwPh7OwMmUyG6OjoCn3mzp0LmUym9HBzc1Pq8/DhQ0yYMAFWVlYwMTFBYGAg8vLy1K6diIiImia1T9IeN24cAGD+/PkVpslkMpSXl9d6rC1btiA0NBRr1qyBj48PoqOjERAQgPT0dNjY2FTo/+DBA7Ru3RrvvPNOtb/71qFDB+zfv196rqenvJrTpk3Dnj17sHXrVpibm2PixIl46623cOzYsVrXTkRERE2X2gHp6cv6n9eKFSswbtw4jB49GgCwZs0a7NmzB19//TVmz55doX+3bt3QrVs3AKh0+hN6enqws7OrdFpBQQG++uorxMbG4tVXXwUArF+/Hu7u7jhx4gR69OhR6XwlJSUoKSmRnhcWFtZuJYmIiKjRUfsrNk0pLS1FUlIS/P39/y5GRwf+/v5ISEh4rrEvX74MBwcHtG7dGkFBQcjOzpamJSUl4dGjR0rLdXNzwwsvvFDtciMjI2Fubi49HB0dn6tGIiIiarieKSAdPnwYb775Jtq2bYu2bdti4MCBOHr0qFpj3LlzB+Xl5bC1tVVqt7W1RW5u7rOUBQDw8fHBhg0bEBcXh9WrVyMzMxMvv/wy7t+/DwDIzc2FXC6HhYWFWssNCwtDQUGB9Lh27doz10hEREQNm9oB6dtvv4W/vz+aNWuGyZMnY/LkyTAyMoKfnx9iY2Proka1vPHGG3jnnXfQqVMnBAQE4Oeff0Z+fj6+//775xrXwMAAZmZmSg8iIiJqmtQ+B2nRokVYunSp0knSkydPxooVK7BgwQKMGDGiVuNYW1tDV1e3wtVjeXl5VZ4/9CwsLCzw4osv4sqVKwAAOzs7lJaWIj8/X+kokqaXS0RERI2X2keQ/vjjD7z55psV2gcOHIjMzMxajyOXy9G1a1fEx8dLbQqFAvHx8fD19VW3rCoVFRUhIyMD9vb2AICuXbtCX19fabnp6enIzs7W6HKJiIio8VL7CJKjoyPi4+PRtm1bpfb9+/erfeJyaGgoQkJC4O3tje7duyM6OhrFxcXSVW3BwcFo2bIlIiMjATw+sfvixYvSv2/cuIGUlBSYmJhI9cyYMQNvvvkmnJyccPPmTUREREBXVxfDhw8HAJibm2Ps2LEIDQ2FpaUlzMzMMGnSJPj6+lZ5BRsRERH9s6gdkKZPn47JkycjJSUFPXv2BAAcO3YMGzZswBdffKHWWEOHDsXt27cRHh6O3NxceHl5IS4uTjpxOzs7Gzo6fx/kunnzJjp37iw9X7ZsGZYtW4Y+ffrg0KFDAIDr169j+PDhuHv3Llq0aIGXXnoJJ06cQIsWLaT5Pv/8c+jo6CAwMBAlJSUICAjA//73P3U3BRERETVRMiGEUHemHTt2YPny5UhNTQUAuLu7Y+bMmRg0aJDGC2yoCgsLYW5ujoKCAp6wDcB59h5tl0ANWFbUAG2XQEQEoPaf32ofQQKAIUOGYMiQIc9cHBEREVFDprUbRRIRERE1VLU6gmRpaYlLly7B2toazZs3h0wmq7LvvXv3NFYcERERkTbUKiB9/vnnMDU1lf5dXUAiIiIiauxqFZBCQkKkf48aNaquaiEiIiJqENQ+B0lXVxe3bt2q0H737l3o6upqpCgiIiIibVI7IFV1V4CSkhLI5fLnLoiIiIhI22p9mf/KlSsBADKZDP/3f/8HExMTaVp5eTmOHDkCNzc3zVdIREREVM9qHZA+//xzAI+PIK1Zs0bp6zS5XA5nZ2esWbNG8xUSERER1bNaB6QnP0T7yiuvYPv27WjevHmdFUVERESkTWrfSfvgwYN1UQcRERFRg/FMPzVy/fp17Nq1C9nZ2SgtLVWatmLFCo0URkRERKQtagek+Ph4DBw4EK1bt0ZaWho6duyIrKwsCCHQpUuXuqiRiIiIqF6pfZl/WFgYZsyYgXPnzsHQ0BDbtm3DtWvX0KdPH7zzzjt1USMRERFRvVL7CFJqaiq+++67xzPr6eGvv/6CiYkJ5s+fj0GDBuHDDz/UeJFE1Lg5z96j7RLUlhU1QNslEJEWqX0EydjYWDrvyN7eHhkZGdK0O3fuaK4yIiIiIi1R+whSjx498Ntvv8Hd3R39+/fH9OnTce7cOWzfvh09evSoixqJiIiI6pXaAWnFihUoKioCAMybNw9FRUXYsmULXF1deQUbERERNQlqB6TWrVtL/zY2Nubds4mIiKjJUfscpGvXruH69evS85MnT2Lq1KlYu3atRgsjIiIi0ha1A9KIESOku2nn5ubC398fJ0+exCeffIL58+drvEAiIiKi+qZ2QDp//jy6d+8OAPj+++/h4eGB48ePY9OmTdiwYYOm6yMiIiKqd2oHpEePHsHAwAAAsH//fgwcOBAA4ObmhpycHM1WR0RERKQFagekDh06YM2aNTh69Cj27duHfv36AQBu3rwJKysrjRdIREREVN/UDkhLlizBl19+ib59+2L48OHw9PQEAOzatUv66o2IiIioMVP7Mv++ffvizp07KCwsRPPmzaX28ePHo1mzZhotjoiIiEgb1D6CBABCCCQlJeHLL7/E/fv3AQByuZwBiYiIiJoEtY8gXb16Ff369UN2djZKSkrw2muvwdTUFEuWLEFJSQlvHElERESNntpHkKZMmQJvb2/8+eefMDIyktqHDBmC+Ph4jRZHREREpA1qH0E6evQojh8/DrlcrtTu7OyMGzduaKwwIiIiIm1R+wiSQqFAeXl5hfbr16/D1NRU7QJiYmLg7OwMQ0ND+Pj44OTJk1X2vXDhAgIDA+Hs7AyZTIbo6OgKfSIjI9GtWzeYmprCxsYGgwcPRnp6ulKfvn37QiaTKT0++OADtWsnIiKipkntgPT6668rBROZTIaioiJERESgf//+ao21ZcsWhIaGIiIiAsnJyfD09ERAQABu3bpVaf8HDx6gdevWiIqKgp2dXaV9Dh8+jAkTJuDEiRPYt28fHj16hNdffx3FxcVK/caNG4ecnBzpsXTpUrVqJyIioqZLJoQQ6sxw/fp1BAQEQAiBy5cvw9vbG5cvX4a1tTWOHDkCGxubWo/l4+ODbt26YdWqVQAeH51ydHTEpEmTMHv27GrndXZ2xtSpUzF16tRq+92+fRs2NjY4fPgwevfuDeDxESQvL69Kj0DVVmFhIczNzVFQUAAzM7NnHqepcJ69R9slEGlUVtQAbZdARHWgtp/fah9BatWqFX7//Xd8/PHHmDZtGjp37oyoqCicOXNGrXBUWlqKpKQk+Pv7/12Mjg78/f2RkJCgbllVKigoAABYWloqtW/atAnW1tbo2LEjwsLC8ODBg2rHKSkpQWFhodKDiIiImia1T9J++PAhDA0NMXLkyOda8J07d1BeXg5bW1uldltbW6SlpT3X2E8oFApMnToVvXr1QseOHaX2ESNGwMnJCQ4ODjh79ixmzZqF9PR0bN++vcqxIiMjMW/ePI3URURERA2b2gHJxsYGQ4YMwciRI+Hn5wcdnWe612S9mDBhAs6fP4/ffvtNqX38+PHSvz08PGBvbw8/Pz9kZGSgTZs2lY4VFhaG0NBQ6XlhYSEcHR3rpnAiIiLSKrXTzcaNG/HgwQMMGjQILVu2xNSpU3H69Gm1F2xtbQ1dXV3k5eUptefl5VV5ArY6Jk6ciN27d+PgwYNo1apVtX19fHwAAFeuXKmyj4GBAczMzJQeRERE1DSpHZCGDBmCrVu3Ii8vD4sXL8bFixfRo0cPvPjii5g/f36tx5HL5ejatavSzSUVCgXi4+Ph6+urblkSIQQmTpyIHTt24MCBA3BxcalxnpSUFACAvb39My+XiIiImo5n/n7M1NQUo0ePxq+//oqzZ8/C2NhY7XN0QkNDsW7dOmzcuBGpqan48MMPUVxcjNGjRwMAgoODERYWJvUvLS1FSkoKUlJSUFpaihs3biAlJUXpyM+ECRPw7bffIjY2FqampsjNzUVubi7++usvAEBGRgYWLFiApKQkZGVlYdeuXQgODkbv3r3RqVOnZ90cRERE1ISofQ7SEw8fPsSuXbsQGxuLuLg42NraYubMmWqNMXToUNy+fRvh4eHIzc2Fl5eXNBYAZGdnK53jdPPmTXTu3Fl6vmzZMixbtgx9+vTBoUOHAACrV68G8PhS/qetX78eo0aNglwux/79+xEdHY3i4mI4OjoiMDAQc+bMeYatQERERE2R2vdB2rt3L2JjY7Fz507o6enh7bffRlBQkHSPoX8K3gdJGe+DRE0N74NE1DTV9vNb7SNIQ4YMwb/+9S9888036N+/P/T19Z+rUCIiIqKGRu2AlJeX90y/uUZERETUWKgdkExNTaFQKHDlyhXcunULCoVCafo/7as2IiIianrUDkgnTpzAiBEjcPXqVaieviSTyVBeXq6x4oiIiIi0Qe2A9MEHH8Db2xt79uyBvb09ZDJZXdRFREREpDVqB6TLly/jhx9+QNu2beuiHiIiIiKtU/tGkT4+PtX+JAcRERFRY6f2EaRJkyZh+vTpyM3NhYeHR4XL/Hk3aiIiImrs1A5IgYGBAIAxY8ZIbTKZDEIInqRNRERETYLaASkzM7Mu6iAiIiJqMNQOSE5OTnVRBxEREVGD8Uw/VpuRkYHo6GikpqYCANq3b48pU6agTZs2Gi2OiIiISBvUvopt7969aN++PU6ePIlOnTqhU6dOSExMRIcOHbBv3766qJGIiIioXql9BGn27NmYNm0aoqKiKrTPmjULr732msaKIyIiItIGtY8gpaamYuzYsRXax4wZg4sXL2qkKCIiIiJtUjsgtWjRAikpKRXaU1JSYGNjo4maiIiIiLRK7a/Yxo0bh/Hjx+OPP/5Az549AQDHjh3DkiVLEBoaqvECiYiIiOqb2gHp008/hampKZYvX46wsDAAgIODA+bOnYvJkydrvEAiIiKi+iYTQohnnfn+/fsAAFNTU40V1FgUFhbC3NwcBQUFMDMz03Y5Wuc8e4+2SyD6x8uKGqDtEogavNp+fj/TnbTLysrg6uqqFIwuX74MfX19ODs7P1PBRERERA2F2idpjxo1CsePH6/QnpiYiFGjRmmiJiIiIiKtUjsgnTlzBr169arQ3qNHj0qvbiMiIiJqbNQOSDKZTDr36GkFBQUoLy/XSFFERERE2qR2QOrduzciIyOVwlB5eTkiIyPx0ksvabQ4IiIiIm1Q+yTtJUuWoHfv3mjXrh1efvllAMDRo0dRWFiIAwcOaLxAIiIiovqm9hGk9u3b4+zZs3j33Xdx69Yt3L9/H8HBwUhLS0PHjh3rokYiIiKieqX2ESTg8Y0hFy9erOlaiIiIiBoEtY8gERERETV1DEhEREREKhiQiIiIiFTUKiDt2rULjx49qutaiIiIiBqEWgWkIUOGID8/HwCgq6uLW7duaayAmJgYODs7w9DQED4+Pjh58mSVfS9cuIDAwEA4OztDJpMhOjr6mcZ8+PAhJkyYACsrK5iYmCAwMBB5eXkaWyciIiJq3GoVkFq0aIETJ04AAIQQkMlkGln4li1bEBoaioiICCQnJ8PT0xMBAQFVBrAHDx6gdevWiIqKgp2d3TOPOW3aNPz000/YunUrDh8+jJs3b+Ktt97SyDoRERFR4ycTQoiaOs2dOxfz58+vVTBS5+dGfHx80K1bN6xatQoAoFAo4OjoiEmTJmH27NnVzuvs7IypU6di6tSpao1ZUFCAFi1aIDY2Fm+//TYAIC0tDe7u7khISECPHj1qVXthYSHMzc1RUFAAMzOzWq9zU+U8e4+2SyD6x8uKGqDtEogavNp+ftfqPkhz587FsGHDcOXKFQwcOBDr16+HhYXFcxVYWlqKpKQkhIWFSW06Ojrw9/dHQkJCnY2ZlJSER48ewd/fX+rj5uaGF154odqAVFJSgpKSEul5YWHhM9VIREREDV+tbxTp5uYGNzc3RERE4J133kGzZs2ea8F37txBeXk5bG1tldptbW2RlpZWZ2Pm5uZCLpdXCHi2trbIzc2tcuzIyEjMmzfvmeoiIiKixkXty/wjIiLQrFkz3L59G7/99ht+++033L59uy5qa1DCwsJQUFAgPa5du6btkoiIiKiOqB2QHjx4gDFjxsDBwQG9e/dG79694eDggLFjx+LBgwe1Hsfa2hq6uroVrh7Ly8ur8gRsTYxpZ2eH0tJS6aq82i7XwMAAZmZmSg8iIiJqmtQOSNOmTcPhw4exa9cu5OfnIz8/Hz/++CMOHz6M6dOn13ocuVyOrl27Ij4+XmpTKBSIj4+Hr6+vumXVesyuXbtCX19fqU96ejqys7OfeblERETUtKj9Y7Xbtm3DDz/8gL59+0pt/fv3h5GREd59912sXr261mOFhoYiJCQE3t7e6N69O6Kjo1FcXIzRo0cDAIKDg9GyZUtERkYCeHwS9sWLF6V/37hxAykpKTAxMUHbtm1rNaa5uTnGjh2L0NBQWFpawszMDJMmTYKvr2+tr2AjIiKipk3tgPTgwYMKJ0EDgI2NjVpfsQHA0KFDcfv2bYSHhyM3NxdeXl6Ii4uTxs/OzoaOzt8HuW7evInOnTtLz5ctW4Zly5ahT58+OHToUK3GBIDPP/8cOjo6CAwMRElJCQICAvC///1PrdqJiIio6arVfZCe5ufnBysrK3zzzTcwNDQEAPz1118ICQnBvXv3sH///joptKHhfZCU8T5IRNrH+yAR1Uyj90F62hdffIGAgAC0atUKnp6eAIDff/8dhoaG2Lt377NXTERERNRAqB2QOnbsiMuXL2PTpk3SvYWGDx+OoKAgGBkZabxAIiIiovqmdkACgGbNmmHcuHGaroWIiIioQVD7Mn8iIiKipo4BiYiIiEgFAxIRERGRCgYkIiIiIhVqB6TWrVvj7t27Fdrz8/PRunVrjRRFREREpE1qB6SsrCyUl5dXaC8pKcGNGzc0UhQRERGRNtX6Mv9du3ZJ/967dy/Mzc2l5+Xl5YiPj4ezs7NGiyMiIiLShloHpMGDBwMAZDIZQkJClKbp6+vD2dkZy5cv12hxRERERNpQ64CkUCgAAC4uLjh16hSsra3rrCgiIiIibVL7TtqZmZl1UQcRERFRg/FMPzUSHx+P+Ph43Lp1Szqy9MTXX3+tkcKIiIiItEXtgDRv3jzMnz8f3t7esLe3h0wmq4u6iIiIiLRG7YC0Zs0abNiwAe+9915d1ENERESkdWrfB6m0tBQ9e/asi1qIiIiIGgS1A9L777+P2NjYuqiFiIiIqEFQ+yu2hw8fYu3atdi/fz86deoEfX19pekrVqzQWHFERERE2qB2QDp79iy8vLwAAOfPn1eaxhO2iYiIqClQOyAdPHiwLuogIiIiajDUPgfpiStXrmDv3r3466+/AABCCI0VRURERKRNageku3fvws/PDy+++CL69++PnJwcAMDYsWMxffp0jRdIREREVN/UDkjTpk2Dvr4+srOz0axZM6l96NChiIuL02hxRERERNqg9jlIv/76K/bu3YtWrVoptbu6uuLq1asaK4yIiIhIW9Q+glRcXKx05OiJe/fuwcDAQCNFEREREWmT2gHp5ZdfxjfffCM9l8lkUCgUWLp0KV555RWNFkdERESkDWp/xbZ06VL4+fnh9OnTKC0txUcffYQLFy7g3r17OHbsWF3USERERFSv1D6C1LFjR1y6dAkvvfQSBg0ahOLiYrz11ls4c+YM2rRpUxc1EhEREdUrtY8gAYC5uTk++eQTTddCRERE1CCofQRp/fr12Lp1a4X2rVu3YuPGjc9URExMDJydnWFoaAgfHx+cPHmy2v5bt26Fm5sbDA0N4eHhgZ9//llpukwmq/Tx2WefSX2cnZ0rTI+Kinqm+omIiKhpUTsgRUZGwtraukK7jY0NFi9erHYBW7ZsQWhoKCIiIpCcnAxPT08EBATg1q1blfY/fvw4hg8fjrFjx+LMmTMYPHgwBg8erPS7cDk5OUqPr7/+GjKZDIGBgUpjzZ8/X6nfpEmT1K6fiIiImh61A1J2djZcXFwqtDs5OSE7O1vtAlasWIFx48Zh9OjRaN++PdasWYNmzZrh66+/rrT/F198gX79+mHmzJlwd3fHggUL0KVLF6xatUrqY2dnp/T48ccf8corr6B169ZKY5mamir1MzY2Vrt+IiIianrUDkg2NjY4e/Zshfbff/8dVlZWao1VWlqKpKQk+Pv7/12Qjg78/f2RkJBQ6TwJCQlK/QEgICCgyv55eXnYs2cPxo4dW2FaVFQUrKys0LlzZ3z22WcoKyurstaSkhIUFhYqPYiIiKhpUvsk7eHDh2Py5MkwNTVF7969AQCHDx/GlClTMGzYMLXGunPnDsrLy2Fra6vUbmtri7S0tErnyc3NrbR/bm5upf03btwIU1NTvPXWW0rtkydPRpcuXWBpaYnjx48jLCwMOTk5WLFiRaXjREZGYt68ebVdNSIiImrE1A5ICxYsQFZWFvz8/KCn93h2hUKB4ODgZzoHqa59/fXXCAoKgqGhoVJ7aGio9O9OnTpBLpfj3//+NyIjIyu9I3hYWJjSPIWFhXB0dKy7womIiEhr1ApIQgjk5uZiw4YNWLhwIVJSUmBkZAQPDw84OTmpvXBra2vo6uoiLy9PqT0vLw92dnaVzmNnZ1fr/kePHkV6ejq2bNlSYy0+Pj4oKytDVlYW2rVrV2G6gYEBf0qFiIjoH0Ktc5CEEGjbti2uX78OV1dXvPPOO/jXv/71TOEIAORyObp27Yr4+HipTaFQID4+Hr6+vpXO4+vrq9QfAPbt21dp/6+++gpdu3aFp6dnjbWkpKRAR0cHNjY2aq4FERERNTVqHUHS0dGBq6sr7t69C1dXV40UEBoaipCQEHh7e6N79+6Ijo5GcXExRo8eDQAIDg5Gy5YtERkZCQCYMmUK+vTpg+XLl2PAgAHYvHkzTp8+jbVr1yqNW1hYiK1bt2L58uUVlpmQkIDExES88sorMDU1RUJCAqZNm4aRI0eiefPmGlkvIiIiarzUPgcpKioKM2fOxOrVq9GxY8fnLmDo0KG4ffs2wsPDkZubCy8vL8TFxUknYmdnZ0NH5+8DXT179kRsbCzmzJmDjz/+GK6urti5c2eFWjZv3gwhBIYPH15hmQYGBti8eTPmzp2LkpISuLi4YNq0aUrnGBEREdE/l0wIIdSZoXnz5njw4AHKysogl8thZGSkNP3evXsaLbChKiwshLm5OQoKCmBmZqbtcrTOefYebZdA9I+XFTVA2yUQNXi1/fxW+whSdHT089RFRERE1OCpHZBCQkLqog4iIiKiBkPtO2kDQEZGBubMmYPhw4dLv5n2yy+/4MKFCxotjoiIiEgb1A5Ihw8fhoeHBxITE7F9+3YUFRUBePxTIxERERovkIiIiKi+qR2QZs+ejYULF2Lfvn2Qy+VS+6uvvooTJ05otDgiIiIibVA7IJ07dw5Dhgyp0G5jY4M7d+5opCgiIiIibVI7IFlYWCAnJ6dC+5kzZ9CyZUuNFEVERESkTWpfxTZs2DDMmjULW7duhUwmg0KhwLFjxzBjxgwEBwfXRY1ERFQLjfF+ZLx3EzVUah9BWrx4Mdzc3ODo6IiioiK0b98evXv3Rs+ePTFnzpy6qJGIiIioXql9BEkul2PdunUIDw/HuXPnUFRUhM6dO2vst9mIiIiItK3WAUmhUOCzzz7Drl27UFpaCj8/P0RERFT4qREiIiKixq7WX7EtWrQIH3/8MUxMTNCyZUt88cUXmDBhQl3WRkRERKQVtQ5I33zzDf73v/9h79692LlzJ3766Sds2rQJCoWiLusjIiIiqne1DkjZ2dno37+/9Nzf3x8ymQw3b96sk8KIiIiItKXWAamsrAyGhoZKbfr6+nj06JHGiyIiIiLSplqfpC2EwKhRo2BgYCC1PXz4EB988AGMjY2ltu3bt2u2QiIiIqJ6VuuAFBISUqFt5MiRGi2GiIiIqCGodUBav359XdZBRERE1GCofSdtIiIioqaOAYmIiIhIBQMSERERkQoGJCIiIiIVDEhEREREKhiQiIiIiFQwIBERERGpYEAiIiIiUsGARERERKSCAYmIiIhIBQMSERERkQoGJCIiIiIVDEhEREREKhpEQIqJiYGzszMMDQ3h4+ODkydPVtt/69atcHNzg6GhITw8PPDzzz8rTR81ahRkMpnSo1+/fkp97t27h6CgIJiZmcHCwgJjx45FUVGRxteNiIiIGh+tB6QtW7YgNDQUERERSE5OhqenJwICAnDr1q1K+x8/fhzDhw/H2LFjcebMGQwePBiDBw/G+fPnlfr169cPOTk50uO7775Tmh4UFIQLFy5g37592L17N44cOYLx48fX2XoSERFR4yETQghtFuDj44Nu3bph1apVAACFQgFHR0dMmjQJs2fPrtB/6NChKC4uxu7du6W2Hj16wMvLC2vWrAHw+AhSfn4+du7cWekyU1NT0b59e5w6dQre3t4AgLi4OPTv3x/Xr1+Hg4NDjXUXFhbC3NwcBQUFMDMzU3e1mxzn2Xu0XQIRUb3Iihqg7RLoOdT281urR5BKS0uRlJQEf39/qU1HRwf+/v5ISEiodJ6EhASl/gAQEBBQof+hQ4dgY2ODdu3a4cMPP8Tdu3eVxrCwsJDCEQD4+/tDR0cHiYmJlS63pKQEhYWFSg8iIiJqmrQakO7cuYPy8nLY2toqtdva2iI3N7fSeXJzc2vs369fP3zzzTeIj4/HkiVLcPjwYbzxxhsoLy+XxrCxsVEaQ09PD5aWllUuNzIyEubm5tLD0dFR7fUlIiKixkFP2wXUhWHDhkn/9vDwQKdOndCmTRscOnQIfn5+zzRmWFgYQkNDpeeFhYUMSURERE2UVo8gWVtbQ1dXF3l5eUrteXl5sLOzq3QeOzs7tfoDQOvWrWFtbY0rV65IY6ieBF5WVoZ79+5VOY6BgQHMzMyUHkRERNQ0aTUgyeVydO3aFfHx8VKbQqFAfHw8fH19K53H19dXqT8A7Nu3r8r+AHD9+nXcvXsX9vb20hj5+flISkqS+hw4cAAKhQI+Pj7Ps0pERETUBGj9Mv/Q0FCsW7cOGzduRGpqKj788EMUFxdj9OjRAIDg4GCEhYVJ/adMmYK4uDgsX74caWlpmDt3Lk6fPo2JEycCAIqKijBz5kycOHECWVlZiI+Px6BBg9C2bVsEBAQAANzd3dGvXz+MGzcOJ0+exLFjxzBx4kQMGzasVlewERERUdOm9XOQhg4ditu3byM8PBy5ubnw8vJCXFycdCJ2dnY2dHT+znE9e/ZEbGws5syZg48//hiurq7YuXMnOnbsCADQ1dXF2bNnsXHjRuTn58PBwQGvv/46FixYAAMDA2mcTZs2YeLEifDz84OOjg4CAwOxcuXK+l15IiIiapC0fh+kxor3QVLG+yAR0T8F74PUuDWK+yARERERNUQMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpEJP2wUQERE1Js6z92i7BLVlRQ3QdgmNToM4ghQTEwNnZ2cYGhrCx8cHJ0+erLb/1q1b4ebmBkNDQ3h4eODnn3+Wpj169AizZs2Ch4cHjI2N4eDggODgYNy8eVNpDGdnZ8hkMqVHVFRUnawfERERNS5aD0hbtmxBaGgoIiIikJycDE9PTwQEBODWrVuV9j9+/DiGDx+OsWPH4syZMxg8eDAGDx6M8+fPAwAePHiA5ORkfPrpp0hOTsb27duRnp6OgQMHVhhr/vz5yMnJkR6TJk2q03UlIiKixkEmhBDaLMDHxwfdunXDqlWrAAAKhQKOjo6YNGkSZs+eXaH/0KFDUVxcjN27d0ttPXr0gJeXF9asWVPpMk6dOoXu3bvj6tWreOGFFwA8PoI0depUTJ06tVZ1lpSUoKSkRHpeWFgIR0dHFBQUwMzMrLar22Q1xkPORET/FPyK7W+FhYUwNzev8fNbq0eQSktLkZSUBH9/f6lNR0cH/v7+SEhIqHSehIQEpf4AEBAQUGV/ACgoKIBMJoOFhYVSe1RUFKysrNC5c2d89tlnKCsrq3KMyMhImJubSw9HR8darCERERE1Rlo9SfvOnTsoLy+Hra2tUrutrS3S0tIqnSc3N7fS/rm5uZX2f/jwIWbNmoXhw4crJcXJkyejS5cusLS0xPHjxxEWFoacnBysWLGi0nHCwsIQGhoqPX9yBImIiIianiZ9FdujR4/w7rvvQgiB1atXK017Oux06tQJcrkc//73vxEZGQkDA4MKYxkYGFTaTkRERE2PVgOStbU1dHV1kZeXp9Sel5cHOzu7Suexs7OrVf8n4ejq1as4cOBAjecJ+fj4oKysDFlZWWjXrt0zrA0REVHD1BjPE9X2eVNaPQdJLpeja9euiI+Pl9oUCgXi4+Ph6+tb6Ty+vr5K/QFg3759Sv2fhKPLly9j//79sLKyqrGWlJQU6OjowMbG5hnXhoiIiJoKrX/FFhoaipCQEHh7e6N79+6Ijo5GcXExRo8eDQAIDg5Gy5YtERkZCQCYMmUK+vTpg+XLl2PAgAHYvHkzTp8+jbVr1wJ4HI7efvttJCcnY/fu3SgvL5fOT7K0tIRcLkdCQgISExPxyiuvwNTUFAkJCZg2bRpGjhyJ5s2ba2dDEBERUYOh9YA0dOhQ3L59G+Hh4cjNzYWXlxfi4uKkE7Gzs7Oho/P3ga6ePXsiNjYWc+bMwccffwxXV1fs3LkTHTt2BADcuHEDu3btAgB4eXkpLevgwYPo27cvDAwMsHnzZsydOxclJSVwcXHBtGnTlM5LIiIion8urd8HqbGq7X0U/ika4/fbRETUcNXVOUiN4j5IRERERA0RAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREalgQCIiIiJSwYBEREREpIIBiYiIiEgFAxIRERGRCgYkIiIiIhUMSEREREQqGJCIiIiIVDAgEREREaloEAEpJiYGzs7OMDQ0hI+PD06ePFlt/61bt8LNzQ2Ghobw8PDAzz//rDRdCIHw8HDY29vDyMgI/v7+uHz5slKfe/fuISgoCGZmZrCwsMDYsWNRVFSk8XUjIiKixkfrAWnLli0IDQ1FREQEkpOT4enpiYCAANy6davS/sePH8fw4cMxduxYnDlzBoMHD8bgwYNx/vx5qc/SpUuxcuVKrFmzBomJiTA2NkZAQAAePnwo9QkKCsKFCxewb98+7N69G0eOHMH48ePrfH2JiIio4ZMJIYQ2C/Dx8UG3bt2watUqAIBCoYCjoyMmTZqE2bNnV+g/dOhQFBcXY/fu3VJbjx494OXlhTVr1kAIAQcHB0yfPh0zZswAABQUFMDW1hYbNmzAsGHDkJqaivbt2+PUqVPw9vYGAMTFxaF///64fv06HBwcaqy7sLAQ5ubmKCgogJmZmSY2RaPmPHuPtksgIqImJCtqQJ2MW9vPb706WXotlZaWIikpCWFhYVKbjo4O/P39kZCQUOk8CQkJCA0NVWoLCAjAzp07AQCZmZnIzc2Fv7+/NN3c3Bw+Pj5ISEjAsGHDkJCQAAsLCykcAYC/vz90dHSQmJiIIUOGVFhuSUkJSkpKpOcFBQUAHm9oAhQlD7RdAhERNSF19fn6ZNyajg9pNSDduXMH5eXlsLW1VWq3tbVFWlpapfPk5uZW2j83N1ea/qStuj42NjZK0/X09GBpaSn1URUZGYl58+ZVaHd0dKxq9YiIiOgZmUfX7fj379+Hubl5ldO1GpAak7CwMKUjVwqFAvfu3YOVlRVkMpkWK9O+wsJCODo64tq1a/y6sY5xW9cPbuf6we1cP7idlQkhcP/+/RpPp9FqQLK2toauri7y8vKU2vPy8mBnZ1fpPHZ2dtX2f/LfvLw82NvbK/Xx8vKS+qieBF5WVoZ79+5VuVwDAwMYGBgotVlYWFS/gv8wZmZmfPPVE27r+sHtXD+4nesHt/Pfqjty9IRWr2KTy+Xo2rUr4uPjpTaFQoH4+Hj4+vpWOo+vr69SfwDYt2+f1N/FxQV2dnZKfQoLC5GYmCj18fX1RX5+PpKSkqQ+Bw4cgEKhgI+Pj8bWj4iIiBonrX/FFhoaipCQEHh7e6N79+6Ijo5GcXExRo8eDQAIDg5Gy5YtERkZCQCYMmUK+vTpg+XLl2PAgAHYvHkzTp8+jbVr1wIAZDIZpk6dioULF8LV1RUuLi749NNP4eDggMGDBwMA3N3d0a9fP4wbNw5r1qzBo0ePMHHiRAwbNqxWV7ARERFR06b1gDR06FDcvn0b4eHhyM3NhZeXF+Li4qSTrLOzs6Gj8/eBrp49eyI2NhZz5szBxx9/DFdXV+zcuRMdO3aU+nz00UcoLi7G+PHjkZ+fj5deeglxcXEwNDSU+mzatAkTJ06En58fdHR0EBgYiJUrV9bfijchBgYGiIiIqPAVJGket3X94HauH9zO9YPb+dlo/T5IRERERA2N1u+kTURERNTQMCARERERqWBAIiIiIlLBgERERESkggGJnllkZCS6desGU1NT2NjYYPDgwUhPT9d2WU1eVFSUdDsL0qwbN25g5MiRsLKygpGRETw8PHD69Gltl9XklJeX49NPP4WLiwuMjIzQpk0bLFiwoMbfxqLqHTlyBG+++SYcHBwgk8mk3yh9QgiB8PBw2Nvbw8jICP7+/rh8+bJ2im0EGJDomR0+fBgTJkzAiRMnsG/fPjx69Aivv/46iouLtV1ak3Xq1Cl8+eWX6NSpk7ZLaXL+/PNP9OrVC/r6+vjll19w8eJFLF++HM2bN9d2aU3OkiVLsHr1aqxatQqpqalYsmQJli5div/+97/aLq1RKy4uhqenJ2JiYiqdvnTpUqxcuRJr1qxBYmIijI2NERAQgIcPH9ZzpY0DL/Mnjbl9+zZsbGxw+PBh9O7dW9vlNDlFRUXo0qUL/ve//2HhwoXw8vJCdHS0tstqMmbPno1jx47h6NGj2i6lyfvXv/4FW1tbfPXVV1JbYGAgjIyM8O2332qxsqZDJpNhx44d0g2ShRBwcHDA9OnTMWPGDABAQUEBbG1tsWHDBgwbNkyL1TZMPIJEGlNQUAAAsLS01HIlTdOECRMwYMAA+Pv7a7uUJmnXrl3w9vbGO++8AxsbG3Tu3Bnr1q3TdllNUs+ePREfH49Lly4BAH7//Xf89ttveOONN7RcWdOVmZmJ3Nxcpf2Hubk5fHx8kJCQoMXKGi6t30mbmgaFQoGpU6eiV69eSnc1J83YvHkzkpOTcerUKW2X0mT98ccfWL16NUJDQ/Hxxx/j1KlTmDx5MuRyOUJCQrRdXpMye/ZsFBYWws3NDbq6uigvL8eiRYsQFBSk7dKarNzcXACQfqXiCVtbW2kaKWNAIo2YMGECzp8/j99++03bpTQ5165dw5QpU7Bv3z6ln8shzVIoFPD29sbixYsBAJ07d8b58+exZs0aBiQN+/7777Fp0ybExsaiQ4cOSElJwdSpU+Hg4MBtTQ0Gv2Kj5zZx4kTs3r0bBw8eRKtWrbRdTpOTlJSEW7duoUuXLtDT04Oenh4OHz6MlStXQk9PD+Xl5dousUmwt7dH+/btldrc3d2RnZ2tpYqarpkzZ2L27NkYNmwYPDw88N5772HatGnSj5KT5tnZ2QEA8vLylNrz8vKkaaSMAYmemRACEydOxI4dO3DgwAG4uLhou6Qmyc/PD+fOnUNKSor08Pb2RlBQEFJSUqCrq6vtEpuEXr16VbhNxaVLl+Dk5KSlipquBw8eKP0IOQDo6upCoVBoqaKmz8XFBXZ2doiPj5faCgsLkZiYCF9fXy1W1nDxKzZ6ZhMmTEBsbCx+/PFHmJqaSt9jm5ubw8jISMvVNR2mpqYVzusyNjaGlZUVz/fSoGnTpqFnz55YvHgx3n33XZw8eRJr167F2rVrtV1ak/Pmm29i0aJFeOGFF9ChQwecOXMGK1aswJgxY7RdWqNWVFSEK1euSM8zMzORkpICS0tLvPDCC5g6dSoWLlwIV1dXuLi44NNPP4WDg4N0pRupEETPCEClj/Xr12u7tCavT58+YsqUKdouo8n56aefRMeOHYWBgYFwc3MTa9eu1XZJTVJhYaGYMmWKeOGFF4ShoaFo3bq1+OSTT0RJSYm2S2vUDh48WOk+OSQkRAghhEKhEJ9++qmwtbUVBgYGws/PT6Snp2u36AaM90EiIiIiUsFzkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZEKBiQiIiIiFQxIRERERCr+cQEpKysLMpkMKSkp2i5FkpaWhh49esDQ0BBeXl7aLqfJ2LBhAywsLLRdhlbJZDLs3LnzucZoKNuxNu8TIQTGjx8PS0tL6X3et29fTJ06tV5rrSujRo2q8WchDh06BJlMhvz8/Dqt5dixY/Dw8IC+vj5/quI5aPMzqTavp5o8ePAAgYGBMDMzq5fXXX2q94A0atQoyGQyREVFKbXv3LkTMpmsvstpECIiImBsbIz09HSlHxL8J2soH8qAZkKGtuTk5OCNN97QdhkaUZv3SVxcHDZs2IDdu3cjJycHHTt2xPbt27FgwYLnWnZDeQ188cUX2LBhg/S8svDXs2dP5OTkwNzcvE5rCQ0NhZeXFzIzM5Vqamwa0r6mMdq4cSOOHj2K48eP18vrrj5p5QiSoaEhlixZgj///FMbi68TpaWlzzxvRkYGXnrpJTg5OcHKykqDVdE/nZ2dHQwMDLRdhkbU5n2SkZEBe3t79OzZE3Z2dtDT04OlpSVMTU2rHPd53rv1zdzcvMYPc7lcDjs7uzr/H86MjAy8+uqraNWq1TMHjMa07alyGRkZcHd3R8eOHevldVev6vvH30JCQsS//vUv4ebmJmbOnCm179ixQzxdTkREhPD09FSa9/PPPxdOTk5KYw0aNEgsWrRI2NjYCHNzczFv3jzx6NEjMWPGDNG8eXPRsmVL8fXXX0vzZGZmCgDiu+++E76+vsLAwEB06NBBHDp0SGlZ586dE/369RPGxsbCxsZGjBw5Uty+fVua3qdPHzFhwgQxZcoUYWVlJfr27Vvp+paXl4t58+aJli1bCrlcLjw9PcUvv/wiTYfKjwpGRERUOc6SJUtEmzZthFwuF46OjmLhwoXS9LNnz4pXXnlFGBoaCktLSzFu3Dhx//59jWyrLVu2iJdeekkYGhoKb29vkZ6eLk6ePCm6du0qjI2NRb9+/cStW7eU6l23bp1wc3MTBgYGol27diImJqbCuNu2bRN9+/YVRkZGolOnTuL48eNCiMp/cPHJdomJiRFt27YVBgYGwsbGRgQGBla6vYQQYv369cLc3Fzs2LFDmuf1118X2dnZSv127twpOnfuLAwMDISLi4uYO3euePTokRBCCCcnJ6U6nJycRH5+vtDR0RGnTp2S/jbNmzcXPj4+0pj/7//9P9GqVSvpeXZ2tnjnnXeEubm5aN68uRg4cKDIzMzU2DarCgCxY8cOtcZYv369cHR0FEZGRmLw4MFi2bJlwtzcvNbbbN68ecLe3l7cuXNH6t+/f3/Rt29fUV5eXmmdmnifhISEVPhbCVHxh32dnJzE/PnzxXvvvSdMTU1FSEiIKCkpERMmTBB2dnbCwMBAvPDCC2Lx4sVS/8rGVVXbfcuhQ4dEt27dhFwuF3Z2dmLWrFnSthNCiK1bt4qOHTtK72U/Pz9RVFQkreOgQYMqXV8AIjMzU3r//Pnnn6KgoEAYGhqKn3/+WamG7du3CxMTE1FcXCyEqN3rU3U9n348+YHqmtatqv1mTfvbmvZ/H330kXB1dRVGRkbCxcVFzJkzR5SWlkrTU1JSRN++fYWJiYkwNTUVXbp0EadOnap2X6PqypUrYuDAgcLGxkYYGxsLb29vsW/fPqU+Tk5OYtGiRWL06NHCxMREODo6ii+//FKpT2JiovDy8hIGBgaia9euYvv27QKAOHPmTKXLFUKIhw8fiunTpwsHBwfRrFkz0b17d3Hw4EFp+pN9XVxcnHBzcxPGxsYiICBA3Lx5U+pTVlYmpk2bJszNzYWlpaWYOXOmCA4Oll5PVfnhhx9E+/bthVwuF05OTmLZsmXStD59+ihtuz59+lQ5zq5du4S3t7cwMDAQVlZWYvDgwdK0e/fuiffee09YWFgIIyMj0a9fP3Hp0qVar9/evXuFgYGB+PPPP5WWOXnyZPHKK69Iz48ePSp9lrVq1UpMmjRJem8JUXHfoJWANGjQILF9+3ZhaGgorl27JoR49oBkamoqJkyYINLS0sRXX30lAIiAgACxaNEicenSJbFgwQKhr68vLefJm7tVq1bihx9+EBcvXhTvv/++MDU1lXbof/75p2jRooUICwsTqampIjk5Wbz22mtKG7pPnz7CxMREzJw5U6SlpYm0tLRK13fFihXCzMxMfPfddyItLU189NFHQl9fX/rj5+TkiA4dOojp06eLnJwcpVDztI8++kg0b95cbNiwQVy5ckUcPXpUrFu3TgghRFFRkbC3txdvvfWWOHfunIiPjxcuLi7SLzg/77Zyc3MTcXFx4uLFi6JHjx6ia9euom/fvuK3334TycnJom3btuKDDz6QlvXtt98Ke3t7sW3bNvHHH3+Ibdu2CUtLS7Fhw4YK4+7evVukp6eLt99+Wzg5OYlHjx6JkpISER0dLczMzEROTo60XU6dOiV0dXVFbGysyMrKEsnJyeKLL76o/IUmHr+p9PX1hbe3tzh+/Lg4ffq06N69u+jZs6fU58iRI8LMzExs2LBBZGRkiF9//VU4OzuLuXPnCiGEuHXrlvQBkJOTIwXBLl26iM8++0wI8Xjna2lpKeRyufT3e//990VQUJAQQojS0lLh7u4uxowZI86ePSsuXrwoRowYIdq1ayf9evnzbrOqVBaQqhvjxIkTQkdHRyxZskSkp6eLL774QlhYWCgFpJq2WVlZmfD19ZV2gKtWrRIWFhbi6tWrVdapifdJfn6+mD9/vmjVqpXS36qygGRmZiaWLVsmrly5Iq5cuSI+++wz4ejoKI4cOSKysrLE0aNHRWxsbLWvAVW12bdcv35dNGvWTPznP/8RqampYseOHcLa2lr6UL5586bQ09MTK1asEJmZmeLs2bMiJiZGWt+nA1J+fr7w9fUV48aNk94nZWVlSgFJCCHefvttMXLkSKVaAwMDpbbavD6fVlZWJnJycoSZmZmIjo4WOTk54sGDBzWu25O/hep+szb72+r2f0IIsWDBAnHs2DGRmZkpdu3aJWxtbcWSJUuk6R06dBAjR44Uqamp4tKlS+L7778XKSkpVe5rKpOSkiLWrFkjzp07Jy5duiTmzJkjDA0NlV7XTk5OwtLSUsTExIjLly+LyMhIoaOjI30+3L9/X7Ro0UKMGDFCnD9/Xvz000+idevWNQak999/X/Ts2VMcOXJEer0aGBhI748n+zp/f39x6tQpkZSUJNzd3cWIESOkMZYsWSKaN28utm3bJi5evCjGjh0rTE1Nqw1Ip0+fFjo6OmL+/PkiPT1drF+/XhgZGUmB+O7du2LcuHHC19dX5OTkiLt371Y6zu7du4Wurq4IDw8XFy9eFCkpKdL/gAghxMCBA4W7u7s4cuSISElJEQEBAaJt27ZSyK1p/crKyoStra34v//7P2lM1bYrV64IY2Nj8fnnn4tLly6JY8eOic6dO4tRo0Yp/f2e3jdoLSAJIUSPHj3EmDFjhBDPHpCcnJyU/q+0Xbt24uWXX5ael5WVCWNjY/Hdd98JIf7eiUVFRUl9Hj16JFq1aiW9oRYsWCBef/11pWVfu3ZNABDp6elCiMdv9M6dO9e4vg4ODmLRokVKbd26dRP/+c9/pOeenp5V/l+LEEIUFhYKAwMDpR3C09auXSuaN2+ulIT37NkjdHR0RG5urhDi+bbV0y+67777TgAQ8fHxUltkZKRo166d9LxNmzbSh8sTCxYsEL6+vlWOe+HCBQFApKamCiH+/j+Gp23btk2YmZmJwsLCKrfV09avXy8AiBMnTkhtqampAoBITEwUQgjh5+en9EYV4vHRH3t7e+n50yHjidDQUDFgwAAhhBDR0dFi6NChSkc92rZtK9auXSuN165dO6FQKKT5S0pKhJGRkdi7d68QQjPbrDKVBaTqxhg+fLjo37+/0hhDhw5V+lvUZptlZGQIU1NTMWvWLGFkZCQ2bdpUZY1CaOZ9IkTFfYQQlQekp//vVQghJk2aJF599VWlv9HTKnsNqKrNvuXjjz+u8FqIiYkRJiYmory8XCQlJQkAIisrq9JlPL3/rGzdhBAVAtKOHTuUjhY9Oar05LVam9dnZczNzaUPytqs25N6VfebNe1va9r/Veazzz4TXbt2lZ6bmppK/7OhqrJ9TW116NBB/Pe//5WeOzk5KYVRhUIhbGxsxOrVq4UQQnz55ZfCyspK/PXXX1Kf1atXVxuQrl69KnR1dcWNGzeU2v38/ERYWJi0DgDElStXpOkxMTHC1tZWem5vby+WLl0qPX/y2qwuII0YMUK89tprSm0zZ84U7du3l55PmTKl2iNHQgjh6+sr/Q+jqkuXLgkA4tixY1LbnTt3hJGRkfj+++9rvX5TpkwRr776qvRc9ajS2LFjxfjx45WWffToUaGjoyP9PVT3DVq9im3JkiXYuHEjUlNTn3mMDh06QEfn79WwtbWFh4eH9FxXVxdWVla4deuW0ny+vr7Sv/X09ODt7S3V8fvvv+PgwYMwMTGRHm5ubgAef9/6RNeuXautrbCwEDdv3kSvXr2U2nv16qXWOqempqKkpAR+fn5VTvf09ISxsbHSMhQKBdLT06W2Z91WnTp1UpoHgNJ8tra20jzFxcXIyMjA2LFjlbbfwoULlbad6rj29vYAUGHZT3vttdfg5OSE1q1b47333sOmTZvw4MGDKvsDj/+23bp1k567ubnBwsJC6W89f/58pVrHjRuHnJycasfu06cPfvvtN5SXl+Pw4cPo27cv+vbti0OHDuHmzZu4cuUK+vbtKy3jypUrMDU1lZZhaWmJhw8fIiMjo063WWWqGyM1NRU+Pj5K/Z9+r9R2m7Vu3RrLli3DkiVLMHDgQIwYMaLKejT1PlGHt7e30vNRo0YhJSUF7dq1w+TJk/Hrr78+89jV7VtSU1Ph6+urdJ5Gr169UFRUhOvXr8PT0xN+fn7w8PDAO++8g3Xr1j33uZr9+/eHvr4+du3aBQDYtm0bzMzM4O/vD6Dm12dt1bRuT6juN2va39a0/wOALVu2oFevXrCzs4OJiQnmzJmD7OxsaXpoaCjef/99+Pv7IyoqSq31eqKoqAgzZsyAu7s7LCwsYGJigtTUVKXlAMrvL5lMBjs7O6X3V6dOnWBoaCj1UX1/qTp37hzKy8vx4osvKm2jw4cPK61Hs2bN0KZNG+m5vb29tNyCggLk5OQovbefvDark5qaWun78vLlyygvL6923qelpKRU+/mlp6enVJuVlRXatWun9P6vbv0AICgoSNr/AsCmTZswYMAA6fy433//HRs2bFDahgEBAVAoFMjMzJTGeXqb6NV6DetA7969ERAQgLCwMIwaNUppmo6ODoQQSm2PHj2qMIa+vr7Sc5lMVmmbQqGodV1FRUV48803sWTJkgrTnnygAFAKJHXJyMhII+M867Z6us+TnZ9q25N5ioqKAADr1q2r8EGrq6tb47jV/Z1MTU2RnJyMQ4cO4ddff0V4eDjmzp2LU6dOPfNJokVFRZg3bx7eeuutCtOe3omp6t27N+7fv4/k5GQcOXIEixcvhp2dHaKiouDp6QkHBwe4urpKy+jatSs2bdpUYZwWLVrU6TarzPOOUdttduTIEejq6iIrKwtlZWXQ09Pq7kaJ6nu3S5cuyMzMxC+//IL9+/fj3Xffhb+/P3744Yd6rUtXVxf79u3D8ePH8euvv+K///0vPvnkEyQmJsLFxeWZxpTL5Xj77bcRGxuLYcOGITY2FkOHDpX+HjW9PjVNddvXtL/9448/qh0vISEBQUFBmDdvHgICAmBubo7Nmzdj+fLlUp+5c+dixIgR2LNnD3755RdERERg8+bNGDJkSK3rnjFjBvbt24dly5ahbdu2MDIywttvv13hRPPn/fxRVVRUBF1dXSQlJVXYH5iYmFS7XNXPUG3RxGdYTevXrVs3tGnTBps3b8aHH36IHTt2KF1dWVRUhH//+9+YPHlyhbFfeOEF6d9Pvz61fh+kqKgo/PTTT0hISFBqb9GiBXJzc5U2gCbvE3HixAnp32VlZUhKSoK7uzuAxzvLCxcuwNnZGW3btlV6qBOKzMzM4ODggGPHjim1Hzt2DO3bt6/1OK6urjAyMqry0mZ3d3f8/vvvKC4uVlqGjo4O2rVrV+vlaIKtrS0cHBzwxx9/VNh26uzg5XJ5pf+HoqenB39/fyxduhRnz55FVlYWDhw4UOU4ZWVlOH36tPQ8PT0d+fn5Sn/r9PT0CrW2bdtWOtqmr69foRYLCwt06tQJq1atgr6+Ptzc3NC7d2+cOXMGu3fvRp8+faS+Xbp0weXLl2FjY1NhGebm5hrbZprg7u6OxMREpban3ytA7bbZli1bsH37dhw6dAjZ2dnVXmavqffJ8zIzM8PQoUOxbt06bNmyBdu2bcO9e/cAVP4aqEp1+xZ3d3ckJCQo7deOHTsGU1NTtGrVCsDjHX+vXr0wb948nDlzBnK5HDt27Kh0WVW9T1QFBQUhLi4OFy5cwIEDBxAUFCRNq+n1WVu1WbfK1LS/rWn/d/z4cTg5OeGTTz6Bt7c3XF1dcfXq1Qr9XnzxRUybNg2//vor3nrrLaxfvx5A7bfhsWPHMGrUKAwZMgQeHh6ws7NDVlZWjfM9zd3dHWfPnsXDhw+lNtX3l6rOnTujvLwct27dqrB97OzsarVcc3Nz2NvbK723n7w2a6q3svfliy++WCGsVadTp07Vfn6VlZUp1Xb37l2kp6er/f4PCgrCpk2b8NNPP0FHRwcDBgyQpnXp0gUXL16sdL8ll8srHU/rAcnDwwNBQUFYuXKlUnvfvn1x+/ZtLF26FBkZGYiJicEvv/yiseXGxMRgx44dSEtLw4QJE/Dnn39izJgxAIAJEybg3r17GD58OE6dOoWMjAzs3bsXo0ePVuuwIgDMnDkTS5YswZYtW5Ceno7Zs2cjJSUFU6ZMqfUYhoaGmDVrFj766CN88803yMjIwIkTJ/DVV18BePyiMDQ0REhICM6fP4+DBw9i0qRJeO+996SvxOrTvHnzEBkZiZUrV+LSpUs4d+4c1q9fjxUrVtR6DGdnZxQVFSE+Ph537tzBgwcPsHv3bqxcuRIpKSm4evUqvvnmGygUimpDoL6+PiZNmoTExEQkJSVh1KhR6NGjB7p37w4ACA8PxzfffIN58+bhwoULSE1NxebNmzFnzhylWuLj45Gbm6v0dUffvn2xadMmKQxZWlrC3d0dW7ZsUQpIQUFBsLa2xqBBg3D06FFkZmbi0KFDmDx5svTVgya2mSZMnjwZcXFxWLZsGS5fvoxVq1YhLi5OqU9N2+z69ev48MMPsWTJErz00ktYv349Fi9eXO0HgSbeJ89jxYoV+O6775CWloZLly5h69atsLOzk45MVvUaqEx1+5b//Oc/uHbtGiZNmoS0tDT8+OOPiIiIQGhoKHR0dJCYmIjFixfj9OnTyM7Oxvbt23H79m0pYKlydnZGYmIisrKycOfOnSqPVPTu3Rt2dnYICgqCi4uL0pHK2rw+a6OmdatKTfvbmvZ/rq6uyM7OxubNm5GRkYGVK1cqBcq//voLEydOxKFDh3D16lUcO3YMp06dkrZpZfuayri6umL79u1ISUnB77//jhEjRqh9ZGjEiBGQyWQYN24cLl68iJ9//hnLli2rdp4XX3wRQUFBCA4Oxvbt25GZmYmTJ08iMjISe/bsqfWyp0yZgqioKOzcuRNpaWn4z3/+U+NNHadPn474+HgsWLAAly5dwsaNG7Fq1SrMmDGj1ssFHt/D7LvvvkNERARSU1Nx7tw56Yihq6srBg0ahHHjxuG3337D77//jpEjR6Jly5YYNGiQWssJCgpCcnIyFi1ahLffflvpFiezZs3C8ePHMXHiRKSkpODy5cv48ccfMXHixKoHrPbMqjqgepKhEI9PbpTL5UK1nNWrVwtHR0dhbGwsgoODxaJFiyq9zP9plZ206OTkJD7//HNpWQBEbGys6N69u5DL5aJ9+/biwIEDSvNcunRJDBkyRLrs0M3NTUydOlU6AbGy5VSmvLxczJ07V7Rs2VLo6+tXuHxZiNqdfFpeXi4WLlwonJychL6+vtJlyELU/jL/Z9lWT588qHoCqBCVn+S4adMm4eXlJeRyuWjevLno3bu32L59e5Xj/vnnnwKA0qWrH3zwgbCyspIuvT169Kjo06ePaN68uXSJ+pYtW6rcZk/q2rZtm2jdurUwMDAQ/v7+Fa6miouLEz179hRGRkbCzMxMdO/eXTrBWojHl6e2bdtW6OnpKb3+nlxY8OQETCEenygIoMJVjTk5OSI4OFhYW1sLAwMD0bp1azFu3DhRUFCg0W2mCpWcpF3TGF999ZVo1aqVMDIyEm+++Wall/lXtc0UCoXw8/MTAQEBSifrTpo0SbRp06bKK4Q09T6p7UnaT17jT6xdu1Z4eXkJY2NjYWZmJvz8/ERycrI0varXwNNqu2+p7lL4ixcvioCAANGiRQthYGAgXnzxRaWTgFXfx+np6aJHjx7CyMio0sv8n/bRRx8JACI8PLxC7bV5fapSPUm7pnUTour9Zk3725r2fzNnzhRWVlbCxMREDB06VHz++efSa7akpEQMGzZMODo6CrlcLhwcHMTEiROVTpRW3ddUJjMzU7zyyivCyMhIODo6ilWrVtXqtaX6uk1ISBCenp5CLpcLLy8vsW3bthqvYistLRXh4eHC2dlZ6OvrC3t7ezFkyBBx9uxZIUTl+2DVC58ePXokpkyZIszMzISFhYUIDQ1V6zL/J9v9ydW7T9TmJG0hHl9k82T/Zm1tLd566y1p2pPL/M3NzYWRkZEICAio9DL/6tbvie7duwsAFd53Qghx8uRJ8dprrwkTExNhbGwsOnXqpHRxiOrfTyZEA/mSkoioEcvKyoKLiwvOnDnDnwwiagK0/hUbERERUUPDgERERESkgl+xEREREangESQiIiIiFQxIRERERCoYkIiIiIhUMCARERERqWBAIiIiIlLBgERERESkggGJiIiISAUDEhEREZGK/w/14lNq7GZmewAAAABJRU5ErkJggg==", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "TAU = 7\n", - "DEFERRAL_PROBABILITY_THRESHOLD = 0.2518938553561718\n", - "NUM_SIMULATIONS = 10\n", - "OUTPUT_DIR = \"benchmark_preannotated\"\n", - "SEEDS = [1,2,3,4,5]" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.484375, Median = 3.0\n", + "Accuracy 0.642857\n", + "Precision 0.653061\n", + "Recall 0.609524\n", + "FPR 0.32381\n", + "F1 0.630542\n", + "Mean H 3.484375\n", + "Correct Adjustment 0.055952\n", + "Incorrect Adjustment 0.060714\n", + "Recovery -0.004762\n", + "Leaderboard String | MODEL_NAME | 64.3 | 65.3 | 61.0 | 63....\n", + "dtype: object\n", + "Evaluating Random Seed 5\n", + "100%|██████████| 5131/5131 [00:47<00:00, 108.92it/s]\n" + ] }, { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def context_selector(context_tuple, split):\n", - " \"\"\"\n", - " We use this generic function for both training and validation data.\n", - " In both cases, its job is to select only those contexts for which the\n", - " FUTURE context is not empty, so we have a next utterance to predict.\n", - " \"\"\"\n", - " matches_split = (context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split)\n", - " is_end = (len(context_tuple.future_context) == 0)\n", - " return matches_split and not is_end\n", - "\n", - "def make_data_selector(split):\n", - " return lambda context_tuple: context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split\n", - "\n", - "train_context_selector = partial(context_selector, split=\"train\")\n", - "val_context_selector = partial(context_selector, split=\"val\")\n", - "test_context_selector = partial(context_selector, split=\"test\")" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "==((====))== Unsloth 2026.6.9: Fast Llama patching. Transformers: 4.57.6. vLLM: 0.10.2.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.8.0+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.4.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.32.post1. FA2 = False]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", - "Unsloth: Offloading input_embeddings to disk to save VRAM\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/reef/conda-envs/lyk25-env/lib/python3.11/site-packages/peft/tuners/tuners_utils.py:1348: UserWarning: Model has `tie_word_embeddings=True` and a tied layer is part of the adapter, but `ensure_weight_tying` is not set to True. This can lead to complications, for example when merging the adapter or converting your model to formats other than safetensors. Check the discussion here: https://github.com/huggingface/peft/issues/2777\n", - " warnings.warn(msg)\n", - "Unsloth 2026.6.9 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Unsloth: Training embed_tokens in mixed precision to save VRAM\n" - ] - } - ], - "source": [ - "simulator_model = UnslothUtteranceSimulatorModel(\n", - " train_config=SIMULATOR_TRAIN_CONFIG,\n", - ")" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Horizon statistics (# of comments between first positive forecast and conversation end):\n", + "Mean = 3.605633802816901, Median = 3.0\n", + "Accuracy 0.678571\n", + "Precision 0.679426\n", + "Recall 0.67619\n", + "FPR 0.319048\n", + "F1 0.677804\n", + "Mean H 3.605634\n", + "Correct Adjustment 0.05\n", + "Incorrect Adjustment 0.070238\n", + "Recovery -0.020238\n", + "Leaderboard String | MODEL_NAME | 67.9 | 67.9 | 67.6 | 67....\n", + "dtype: object\n", + "{'Accuracy': np.float64(0.6645238095238095), 'Precision': np.float64(0.6649554573724549), 'Recall': np.float64(0.6628571428571428), 'FPR': np.float64(0.33380952380952383), 'F1': np.float64(0.6636405952685067), 'Mean H': np.float64(3.6320544396885324), 'Correct Adjustment': np.float64(0.05619047619047619), 'Incorrect Adjustment': np.float64(0.07238095238095239), 'Recovery': np.float64(-0.016190476190476193), 'Leaderboard String': ['| MODEL_NAME | 66.2 | 66.2 | 66.2 | 66.2 | 33.8 | 3.59 | -1.7 (5.0 - 6.7) |', '| MODEL_NAME | 66.7 | 66.7 | 66.4 | 66.6 | 33.1 | 3.73 | -2.1 (5.5 - 7.6) |', '| MODEL_NAME | 67.3 | 66.3 | 70.2 | 68.2 | 35.7 | 3.75 | -1.8 (7.0 - 8.8) |', '| MODEL_NAME | 64.3 | 65.3 | 61.0 | 63.1 | 32.4 | 3.48 | -0.5 (5.6 - 6.1) |', '| MODEL_NAME | 67.9 | 67.9 | 67.6 | 67.8 | 31.9 | 3.61 | -2.0 (5.0 - 7.0) |']}\n" + ] + } + ], + "source": [ + "all_results = {}\n", + "for seed in range(1,6):\n", + " print(f\"Evaluating Random Seed {seed}\")\n", + " config_dict = TransformerForecasterConfig(\n", + " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", + " context_mode=\"normal\", # set to normal by default\n", + " device=DEVICE\n", + " )\n", + " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", + "\n", + " #Load pre-tuned config\n", + " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", + " with open(tuned_config_file, 'r') as file:\n", + " tuned_config = json.load(file)\n", + "\n", + " encoder_model = TransformerEncoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", + " encoder_model.best_threshold = tuned_config['best_threshold']\n", + " encoder_forecaster = Forecaster(encoder_model, label_metadata)\n", + "\n", + " # corpus = copy.deepcopy(corpus)\n", + " corpus = encoder_forecaster.transform(corpus, transform_selector)\n", + " _, cur_metrics= encoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", + "\n", + " update_metrics(all_results, cur_metrics)\n", + "\n", + "for metric in all_results:\n", + " if metric == \"Leaderboard String\":\n", + " continue\n", + " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n", + "\n", + "print(all_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Evaluating Random Seed 1\n", - "Unsloth: If you want to finetune Gemma 2, install flash-attn to make it faster!\n", - "To install flash-attn, do the below:\n", - "\n", - "pip install --no-deps --upgrade \"flash-attn>=2.6.3\"\n", - "==((====))== Unsloth 2026.6.9: Fast Gemma2 patching. Transformers: 4.57.6. vLLM: 0.10.2.\n", - " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", - "O^O/ \\_/ \\ Torch: 2.8.0+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.4.0\n", - "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.32.post1. FA2 = False]\n", - " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", - "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "0it [00:00, ?it/s]The attention mask is not set and cannot be inferred from input because pad token is same as eos token. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n", - "AUTOTUNE bmm(16x530x256, 16x256x530)\n", - "strides: [s60*s67, s67, 1], [s60*s67, 1, s67]\n", - "dtypes: torch.bfloat16, torch.bfloat16\n", - " triton_bmm_14 0.0655 ms 100.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", - " triton_bmm_13 0.0676 ms 97.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", - " triton_bmm_5 0.0737 ms 88.9% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=16, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", - " triton_bmm_6 0.0737 ms 88.9% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", - " triton_bmm_9 0.0737 ms 88.9% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", - " triton_bmm_10 0.0748 ms 87.7% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", - " triton_bmm_18 0.0799 ms 82.1% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", - " triton_bmm_15 0.0860 ms 76.2% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=8\n", - " triton_bmm_3 0.0870 ms 75.3% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=32, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", - " bmm 0.0881 ms 74.4% \n", - "SingleProcess AUTOTUNE benchmarking takes 0.4082 seconds and 0.0098 seconds precompiling for 20 choices\n", - "AUTOTUNE bmm(16x530x530, 16x530x256)\n", - "strides: [s60**2, s60, 1], [s60*s67, s67, 1]\n", - "dtypes: torch.bfloat16, torch.bfloat16\n", - " triton_bmm_29 0.0584 ms 100.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", - " triton_bmm_35 0.0584 ms 100.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", - " triton_bmm_33 0.0594 ms 98.3% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", - " triton_bmm_28 0.0604 ms 96.6% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", - " triton_bmm_32 0.0604 ms 96.6% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", - " triton_bmm_25 0.0614 ms 95.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", - " triton_bmm_37 0.0614 ms 95.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", - " triton_bmm_34 0.0645 ms 90.5% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=8\n", - " triton_bmm_24 0.0707 ms 82.6% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=16, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", - " triton_bmm_26 0.0707 ms 82.6% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=8\n", - "SingleProcess AUTOTUNE benchmarking takes 0.3380 seconds and 0.1776 seconds precompiling for 20 choices\n", - "100%|██████████| 1/1 [00:14<00:00, 14.22s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.92s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.97s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.18s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.36s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.14s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.22s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.37s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.16s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.22s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.17s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.21s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.55s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.62s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.37s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.52s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.34s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.52s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.83s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.60s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.75s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.10s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.33s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.48s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.25s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.28s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.52s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.66s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.42s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.56s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.87s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.11s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.29s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.32s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.44s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.66s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.28s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.56s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.69s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.78s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.83s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.97s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.05s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.09s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.24s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.97s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.19s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.42s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.47s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.26s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.50s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.52s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.50s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.55s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.58s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.60s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.28s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.35s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.52s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.61s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.76s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.31s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.40s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.26s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.35s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.19s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.40s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.54s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.01s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.11s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.35s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.47s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.74s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.84s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.97s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.00s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.06s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.09s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.15s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.45s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.51s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.84s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.88s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.92s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.98s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.08s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.13s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.18s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.35s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.57s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.62s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.67s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.98s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.51s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.66s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.97s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.11s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.25s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.42s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.53s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.58s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.74s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.97s/it]\n", - "100%|██████████| 1/1 [00:15<00:00, 15.16s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.45s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.79s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.84s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.87s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.05s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.11s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.20s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.24s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.31s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.36s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.43s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.18s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.25s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.50s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.61s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.66s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.74s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.77s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.24s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.47s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.55s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.61s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.22s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.27s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.24s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.31s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.38s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.47s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.55s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.59s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.26s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.50s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.56s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.87s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.93s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.10s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.12s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.17s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.56s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.90s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.01s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.19s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.25s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.41s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.26s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.40s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.56s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.91s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.05s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.23s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.28s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.48s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.57s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.45s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.77s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.28s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.50s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.54s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.64s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.31s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.34s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.39s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.43s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.18s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.24s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.31s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.63s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.70s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.84s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.90s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.09s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.16s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.32s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.36s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.41s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.63s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.85s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.54s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.61s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.65s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.75s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.84s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.87s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.97s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.01s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.11s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.25s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.37s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.56s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.68s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.84s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.20s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.23s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.48s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.83s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.02s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.08s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.31s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.53s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.93s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.64s/it]\n", - "225it [1:00:13, 18.50s/it]Unsloth: Input IDs of shape torch.Size([10, 2175]) with length 2175 > the model's max sequence length of 2048.\n", - "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", - "100%|██████████| 1/1 [00:15<00:00, 15.41s/it]\n", - "226it [1:00:37, 20.02s/it]Unsloth: Input IDs of shape torch.Size([10, 3092]) with length 3092 > the model's max sequence length of 2048.\n", - "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", - "100%|██████████| 1/1 [00:15<00:00, 15.40s/it]\n", - "227it [1:01:04, 22.20s/it]AUTOTUNE bmm(16x4389x256, 16x256x4389)\n", - "strides: [s31*s67, s67, 1], [s31*s67, 1, s67]\n", - "dtypes: torch.bfloat16, torch.bfloat16\n", - " triton_bmm_51 3.1570 ms 100.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", - " triton_bmm_47 3.1857 ms 99.1% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", - " triton_bmm_56 3.4437 ms 91.7% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", - " triton_bmm_43 3.4898 ms 90.5% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=16, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", - " triton_bmm_52 3.5779 ms 88.2% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", - " triton_bmm_48 3.6372 ms 86.8% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", - " triton_bmm_44 4.0520 ms 77.9% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", - " bmm 4.1554 ms 76.0% \n", - " triton_bmm_53 4.2025 ms 75.1% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=8\n", - " triton_bmm_40 5.3750 ms 58.7% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=32, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", - "SingleProcess AUTOTUNE benchmarking takes 1.7333 seconds and 0.0006 seconds precompiling for 20 choices\n", - "AUTOTUNE bmm(16x4389x4389, 16x4389x256)\n", - "strides: [s31**2, s31, 1], [s31*s67, s67, 1]\n", - "dtypes: torch.bfloat16, torch.bfloat16\n", - " bmm 2.1832 ms 100.0% \n", - " triton_bmm_75 2.6081 ms 83.7% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=5, num_warps=8\n", - " triton_bmm_66 2.7197 ms 80.3% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", - " triton_bmm_70 2.8170 ms 77.5% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", - " triton_bmm_73 2.9481 ms 74.1% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=4\n", - " triton_bmm_71 2.9747 ms 73.4% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", - " triton_bmm_67 3.2102 ms 68.0% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=4, num_warps=8\n", - " triton_bmm_63 3.4335 ms 63.6% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=4\n", - " triton_bmm_72 3.4365 ms 63.5% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=32, BLOCK_M=128, BLOCK_N=128, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=2, num_warps=8\n", - " triton_bmm_64 3.6792 ms 59.3% ACC_TYPE='tl.float32', ALLOW_TF32=False, BLOCK_K=64, BLOCK_M=64, BLOCK_N=64, EVEN_K=False, GROUP_M=8, USE_FAST_ACCUM=False, num_stages=3, num_warps=8\n", - "SingleProcess AUTOTUNE benchmarking takes 2.2529 seconds and 0.0011 seconds precompiling for 20 choices\n", - "Unsloth: Input IDs of shape torch.Size([10, 4044]) with length 4044 > the model's max sequence length of 2048.\n", - "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", - "100%|██████████| 1/1 [00:15<00:00, 15.38s/it]\n", - "228it [1:01:47, 28.28s/it]Unsloth: Input IDs of shape torch.Size([10, 4221]) with length 4221 > the model's max sequence length of 2048.\n", - "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", - "100%|██████████| 1/1 [00:15<00:00, 15.39s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.87s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.01s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.18s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.27s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.43s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.67s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.85s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.29s/it]\n", - "100%|██████████| 1/1 [00:15<00:00, 15.09s/it]\n", - "238it [1:04:59, 19.85s/it]Unsloth: Input IDs of shape torch.Size([10, 2259]) with length 2259 > the model's max sequence length of 2048.\n", - "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", - "100%|██████████| 1/1 [00:15<00:00, 15.40s/it]\n", - "239it [1:05:23, 21.05s/it]Unsloth: Input IDs of shape torch.Size([10, 2880]) with length 2880 > the model's max sequence length of 2048.\n", - "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", - "100%|██████████| 1/1 [00:15<00:00, 15.40s/it]\n", - "240it [1:05:49, 22.65s/it]Unsloth: Input IDs of shape torch.Size([10, 3299]) with length 3299 > the model's max sequence length of 2048.\n", - "We shall truncate it ourselves. It's imperative if you correct this issue first.\n", - "100%|██████████| 1/1 [00:15<00:00, 15.40s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.83s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.97s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.33s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.61s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.76s/it]\n", - "100%|██████████| 1/1 [00:13<00:00, 13.96s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.07s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.14s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.37s/it]\n", - "100%|██████████| 1/1 [00:14<00:00, 14.41s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.27s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.33s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.34s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.44s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.55s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.65s/it]\n", - "100%|██████████| 1/1 [00:12<00:00, 12.84s/it]" - ] - } - ], - "source": [ - "from convokit.decisionpolicy import DeferralDecisionPolicy\n", - "\n", - "all_results = {}\n", - "for seed in range(1,6):\n", - " print(f\"Evaluating Random Seed {seed}\")\n", - " config_dict = TransformerForecasterConfig(\n", - " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", - " context_mode=\"normal\", # set to normal by default\n", - " device=DEVICE\n", - " )\n", - " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", - "\n", - " #Load pre-tuned config\n", - " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", - " with open(tuned_config_file, 'r') as file:\n", - " tuned_config = json.load(file)\n", - "\n", - " decoder_model = TransformerDecoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", - " decoder_model.decision_policy = DeferralDecisionPolicy(\n", - " simulator=simulator_model,\n", - " threshold=tuned_config['best_threshold'],\n", - " tau=TAU,\n", - " )\n", - " decoder_model.best_threshold = tuned_config['best_threshold']\n", - " decoder_forecaster = Forecaster(decoder_model, label_metadata)\n", - "\n", - " # corpus = copy.deepcopy(corpus)\n", - " corpus = decoder_forecaster.transform(corpus, transform_selector)\n", - " _, cur_metrics= decoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", - "\n", - " update_metrics(all_results, cur_metrics)\n", - "\n", - "for metric in all_results:\n", - " if metric == \"Leaderboard String\":\n", - " continue\n", - " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"Accuracy\": 0.6645238095238095,\n", + " \"Precision\": 0.6649554573724549,\n", + " \"Recall\": 0.6628571428571428,\n", + " \"FPR\": 0.33380952380952383,\n", + " \"F1\": 0.6636405952685067,\n", + " \"Mean H\": 3.6320544396885324,\n", + " \"Correct Adjustment\": 0.05619047619047619,\n", + " \"Incorrect Adjustment\": 0.07238095238095239,\n", + " \"Recovery\": -0.016190476190476193,\n", + " \"Leaderboard String\": \"| BERT-base | 66.5 | 66.5 | 66.3 | 66.4 | 33.4 | 3.63 | -1.6 (5.6 - 7.2) |\"\n", + "}\n" + ] + } + ], + "source": [ + "leaderboard_string = (f\"| BERT-base | \"\n", + " f\"{all_results['Accuracy']*100:.1f} | \"\n", + " f\"{all_results['Precision']*100:.1f} | \"\n", + " f\"{all_results['Recall']*100:.1f} | \"\n", + " f\"{all_results['F1']*100:.1f} | \"\n", + " f\"{all_results['FPR']*100:.1f} | \"\n", + " f\"{all_results['Mean H']:.2f} | \"\n", + " f\"{(all_results['Correct Adjustment']-all_results['Incorrect Adjustment'])*100:.1f} \"\n", + " f\"({all_results['Correct Adjustment']*100:.1f} - {all_results['Incorrect Adjustment']*100:.1f}) |\")\n", + "all_results['Leaderboard String'] = leaderboard_string\n", + "print(json.dumps(all_results, indent=4))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Transformer Decoder-based Forecaster" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "name": "stdout", + "output_type": "stream", + "text": [ + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/README.md\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/adapter_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/adapter_model.safetensors\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/optimizer.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/rng_state.pth\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/scheduler.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/special_tokens_map.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/tokenizer.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/tokenizer_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/trainer_state.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/checkpoint-736/training_args.bin\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/dev_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-1/test_result.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/README.md\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/adapter_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/adapter_model.safetensors\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/optimizer.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/rng_state.pth\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/scheduler.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/special_tokens_map.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/tokenizer.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/tokenizer_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/trainer_state.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/checkpoint-736/training_args.bin\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/dev_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-2/test_result.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/README.md\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/adapter_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/adapter_model.safetensors\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/optimizer.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/rng_state.pth\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/scheduler.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/special_tokens_map.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/tokenizer.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/tokenizer_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/trainer_state.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/checkpoint-736/training_args.bin\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/dev_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-3/test_result.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/README.md\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/adapter_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/adapter_model.safetensors\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/optimizer.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/rng_state.pth\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/scheduler.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/special_tokens_map.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/tokenizer.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/tokenizer_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/trainer_state.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/checkpoint-736/training_args.bin\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/dev_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-4/test_result.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/README.md\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/adapter_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/adapter_model.safetensors\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/optimizer.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/rng_state.pth\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/scheduler.pt\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/special_tokens_map.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/tokenizer.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/tokenizer_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/trainer_state.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/checkpoint-736/training_args.bin\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/dev_config.json\n", + "skipped existing: YOUR_MODEL_DIRECTORY/cga-cmv-large/google/gemma-2-9b-it/seed-5/test_result.json\n" + ] } - ], - "metadata": { - "kernelspec": { - "display_name": "lyk25-env", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.11" + ], + "source": [ + "MODEL = \"google/gemma-2-9b-it\"\n", + "BASE_URL = f\"https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/{corpus_name}/{MODEL}/\"\n", + "DOWNLOAD_DIR = f\"{YOUR_MODEL_DIRECTORY}/{corpus_name}/{MODEL}\"\n", + "\n", + "os.makedirs(DOWNLOAD_DIR, exist_ok=True)\n", + "download_recursive(BASE_URL, DOWNLOAD_DIR)\n", + "forecasting_models_path = DOWNLOAD_DIR" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# This cell takes around 80 mins on a single NVIDIA RTX A6000\n", + "all_results = {}\n", + "for seed in range(1,6):\n", + " print(f\"Evaluating Random Seed {seed}\")\n", + " config_dict = TransformerForecasterConfig(\n", + " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", + " context_mode=\"normal\", # set to normal by default\n", + " device=DEVICE\n", + " )\n", + " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", + "\n", + " #Load pre-tuned config\n", + " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", + " with open(tuned_config_file, 'r') as file:\n", + " tuned_config = json.load(file)\n", + "\n", + " decoder_model = TransformerDecoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", + " decoder_model.best_threshold = tuned_config['best_threshold']\n", + " decoder_model.decision_policy.reuse_cached_forecast_probs = False\n", + " decoder_forecaster = Forecaster(decoder_model, label_metadata)\n", + "\n", + " corpus = decoder_forecaster.transform(corpus, transform_selector)\n", + " _, cur_metrics= decoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", + "\n", + " update_metrics(all_results, cur_metrics)\n", + "\n", + "for metric in all_results:\n", + " if metric == \"Leaderboard String\":\n", + " continue\n", + " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "leaderboard_string = (f\"| Gemma2-9B | \"\n", + " f\"{all_results['Accuracy']*100:.1f} | \"\n", + " f\"{all_results['Precision']*100:.1f} | \"\n", + " f\"{all_results['Recall']*100:.1f} | \"\n", + " f\"{all_results['F1']*100:.1f} | \"\n", + " f\"{all_results['FPR']*100:.1f} | \"\n", + " f\"{all_results['Mean H']:.2f} | \"\n", + " f\"{(all_results['Correct Adjustment']-all_results['Incorrect Adjustment'])*100:.1f} \"\n", + " f\"({all_results['Correct Adjustment']*100:.1f} - {all_results['Incorrect Adjustment']*100:.1f}) |\")\n", + "all_results['Leaderboard String'] = leaderboard_string\n", + "print(json.dumps(all_results, indent=4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## With DeferralDecisionPolicy\n", + "\n", + "We can also try attaching a DeferralDecisionPolicy to the same model." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "SIMULATOR_TRAIN_CONFIG = {\n", + " \"per_device_train_batch_size\": 16,\n", + " \"per_device_eval_batch_size\": 16,\n", + " \"eval_strategy\": \"steps\",\n", + " \"save_strategy\": \"steps\",\n", + " \"save_steps\": 30,\n", + " \"gradient_accumulation_steps\": 4,\n", + " \"warmup_steps\": 5,\n", + " \"num_train_epochs\": 1,\n", + " \"eval_steps\": 30,\n", + " \"learning_rate\": 2e-4,\n", + " \"logging_steps\": 5,\n", + " \"optim\": \"adamw_8bit\",\n", + " \"weight_decay\": 0.01,\n", + " \"lr_scheduler_type\": \"linear\",\n", + " \"output_dir\": \"outputs/simulator_finetune\",\n", + " \"logging_dir\": \"logs\",\n", + " \"load_best_model_at_end\": True,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "TAU = 7\n", + "DEFERRAL_PROBABILITY_THRESHOLD = 0.2518938553561718\n", + "NUM_SIMULATIONS = 10\n", + "OUTPUT_DIR = \"benchmark_preannotated\"\n", + "SEEDS = [1,2,3,4,5]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def context_selector(context_tuple, split):\n", + " \"\"\"\n", + " We use this generic function for both training and validation data.\n", + " In both cases, its job is to select only those contexts for which the\n", + " FUTURE context is not empty, so we have a next utterance to predict.\n", + " \"\"\"\n", + " matches_split = (context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split)\n", + " is_end = (len(context_tuple.future_context) == 0)\n", + " return matches_split and not is_end\n", + "\n", + "def make_data_selector(split):\n", + " return lambda context_tuple: context_tuple.current_utterance.get_conversation().meta.get(\"split\") == split\n", + "\n", + "train_context_selector = partial(context_selector, split=\"train\")\n", + "val_context_selector = partial(context_selector, split=\"val\")\n", + "test_context_selector = partial(context_selector, split=\"test\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==((====))== Unsloth 2026.6.9: Fast Llama patching. Transformers: 4.57.6. vLLM: 0.10.2.\n", + " \\\\ /| NVIDIA RTX A6000. Num GPUs = 1. Max memory: 47.536 GB. Platform: Linux.\n", + "O^O/ \\_/ \\ Torch: 2.8.0+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.4.0\n", + "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.32.post1. FA2 = False]\n", + " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", + "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n", + "Unsloth: Offloading input_embeddings to disk to save VRAM\n", + "/reef/conda-envs/lyk25-env/lib/python3.11/site-packages/peft/tuners/tuners_utils.py:1348: UserWarning: Model has `tie_word_embeddings=True` and a tied layer is part of the adapter, but `ensure_weight_tying` is not set to True. This can lead to complications, for example when merging the adapter or converting your model to formats other than safetensors. Check the discussion here: https://github.com/huggingface/peft/issues/2777\n", + " warnings.warn(msg)\n", + "Unsloth 2026.6.9 patched 32 layers with 32 QKV layers, 32 O layers and 32 MLP layers.\n", + "Unsloth: Training embed_tokens in mixed precision to save VRAM\n" + ] } + ], + "source": [ + "simulator_model = UnslothUtteranceSimulatorModel(\n", + " train_config=SIMULATOR_TRAIN_CONFIG,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from convokit.decisionpolicy import DeferralDecisionPolicy\n", + "\n", + "all_results = {}\n", + "for seed in range(1,6):\n", + " print(f\"Evaluating Random Seed {seed}\")\n", + " config_dict = TransformerForecasterConfig(\n", + " output_dir=f\"{YOUR_SAVING_DIRECTORY}/{corpus_name}/{MODEL}/seed{seed}\",\n", + " context_mode=\"normal\", # set to normal by default\n", + " device=DEVICE\n", + " )\n", + " saved_model_path = os.path.join(forecasting_models_path, f'seed-{seed}')\n", + "\n", + " #Load pre-tuned config\n", + " tuned_config_file = os.path.join(saved_model_path, \"dev_config.json\")\n", + " with open(tuned_config_file, 'r') as file:\n", + " tuned_config = json.load(file)\n", + "\n", + " decoder_model = TransformerDecoderModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", + " decoder_model.decision_policy = DeferralDecisionPolicy(\n", + " simulator=simulator_model,\n", + " threshold=tuned_config['best_threshold'],\n", + " tau=TAU,\n", + " )\n", + " decoder_model.decision_policy.reuse_cached_forecast_probs = False\n", + " decoder_model.best_threshold = tuned_config['best_threshold']\n", + " decoder_forecaster = Forecaster(decoder_model, label_metadata)\n", + "\n", + " # corpus = copy.deepcopy(corpus)\n", + " corpus = decoder_forecaster.transform(corpus, transform_selector)\n", + " _, cur_metrics= decoder_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")\n", + "\n", + " update_metrics(all_results, cur_metrics)\n", + "\n", + "for metric in all_results:\n", + " if metric == \"Leaderboard String\":\n", + " continue\n", + " all_results[metric] = sum(all_results[metric]) / len(all_results[metric])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 2 + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 } From 82f2605c8c0a89dea9bc441607fc99c65cd2c5fb Mon Sep 17 00:00:00 2001 From: laerdon Date: Sun, 28 Jun 2026 04:15:25 +0000 Subject: [PATCH 20/21] bug fix forecaster demo --- .../Run Transformer Fine-tuned Models.ipynb | 49 ++++++++++--------- 1 file changed, 26 insertions(+), 23 deletions(-) diff --git a/examples/forecaster/Run Transformer Fine-tuned Models.ipynb b/examples/forecaster/Run Transformer Fine-tuned Models.ipynb index 4f4e9c415..4cdb10ffd 100644 --- a/examples/forecaster/Run Transformer Fine-tuned Models.ipynb +++ b/examples/forecaster/Run Transformer Fine-tuned Models.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -26,26 +26,29 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-06-27 20:18:39.864582: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", - "2026-06-27 20:18:39.887405: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "/reef/lyk25/ConvoKit/dist/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "E0000 00:00:1782591519.912052 859600 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "E0000 00:00:1782591519.919822 859600 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "W0000 00:00:1782591519.938735 859600 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1782591519.938755 859600 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1782591519.938757 859600 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1782591519.938760 859600 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "2026-06-27 20:18:39.944875: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + "I0000 00:00:1782619476.409075 1013993 port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "I0000 00:00:1782619476.481779 1013993 cpu_feature_guard.cc:227] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1782619477.990444 1013993 port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "INFO 06-27 20:18:48 [__init__.py:216] Automatically detected platform cuda.\n", "🦥 Unsloth Zoo will now patch everything to make training faster!\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Unable to import `torchao` Tensor objects. This may affect loading checkpoints serialized with `torchao`\n" + ] } ], "source": [ @@ -78,16 +81,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# CPU mode (noting that it will be slower)\n", "DEVICE = \"cuda\"\n", "\n", - "corpus_name = \"cga-wikiconv\"\n", + "# corpus_name = \"cga-wikiconv\"\n", "# corpus_name = \"cga-cmv-legacy\"\n", - "# corpus_name = \"cga-cmv-large\"\n", + "corpus_name = \"cga-cmv-large\"\n", "label_metadata = \"has_removed_comment\" if 'cmv' in corpus_name else 'conversation_has_personal_attack'\n", "\n", "YOUR_MODEL_DIRECTORY = \"YOUR_MODEL_DIRECTORY\"\n", @@ -96,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -125,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -223,11 +226,11 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "def transform_selector(context_tuple, corpus_name):\n", + "def transform_selector(context_tuple):\n", " \"\"\"\n", " For transform we only need to check that the conversation is in the test split\n", " \"\"\"\n", @@ -238,7 +241,7 @@ " matches_split = (context_tuple.current_utterance.get_conversation().meta[\"split\"] == \"test\")\n", " is_end = (len(context_tuple.context) == convo_length)\n", "\n", - " if corpus_name.contains(\"cmv\"):\n", + " if \"cmv\" in corpus_name:\n", " return (matches_split)\n", " else:\n", " return (matches_split and not is_end)\n", @@ -505,7 +508,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -813,7 +816,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -827,7 +830,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.11" + "version": "3.12.4" } }, "nbformat": 4, From c9d3cd5e8fbee923b45d097ff55085f291a75c7d Mon Sep 17 00:00:00 2001 From: laerdon Date: Wed, 1 Jul 2026 00:35:08 +0000 Subject: [PATCH 21/21] Forecaster docs bugfix --- docs/source/forecaster.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/forecaster.rst b/docs/source/forecaster.rst index 6072d0f45..ba5b71ef3 100644 --- a/docs/source/forecaster.rst +++ b/docs/source/forecaster.rst @@ -73,9 +73,9 @@ Unless otherwise specified, the performance is reported using the ThresholdDecis +=====================+===================================+=======+======+=======+=======+======+==========+=========================+ | Gemma2 9B | ThresholdDecisionPolicy | 71.0 | 69.1 | 76.1 | 72.3 | 34.2 | 3.9 | +1.8 (8.4 - 6.6) | +---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Gemma2 9B | DeferralDecisionPolicy | 70.9 | 72.0 | 68.4 | 70.1 | 26.7 | 3.8 | -0.1 (7.0 - 7.1) | +| Gemma2 9B | DeferralDecisionPolicy | 70.9 | 72.1 | 68.4 | 70.2 | 26.7 | 3.8 | -0.1 (7.0 - 7.1) | +---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ -| Gemma2 9B | SimulationAverageDecisionPolicy | 70.2 | 68.1 | 76.6 | 72.0 | 36.1 | 4.0 | -1.2 (9.3 - 10.5) | +| Gemma2 9B | SimulationAverageDecisionPolicy | 70.2 | 68.1 | 76.6 | 72.0 | 36.2 | 4.0 | -1.2 (9.3 - 10.5) | +---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+ | Mistral 7B | ThresholdDecisionPolicy | 70.7 | 68.8 | 76.0 | 72.1 | 34.6 | 4.0 | +2.9 (8.1 - 5.2) | +---------------------+-----------------------------------+-------+------+-------+-------+------+----------+-------------------------+