diff --git a/convokit/coordination/coordination.py b/convokit/coordination/coordination.py index 1d524479..a181dc35 100644 --- a/convokit/coordination/coordination.py +++ b/convokit/coordination/coordination.py @@ -486,9 +486,10 @@ def _scores_over_utterances( target = utt1.speaker if speaker == target: continue - speaker, target = Coordination._annot_speaker( - speaker, utt2, split_by_attribs - ), Coordination._annot_speaker(target, utt1, split_by_attribs) + speaker, target = ( + Coordination._annot_speaker(speaker, utt2, split_by_attribs), + Coordination._annot_speaker(target, utt1, split_by_attribs), + ) speaker_filter = speaker_utterance_selector(utt2, utt1) target_filter = target_utterance_selector(utt2, utt1) diff --git a/convokit/forecaster/BERTCGAModel.py b/convokit/forecaster/BERTCGAModel.py new file mode 100644 index 00000000..1142f348 --- /dev/null +++ b/convokit/forecaster/BERTCGAModel.py @@ -0,0 +1,252 @@ +import os +import torch +import torch.nn.functional as F +import pandas as pd +import numpy as np +import json +from tqdm import tqdm +from sklearn.metrics import roc_curve +from datasets import Dataset, DatasetDict +from transformers import ( + AutoConfig, + AutoModelForSequenceClassification, + AutoTokenizer, + TrainingArguments, + Trainer, +) +from .forecasterModel import ForecasterModel +import shutil + + +os.environ["TOKENIZERS_PARALLELISM"] = "false" +DEFAULT_CONFIG = { + "output_dir": "BERTCGAModel", + "per_device_batch_size": 4, + "num_train_epochs": 2, + "learning_rate": 6.7e-6, + "random_seed": 1, + "device": "cuda", +} + + +class BERTCGAModel(ForecasterModel): + """ + Wrapper for Huggingface Transformers AutoModel + """ + + def __init__(self, model_name_or_path, config=DEFAULT_CONFIG): + super().__init__() + try: + self.tokenizer = AutoTokenizer.from_pretrained( + model_name_or_path, + model_max_length=512, + truncation_side="left", + padding_side="right", + ) + except: + # The checkpoint didn't save tokenizer + model_config_file = os.path.join(model_name_or_path, "config.json") + with open(model_config_file, "r") as file: + original_model = json.load(file)["_name_or_path"] + self.tokenizer = AutoTokenizer.from_pretrained( + original_model, model_max_length=512, truncation_side="left", padding_side="right" + ) + self.best_threshold = None + model_config = AutoConfig.from_pretrained( + model_name_or_path, num_labels=2, problem_type="single_label_classification" + ) + self.model = AutoModelForSequenceClassification.from_pretrained( + model_name_or_path, ignore_mismatched_sizes=True, config=model_config + ).to(config["device"]) + if not os.path.exists(config["output_dir"]): + os.makedirs(config["output_dir"]) + self.config = config + return + + def _tokenize(self, context): + tokenized_context = self.tokenizer.encode_plus( + text=f" {self.tokenizer.sep_token} ".join([u.text for u in context]), + add_special_tokens=True, + padding="max_length", + truncation=True, + max_length=512, + ) + return tokenized_context + + def _context_to_bert_data(self, contexts): + pairs = {"id": [], "input_ids": [], "attention_mask": [], "labels": []} + for context in contexts: + convo = context.current_utterance.get_conversation() + label = self.labeler(convo) + + if ("context_mode" not in self.config) or self.config["context_mode"] == "normal": + context_utts = context.context + elif self.config["context_mode"] == "no-context": + context_utts = [context.current_utterance] + tokenized_context = self._tokenize(context_utts) + pairs["input_ids"].append(tokenized_context["input_ids"]) + pairs["attention_mask"].append(tokenized_context["attention_mask"]) + pairs["labels"].append(label) + pairs["id"].append(context.current_utterance.id) + return Dataset.from_dict(pairs) + + @torch.inference_mode + @torch.no_grad + def _predict( + self, + dataset, + model=None, + threshold=0.5, + forecast_prob_attribute_name=None, + forecast_attribute_name=None, + ): + """ + Return predictions in DataFrame + """ + if not forecast_prob_attribute_name: + forecast_prob_attribute_name = "score" + if not forecast_attribute_name: + forecast_attribute_name = "pred" + if not model: + model = self.model.to(self.config["device"]) + utt_ids = [] + preds = [] + scores = [] + for data in tqdm(dataset): + input_ids = ( + data["input_ids"].to(self.config["device"], dtype=torch.long).reshape([1, -1]) + ) + attention_mask = ( + data["attention_mask"].to(self.config["device"], dtype=torch.long).reshape([1, -1]) + ) + outputs = model(input_ids=input_ids, attention_mask=attention_mask) + probs = F.softmax(outputs.logits, dim=-1) + utt_ids.append(data["id"]) + raw_score = probs[0, 1].item() + preds.append(int(raw_score > threshold)) + scores.append(raw_score) + + return pd.DataFrame( + {forecast_attribute_name: preds, forecast_prob_attribute_name: scores}, index=utt_ids + ) + + def _tune_best_val_accuracy(self, val_dataset, val_contexts): + """ + Save the tuned model to self.best_threshold and self.model + """ + checkpoints = os.listdir(self.config["output_dir"]) + best_val_accuracy = 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._predict(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} + count_correct = 0 + for utt_id in val_scores.index: + count_correct += 1 + convo_id = utt2convo[utt_id] + utt_score = val_scores.loc[utt_id].score + 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._predict(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) + return + + def fit(self, contexts, val_contexts): + """ + Description: Train the conversational forecasting model on the given data + Parameters: + contexts: an iterator over context tuples, as defined by the above data format + val_contexts: an optional second iterator over context tuples to be used as a separate held-out validation set. + The generator for this must be the same as test generator + """ + 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.set_format("torch") + + training_args = TrainingArguments( + output_dir=self.config["output_dir"], + per_device_train_batch_size=self.config["per_device_batch_size"], + num_train_epochs=self.config["num_train_epochs"], + learning_rate=self.config["learning_rate"], + logging_strategy="epoch", + weight_decay=0.01, + eval_strategy="no", + save_strategy="epoch", + prediction_loss_only=False, + seed=self.config["random_seed"], + ) + trainer = Trainer(model=self.model, args=training_args, train_dataset=dataset["train"]) + trainer.train() + + self._tune_best_val_accuracy(dataset["val_for_tuning"], val_contexts) + return + + def transform(self, contexts, forecast_attribute_name, forecast_prob_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, + ) + + 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/README.md b/convokit/forecaster/README.md new file mode 100644 index 00000000..8f85d0f1 --- /dev/null +++ b/convokit/forecaster/README.md @@ -0,0 +1,13 @@ +**Table 1: Forecasting derailment on \newcmv 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 adjustment rates. The best performance across each metric is indicated in **bold**. +| Model | Acc ↑ | P ↑ | R ↑ | F1 ↑ | FPR ↓ | Mean H ↑ | Recovery ↑ (CA/N - IA/N) | +|--------------------------------|--------|-------|-------|-------|--------|---------|-------------------------| +| Human (84 convos) round-1 | 62.2 | 67.8 | 48.9 | 54.6 | 24.4 | 3.64 | - | +| Human (84 convos) round-2 | 70.0 | 75.9 | 55.6 | 63.9 | 15.6 | 3.13 | - | +| RoBERTa-large | **68.4** | 67.5 | 71.1 | 69.2 | 34.3 | 4.14 | +1.1 (7.2 - 6.1) | +| Gemma-2 27B-IT (finetuned) | **68.4** | 66.2 | 75.2 | **70.4** | 38.5 | 4.30 | +0.0 (10.7 - 10.7) | +| GPT-4o (12/2024; zero-shot) | 66.6 | **71.0** | 56.3 | 62.8 | **23.0** | 3.78 | -1.5 (5.9 - 7.4) | +| BERT-base | 65.2 | 63.5 | 72.0 | 67.4 | 41.6 | 4.45 | +2.1 (9.8 - 7.7) | +| CRAFT | 62.8 | 59.4 | 81.1 | 68.5 | 55.5 | 4.69 | +4.9 (12.0 - 7.1) | +| Gemma-2 27B-IT (zero-shot) | 59.4 | 55.7 | **92.2** | 69.4 | 73.5 | **5.27** | **+7.1** (12.2 - 5.1) | + diff --git a/convokit/forecaster/__init__.py b/convokit/forecaster/__init__.py index 5bfd23d7..d0bcaced 100644 --- a/convokit/forecaster/__init__.py +++ b/convokit/forecaster/__init__.py @@ -5,4 +5,5 @@ if "torch" in sys.modules: from .CRAFTModel import * + from .BERTCGAModel import * from .CRAFT import * diff --git a/convokit/forecaster/forecaster.py b/convokit/forecaster/forecaster.py index 346c0110..c3c259ac 100644 --- a/convokit/forecaster/forecaster.py +++ b/convokit/forecaster/forecaster.py @@ -216,6 +216,7 @@ def summarize( "label": [], "score": [], "forecast": [], + "last_utterance_forecast": [], } for convo in corpus.iter_conversations(): if selector(convo): @@ -237,6 +238,7 @@ def summarize( ) conversational_forecasts_df["score"].append(np.max(forecast_scores)) conversational_forecasts_df["forecast"].append(np.max(forecasts)) + conversational_forecasts_df["last_utterance_forecast"].append(forecasts[-1]) conversational_forecasts_df = pd.DataFrame(conversational_forecasts_df).set_index( "conversation_id" ) @@ -260,21 +262,53 @@ def summarize( (conversational_forecasts_df["label"] == 1) & (conversational_forecasts_df["forecast"] == 0) ).sum() + # Correct Adjustments + ca = ( + (conversational_forecasts_df["label"] == 0) + & (conversational_forecasts_df["forecast"] == 1) + & (conversational_forecasts_df["last_utterance_forecast"] == 0) + ).mean() + # Incorrect Adjustments + ia = ( + (conversational_forecasts_df["label"] == 1) + & (conversational_forecasts_df["forecast"] == 1) + & (conversational_forecasts_df["last_utterance_forecast"] == 0) + ).mean() + p = tp / (tp + fp) r = tp / (tp + fn) fpr = fp / (fp + tn) f1 = 2 / (((tp + fp) / tp) + ((tp + fn) / tp)) - metrics = {"Accuracy": acc, "Precision": p, "Recall": r, "FPR": fpr, "F1": f1} - - print(pd.Series(metrics)) comments_until_end = self._draw_horizon_plot(corpus, selector) comments_until_end_vals = list(comments_until_end.values()) + mean_h = np.mean(comments_until_end_vals) - 1 print( "Horizon statistics (# of comments between first positive forecast and conversation end):" ) - print( - f"Mean = {np.mean(comments_until_end_vals)}, Median = {np.median(comments_until_end_vals)}" - ) + print(f"Mean = {mean_h}, Median = {np.median(comments_until_end_vals) - 1}") + leaderboard_string = ( + f"| MODEL_NAME | " + f"{acc*100:.1f} | " + f"{p*100:.1f} | " + f"{r*100:.1f} | " + f"{f1*100:.1f} | " + f"{fpr*100:.1f} | " + f"{mean_h:.2f} | " + f"{(ca-ia)*100:.1f} ({ca*100:.1f} - {ia*100:.1f}) |" + ) + metrics = { + "Accuracy": acc, + "Precision": p, + "Recall": r, + "FPR": fpr, + "F1": f1, + "Mean H": mean_h, + "Correct Adjustment": ca, + "Incorrect Adjustment": ia, + "Recovery": ca - ia, + "Leaderboard String": leaderboard_string, + } + print(pd.Series(metrics)) return conversational_forecasts_df, metrics diff --git a/download_config.json b/download_config.json index 5afa7cba..4c8f38f4 100644 --- a/download_config.json +++ b/download_config.json @@ -124,6 +124,12 @@ "https://zissou.infosci.cornell.edu/convokit/models/craft_cmv/craft_full.tar", "https://zissou.infosci.cornell.edu/convokit/models/craft_cmv/index2word.json", "https://zissou.infosci.cornell.edu/convokit/models/craft_cmv/word2index.json" - ] + ], + "cga-cmv-large/roberta-large": ["https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/cga-cmv-large/roberta-large.tar"], + "cga-cmv-large/bert-base-cased": ["https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/cga-cmv-large/bert-base-cased.tar"], + "cga-cmv-legacy/roberta-large": ["https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/cga-cmv-legacy/roberta-large.tar"], + "cga-cmv-legacy/bert-base-cased": ["https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/cga-cmv-legacy/bert-base-cased.tar"], + "cga-wikiconv/roberta-large": ["https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/cga-wikiconv/roberta-large.tar"], + "cga-wikiconv/bert-base-cased": ["https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/cga-wikiconv/bert-base-cased.tar"] } } diff --git a/examples/forecaster/BERTCGA Forecaster demo.ipynb b/examples/forecaster/BERTCGA Forecaster demo.ipynb new file mode 100644 index 00000000..b5df54d6 --- /dev/null +++ b/examples/forecaster/BERTCGA Forecaster demo.ipynb @@ -0,0 +1,605 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a76caad0-a440-43cf-bfcd-af0ad6d68042", + "metadata": {}, + "source": [ + "# ConvoKit Forecaster framework: BERTCGA demo\n", + "\n", + "The `Forecaster` class provides a generic interface to *conversational forecasting models*, a class of models designed to computationally capture the trajectory of conversations in order to predict future events. Though individual conversational forecasting models can get quite complex, the `Forecaster` API abstracts away the implementation details into a standard fit-transform interface. To demonstrate the power of this framework, this notebook walks through an example of fine-tuning the `BERTCGA` (including all BERT-styled models: `BERT`, `RoBERTa`, `SpanBERT`, `DeBERTa`, ...) conversational forecasting model on the CGA-CMV corpus. You will see how the `Forecaster` API allows us to load the data, select training, validation, and testing samples, train the BERTCGA model, and perform evaluation - replicating the original paper's full pipeline (minus pre-training, which is considered outside the scope of ConvoKit) all in only a few lines of code!\n", + "\n", + "Let's start by importing the necessary ConvoKit classes and functions, and loading the CGA-CMV corpus." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "326d6337-43c1-48c4-90de-d907b5fa32b6", + "metadata": {}, + "outputs": [], + "source": [ + "from convokit import download, Corpus, Forecaster, BERTCGAModel\n", + "from functools import partial\n", + "import json, os" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3c530c49-80d9-455d-a062-cb31a7514d85", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset already exists at /home/sqt2/CALMpaper/ConvoKit/examples/forecaster/YOUR_DATA_DIRECTORY/conversations-gone-awry-cmv-corpus\n" + ] + } + ], + "source": [ + "corpus = Corpus(filename=download(\"conversations-gone-awry-cmv-corpus\", data_dir=\"YOUR_DATA_DIRECTORY\"))" + ] + }, + { + "cell_type": "markdown", + "id": "a4d27b1a-3d1f-4039-b10f-21b6dd230c10", + "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. \n", + "\n", + "But in practice, we often want to be pickier about what we mean by \"context\". At a basic level, we might want to select only specific contexts during training versus during evaluation. The simplest version of this is the desire to split the conversations by training and testing splits, but more specifically, we might also want to select only certain contexts within a conversation. This is necessary for BERTCGA training, which works by taking only the chronologically last context (i.e., all utterances up to and not including the toxic comment, or up to the end of the conversation) as a labeled training instance. This is where selectors come in! A selector is a user-provided function that takes in a context and returns a boolean representing whether or not that context should be used. You can provide separate selectors for `fit` and `transform`, and `fit` also takes in a second selector that you can use to define validation data.\n", + "\n", + "Here we show how to implement the necessary selectors for BERTCGA." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6bfdb2b9-757a-4a44-89dc-a6e3b6249ac8", + "metadata": {}, + "outputs": [], + "source": [ + "def generic_fit_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 empty. This is in accordance with how CRAFT Model was\n", + " originally trained on CGA-CMV, taking the last context from each\n", + " conversation (\"last\" defined as being up to and including the chronologically\n", + " last utterance as recorded in the corpus)\n", + " \"\"\"\n", + " matches_split = (context_tuple.current_utterance.get_conversation().meta[\"split\"] == split)\n", + " is_end = (len(context_tuple.future_context) == 0)\n", + " return (matches_split and is_end)\n", + "\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", + " return (context_tuple.current_utterance.get_conversation().meta[\"split\"] == \"test\")" + ] + }, + { + "cell_type": "markdown", + "id": "9614aff5-843e-4b3b-b03f-6f57f8e76b8a", + "metadata": {}, + "source": [ + "## Initialize the Forecaster and BERTCGAModel backend\n", + "\n", + "Now the rest of the process is pretty straightforward! We simply need to:\n", + "1. Initialize a backend `ForecasterModel` for the `Forecaster` to use, in this case we choose ConvoKit's implementation of BERTCGA.\n", + "2. Initialize a `Forecaster` instance to wrap that `ForecasterModel` in a generic fit-transform API" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9ee62d7f", + "metadata": {}, + "outputs": [], + "source": [ + "# CPU mode (noting that it will be slower)\n", + "DEVICE = \"cuda\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "653febf7-ef59-4e8b-8ce2-39b4a33c3747", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-cased and are newly initialized: ['classifier.bias', 'classifier.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 = 'bert-base-cased'\n", + "# roberta-large can also be used with this class\n", + "config_dict = {\n", + " \"output_dir\": \"YOUR_SAVING_DIRECTORY\", \n", + " \"per_device_batch_size\": 4, \n", + " \"num_train_epochs\": 4, \n", + " \"learning_rate\": 6.7e-6,\n", + " \"random_seed\": 1,\n", + " \"device\": DEVICE\n", + "}\n", + "bert_model = BERTCGAModel(model_name_or_path, config=config_dict)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c971ec31-964b-4df0-a7bb-d064ae62c5a3", + "metadata": {}, + "outputs": [], + "source": [ + "bert_forecaster = Forecaster(bert_model, \"has_removed_comment\")" + ] + }, + { + "cell_type": "markdown", + "id": "b840f526-dafd-4022-b5a1-90adecbd1591", + "metadata": {}, + "source": [ + "## Fine-tune the model using Forecaster.fit\n", + "\n", + "And now, just like any other ConvoKit Transformer, model training is done simply by calling `fit` (note how we pass in the selectors we previously defined!)..." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8590e7b3-f633-4844-baea-18bee961eebd", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "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" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [4108/4108 07:19, 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
10270.669800
20540.615500
30810.560400
41080.512400

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1368/1368 [00:12<00:00, 110.08it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: checkpoint-1027 0.6461988304093568\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1368/1368 [00:12<00:00, 110.04it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: checkpoint-2054 0.6659356725146199\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1368/1368 [00:12<00:00, 109.91it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: checkpoint-3081 0.6732456140350878\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1368/1368 [00:12<00:00, 107.93it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: checkpoint-4108 0.6769005847953217\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1368/1368 [00:12<00:00, 108.49it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Deleting: YOUR_SAVING_DIRECTORY/checkpoint-1027\n", + "Deleting: YOUR_SAVING_DIRECTORY/checkpoint-2054\n", + "Deleting: YOUR_SAVING_DIRECTORY/checkpoint-3081\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bert_forecaster.fit(corpus, \n", + " partial(generic_fit_selector, split=\"train\"), \n", + " val_context_selector=partial(generic_fit_selector, split=\"val\"))" + ] + }, + { + "cell_type": "markdown", + "id": "3238e632-4e1b-4ba1-938a-b9aeef07f0cf", + "metadata": {}, + "source": [ + "## Run the fitted model on the test set and perform evaluation\n", + "\n", + "...and inference is done simply by calling `transform`! (again, note the selector)" + ] + }, + { + "cell_type": "markdown", + "id": "2d5e34ca", + "metadata": {}, + "source": [ + "### Normal Model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b1a978a8", + "metadata": {}, + "outputs": [], + "source": [ + "config_dict = {\n", + " \"output_dir\": \"YOUR_SAVING_DIRECTORY\", \n", + " \"per_device_batch_size\": 4, \n", + " \"num_train_epochs\": 4, \n", + " \"learning_rate\": 6.7e-6,\n", + " \"random_seed\": 1,\n", + " \"context_mode\": \"normal\", # set to normal by default\n", + " \"device\": DEVICE\n", + "}\n", + "config_file = os.path.join(\"YOUR_SAVING_DIRECTORY\", \"dev_config.json\")\n", + "with open(config_file, 'r') as file:\n", + " model_config = json.load(file)\n", + "normal_bert = BERTCGAModel(os.path.join(\"YOUR_SAVING_DIRECTORY\", model_config['best_checkpoint']), config=config_dict)\n", + "normal_bert.best_threshold = model_config['best_threshold']\n", + "normal_bert_forecaster = Forecaster(normal_bert, \"has_removed_comment\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4d3e4892-f6ef-4b6f-a9e4-d318f8cb96b9", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 8466/8466 [01:17<00:00, 108.85it/s]\n" + ] + } + ], + "source": [ + "corpus = normal_bert_forecaster.transform(corpus, transform_selector)" + ] + }, + { + "cell_type": "markdown", + "id": "9f517cfb-3a1d-4279-bf09-96695938d30c", + "metadata": {}, + "source": [ + "Finally, to get a human-readable interpretation of model performance, we can use `summarize` to generate a table of standard performance metrics. It also returns a table of conversation-level predictions in case you want to do more complex analysis!" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c7fa3d49-39c1-4dd4-9f8e-ca31f421ac5a", + "metadata": {}, + "outputs": [ + { + "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.8336380255941496, Median = 3.0\n", + "Accuracy 0.614035\n", + "Precision 0.583156\n", + "Recall 0.799708\n", + "FPR 0.571637\n", + "F1 0.674476\n", + "Mean H 3.833638\n", + "Correct Adjustment 0.120614\n", + "Incorrect Adjustment 0.075292\n", + "Recovery 0.045322\n", + "Leaderboard String | MODEL_NAME | 61.4 | 58.3 | 80.0 | 67....\n", + "dtype: object\n" + ] + }, + { + "data": { + "text/plain": [ + "( label score forecast last_utterance_forecast\n", + " conversation_id \n", + " cus26gy 1 0.880532 1.0 1.0\n", + " cus37h0 1 0.953645 1.0 1.0\n", + " cus142u 0 0.932500 1.0 1.0\n", + " cus19ml 0 0.921860 1.0 0.0\n", + " cusxft0 1 0.166532 0.0 0.0\n", + " ... ... ... ... ...\n", + " e8qli0i 0 0.185570 0.0 0.0\n", + " e8qm4aj 0 0.093030 0.0 0.0\n", + " e8ql8ii 0 0.852890 1.0 1.0\n", + " e8qzjei 1 0.952173 1.0 1.0\n", + " e8r00ko 0 0.884986 1.0 0.0\n", + " \n", + " [1368 rows x 4 columns],\n", + " {'Accuracy': 0.6140350877192983,\n", + " 'Precision': 0.5831556503198294,\n", + " 'Recall': 0.7997076023391813,\n", + " 'FPR': 0.5716374269005848,\n", + " 'F1': 0.6744759556103577,\n", + " 'Mean H': 3.8336380255941496,\n", + " 'Correct Adjustment': 0.1206140350877193,\n", + " 'Incorrect Adjustment': 0.07529239766081872,\n", + " 'Recovery': 0.04532163742690058,\n", + " 'Leaderboard String': '| MODEL_NAME | 61.4 | 58.3 | 80.0 | 67.4 | 57.2 | 3.83 | 4.5 (12.1 - 7.5) |'})" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "normal_bert_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")" + ] + }, + { + "cell_type": "markdown", + "id": "1abddbd9", + "metadata": {}, + "source": [ + "### No-Context Model" + ] + }, + { + "cell_type": "markdown", + "id": "e7c72044", + "metadata": {}, + "source": [ + "Capturing conversational context and dynamics is a critical aspect of conversational forecast models. To evaluate whether a model possesses this capability, we introduce the No-Context Setting, where models are deprived of access to conversational history. Specifically, instead of providing the full context, we feed only the most recent utterance at each timestamp, removing any contextual information about prior interactions." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cb7a6c82", + "metadata": {}, + "outputs": [], + "source": [ + "config_dict = {\n", + " \"output_dir\": \"YOUR_SAVING_DIRECTORY/no-context\", \n", + " \"per_device_batch_size\": 4, \n", + " \"num_train_epochs\": 4, \n", + " \"learning_rate\": 6.7e-6,\n", + " \"random_seed\": 1,\n", + " \"context_mode\": \"no-context\", # set to normal by default\n", + " \"device\": DEVICE\n", + "}\n", + "config_file = os.path.join(\"YOUR_SAVING_DIRECTORY\", \"dev_config.json\")\n", + "with open(config_file, 'r') as file:\n", + " model_config = json.load(file)\n", + "nocontext_bert = BERTCGAModel(os.path.join(\"YOUR_SAVING_DIRECTORY\", model_config['best_checkpoint']), config=config_dict)\n", + "nocontext_bert.best_threshold = model_config['best_threshold']\n", + "nocontext_bert_forecaster = Forecaster(nocontext_bert, \"has_removed_comment\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2bd36200", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 8466/8466 [01:18<00:00, 107.36it/s]\n" + ] + } + ], + "source": [ + "corpus = nocontext_bert_forecaster.transform(corpus, transform_selector)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b5a938e7", + "metadata": {}, + "outputs": [ + { + "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 = 4.0287539936102235, Median = 3.0\n", + "Accuracy 0.600146\n", + "Precision 0.561435\n", + "Recall 0.915205\n", + "FPR 0.714912\n", + "F1 0.695942\n", + "Mean H 4.028754\n", + "Correct Adjustment 0.207602\n", + "Incorrect Adjustment 0.164474\n", + "Recovery 0.043129\n", + "Leaderboard String | MODEL_NAME | 60.0 | 56.1 | 91.5 | 69....\n", + "dtype: object\n" + ] + }, + { + "data": { + "text/plain": [ + "( label score forecast last_utterance_forecast\n", + " conversation_id \n", + " cus26gy 1 0.948133 1.0 0.0\n", + " cus37h0 1 0.940318 1.0 1.0\n", + " cus142u 0 0.894471 1.0 0.0\n", + " cus19ml 0 0.921860 1.0 0.0\n", + " cusxft0 1 0.220547 0.0 0.0\n", + " ... ... ... ... ...\n", + " e8qli0i 0 0.185570 0.0 0.0\n", + " e8qm4aj 0 0.471338 1.0 1.0\n", + " e8ql8ii 0 0.864208 1.0 0.0\n", + " e8qzjei 1 0.951614 1.0 1.0\n", + " e8r00ko 0 0.920416 1.0 0.0\n", + " \n", + " [1368 rows x 4 columns],\n", + " {'Accuracy': 0.6001461988304093,\n", + " 'Precision': 0.5614349775784754,\n", + " 'Recall': 0.9152046783625731,\n", + " 'FPR': 0.7149122807017544,\n", + " 'F1': 0.6959421901056142,\n", + " 'Mean H': 4.0287539936102235,\n", + " 'Correct Adjustment': 0.20760233918128654,\n", + " 'Incorrect Adjustment': 0.16447368421052633,\n", + " 'Recovery': 0.04312865497076021,\n", + " 'Leaderboard String': '| MODEL_NAME | 60.0 | 56.1 | 91.5 | 69.6 | 71.5 | 4.03 | 4.3 (20.8 - 16.4) |'})" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nocontext_bert_forecaster.summarize(corpus, lambda c: c.meta['split'] == \"test\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/forecaster/Forecasting Models.ipynb b/examples/forecaster/Forecasting Models.ipynb new file mode 100644 index 00000000..3f685451 --- /dev/null +++ b/examples/forecaster/Forecasting Models.ipynb @@ -0,0 +1,690 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook is for reproducing all results reported in paper \"Every Comment, Every Conversation, All at Once: Evaluating Conversational Forecasting Models\".\n", + "The results include:\n", + "1. Performance of CRAFT models\n", + "2. Performance of BERT-base and RoBERTa-large models\n", + "3. Performance of zero-shot Gemma-2 and GPT-4o\n", + "4. Performance of fine-tuned Gemma-2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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" + ] + }, + { + "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, Corpus, Forecaster, BERTCGAModel\n", + "import tarfile\n", + "import json, os, shutil" + ] + }, + { + "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_DATA_DIRECTORY = \"YOUR_DATA_DIRECTORY\"\n", + "YOUR_SAVING_DIRECTORY = \"YOUR_SAVING_DIRECTORY\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading conversations-gone-awry-corpus to /reef/sqt2/DevTest-newConvokit/YOUR_DATA_DIRECTORY/conversations-gone-awry-corpus\n", + "Downloading conversations-gone-awry-corpus from http://zissou.infosci.cornell.edu/convokit/datasets/conversations-gone-awry-corpus/conversations-gone-awry-corpus.zip (45.2MB)... " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done\n" + ] + } + ], + "source": [ + "if corpus_name == \"cga-wikiconv\":\n", + " corpus = Corpus(filename=download(\"conversations-gone-awry-corpus\", data_dir=YOUR_DATA_DIRECTORY))\n", + "elif corpus_name == \"cga-cmv-legacy\":\n", + " corpus = Corpus(filename=download(\"conversations-gone-awry-cmv-corpus\", data_dir=YOUR_DATA_DIRECTORY))\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": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading cga-wikiconv/bert-base-cased to /reef/sqt2/DevTest-newConvokit/YOUR_MODEL_DIRECTORY/tar_files/cga-wikiconv/bert-base-cased\n", + "Downloading cga-wikiconv/bert-base-cased/bert-base-cased.tar from https://zissou.infosci.cornell.edu/convokit/models/forecaster_models/cga-wikiconv/bert-base-cased.tar (11460.7MB)... " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done\n" + ] + } + ], + "source": [ + "model = \"bert-base-cased\"\n", + "# model = \"roberta-large\"\n", + "tarfile_path = download(f\"{corpus_name}/{model}\", data_dir=f\"{YOUR_MODEL_DIRECTORY}/tar_files\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/reef/sqt2/DevTest-newConvokit/YOUR_MODEL_DIRECTORY/forecasting_models/cga-wikiconv/bert-base-cased'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "with tarfile.open(f\"{tarfile_path}/{model}.tar\", 'r') as tar:\n", + " tar.extractall()\n", + "forecasting_models_path = f\"{YOUR_MODEL_DIRECTORY}/forecasting_models/{corpus_name}/{model}\"\n", + "shutil.move(f\"{model}\", forecasting_models_path)" + ] + }, + { + "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": 9, + "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)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "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": [ + "# BERT and RoBERTa Forecaster" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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, 107.60it/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.5488215488215484, Median = 3.0\n", + "Accuracy 0.683333\n", + "Precision 0.675\n", + "Recall 0.707143\n", + "FPR 0.340476\n", + "F1 0.690698\n", + "Mean H 3.548822\n", + "Correct Adjustment 0.036905\n", + "Incorrect Adjustment 0.053571\n", + "Recovery -0.016667\n", + "Leaderboard String | MODEL_NAME | 68.3 | 67.5 | 70.7 | 69....\n", + "dtype: object\n", + "Evaluating Random Seed 2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:46<00:00, 109.17it/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.5134099616858236, Median = 3.0\n", + "Accuracy 0.666667\n", + "Precision 0.683246\n", + "Recall 0.621429\n", + "FPR 0.288095\n", + "F1 0.650873\n", + "Mean H 3.51341\n", + "Correct Adjustment 0.05\n", + "Incorrect Adjustment 0.066667\n", + "Recovery -0.016667\n", + "Leaderboard String | MODEL_NAME | 66.7 | 68.3 | 62.1 | 65....\n", + "dtype: object\n", + "Evaluating Random Seed 3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:47<00:00, 108.96it/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.609427609427609, Median = 3.0\n", + "Accuracy 0.679762\n", + "Precision 0.670429\n", + "Recall 0.707143\n", + "FPR 0.347619\n", + "F1 0.688297\n", + "Mean H 3.609428\n", + "Correct Adjustment 0.041667\n", + "Incorrect Adjustment 0.060714\n", + "Recovery -0.019048\n", + "Leaderboard String | MODEL_NAME | 68.0 | 67.0 | 70.7 | 68....\n", + "dtype: object\n", + "Evaluating Random Seed 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:46<00:00, 109.29it/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.5428571428571427, Median = 3.0\n", + "Accuracy 0.65\n", + "Precision 0.673077\n", + "Recall 0.583333\n", + "FPR 0.283333\n", + "F1 0.625\n", + "Mean H 3.542857\n", + "Correct Adjustment 0.05\n", + "Incorrect Adjustment 0.066667\n", + "Recovery -0.016667\n", + "Leaderboard String | MODEL_NAME | 65.0 | 67.3 | 58.3 | 62....\n", + "dtype: object\n", + "Evaluating Random Seed 5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:47<00:00, 108.61it/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.517605633802817, Median = 3.0\n", + "Accuracy 0.665476\n", + "Precision 0.662005\n", + "Recall 0.67619\n", + "FPR 0.345238\n", + "F1 0.669022\n", + "Mean H 3.517606\n", + "Correct Adjustment 0.067857\n", + "Incorrect Adjustment 0.07619\n", + "Recovery -0.008333\n", + "Leaderboard String | MODEL_NAME | 66.5 | 66.2 | 67.6 | 66....\n", + "dtype: object\n", + "Evaluating Random Seed 6\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:46<00:00, 109.30it/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.6198630136986303, Median = 3.0\n", + "Accuracy 0.679762\n", + "Precision 0.674365\n", + "Recall 0.695238\n", + "FPR 0.335714\n", + "F1 0.684642\n", + "Mean H 3.619863\n", + "Correct Adjustment 0.055952\n", + "Incorrect Adjustment 0.069048\n", + "Recovery -0.013095\n", + "Leaderboard String | MODEL_NAME | 68.0 | 67.4 | 69.5 | 68....\n", + "dtype: object\n", + "Evaluating Random Seed 7\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:47<00:00, 108.73it/s]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAGwCAYAAABSN5pGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAVNpJREFUeJzt3XlcVPX+P/DXsMyArAKyKYILiQuCiSJaSkFhenOtXEhwSW9dVzBTy0StBE3NvHI1/Zba72qS1yWXoojcUtxAXAGVRFxYXAIEE5X5/P7wwck5gDI6cBBfz8djHjGf85nPeZ/jzJlXZ86iEkIIEBEREZHESOkCiIiIiOoaBiQiIiIiGQYkIiIiIhkGJCIiIiIZBiQiIiIiGQYkIiIiIhkGJCIiIiIZE6ULeFpptVpcuXIFVlZWUKlUSpdDRERE1SCEwM2bN+Hq6gojo6r3EzEgPaYrV67Azc1N6TKIiIjoMVy8eBFNmjSpcjoD0mOysrICcH8FW1tbK1wNERERVUdRURHc3Nyk7/GqMCA9pvKf1aytrRmQiIiInjKPOjyGB2kTERERyTAgEREREckwIBERERHJMCARERERyTAgEREREckwIBERERHJMCARERERyTAgEREREckwIBERERHJKB6QYmNj4eHhATMzM/j7++PQoUNV9j116hQGDhwIDw8PqFQqLF68uEKf8mnyx9ixY6U+gYGBFaa/++67NbF4RERE9BRSNCDFxcUhMjISUVFRSElJgY+PD0JCQpCfn19p/1u3bqF58+aIiYmBs7NzpX0OHz6MnJwc6ZGQkAAAePPNN3X6jR49Wqff/PnzDbtwRERE9NRSNCAtWrQIo0ePxogRI9CmTRssX74cDRo0wDfffFNp/06dOuHzzz/H4MGDodFoKu3TqFEjODs7S4/t27ejRYsW6NGjh06/Bg0a6PTj/dSIiIionGIB6c6dO0hOTkZwcPDfxRgZITg4GElJSQabx3//+1+MHDmywk3p1q5dCwcHB7Rr1w7Tp0/HrVu3HjpWaWkpioqKdB5ERERUP5koNeNr166hrKwMTk5OOu1OTk5IT083yDy2bNmCgoICDB8+XKd96NChcHd3h6urK44fP46pU6ciIyMDmzZtqnKs6OhozJ492yB1ERERUd2mWECqDV9//TVee+01uLq66rSPGTNG+tvb2xsuLi4ICgpCZmYmWrRoUelY06dPR2RkpPS8qKgIbm5uNVM4ERERKUqxgOTg4ABjY2Pk5eXptOfl5VV5ALY+Lly4gF9//fWhe4XK+fv7AwDOnTtXZUDSaDRVHvdE9Y/HtB2Kzj8rprei8ycietYpdgySWq1Gx44dkZiYKLVptVokJiYiICDgicdftWoVHB0d0bv3o79oUlNTAQAuLi5PPF8iIiJ6+in6E1tkZCTCw8Ph5+eHzp07Y/HixSgpKcGIESMAAGFhYWjcuDGio6MB3D/o+vTp09Lfly9fRmpqKiwtLdGyZUtpXK1Wi1WrViE8PBwmJrqLmJmZiXXr1qFXr16wt7fH8ePHERERge7du6N9+/a1tORERERUlykakAYNGoSrV69i5syZyM3Nha+vL+Lj46UDt7Ozs2Fk9PdOritXrqBDhw7S8wULFmDBggXo0aMHdu3aJbX/+uuvyM7OxsiRIyvMU61W49dff5XCmJubGwYOHIgZM2bU3IISERHRU0UlhBBKF/E0Kioqgo2NDQoLC3kNpXqIxyAREdVP1f3+VvxWI0RERER1DQMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZGMidIFEFXGY9oOpUt4ptWF9Z8V01vpEojoGcY9SEREREQyDEhEREREMgxIRERERDIMSEREREQyDEhEREREMjyLjagOqgtnkRERPcu4B4mIiIhIhgGJiIiISIYBiYiIiEiGAYmIiIhIhgGJiIiISIYBiYiIiEhG8YAUGxsLDw8PmJmZwd/fH4cOHaqy76lTpzBw4EB4eHhApVJh8eLFFfrMmjULKpVK5+Hl5aXT5/bt2xg7dizs7e1haWmJgQMHIi8vz9CLRkRERE8pRQNSXFwcIiMjERUVhZSUFPj4+CAkJAT5+fmV9r916xaaN2+OmJgYODs7Vzlu27ZtkZOTIz1+//13nekRERHYtm0bNmzYgN27d+PKlSsYMGCAQZeNiIiInl6KXihy0aJFGD16NEaMGAEAWL58OXbs2IFvvvkG06ZNq9C/U6dO6NSpEwBUOr2ciYlJlQGqsLAQX3/9NdatW4eXX34ZALBq1Sq0bt0aBw4cQJcuXSp9XWlpKUpLS6XnRUVF1VtIIiIieuootgfpzp07SE5ORnBw8N/FGBkhODgYSUlJTzT22bNn4erqiubNmyM0NBTZ2dnStOTkZNy9e1dnvl5eXmjatOlD5xsdHQ0bGxvp4ebm9kQ1EhERUd2lWEC6du0aysrK4OTkpNPu5OSE3Nzcxx7X398fq1evRnx8PJYtW4bz58/jxRdfxM2bNwEAubm5UKvVsLW11Wu+06dPR2FhofS4ePHiY9dIREREdVu9uxfba6+9Jv3dvn17+Pv7w93dHd9//z1GjRr12ONqNBpoNBpDlEhERER1nGIBycHBAcbGxhXOHsvLy3voAdj6srW1xXPPPYdz584BAJydnXHnzh0UFBTo7EUy9HyfdrxZKhERPcsU+4lNrVajY8eOSExMlNq0Wi0SExMREBBgsPkUFxcjMzMTLi4uAICOHTvC1NRUZ74ZGRnIzs426HyJiIjo6aXoT2yRkZEIDw+Hn58fOnfujMWLF6OkpEQ6qy0sLAyNGzdGdHQ0gPsHdp8+fVr6+/Lly0hNTYWlpSVatmwJAHj//ffx+uuvw93dHVeuXEFUVBSMjY0xZMgQAICNjQ1GjRqFyMhI2NnZwdraGuPHj0dAQECVZ7ARERHRs0XRgDRo0CBcvXoVM2fORG5uLnx9fREfHy8duJ2dnQ0jo793cl25cgUdOnSQni9YsAALFixAjx49sGvXLgDApUuXMGTIEFy/fh2NGjXCCy+8gAMHDqBRo0bS67744gsYGRlh4MCBKC0tRUhICP7zn//UzkITERFRnacSQgili3gaFRUVwcbGBoWFhbC2tla6HIPjMUiktKyY3kqXQET1UHW/vxW/1QgRERFRXcOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJKN3QFqzZg127NghPf/ggw9ga2uLrl274sKFCwYtjoiIiEgJegekuXPnwtzcHACQlJSE2NhYzJ8/Hw4ODoiIiDB4gURERES1zUTfF1y8eBEtW7YEAGzZsgUDBw7EmDFj0K1bNwQGBhq6PiIiIqJap/ceJEtLS1y/fh0A8Msvv+CVV14BAJiZmeGvv/4ybHVERERECtB7D9Irr7yCd955Bx06dMCZM2fQq1cvAMCpU6fg4eFh6PqIiIiIap3ee5BiY2MREBCAq1evYuPGjbC3twcAJCcnY8iQIQYvkIiIiKi26b0HydbWFkuXLq3QPnv2bIMURERERKQ0vQMSABQUFODQoUPIz8+HVquV2lUqFYYNG2aw4oiIiIiUoPdPbNu2bUPTpk3Rs2dPjBs3DhMnTtR56Cs2NhYeHh4wMzODv78/Dh06VGXfU6dOYeDAgfDw8IBKpcLixYsr9ImOjkanTp1gZWUFR0dH9OvXDxkZGTp9AgMDoVKpdB7vvvuu3rUTERFR/aR3QJo8eTJGjhyJ4uJiFBQU4M8//5QeN27c0GusuLg4REZGIioqCikpKfDx8UFISAjy8/Mr7X/r1i00b94cMTExcHZ2rrTP7t27MXbsWBw4cAAJCQm4e/cuXn31VZSUlOj0Gz16NHJycqTH/Pnz9aqdiIiI6i+9f2K7fPkyJkyYgAYNGjzxzBctWoTRo0djxIgRAIDly5djx44d+OabbzBt2rQK/Tt16oROnToBQKXTASA+Pl7n+erVq+Ho6Ijk5GR0795dam/QoEGVIYuIiIiebXrvQQoJCcGRI0eeeMZ37txBcnIygoOD/y7GyAjBwcFISkp64vHLFRYWAgDs7Ox02teuXQsHBwe0a9cO06dPx61btx46TmlpKYqKinQeREREVD/pvQepd+/emDJlCk6fPg1vb2+YmprqTO/Tp0+1xrl27RrKysrg5OSk0+7k5IT09HR9y6qUVqvFpEmT0K1bN7Rr105qHzp0KNzd3eHq6orjx49j6tSpyMjIwKZNm6ocKzo6mmfqERERPSP0DkijR48GAMyZM6fCNJVKhbKysievykDGjh2LkydP4vfff9dpHzNmjPS3t7c3XFxcEBQUhMzMTLRo0aLSsaZPn47IyEjpeVFREdzc3GqmcCIiIlKU3gHpwdP6n4SDgwOMjY2Rl5en056Xl2eQY4PGjRuH7du3Y8+ePWjSpMlD+/r7+wMAzp07V2VA0mg00Gg0T1wXERER1X16H4NkKGq1Gh07dkRiYqLUptVqkZiYiICAgMceVwiBcePGYfPmzfjtt9/QrFmzR74mNTUVAODi4vLY8yUiIqL647EuFLl7924sWLAAaWlpAIA2bdpgypQpePHFF/UaJzIyEuHh4fDz80Pnzp2xePFilJSUSGe1hYWFoXHjxoiOjgZw/8Du06dPS39fvnwZqampsLS0RMuWLQHc/1lt3bp1+OGHH2BlZYXc3FwAgI2NDczNzZGZmYl169ahV69esLe3x/HjxxEREYHu3bujffv2j7M6iIiIqJ7Rew/Sf//7XwQHB6NBgwaYMGECJkyYAHNzcwQFBWHdunV6jTVo0CAsWLAAM2fOhK+vL1JTUxEfHy8duJ2dnY2cnByp/5UrV9ChQwd06NABOTk5WLBgATp06IB33nlH6rNs2TIUFhYiMDAQLi4u0iMuLg7A/T1Xv/76K1599VV4eXlh8uTJGDhwILZt26bvqiAiIqJ6SiWEEPq8oHXr1hgzZgwiIiJ02hctWoSVK1dKe5Xqu6KiItjY2KCwsBDW1tZKl2NwHtN2KF0CPeOyYnorXQIR1UPV/f7Wew/SH3/8gddff71Ce58+fXD+/Hl9hyMiIiKqc/QOSG5ubjoHVpf79ddfedo7ERER1Qt6H6Q9efJkTJgwAampqejatSsAYN++fVi9ejW+/PJLgxdIREREVNv0DkjvvfcenJ2dsXDhQnz//fcA7h+XFBcXh759+xq8QCIiIqLa9lin+ffv3x/9+/c3dC1EREREdYJiF4okIiIiqquqtQfJzs4OZ86cgYODAxo2bAiVSlVl3xs3bhisOCIiIiIlVCsgffHFF7CyspL+flhAIiIiInraVSsghYeHS38PHz68pmohIiIiqhP0PgbJ2NgY+fn5FdqvX78OY2NjgxRFREREpCS9A1JVdyYpLS2FWq1+4oKIiIiIlFbt0/yXLFkCAFCpVPi///s/WFpaStPKysqwZ88eeHl5Gb5CIiIiolpW7YD0xRdfALi/B2n58uU6P6ep1Wp4eHhg+fLlhq+QiIiIqJZVOyCV34j2pZdewqZNm9CwYcMaK4qIiIhISXpfSXvnzp01UQcRERFRnfFYtxq5dOkStm7diuzsbNy5c0dn2qJFiwxSGBEREZFS9A5IiYmJ6NOnD5o3b4709HS0a9cOWVlZEELg+eefr4kaiYiIiGqV3qf5T58+He+//z5OnDgBMzMzbNy4ERcvXkSPHj3w5ptv1kSNRERERLVK74CUlpaGsLAwAICJiQn++usvWFpaYs6cOZg3b57BCyQiIiKqbXoHJAsLC+m4IxcXF2RmZkrTrl27ZrjKiIiIiBSi9zFIXbp0we+//47WrVujV69emDx5Mk6cOIFNmzahS5cuNVEjERERUa3SOyAtWrQIxcXFAIDZs2ejuLgYcXFx8PT05BlsREREVC/oHZCaN28u/W1hYcGrZxMREVG9o/cxSBcvXsSlS5ek54cOHcKkSZOwYsUKgxZGREREpBS9A9LQoUOlq2nn5uYiODgYhw4dwkcffYQ5c+YYvEAiIiKi2qZ3QDp58iQ6d+4MAPj+++/h7e2N/fv3Y+3atVi9erWh6yMiIiKqdXoHpLt370Kj0QAAfv31V/Tp0wcA4OXlhZycHMNWR0RERKQAvQNS27ZtsXz5cuzduxcJCQno2bMnAODKlSuwt7c3eIFEREREtU3vgDRv3jx89dVXCAwMxJAhQ+Dj4wMA2Lp1q/TTGxEREdHTTO/T/AMDA3Ht2jUUFRWhYcOGUvuYMWPQoEEDgxZHREREpAS99yABgBACycnJ+Oqrr3Dz5k0AgFqtZkAiIiKiekHvPUgXLlxAz549kZ2djdLSUrzyyiuwsrLCvHnzUFpaygtHEhER0VNP7z1IEydOhJ+fH/7880+Ym5tL7f3790diYqJBiyMiIiJSgt57kPbu3Yv9+/dDrVbrtHt4eODy5csGK4yIiIhIKXrvQdJqtSgrK6vQfunSJVhZWRmkKCIiIiIl6R2QXn31VSxevFh6rlKpUFxcjKioKPTq1cuQtREREREpQu+f2BYuXIiQkBC0adMGt2/fxtChQ3H27Fk4ODjgu+++q4kaiYiIiGqV3gGpSZMmOHbsGNavX4/jx4+juLgYo0aNQmhoqM5B20RERERPK70D0u3bt2FmZoa33367JuohIiIiUpzexyA5OjoiPDwcCQkJ0Gq1NVETERERkaL0Dkhr1qzBrVu30LdvXzRu3BiTJk3CkSNHHruA2NhYeHh4wMzMDP7+/jh06FCVfU+dOoWBAwfCw8MDKpVK52Bxfca8ffs2xo4dC3t7e1haWmLgwIHIy8t77GUgIiKi+kXvgNS/f39s2LABeXl5mDt3Lk6fPo0uXbrgueeew5w5c/QaKy4uDpGRkYiKikJKSgp8fHwQEhKC/Pz8SvvfunULzZs3R0xMDJydnR97zIiICGzbtg0bNmzA7t27ceXKFQwYMECv2omIiKj+UgkhxJMOcvr0aYSGhuL48eOVXiOpKv7+/ujUqROWLl0K4P41ltzc3DB+/HhMmzbtoa/18PDApEmTMGnSJL3GLCwsRKNGjbBu3Tq88cYbAID09HS0bt0aSUlJ6NKlS6XzKy0tRWlpqfS8qKgIbm5uKCwshLW1dbWX+WnhMW2H0iXQMy4rprfSJRBRPVRUVAQbG5tHfn8/1s1qgfs/U33//ffo168fnn/+edy4cQNTpkyp9uvv3LmD5ORkBAcH/12MkRGCg4ORlJT0WDVVZ8zk5GTcvXtXp4+XlxeaNm360PlGR0fDxsZGeri5uT1WjURERFT36R2Qfv75Z4SHh8PJyQnvvfcenJyc8Msvv+DChQuIiYmp9jjXrl1DWVkZnJycdNqdnJyQm5urb1nVHjM3NxdqtRq2trZ6zXf69OkoLCyUHhcvXnysGomIiKju0/s0//79++Mf//gHvv32W/Tq1QumpqY1UVedo9FooNFolC6DiIiIaoHeASkvL88g91xzcHCAsbFxhbPH8vLyqjwA2xBjOjs7486dOygoKNDZi/Qk8yUiIqL6Re+f2KysrKDVanHmzBn8/vvv2LNnj86jutRqNTp27IjExESpTavVIjExEQEBAfqWVe0xO3bsCFNTU50+GRkZyM7Ofuz5EhERUf2i9x6kAwcOYOjQobhw4QLkJ8CpVCq9zmKLjIxEeHg4/Pz80LlzZyxevBglJSUYMWIEACAsLAyNGzdGdHQ0gPsHYZ8+fVr6+/Lly0hNTYWlpSVatmxZrTFtbGwwatQoREZGws7ODtbW1hg/fjwCAgKqPIONiIiIni16B6R3330Xfn5+2LFjB1xcXKBSqR575oMGDcLVq1cxc+ZM5ObmwtfXF/Hx8dJB1tnZ2TAy+nsn15UrV9ChQwfp+YIFC7BgwQL06NEDu3btqtaYAPDFF1/AyMgIAwcORGlpKUJCQvCf//znsZeDiIiI6he9r4NkYWGBY8eOSXtsnlXVvY7C04rXQSKl8TpIRFQTauw6SP7+/jh37twTFUdERERUl+n9E9v48eMxefJk5Obmwtvbu8Jp/u3btzdYcURERERK0DsgDRw4EAAwcuRIqU2lUkEIofdB2kRERER1kd4B6fz58zVRBxEREVGdoXdAcnd3r4k6iIiIiOoMvQMSAGRmZmLx4sVIS0sDALRp0wYTJ05EixYtDFocERERkRIe62a1bdq0waFDh9C+fXu0b98eBw8eRNu2bZGQkFATNRIRERHVKr33IE2bNg0RERGIiYmp0D516lS88sorBiuOiIiISAl670FKS0vDqFGjKrSPHDlSug0IERER0dNM74DUqFEjpKamVmhPTU2Fo6OjIWoiIiIiUpTeP7GNHj0aY8aMwR9//IGuXbsCAPbt24d58+YhMjLS4AUSERER1Ta9A9LHH38MKysrLFy4ENOnTwcAuLq6YtasWZgwYYLBCyQiIiKqbXoHJJVKhYiICERERODmzZsAACsrK4MXRkRERKSUx7qS9r179+Dp6akTjM6ePQtTU1N4eHgYsj4iIiKiWqf3QdrDhw/H/v37K7QfPHgQw4cPN0RNRERERIrSOyAdPXoU3bp1q9DepUuXSs9uIyIiInraPNYxSOXHHj2osLAQZWVlBimKiMhj2g5F558V01vR+RORsvTeg9S9e3dER0frhKGysjJER0fjhRdeMGhxRERERErQew/SvHnz0L17d7Rq1QovvvgiAGDv3r0oKirCb7/9ZvACiYiIiGqb3nuQ2rRpg+PHj+Ott95Cfn4+bt68ibCwMKSnp6Ndu3Y1USMRERFRrdJ7DxJw/8KQc+fONXQtRERERHWC3nuQiIiIiOo7BiQiIiIiGQYkIiIiIplqBaStW7fi7t27NV0LERERUZ1QrYDUv39/FBQUAACMjY2Rn59fkzURERERKapaAalRo0Y4cOAAAEAIAZVKVaNFERERESmpWqf5v/vuu+jbty9UKhVUKhWcnZ2r7MvbjRAREdHTrloBadasWRg8eDDOnTuHPn36YNWqVbC1ta3h0oiIiIiUUe0LRXp5ecHLywtRUVF488030aBBg5qsi4iIiEgxel9JOyoqCgBw9epVZGRkAABatWqFRo0aGbYyIiIiIoXofR2kW7duYeTIkXB1dUX37t3RvXt3uLq6YtSoUbh161ZN1EhERERUq/QOSBEREdi9eze2bt2KgoICFBQU4IcffsDu3bsxefLkmqiRiIiIqFbp/RPbxo0b8b///Q+BgYFSW69evWBubo633noLy5YtM2R9RERERLXusX5ic3JyqtDu6OjIn9iIiIioXtA7IAUEBCAqKgq3b9+W2v766y/Mnj0bAQEBBi2OiIiISAl6/8T25ZdfIiQkBE2aNIGPjw8A4NixYzAzM8PPP/9s8AKJiIiIapveAaldu3Y4e/Ys1q5di/T0dADAkCFDEBoaCnNzc4MXSERERFTb9A5IANCgQQOMHj3a0LUQERER1Ql6H4NUE2JjY+Hh4QEzMzP4+/vj0KFDD+2/YcMGeHl5wczMDN7e3vjxxx91ppffM07++Pzzz6U+Hh4eFabHxMTUyPIRERHR00XxgBQXF4fIyEhERUUhJSUFPj4+CAkJQX5+fqX99+/fjyFDhmDUqFE4evQo+vXrh379+uHkyZNSn5ycHJ3HN998A5VKhYEDB+qMNWfOHJ1+48ePr9FlJSIioqeDSgghlCzA398fnTp1wtKlSwEAWq0Wbm5uGD9+PKZNm1ah/6BBg1BSUoLt27dLbV26dIGvry+WL19e6Tz69euHmzdvIjExUWrz8PDApEmTMGnSpMequ6ioCDY2NigsLIS1tfVjjVGXeUzboXQJRIrKiumtdAlEVAOq+/2t6B6kO3fuIDk5GcHBwVKbkZERgoODkZSUVOlrkpKSdPoDQEhISJX98/LysGPHDowaNarCtJiYGNjb26NDhw74/PPPce/evSprLS0tRVFRkc6DiIiI6ie9A1Lz5s1x/fr1Cu0FBQVo3ry5XmNdu3YNZWVlFS486eTkhNzc3Epfk5ubq1f/NWvWwMrKCgMGDNBpnzBhAtavX4+dO3fin//8J+bOnYsPPvigylqjo6NhY2MjPdzc3KqziERERPQU0vsstqysLJSVlVVoLy0txeXLlw1SlCF98803CA0NhZmZmU57ZGSk9Hf79u2hVqvxz3/+E9HR0dBoNBXGmT59us5rioqKGJKIiIjqqWoHpK1bt0p///zzz7CxsZGel5WVITExER4eHnrN3MHBAcbGxsjLy9Npz8vLg7Ozc6WvcXZ2rnb/vXv3IiMjA3FxcY+sxd/fH/fu3UNWVhZatWpVYbpGo6k0OBEREVH9U+2A1K9fPwD3T6EPDw/XmWZqagoPDw8sXLhQr5mr1Wp07NgRiYmJ0vharRaJiYkYN25cpa8JCAhAYmKizsHVCQkJld7m5Ouvv0bHjh2lK34/TGpqKoyMjODo6KjXMhAREVH9U+2ApNVqAQDNmjXD4cOH4eDgYJACIiMjER4eDj8/P3Tu3BmLFy9GSUkJRowYAQAICwtD48aNER0dDQCYOHEievTogYULF6J3795Yv349jhw5ghUrVuiMW1RUhA0bNlQa2pKSknDw4EG89NJLsLKyQlJSEiIiIvD222+jYcOGBlkuIiIienrpfQzS+fPnDVrAoEGDcPXqVcycORO5ubnw9fVFfHy8dCB2dnY2jIz+Ppa8a9euWLduHWbMmIEPP/wQnp6e2LJlC9q1a6cz7vr16yGEwJAhQyrMU6PRYP369Zg1axZKS0vRrFkzRERE6BxjRERERM+ux7oOUmJiIhITE5Gfny/tWSr3zTffGKy4uozXQSKq33gdJKL6qbrf33rvQZo9ezbmzJkDPz8/uLi4QKVSPVGhRERERHWN3gFp+fLlWL16NYYNG1YT9RAREREpTu8LRd65cwddu3atiVqIiIiI6gS9A9I777yDdevW1UQtRERERHWC3j+x3b59GytWrMCvv/6K9u3bw9TUVGf6okWLDFYcERERkRL0DkjHjx+Hr68vAODkyZM603jANhEREdUHegeknTt31kQdRERERHWG3scglTt37hx+/vln/PXXXwCAx7icEhEREVGdpHdAun79OoKCgvDcc8+hV69eyMnJAQCMGjUKkydPNniBRERERLVN74AUEREBU1NTZGdno0GDBlL7oEGDEB8fb9DiiIiIiJSg9zFIv/zyC37++Wc0adJEp93T0xMXLlwwWGFEREpS+nY7vNUJkbL03oNUUlKis+eo3I0bN6DRaAxSFBEREZGS9A5IL774Ir799lvpuUqlglarxfz58/HSSy8ZtDgiIiIiJej9E9v8+fMRFBSEI0eO4M6dO/jggw9w6tQp3LhxA/v27auJGomIiIhqld57kNq1a4czZ87ghRdeQN++fVFSUoIBAwbg6NGjaNGiRU3USERERFSr9N6DBAA2Njb46KOPDF0LERERUZ2g9x6kVatWYcOGDRXaN2zYgDVr1hikKCIiIiIl6R2QoqOj4eDgUKHd0dERc+fONUhRRERERErSOyBlZ2ejWbNmFdrd3d2RnZ1tkKKIiIiIlKR3QHJ0dMTx48crtB87dgz29vYGKYqIiIhISXoHpCFDhmDChAnYuXMnysrKUFZWht9++w0TJ07E4MGDa6JGIiIiolql91lsn3zyCbKyshAUFAQTk/sv12q1CAsL4zFIREREVC/oFZCEEMjNzcXq1avx6aefIjU1Febm5vD29oa7u3tN1UhERERUq/QOSC1btsSpU6fg6ekJT0/PmqqLiIiISDF6HYNkZGQET09PXL9+vabqISIiIlKc3gdpx8TEYMqUKTh58mRN1ENERESkOL0P0g4LC8OtW7fg4+MDtVoNc3Nznek3btwwWHFEREREStA7IC1evLgGyiAiIiKqO/QOSOHh4TVRBxEREVGdofcxSACQmZmJGTNmYMiQIcjPzwcA/PTTTzh16pRBiyMiIiJSgt4Baffu3fD29sbBgwexadMmFBcXA7h/q5GoqCiDF0hERERU2/QOSNOmTcOnn36KhIQEqNVqqf3ll1/GgQMHDFocERERkRL0DkgnTpxA//79K7Q7Ojri2rVrBimKiIiISEl6ByRbW1vk5ORUaD969CgaN25skKKIiIiIlKR3QBo8eDCmTp2K3NxcqFQqaLVa7Nu3D++//z7CwsJqokYiIiKiWqV3QJo7dy68vLzg5uaG4uJitGnTBt27d0fXrl0xY8aMmqiRiIiIqFbpfR0ktVqNlStXYubMmThx4gSKi4vRoUMH3riWiIiI6o1qByStVovPP/8cW7duxZ07dxAUFISoqKgKtxohIiIietpV+ye2zz77DB9++CEsLS3RuHFjfPnllxg7dmxN1kZERESkiGoHpG+//Rb/+c9/8PPPP2PLli3Ytm0b1q5dC61WW5P1EREREdW6agek7Oxs9OrVS3oeHBwMlUqFK1euPHERsbGx8PDwgJmZGfz9/XHo0KGH9t+wYQO8vLxgZmYGb29v/PjjjzrThw8fDpVKpfPo2bOnTp8bN24gNDQU1tbWsLW1xahRo6SrghMREdGzrdoB6d69ezAzM9NpMzU1xd27d5+ogLi4OERGRiIqKgopKSnw8fFBSEiIdI83uf3792PIkCEYNWoUjh49in79+qFfv344efKkTr+ePXsiJydHenz33Xc600NDQ3Hq1CkkJCRg+/bt2LNnD8aMGfNEy0JERET1g0oIIarT0cjICK+99ho0Go3Utm3bNrz88suwsLCQ2jZt2qRXAf7+/ujUqROWLl0K4P7B4G5ubhg/fjymTZtWof+gQYNQUlKC7du3S21dunSBr68vli9fDuD+HqSCggJs2bKl0nmmpaWhTZs2OHz4MPz8/AAA8fHx6NWrFy5dugRXV9dH1l1UVAQbGxsUFhbC2tpar2V+GnhM26F0CUTPtKyY3kqXQFQvVff7u9p7kMLDw+Ho6AgbGxvp8fbbb8PV1VWnTR937txBcnIygoOD/y7IyAjBwcFISkqq9DVJSUk6/QEgJCSkQv9du3bB0dERrVq1wnvvvYfr16/rjGFrayuFI+D+T4ZGRkY4ePBgpfMtLS1FUVGRzoOIiIjqp2qf5r9q1SqDz/zatWsoKyuDk5OTTruTkxPS09MrfU1ubm6l/XNzc6XnPXv2xIABA9CsWTNkZmbiww8/xGuvvYakpCQYGxsjNzcXjo6OOmOYmJjAzs5OZ5wHRUdHY/bs2Y+zmERERPSU0ftCkU+DwYMHS397e3ujffv2aNGiBXbt2oWgoKDHGnP69OmIjIyUnhcVFcHNze2JayUiIqK6R+9bjRiSg4MDjI2NkZeXp9Oel5cHZ2fnSl/j7OysV38AaN68ORwcHHDu3DlpDPlB4Pfu3cONGzeqHEej0cDa2lrnQURERPWTogFJrVajY8eOSExMlNq0Wi0SExMREBBQ6WsCAgJ0+gNAQkJClf0B4NKlS7h+/TpcXFykMQoKCpCcnCz1+e2336DVauHv7/8ki0RERET1gKIBCQAiIyOxcuVKrFmzBmlpaXjvvfdQUlKCESNGAADCwsIwffp0qf/EiRMRHx+PhQsXIj09HbNmzcKRI0cwbtw4AEBxcTGmTJmCAwcOICsrC4mJiejbty9atmyJkJAQAEDr1q3Rs2dPjB49GocOHcK+ffswbtw4DB48uFpnsBEREVH9pvgxSIMGDcLVq1cxc+ZM5ObmwtfXF/Hx8dKB2NnZ2TAy+jvHde3aFevWrcOMGTPw4YcfwtPTE1u2bEG7du0AAMbGxjh+/DjWrFmDgoICuLq64tVXX8Unn3yic4mCtWvXYty4cQgKCoKRkREGDhyIJUuW1O7CExERUZ1U7esgkS5eB4mIahKvg0RUMwx+HSQiIiKiZwUDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRjInSBRARUUUe03YoOv+smN6Kzp9IadyDRERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJFMnAlJsbCw8PDxgZmYGf39/HDp06KH9N2zYAC8vL5iZmcHb2xs//vijNO3u3buYOnUqvL29YWFhAVdXV4SFheHKlSs6Y3h4eEClUuk8YmJiamT5iIiI6OmieECKi4tDZGQkoqKikJKSAh8fH4SEhCA/P7/S/vv378eQIUMwatQoHD16FP369UO/fv1w8uRJAMCtW7eQkpKCjz/+GCkpKdi0aRMyMjLQp0+fCmPNmTMHOTk50mP8+PE1uqxERET0dFAJIYSSBfj7+6NTp05YunQpAECr1cLNzQ3jx4/HtGnTKvQfNGgQSkpKsH37dqmtS5cu8PX1xfLlyyudx+HDh9G5c2dcuHABTZs2BXB/D9KkSZMwadKkatVZWlqK0tJS6XlRURHc3NxQWFgIa2vr6i7uU0Pp+0ARkbJ4Lzaqr4qKimBjY/PI729F9yDduXMHycnJCA4OltqMjIwQHByMpKSkSl+TlJSk0x8AQkJCquwPAIWFhVCpVLC1tdVpj4mJgb29PTp06IDPP/8c9+7dq3KM6Oho2NjYSA83N7dqLCERERE9jUyUnPm1a9dQVlYGJycnnXYnJyekp6dX+prc3NxK++fm5lba//bt25g6dSqGDBmikxQnTJiA559/HnZ2dti/fz+mT5+OnJwcLFq0qNJxpk+fjsjISOl5+R4kIiIiqn8UDUg17e7du3jrrbcghMCyZct0pj0Ydtq3bw+1Wo1//vOfiI6OhkajqTCWRqOptJ2IiIjqH0V/YnNwcICxsTHy8vJ02vPy8uDs7Fzpa5ydnavVvzwcXbhwAQkJCY88Tsjf3x/37t1DVlaW/gtCRERE9YqiAUmtVqNjx45ITEyU2rRaLRITExEQEFDpawICAnT6A0BCQoJO//JwdPbsWfz666+wt7d/ZC2pqakwMjKCo6PjYy4NERER1ReK/8QWGRmJ8PBw+Pn5oXPnzli8eDFKSkowYsQIAEBYWBgaN26M6OhoAMDEiRPRo0cPLFy4EL1798b69etx5MgRrFixAsD9cPTGG28gJSUF27dvR1lZmXR8kp2dHdRqNZKSknDw4EG89NJLsLKyQlJSEiIiIvD222+jYcOGyqwIIiIiqjMUD0iDBg3C1atXMXPmTOTm5sLX1xfx8fHSgdjZ2dkwMvp7R1fXrl2xbt06zJgxAx9++CE8PT2xZcsWtGvXDgBw+fJlbN26FQDg6+urM6+dO3ciMDAQGo0G69evx6xZs1BaWopmzZohIiJC57gkIiIienYpfh2kp1V1r6PwtOJ1kIiebbwOEtVXT8V1kIiIiIjqIgYkIiIiIhkGJCIiIiIZBiQiIiIiGQYkIiIiIhkGJCIiIiIZBiQiIiIiGQYkIiIiIhkGJCIiIiIZBiQiIiIiGQYkIiIiIhkGJCIiIiIZBiQiIiIiGQYkIiIiIhkGJCIiIiIZBiQiIiIiGQYkIiIiIhkGJCIiIiIZBiQiIiIiGQYkIiIiIhkGJCIiIiIZBiQiIiIiGQYkIiIiIhkGJCIiIiIZE6ULICKiusdj2g5F558V01vR+RNxDxIRERGRDAMSERERkQwDEhEREZEMAxIRERGRDAMSERERkQzPYiMiojpH6bPoAJ5J96zjHiQiIiIiGQYkIiIiIhkGJCIiIiIZBiQiIiIiGQYkIiIiIhmexUZERFQJpc+k41l0yuIeJCIiIiIZBiQiIiIimToRkGJjY+Hh4QEzMzP4+/vj0KFDD+2/YcMGeHl5wczMDN7e3vjxxx91pgshMHPmTLi4uMDc3BzBwcE4e/asTp8bN24gNDQU1tbWsLW1xahRo1BcXGzwZSMiIqKnj+IBKS4uDpGRkYiKikJKSgp8fHwQEhKC/Pz8Svvv378fQ4YMwahRo3D06FH069cP/fr1w8mTJ6U+8+fPx5IlS7B8+XIcPHgQFhYWCAkJwe3bt6U+oaGhOHXqFBISErB9+3bs2bMHY8aMqfHlJSIiorpPJYQQShbg7++PTp06YenSpQAArVYLNzc3jB8/HtOmTavQf9CgQSgpKcH27dulti5dusDX1xfLly+HEAKurq6YPHky3n//fQBAYWEhnJycsHr1agwePBhpaWlo06YNDh8+DD8/PwBAfHw8evXqhUuXLsHV1fWRdRcVFcHGxgaFhYWwtrY2xKqoU5Q+OJGI6FnHg7RrRnW/vxU9i+3OnTtITk7G9OnTpTYjIyMEBwcjKSmp0tckJSUhMjJSpy0kJARbtmwBAJw/fx65ubkIDg6WptvY2MDf3x9JSUkYPHgwkpKSYGtrK4UjAAgODoaRkREOHjyI/v37V5hvaWkpSktLpeeFhYUA7q/o+khbekvpEoiInmn19ftFaeXr9VH7hxQNSNeuXUNZWRmcnJx02p2cnJCenl7pa3Jzcyvtn5ubK00vb3tYH0dHR53pJiYmsLOzk/rIRUdHY/bs2RXa3dzcqlo8IiKix2azWOkK6rebN2/Cxsamyum8DlI1TZ8+XWfPlVarxY0bN2Bvbw+VSqVgZYZXVFQENzc3XLx4sV7+fPgoXP5ne/kBroNnffkBroP6vPxCCNy8efORh9MoGpAcHBxgbGyMvLw8nfa8vDw4OztX+hpnZ+eH9i//b15eHlxcXHT6+Pr6Sn3kB4Hfu3cPN27cqHK+Go0GGo1Gp83W1vbhC/iUs7a2rncfDH1w+Z/t5Qe4Dp715Qe4Durr8j9sz1E5Rc9iU6vV6NixIxITE6U2rVaLxMREBAQEVPqagIAAnf4AkJCQIPVv1qwZnJ2ddfoUFRXh4MGDUp+AgAAUFBQgOTlZ6vPbb79Bq9XC39/fYMtHRERETyfFf2KLjIxEeHg4/Pz80LlzZyxevBglJSUYMWIEACAsLAyNGzdGdHQ0AGDixIno0aMHFi5ciN69e2P9+vU4cuQIVqxYAQBQqVSYNGkSPv30U3h6eqJZs2b4+OOP4erqin79+gEAWrdujZ49e2L06NFYvnw57t69i3HjxmHw4MHVOoONiIiI6jfFA9KgQYNw9epVzJw5E7m5ufD19UV8fLx0kHV2djaMjP7e0dW1a1esW7cOM2bMwIcffghPT09s2bIF7dq1k/p88MEHKCkpwZgxY1BQUIAXXngB8fHxMDMzk/qsXbsW48aNQ1BQEIyMjDBw4EAsWbKk9ha8DtNoNIiKiqrwk+Kzgsv/bC8/wHXwrC8/wHXwrC8/UAeug0RERERU1yh+JW0iIiKiuoYBiYiIiEiGAYmIiIhIhgGJiIiISIYBiQDcv5VKp06dYGVlBUdHR/Tr1w8ZGRlKl6WYmJgY6ZIRz5LLly/j7bffhr29PczNzeHt7Y0jR44oXVatKCsrw8cff4xmzZrB3NwcLVq0wCeffPLI+zU9zfbs2YPXX38drq6uUKlU0j0tywkhMHPmTLi4uMDc3BzBwcE4e/asMsXWgIct/927dzF16lR4e3vDwsICrq6uCAsLw5UrV5QruAY86j3woHfffRcqlQqLFy+utfqUxIBEAIDdu3dj7NixOHDgABISEnD37l28+uqrKCkpUbq0Wnf48GF89dVXaN++vdKl1Ko///wT3bp1g6mpKX766SecPn0aCxcuRMOGDZUurVbMmzcPy5Ytw9KlS5GWloZ58+Zh/vz5+Pe//610aTWmpKQEPj4+iI2NrXT6/PnzsWTJEixfvhwHDx6EhYUFQkJCcPv27VqutGY8bPlv3bqFlJQUfPzxx0hJScGmTZuQkZGBPn36KFBpzXnUe6Dc5s2bceDAgWfrWoGCqBL5+fkCgNi9e7fSpdSqmzdvCk9PT5GQkCB69OghJk6cqHRJtWbq1KnihRdeULoMxfTu3VuMHDlSp23AgAEiNDRUoYpqFwCxefNm6blWqxXOzs7i888/l9oKCgqERqMR3333nQIV1iz58lfm0KFDAoC4cOFC7RRVy6paB5cuXRKNGzcWJ0+eFO7u7uKLL76o9dqUwD1IVKnCwkIAgJ2dncKV1K6xY8eid+/eCA4OVrqUWrd161b4+fnhzTffhKOjIzp06ICVK1cqXVat6dq1KxITE3HmzBkAwLFjx/D777/jtddeU7gyZZw/fx65ubk6nwUbGxv4+/sjKSlJwcqUU1hYCJVKVe/vw/kgrVaLYcOGYcqUKWjbtq3S5dQqxa+kTXWPVqvFpEmT0K1bN50rlNd369evR0pKCg4fPqx0KYr4448/sGzZMkRGRuLDDz/E4cOHMWHCBKjVaoSHhytdXo2bNm0aioqK4OXlBWNjY5SVleGzzz5DaGio0qUpIjc3FwCkuxqUc3JykqY9S27fvo2pU6diyJAh9fLmrVWZN28eTExMMGHCBKVLqXUMSFTB2LFjcfLkSfz+++9Kl1JrLl68iIkTJyIhIUHnljTPEq1WCz8/P8ydOxcA0KFDB5w8eRLLly9/JgLS999/j7Vr12LdunVo27YtUlNTMWnSJLi6uj4Ty09Vu3v3Lt566y0IIbBs2TKly6k1ycnJ+PLLL5GSkgKVSqV0ObWOP7GRjnHjxmH79u3YuXMnmjRponQ5tSY5ORn5+fl4/vnnYWJiAhMTE+zevRtLliyBiYkJysrKlC6xxrm4uKBNmzY6ba1bt0Z2drZCFdWuKVOmYNq0aRg8eDC8vb0xbNgwRERESDfKftY4OzsDAPLy8nTa8/LypGnPgvJwdOHCBSQkJDxTe4/27t2L/Px8NG3aVNouXrhwAZMnT4aHh4fS5dU47kEiAPdP5x0/fjw2b96MXbt2oVmzZkqXVKuCgoJw4sQJnbYRI0bAy8sLU6dOhbGxsUKV1Z5u3bpVuLTDmTNn4O7urlBFtevWrVs6N8YGAGNjY2i1WoUqUlazZs3g7OyMxMRE+Pr6AgCKiopw8OBBvPfee8oWV0vKw9HZs2exc+dO2NvbK11SrRo2bFiF4zFDQkIwbNgwjBgxQqGqag8DEgG4/7PaunXr8MMPP8DKyko6xsDGxgbm5uYKV1fzrKysKhxvZWFhAXt7+2fmOKyIiAh07doVc+fOxVtvvYVDhw5hxYoVWLFihdKl1YrXX38dn332GZo2bYq2bdvi6NGjWLRoEUaOHKl0aTWmuLgY586dk56fP38eqampsLOzQ9OmTTFp0iR8+umn8PT0RLNmzfDxxx/D1dUV/fr1U65oA3rY8ru4uOCNN95ASkoKtm/fjrKyMmm7aGdnB7VarVTZBvWo94A8FJqamsLZ2RmtWrWq7VJrn9Kn0VHdAKDSx6pVq5QuTTHP2mn+Qgixbds20a5dO6HRaISXl5dYsWKF0iXVmqKiIjFx4kTRtGlTYWZmJpo3by4++ugjUVpaqnRpNWbnzp2Vfu7Dw8OFEPdP9f/444+Fk5OT0Gg0IigoSGRkZChbtAE9bPnPnz9f5XZx586dSpduMI96D8g9S6f5q4Sox5eJJSIiInoMPEibiIiISIYBiYiIiEiGAYmIiIhIhgGJiIiISIYBiYiIiEiGAYmIiIhIhgGJiIiISIYBiYiIiEjmmQtIWVlZUKlUSE1NVboUSXp6Orp06QIzMzPpnkf05FavXg1bW1uly1CUSqXCli1bnmiMurIeq/M5EUJgzJgxsLOzkz7ngYGBmDRpUq3WWlOGDx/+yNt87Nq1CyqVCgUFBTVay759++Dt7Q1TU9N6c+sRJSj5nVSd99Oj3Lp1CwMHDoS1tXWtvO9qU60HpOHDh0OlUiEmJkanfcuWLVCpVLVdTp0QFRUFCwsLZGRkIDExUely6oS68qUMGCZkKCUnJwevvfaa0mUYRHU+J/Hx8Vi9ejW2b9+OnJwctGvXDps2bcInn3zyRPOuK++BL7/8EqtXr5aeVxb+unbtipycHNjY2NRoLZGRkfD19cX58+d1anra1KVtzdNozZo12Lt3L/bv318r77vapMgeJDMzM8ybNw9//vmnErOvEXfu3Hns12ZmZuKFF16Au7v7M3e3aKpZzs7O0Gg0SpdhENX5nGRmZsLFxQVdu3aFs7MzTExMYGdnBysrqyrHfZLPbm2zsbF55Je5Wq2Gs7Nzjf8PZ2ZmJl5++WU0adLksQPG07TuqXKZmZlo3bo12rVrVyvvu1pV2zd/Cw8PF//4xz+El5eXmDJlitS+efNm8WA5UVFRwsfHR+e1X3zxhXB3d9cZq2/fvuKzzz4Tjo6OwsbGRsyePVvcvXtXvP/++6Jhw4aicePG4ptvvpFeU34Dwu+++04EBAQIjUYj2rZtK3bt2qUzrxMnToiePXsKCwsL4ejoKN5++21x9epVaXqPHj3E2LFjxcSJE4W9vb0IDAysdHnLysrE7NmzRePGjYVarRY+Pj7ip59+kqZDdoPAqKioKseZN2+eaNGihVCr1cLNzU18+umn0vTjx4+Ll156SZiZmQk7OzsxevRocfPmTYOsq7i4OPHCCy8IMzMz4efnJzIyMsShQ4dEx44dhYWFhejZs6fIz8/XqXflypXCy8tLaDQa0apVKxEbG1th3I0bN4rAwEBhbm4u2rdvL/bv3y+EqPzmieXrJTY2VrRs2VJoNBrh6OgoBg4cWOn6EkKIVatWCRsbG7F582bpNa+++qrIzs7W6bdlyxbRoUMHodFoRLNmzcSsWbPE3bt3hRD3b8z4YB3u7u6ioKBAGBkZicOHD0v/Ng0bNhT+/v7SmP/v//0/0aRJE+l5dna2ePPNN4WNjY1o2LCh6NOnjzh//rzB1llVAIjNmzfrNcaqVauEm5ubMDc3F/369RMLFiwQNjY21V5ns2fPFi4uLuLatWtS/169eonAwEBRVlZWaZ2G+JyEh4dX+LcSouJNh93d3cWcOXPEsGHDhJWVlQgPDxelpaVi7NixwtnZWWg0GtG0aVMxd+5cqX9l48pVd9uya9cu0alTJ6FWq4Wzs7OYOnWqtO6EEGLDhg2iXbt20mc5KChIFBcXS8vYt2/fSpcXgDh//rz0+fnzzz9FYWGhMDMzEz/++KNODZs2bRKWlpaipKRECFG996d8OR98lN/U+lHLVtV281Hb20dt/z744APh6ekpzM3NRbNmzcSMGTPEnTt3pOmpqakiMDBQWFpaCisrK/H888+Lw4cPP3RbI3fu3DnRp08f4ejoKCwsLISfn59ISEjQ6ePu7i4+++wzMWLECGFpaSnc3NzEV199pdPn4MGDwtfXV2g0GtGxY0exadMmAUAcPXq00vkKIcTt27fF5MmThaurq2jQoIHo3Lmzzg1zy7d18fHxwsvLS1hYWIiQkBBx5coVqc+9e/dERESEsLGxEXZ2dmLKlCkiLCxMej9V5X//+59o06aNUKvVwt3dXSxYsECa1qNHD51116NHjyrH2bp1q/Dz8xMajUbY29uLfv36SdNu3Lghhg0bJmxtbYW5ubno2bOnOHPmTLWX7+effxYajUb8+eefOvOcMGGCeOmll6Tne/fulb7LmjRpIsaPHy99toSouG1QJCD17dtXbNq0SZiZmYmLFy8KIR4/IFlZWYmxY8eK9PR08fXXXwsAIiQkRHz22WfizJkz4pNPPhGmpqbSfMo/3E2aNBH/+9//xOnTp8U777wjrKyspA36n3/+KRo1aiSmT58u0tLSREpKinjllVd0VnSPHj2EpaWlmDJlikhPTxfp6emVLu+iRYuEtbW1+O6770R6err44IMPhKmpqfSPn5OTI9q2bSsmT54scnJydELNgz744APRsGFDsXr1anHu3Dmxd+9esXLlSiGEEMXFxcLFxUUMGDBAnDhxQiQmJopmzZrp3I35SdaVl5eXiI+PF6dPnxZdunQRHTt2FIGBgeL3338XKSkpomXLluLdd9+V5vXf//5XuLi4iI0bN4o//vhDbNy4UdjZ2YnVq1dXGHf79u0iIyNDvPHGG8Ld3V3cvXtXlJaWisWLFwtra2uRk5MjrZfDhw8LY2NjsW7dOpGVlSVSUlLEl19+WfkbTdz/UJmamgo/Pz+xf/9+ceTIEdG5c2fRtWtXqc+ePXuEtbW1WL16tcjMzBS//PKL8PDwELNmzRJCCJGfny99AeTk5EhB8Pnnnxeff/65EOL+xtfOzk6o1Wrp3++dd94RoaGhQggh7ty5I1q3bi1Gjhwpjh8/Lk6fPi2GDh0qWrVqJd0p/knXWVUqC0gPG+PAgQPCyMhIzJs3T2RkZIgvv/xS2Nra6gSkR62ze/fuiYCAAGkDuHTpUmFraysuXLhQZZ2G+JwUFBSIOXPmiCZNmuj8W1UWkKytrcWCBQvEuXPnxLlz58Tnn38u3NzcxJ49e0RWVpbYu3evWLdu3UPfA3LV2bZcunRJNGjQQPzrX/8SaWlpYvPmzcLBwUH6Ur5y5YowMTERixYtEufPnxfHjx8XsbGx0vI+GJAKCgpEQECAGD16tPQ5uXfvnk5AEkKIN954Q7z99ts6tQ4cOFBqq87780H37t0TOTk5wtraWixevFjk5OSIW7duPXLZyv8t5NvN6mxvH7b9E0KITz75ROzbt0+cP39ebN26VTg5OYl58+ZJ09u2bSvefvttkZaWJs6cOSO+//57kZqaWuW2pjKpqali+fLl4sSJE+LMmTNixowZwszMTOd97e7uLuzs7ERsbKw4e/asiI6OFkZGRtL3w82bN0WjRo3E0KFDxcmTJ8W2bdtE8+bNHxmQ3nnnHdG1a1exZ88e6f2q0Wikz0f5ti44OFgcPnxYJCcni9atW4uhQ4dKY8ybN080bNhQbNy4UZw+fVqMGjVKWFlZPTQgHTlyRBgZGYk5c+aIjIwMsWrVKmFubi4F4uvXr4vRo0eLgIAAkZOTI65fv17pONu3bxfGxsZi5syZ4vTp0yI1NVX6HxAhhOjTp49o3bq12LNnj0hNTRUhISGiZcuWUsh91PLdu3dPODk5if/7v/+TxpS3nTt3TlhYWIgvvvhCnDlzRuzbt0906NBBDB8+XOff78Ftg2IBSQghunTpIkaOHCmEePyA5O7urvN/pa1atRIvvvii9PzevXvCwsJCfPfdd0KIvzdiMTExUp+7d++KJk2aSB+oTz75RLz66qs687548aIAIDIyMoQQ9z/oHTp0eOTyurq6is8++0ynrVOnTuJf//qX9NzHx6fK/2sRQoiioiKh0Wh0NggPWrFihWjYsKFOEt6xY4cwMjISubm5QognW1cPvum+++47AUAkJiZKbdHR0aJVq1bS8xYtWkhfLuU++eQTERAQUOW4p06dEgBEWlqaEOLv/2N40MaNG4W1tbUoKiqqcl09aNWqVQKAOHDggNSWlpYmAIiDBw8KIYQICgrS+aAKcX/vj4uLi/T8wZBRLjIyUvTu3VsIIcTixYvFoEGDdPZ6tGzZUqxYsUIar1WrVkKr1UqvLy0tFebm5uLnn38WQhhmnVWmsoD0sDGGDBkievXqpTPGoEGDdP4tqrPOMjMzhZWVlZg6daowNzcXa9eurbJGIQzzORGi4jZCiMoD0oP/9yqEEOPHjxcvv/yyzr/Rgyp7D8hVZ9vy4YcfVngvxMbGCktLS1FWViaSk5MFAJGVlVXpPB7cfla2bEKICgFp8+bNOnuLyvcqlb9Xq/P+rIyNjY30RVmdZSuvV77dfNT29lHbv8p8/vnnomPHjtJzKysr6X825Crb1lRX27Ztxb///W/pubu7u04Y1Wq1wtHRUSxbtkwIIcRXX30l7O3txV9//SX1WbZs2UMD0oULF4SxsbG4fPmyTntQUJCYPn26tAwAxLlz56TpsbGxwsnJSXru4uIi5s+fLz0vf28+LCANHTpUvPLKKzptU6ZMEW3atJGeT5w48aF7joQQIiAgQPofRrkzZ84IAGLfvn1S27Vr14S5ubn4/vvvq718EydOFC+//LL0XL5XadSoUWLMmDE68967d68wMjKS/j3k2wZFz2KbN28e1qxZg7S0tMceo23btjAy+nsxnJyc4O3tLT03NjaGvb098vPzdV4XEBAg/W1iYgI/Pz+pjmPHjmHnzp2wtLSUHl5eXgDu/95armPHjg+traioCFeuXEG3bt102rt166bXMqelpaG0tBRBQUFVTvfx8YGFhYXOPLRaLTIyMqS2x11X7du313kNAJ3XOTk5Sa8pKSlBZmYmRo0apbP+Pv30U511Jx/XxcUFACrM+0GvvPIK3N3d0bx5cwwbNgxr167FrVu3quwP3P+37dSpk/Tcy8sLtra2Ov/Wc+bM0al19OjRyMnJeejYPXr0wO+//46ysjLs3r0bgYGBCAwMxK5du3DlyhWcO3cOgYGB0jzOnTsHKysraR52dna4ffs2MjMza3SdVeZhY6SlpcHf31+n/4Oflequs+bNm2PBggWYN28e+vTpg6FDh1ZZj6E+J/rw8/PTeT58+HCkpqaiVatWmDBhAn755ZfHHvth25a0tDQEBAToHKfRrVs3FBcX49KlS/Dx8UFQUBC8vb3x5ptvYuXKlU98rGavXr1gamqKrVu3AgA2btwIa2trBAcHA3j0+7O6HrVs5eTbzUdtbx+1/QOAuLg4dOvWDc7OzrC0tMSMGTOQnZ0tTY+MjMQ777yD4OBgxMTE6LVc5YqLi/H++++jdevWsLW1haWlJdLS0nTmA+h+vlQqFZydnXU+X+3bt4eZmZnUR/75kjtx4gTKysrw3HPP6ayj3bt36yxHgwYN0KJFC+m5i4uLNN/CwkLk5OTofLbL35sPk5aWVunn8uzZsygrK3voax+Umpr60O8vExMTndrs7e3RqlUrnc//w5YPAEJDQ6XtLwCsXbsWvXv3lo6PO3bsGFavXq2zDkNCQqDVanH+/HlpnAfXiUm1l7AGdO/eHSEhIZg+fTqGDx+uM83IyAhCCJ22u3fvVhjD1NRU57lKpaq0TavVVruu4uJivP7665g3b16FaeVfKAB0AklNMjc3N8g4j7uuHuxTvvGTt5W/pri4GACwcuXKCl+0xsbGjxz3Yf9OVlZWSElJwa5du/DLL79g5syZmDVrFg4fPvzYB4kWFxdj9uzZGDBgQIVpD27E5Lp3746bN28iJSUFe/bswdy5c+Hs7IyYmBj4+PjA1dUVnp6e0jw6duyItWvXVhinUaNGNbrOKvOkY1R3ne3ZswfGxsbIysrCvXv3YGKi6OZGh/yz+/zzz+P8+fP46aef8Ouvv+Ktt95CcHAw/ve//9VqXcbGxkhISMD+/fvxyy+/4N///jc++ugjHDx4EM2aNXusMdVqNd544w2sW7cOgwcPxrp16zBo0CDp3+NR709Dk6/7R21v//jjj4eOl5SUhNDQUMyePRshISGwsbHB+vXrsXDhQqnPrFmzMHToUOzYsQM//fQToqKisH79evTv37/adb///vtISEjAggUL0LJlS5ibm+ONN96ocKD5k37/yBUXF8PY2BjJyckVtgeWlpYPna/8O1QphvgOe9TyderUCS1atMD69evx3nvvYfPmzTpnVxYXF+Of//wnJkyYUGHspk2bSn8/+P5U/DpIMTEx2LZtG5KSknTaGzVqhNzcXJ0VYMjrRBw4cED6+969e0hOTkbr1q0B3N9Ynjp1Ch4eHmjZsqXOQ59QZG1tDVdXV+zbt0+nfd++fWjTpk21x/H09IS5uXmVpza3bt0ax44dQ0lJic48jIyM0KpVq2rPxxCcnJzg6uqKP/74o8K602cDr1arK/0/FBMTEwQHB2P+/Pk4fvw4srKy8Ntvv1U5zr1793DkyBHpeUZGBgoKCnT+rTMyMirU2rJlS2lvm6mpaYVabG1t0b59eyxduhSmpqbw8vJC9+7dcfToUWzfvh09evSQ+j7//PM4e/YsHB0dK8zDxsbGYOvMEFq3bo2DBw/qtD34WQGqt87i4uKwadMm7Nq1C9nZ2Q89zd5Qn5MnZW1tjUGDBmHlypWIi4vDxo0bcePGDQCVvweq8rBtS+vWrZGUlKSzXdu3bx+srKzQpEkTAPc3/N26dcPs2bNx9OhRqNVqbN68udJ5VfU5kQsNDUV8fDxOnTqF3377DaGhodK0R70/q6s6y1aZR21vH7X9279/P9zd3fHRRx/Bz88Pnp6euHDhQoV+zz33HCIiIvDLL79gwIABWLVqFYDqr8N9+/Zh+PDh6N+/P7y9veHs7IysrKxHvu5BrVu3xvHjx3H79m2pTf75kuvQoQPKysqQn59fYf04OztXa742NjZwcXHR+WyXvzcfVW9ln8vnnnuuQlh7mPbt2z/0++vevXs6tV2/fh0ZGRl6f/5DQ0Oxdu1abNu2DUZGRujdu7c07fnnn8fp06cr3W6p1epKx1M8IHl7eyM0NBRLlizRaQ8MDMTVq1cxf/58ZGZmIjY2Fj/99JPB5hsbG4vNmzcjPT0dY8eOxZ9//omRI0cCAMaOHYsbN25gyJAhOHz4MDIzM/Hzzz9jxIgReu1WBIApU6Zg3rx5iIuLQ0ZGBqZNm4bU1FRMnDix2mOYmZlh6tSp+OCDD/Dtt98iMzMTBw4cwNdffw3g/pvCzMwM4eHhOHnyJHbu3Inx48dj2LBh0k9itWn27NmIjo7GkiVLcObMGZw4cQKrVq3CokWLqj2Gh4cHiouLkZiYiGvXruHWrVvYvn07lixZgtTUVFy4cAHffvsttFrtQ0Ogqakpxo8fj4MHDyI5ORnDhw9Hly5d0LlzZwDAzJkz8e2332L27Nk4deoU0tLSsH79esyYMUOnlsTEROTm5ur83BEYGIi1a9dKYcjOzg6tW7dGXFycTkAKDQ2Fg4MD+vbti7179+L8+fPYtWsXJkyYIP30YIh1ZggTJkxAfHw8FixYgLNnz2Lp0qWIj4/X6fOodXbp0iW89957mDdvHl544QWsWrUKc+fOfegXgSE+J09i0aJF+O6775Ceno4zZ85gw4YNcHZ2lvZMVvUeqMzDti3/+te/cPHiRYwfPx7p6en44YcfEBUVhcjISBgZGeHgwYOYO3cujhw5guzsbGzatAlXr16VApach4cHDh48iKysLFy7dq3KPRXdu3eHs7MzQkND0axZM509ldV5f1bHo5atKo/a3j5q++fp6Yns7GysX78emZmZWLJkiU6g/OuvvzBu3Djs2rULFy5cwL59+3D48GFpnVa2ramMp6cnNm3ahNTUVBw7dgxDhw7Ve8/Q0KFDoVKpMHr0aJw+fRo//vgjFixY8NDXPPfccwgNDUVYWBg2bdqE8+fP49ChQ4iOjsaOHTuqPe+JEyciJiYGW7ZsQXp6Ov71r3898qKOkydPRmJiIj755BOcOXMGa9aswdKlS/H+++9Xe77A/WuYfffdd4iKikJaWhpOnDgh7TH09PRE3759MXr0aPz+++84duwY3n77bTRu3Bh9+/bVaz6hoaFISUnBZ599hjfeeEPnEidTp07F/v37MW7cOKSmpuLs2bP44YcfMG7cuKoHfOiRVTVAfpChEPcPblSr1UJezrJly4Sbm5uwsLAQYWFh4rPPPqv0NP8HVXbQoru7u/jiiy+keQEQ69atE507dxZqtVq0adNG/PbbbzqvOXPmjOjfv7902qGXl5eYNGmSdABiZfOpTFlZmZg1a5Zo3LixMDU1rXD6shDVO/i0rKxMfPrpp8Ld3V2YmprqnIYsRPVP83+cdfXgwYPyA0CFqPwgx7Vr1wpfX1+hVqtFw4YNRffu3cWmTZuqHPfPP/8UAHROXX333XeFvb29dOrt3r17RY8ePUTDhg2lU9Tj4uKqXGfldW3cuFE0b95caDQaERwcXOFsqvj4eNG1a1dhbm4urK2tRefOnaUDrIW4f3pqy5YthYmJic77r/zEgvIDMIW4f6AggApnNebk5IiwsDDh4OAgNBqNaN68uRg9erQoLCw06DqTQyUHaT9qjK+//lo0adJEmJubi9dff73S0/yrWmdarVYEBQWJkJAQnYN1x48fL1q0aFHlGUKG+pxU9yDt8vd4uRUrVghfX19hYWEhrK2tRVBQkEhJSZGmV/UeeFB1ty0POxX+9OnTIiQkRDRq1EhoNBrx3HPP6RwELP8cZ2RkiC5dughzc/NKT/N/0AcffCAAiJkzZ1aovTrvTzn5QdqPWjYhqt5uPmp7+6jt35QpU4S9vb2wtLQUgwYNEl988YX0ni0tLRWDBw8Wbm5uQq1WC1dXVzFu3DidA6Xl25rKnD9/Xrz00kvC3NxcuLm5iaVLl1brvSV/3yYlJQkfHx+hVquFr6+v2Lhx4yPPYrtz546YOXOm8PDwEKampsLFxUX0799fHD9+XAhR+TZYfuLT3bt3xcSJE4W1tbWwtbUVkZGRep3mX77ey8/eLVedg7SFuH+STfn2zcHBQQwYMECaVn6av42NjTA3NxchISGVnub/sOUr17lzZwGgwudOCCEOHTokXnnlFWFpaSksLCxE+/btdU4Okf/7qYSoIz9SEhE9xbKystCsWTMcPXqUtwwiqgcU/4mNiIiIqK5hQCIiIiKS4U9sRERERDLcg0REREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJMOARERERCTDgEREREQkw4BEREREJPP/AaG35Vm4tzLzAAAAAElFTkSuQmCC", + "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.867507886435331, Median = 4.0\n", + "Accuracy 0.663095\n", + "Precision 0.637827\n", + "Recall 0.754762\n", + "FPR 0.428571\n", + "F1 0.691385\n", + "Mean H 3.867508\n", + "Correct Adjustment 0.075\n", + "Incorrect Adjustment 0.072619\n", + "Recovery 0.002381\n", + "Leaderboard String | MODEL_NAME | 66.3 | 63.8 | 75.5 | 69....\n", + "dtype: object\n", + "Evaluating Random Seed 8\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:46<00:00, 109.62it/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.5703971119133575, Median = 3.0\n", + "Accuracy 0.678571\n", + "Precision 0.685644\n", + "Recall 0.659524\n", + "FPR 0.302381\n", + "F1 0.67233\n", + "Mean H 3.570397\n", + "Correct Adjustment 0.05\n", + "Incorrect Adjustment 0.075\n", + "Recovery -0.025\n", + "Leaderboard String | MODEL_NAME | 67.9 | 68.6 | 66.0 | 67....\n", + "dtype: object\n", + "Evaluating Random Seed 9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:46<00:00, 109.24it/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.6156462585034017, Median = 3.0\n", + "Accuracy 0.659524\n", + "Precision 0.647577\n", + "Recall 0.7\n", + "FPR 0.380952\n", + "F1 0.672769\n", + "Mean H 3.615646\n", + "Correct Adjustment 0.053571\n", + "Incorrect Adjustment 0.058333\n", + "Recovery -0.004762\n", + "Leaderboard String | MODEL_NAME | 66.0 | 64.8 | 70.0 | 67....\n", + "dtype: object\n", + "Evaluating Random Seed 10\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5131/5131 [00:46<00:00, 109.96it/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.6433566433566433, Median = 3.0\n", + "Accuracy 0.659524\n", + "Precision 0.652968\n", + "Recall 0.680952\n", + "FPR 0.361905\n", + "F1 0.666667\n", + "Mean H 3.643357\n", + "Correct Adjustment 0.042857\n", + "Incorrect Adjustment 0.061905\n", + "Recovery -0.019048\n", + "Leaderboard String | MODEL_NAME | 66.0 | 65.3 | 68.1 | 66....\n", + "dtype: object\n", + "{'Accuracy': np.float64(0.6685714285714287), 'Precision': np.float64(0.6662137103526862), 'Recall': np.float64(0.6785714285714287), 'FPR': np.float64(0.3414285714285714), 'F1': np.float64(0.6711682543124684), 'Mean H': np.float64(3.604889281050231), 'Correct Adjustment': np.float64(0.052380952380952375), 'Incorrect Adjustment': np.float64(0.06607142857142859), 'Recovery': np.float64(-0.013690476190476192), 'Leaderboard String': ['| MODEL_NAME | 68.3 | 67.5 | 70.7 | 69.1 | 34.0 | 3.55 | -1.7 (3.7 - 5.4) |', '| MODEL_NAME | 66.7 | 68.3 | 62.1 | 65.1 | 28.8 | 3.51 | -1.7 (5.0 - 6.7) |', '| MODEL_NAME | 68.0 | 67.0 | 70.7 | 68.8 | 34.8 | 3.61 | -1.9 (4.2 - 6.1) |', '| MODEL_NAME | 65.0 | 67.3 | 58.3 | 62.5 | 28.3 | 3.54 | -1.7 (5.0 - 6.7) |', '| MODEL_NAME | 66.5 | 66.2 | 67.6 | 66.9 | 34.5 | 3.52 | -0.8 (6.8 - 7.6) |', '| MODEL_NAME | 68.0 | 67.4 | 69.5 | 68.5 | 33.6 | 3.62 | -1.3 (5.6 - 6.9) |', '| MODEL_NAME | 66.3 | 63.8 | 75.5 | 69.1 | 42.9 | 3.87 | 0.2 (7.5 - 7.3) |', '| MODEL_NAME | 67.9 | 68.6 | 66.0 | 67.2 | 30.2 | 3.57 | -2.5 (5.0 - 7.5) |', '| MODEL_NAME | 66.0 | 64.8 | 70.0 | 67.3 | 38.1 | 3.62 | -0.5 (5.4 - 5.8) |', '| MODEL_NAME | 66.0 | 65.3 | 68.1 | 66.7 | 36.2 | 3.64 | -1.9 (4.3 - 6.2) |']}\n" + ] + } + ], + "source": [ + "all_results = {}\n", + "for seed in range(1,11):\n", + " print(f\"Evaluating Random Seed {seed}\")\n", + " config_dict = {\n", + " \"output_dir\": f\"{YOUR_SAVING_DIRECTORY}/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", + " normal_bert = BERTCGAModel(os.path.join(saved_model_path, tuned_config['best_checkpoint']), config=config_dict)\n", + " normal_bert.best_threshold = tuned_config['best_threshold']\n", + " normal_bert_forecaster = Forecaster(normal_bert, label_metadata)\n", + "\n", + " # corpus = copy.deepcopy(corpus)\n", + " corpus = normal_bert_forecaster.transform(corpus, transform_selector)\n", + " _, cur_metrics= normal_bert_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": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"Accuracy\": 0.6685714285714287,\n", + " \"Precision\": 0.6662137103526862,\n", + " \"Recall\": 0.6785714285714287,\n", + " \"FPR\": 0.3414285714285714,\n", + " \"F1\": 0.6711682543124684,\n", + " \"Mean H\": 3.604889281050231,\n", + " \"Correct Adjustment\": 0.052380952380952375,\n", + " \"Incorrect Adjustment\": 0.06607142857142859,\n", + " \"Recovery\": -0.013690476190476192,\n", + " \"Leaderboard String\": \"| BERT-base | 66.9 | 66.6 | 67.9 | 67.1 | 34.1 | 3.60 | -1.4 (5.2 - 6.6) |\"\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": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "sqt_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.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/setup.py b/setup.py index 8cf22b4e..13418dde 100644 --- a/setup.py +++ b/setup.py @@ -74,6 +74,7 @@ ], extras_require={ "craft": ["torch>=0.12"], + "forecaster": ["torch>=0.12", "datasets"], }, classifiers=[ "Programming Language :: Python",