From 179e8ab9e0c307ceaa46930abf2dcd3acc74edb5 Mon Sep 17 00:00:00 2001 From: AndreFCruz Date: Wed, 5 Jun 2024 13:53:01 +0200 Subject: [PATCH] running benchmark on sub-populations --- .github/workflows/python-tests-with-tox.yml | 2 +- .github/workflows/python-tests.yml | 2 +- folktexts/benchmark.py | 25 +- folktexts/classifier.py | 9 +- folktexts/cli/_utils.py | 4 +- folktexts/cli/experiments.py | 4 +- folktexts/cli/launch_acs_benchmarks.py | 36 +- folktexts/cli/run_acs_benchmark.py | 11 +- folktexts/dataset.py | 16 +- folktexts/evaluation.py | 2 +- folktexts/task.py | 2 +- notebooks/parse-results.ipynb | 2272 +++++++++++++++++++ pyproject.toml | 11 +- 13 files changed, 2339 insertions(+), 57 deletions(-) create mode 100644 notebooks/parse-results.ipynb diff --git a/.github/workflows/python-tests-with-tox.yml b/.github/workflows/python-tests-with-tox.yml index 4f7bf5f..441c10c 100644 --- a/.github/workflows/python-tests-with-tox.yml +++ b/.github/workflows/python-tests-with-tox.yml @@ -9,7 +9,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ['3.8', '3.9', '3.10', '3.11', '3.12'] + python-version: ["3.10", "3.11", "3.12"] steps: - uses: actions/checkout@v3 diff --git a/.github/workflows/python-tests.yml b/.github/workflows/python-tests.yml index 10a9f3d..0b8a8db 100644 --- a/.github/workflows/python-tests.yml +++ b/.github/workflows/python-tests.yml @@ -23,7 +23,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"] + python-version: ["3.10", "3.11", "3.12"] steps: - uses: actions/checkout@v4 diff --git a/folktexts/benchmark.py b/folktexts/benchmark.py index db22865..792bcc1 100755 --- a/folktexts/benchmark.py +++ b/folktexts/benchmark.py @@ -2,25 +2,25 @@ """ from __future__ import annotations +import dataclasses import logging from functools import partial from pathlib import Path -import dataclasses import numpy as np from transformers import AutoModelForCausalLM, AutoTokenizer -from ._io import save_json, load_json +from ._io import load_json, save_json from ._utils import hash_dict, is_valid_number from .acs.acs_dataset import ACSDataset from .acs.acs_questions import acs_multiple_choice_qa_map, acs_numeric_qa_map from .acs.acs_tasks import ACSTaskMetadata -from .task import TaskMetadata from .classifier import LLMClassifier from .dataset import Dataset from .evaluation import evaluate_predictions from .plotting import render_evaluation_plots, render_fairness_plots from .prompting import encode_row_prompt, encode_row_prompt_chat, encode_row_prompt_few_shot +from .task import TaskMetadata DEFAULT_SEED = 42 @@ -36,7 +36,7 @@ class BenchmarkConfig: batch_size: int | None = None context_size: int | None = None correct_order_bias: bool = True - feature_subset: tuple[str] | None = None + feature_subset: list[str] | None = None population_filter: dict | None = None seed: int = DEFAULT_SEED @@ -53,6 +53,15 @@ def save_to_disk(self, path: str | Path): """Save the configuration to disk.""" save_json(dataclasses.asdict(self), path) + def __hash__(self) -> int: + cfg = dataclasses.asdict(self) + cfg["feature_subset"] = tuple(cfg["feature_subset"]) if cfg["feature_subset"] else None + cfg["population_filter_hash"] = ( + hash_dict(cfg["population_filter"]) + if cfg["population_filter"] else None + ) + return int(hash_dict(cfg), 16) + class CalibrationBenchmark: """A benchmark class for measuring and evaluating LLM calibration.""" @@ -163,9 +172,10 @@ def run(self, fit_threshold: int | False = False) -> float: s_test = self.dataset.get_sensitive_attribute_data().loc[y_test.index] # Get LLM risk-estimate predictions for each row in the test set + test_predictions_save_path = self._get_predictions_save_path("test") self._y_test_scores = self.llm_clf.predict_proba( data=X_test, - predictions_save_path=self._get_predictions_save_path("test"), + predictions_save_path=test_predictions_save_path, labels=y_test, # used only to save alongside predictions in disk ) @@ -190,6 +200,9 @@ def run(self, fit_threshold: int | False = False) -> float: model_name=self.llm_clf.model_name, ) + # Save predictions save path + self._results["predictions_path"] = test_predictions_save_path.as_posix() + # Log main results msg = ( f"\n** Test results **\n" @@ -305,7 +318,7 @@ def make_benchmark( task = TaskMetadata.get_task(task) if config.feature_subset is not None and len(config.feature_subset) > 0: - task = task.create_task_with_feature_subset(list(config.feature_subset)) + task = task.create_task_with_feature_subset(config.feature_subset) dataset.task = task # Check dataset is compatible with task diff --git a/folktexts/classifier.py b/folktexts/classifier.py index 85e604d..c95c358 100755 --- a/folktexts/classifier.py +++ b/folktexts/classifier.py @@ -103,9 +103,12 @@ def model_name(self) -> str: @threshold.setter def threshold(self, value: float) -> float: - assert 0 <= value <= 1, "Threshold must be between 0 and 1." - logging.debug(f"Setting threshold to {value}.") - self._threshold = value + if not 0 <= value <= 1: + logging.error(f"Threshold must be between 0 and 1; got {value}.") + + # Clip threshold to valid range + self._threshold = np.clip(value, 0, 1) + logging.info(f"Set threshold to {self._threshold}.") def __hash__(self) -> int: """Generate a unique hash for the LLMClassifier object.""" diff --git a/folktexts/cli/_utils.py b/folktexts/cli/_utils.py index e05abfd..d135583 100644 --- a/folktexts/cli/_utils.py +++ b/folktexts/cli/_utils.py @@ -29,7 +29,9 @@ def _handle_str_value(val: str) -> int | float | str | bool: for arg in cmdline_args: parsed_arg = arg.lstrip("-").replace("-", "_") if "=" in parsed_arg: - key, val = parsed_arg.split("=") + split_idx = parsed_arg.index("=") + key = parsed_arg[:split_idx] + val = parsed_arg[split_idx + 1:] kwargs_dict[key] = _handle_str_value(val) else: kwargs_dict[parsed_arg] = True diff --git a/folktexts/cli/experiments.py b/folktexts/cli/experiments.py index b93388f..22cb1e1 100644 --- a/folktexts/cli/experiments.py +++ b/folktexts/cli/experiments.py @@ -17,7 +17,7 @@ DEFAULT_JOB_MEMORY_GB = 62 # GBs of memory DEFAULT_GPU_MEMORY_GB = 30 # GBs of GPU memory -MAX_RUNNING_PRICE = 1000 +MAX_RUNNING_PRICE = 1500 # Max price for running a job @dataclass @@ -97,7 +97,7 @@ def launch_experiment_job(exp: Experiment): # Concurrency limits: # > each job uses this amount of resources out of a pool of 10k - "concurrency_limits": "user.llm_clf:500", # 20 jobs in parallel + "concurrency_limits": "user.folktexts:100", # 100 jobs in parallel "+MaxRunningPrice": MAX_RUNNING_PRICE, "+RunningPriceExceededAction": classad.quote("restart"), diff --git a/folktexts/cli/launch_acs_benchmarks.py b/folktexts/cli/launch_acs_benchmarks.py index 9242e8c..72caea1 100755 --- a/folktexts/cli/launch_acs_benchmarks.py +++ b/folktexts/cli/launch_acs_benchmarks.py @@ -8,7 +8,6 @@ from pprint import pprint from folktexts._io import load_json, save_json -from folktexts._utils import get_current_date from folktexts.llm_utils import get_model_folder_path, get_model_size_B from .experiments import Experiment, launch_experiment_job @@ -16,7 +15,7 @@ # All ACS prediction tasks ACS_TASKS = ( "ACSIncome", - # "ACSEmployment", # TODO: get other ACS tasks running + # "ACSEmployment", # TODO: run on other ACS tasks # "ACSMobility", # "ACSTravelTime", # "ACSPublicCoverage", @@ -26,14 +25,13 @@ # Useful paths # ################ ROOT_DIR = Path("/fast/groups/sf") -# ROOT_DIR = Path("/fast/acruz") # ROOT_DIR = Path("~").expanduser().resolve() # on local machine # ACS data directory ACS_DATA_DIR = ROOT_DIR / "data" # Directory to save results in (make sure it exists) -RESULTS_DIR = ROOT_DIR / "folktexts-results" / get_current_date() +RESULTS_DIR = ROOT_DIR / "folktexts-results" RESULTS_DIR.mkdir(exist_ok=True, parents=False) # Models save directory @@ -49,14 +47,12 @@ BATCH_SIZE = 30 CONTEXT_SIZE = 500 CORRECT_ORDER_BIAS = True -FIT_THRESHOLD = 100 VERBOSE = True JOB_CPUS = 4 JOB_MEMORY_GB = 60 -# JOB_BID = 50 -JOB_BID = 505 +JOB_BID = 250 # LLMs to evaluate LLM_MODELS = [ @@ -65,20 +61,20 @@ "google/gemma-1.1-2b-it", # # ** Medium models ** - # "google/gemma-7b", - # "google/gemma-1.1-7b-it", - # "mistralai/Mistral-7B-v0.1", - # "mistralai/Mistral-7B-Instruct-v0.2", - # "meta-llama/Meta-Llama-3-8B", - # "meta-llama/Meta-Llama-3-8B-Instruct", + "google/gemma-7b", + "google/gemma-1.1-7b-it", + "mistralai/Mistral-7B-v0.1", + "mistralai/Mistral-7B-Instruct-v0.2", + "meta-llama/Meta-Llama-3-8B", + "meta-llama/Meta-Llama-3-8B-Instruct", # # ** Large models ** - # "01-ai/Yi-34B", - # "01-ai/Yi-34B-Chat", - # "mistralai/Mixtral-8x7B-v0.1", - # "mistralai/Mixtral-8x7B-Instruct-v0.1", - # "meta-llama/Meta-Llama-3-70B", - # "meta-llama/Meta-Llama-3-70B-Instruct", + "01-ai/Yi-34B", + "01-ai/Yi-34B-Chat", + "mistralai/Mixtral-8x7B-v0.1", + "mistralai/Mixtral-8x7B-Instruct-v0.1", + "meta-llama/Meta-Llama-3-70B", + "meta-llama/Meta-Llama-3-70B-Instruct", # "mistralai/Mixtral-8x22B-v0.1", # "mistralai/Mixtral-8x22B-Instruct-v0.1", ] @@ -115,7 +111,7 @@ def make_llm_as_clf_experiment( experiment_kwargs.setdefault("batch_size", math.ceil(BATCH_SIZE / n_shots)) experiment_kwargs.setdefault("context_size", CONTEXT_SIZE * n_shots) experiment_kwargs.setdefault("data_dir", ACS_DATA_DIR.as_posix()) - experiment_kwargs.setdefault("fit_threshold", FIT_THRESHOLD) + # experiment_kwargs.setdefault("fit_threshold", FIT_THRESHOLD) # Define experiment exp = Experiment( diff --git a/folktexts/cli/run_acs_benchmark.py b/folktexts/cli/run_acs_benchmark.py index 017b416..43cc3c6 100755 --- a/folktexts/cli/run_acs_benchmark.py +++ b/folktexts/cli/run_acs_benchmark.py @@ -1,8 +1,8 @@ #!/usr/bin/env python3 """Runs the LLM calibration benchmark from the command line. """ -import logging import json +import logging import sys from argparse import ArgumentParser from pathlib import Path @@ -119,11 +119,8 @@ def setup_arg_parser() -> ArgumentParser: # Parse population filter if provided population_filter_dict = None if args.use_population_filter: - import ipdb; ipdb.set_trace() # TODO: debug - population_filter_dict = dict() - for filter_str in args.use_population_filter: # TODO: split by whitespace? - col_name, col_value = filter_str.split("=") - population_filter_dict[col_name] = col_value + from ._utils import cmd_line_args_to_kwargs + population_filter_dict = cmd_line_args_to_kwargs(args.use_population_filter) # Load model and tokenizer from folktexts.llm_utils import load_model_tokenizer @@ -139,7 +136,7 @@ def setup_arg_parser() -> ArgumentParser: batch_size=args.batch_size, context_size=args.context_size, correct_order_bias=not args.dont_correct_order_bias, - feature_subset=tuple(args.use_feature_subset) or None, + feature_subset=args.use_feature_subset or None, population_filter=population_filter_dict, seed=args.seed, ) diff --git a/folktexts/dataset.py b/folktexts/dataset.py index dba5d63..79357b9 100755 --- a/folktexts/dataset.py +++ b/folktexts/dataset.py @@ -59,7 +59,6 @@ def __init__( self._test_size = test_size self._val_size = val_size or 0 self._train_size = 1 - self._test_size - self._val_size - self._subsampling = subsampling assert self._train_size > 0 self._seed = seed @@ -79,8 +78,9 @@ def __init__( self._val_indices = None # Subsample the train/test/val data (if requested) - if self._subsampling is not None: - self._subsample_inplace(self._subsampling) + self._subsampling = None + if subsampling is not None: + self._subsample_inplace(subsampling) @property def data(self) -> pd.DataFrame: @@ -115,7 +115,7 @@ def val_size(self) -> float: @property def subsampling(self) -> float: - return self._subsampling + return getattr(self, "_subsampling", None) @property def seed(self) -> int: @@ -155,7 +155,7 @@ def _subsample_inplace(self, subsampling: float) -> "Dataset": self._val_indices = self._val_indices[: new_val_size] # Update subsampling factor - self._subsampling = (self._subsampling or 1) * subsampling + self._subsampling = (getattr(self, "_subsampling", None) or 1) * subsampling # Log new dataset size msg = ( @@ -177,8 +177,6 @@ def _filter_inplace( population_feature_values: dict, ) -> "Dataset": """Subset the dataset in-place: keep only samples with the given feature values.""" - import ipdb; ipdb.set_trace() - # Check argument is of valid type if not isinstance(population_feature_values, dict): raise ValueError( @@ -188,8 +186,8 @@ def _filter_inplace( # Check argument keys are valid columns if not all(key in self.data.columns for key in population_feature_values.keys()): raise ValueError( - f"Invalid `population_feature_values` keys: " - f"{population_feature_values.keys()}.") + f"Invalid `population_feature_values` keys; columns don't exist " + f"in the dataset: {list(population_feature_values.keys())}.") # Create boolean filter based on the given feature values population_filter = pd.Series(True, index=self.data.index) diff --git a/folktexts/evaluation.py b/folktexts/evaluation.py index 99969fd..0d716e2 100644 --- a/folktexts/evaluation.py +++ b/folktexts/evaluation.py @@ -268,7 +268,7 @@ def evaluate_predictions( results.update(evaluate_binary_predictions(y_true, y_pred_binary)) # Add loss functions as proxies for calibration - results["log_loss"] = log_loss(y_true, y_pred_scores) + results["log_loss"] = log_loss(y_true, y_pred_scores, labels=[0, 1]) results["brier_score_loss"] = brier_score_loss(y_true, y_pred_scores) # Evaluate fairness metrics diff --git a/folktexts/task.py b/folktexts/task.py index b422687..38bab56 100755 --- a/folktexts/task.py +++ b/folktexts/task.py @@ -2,8 +2,8 @@ """ from __future__ import annotations -import logging import dataclasses +import logging from dataclasses import dataclass, field from typing import Callable, ClassVar, Iterable diff --git a/notebooks/parse-results.ipynb b/notebooks/parse-results.ipynb new file mode 100644 index 0000000..3c2a2c3 --- /dev/null +++ b/notebooks/parse-results.ipynb @@ -0,0 +1,2272 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3b241208-d10f-43cf-a486-84c54bbf43c3", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import os\n", + "import re\n", + "import json\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "def load_json(path: str | Path) -> object:\n", + " \"\"\"Loads a JSON file from disk and returns the deserialized object.\"\"\"\n", + " with open(path, \"r\") as f_in:\n", + " return json.load(f_in)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "26089a60-81c0-4736-8ba5-99572ec01398", + "metadata": {}, + "outputs": [], + "source": [ + "# ROOT_DIR = Path(\"/fast/groups/sf/\") # CLUSTER\n", + "ROOT_DIR = Path(\"/Volumes/sf/\") # LOCAL\n", + "\n", + "RESULTS_ROOT_DIR = ROOT_DIR / \"folktexts-results\" / \"2024-06-05\"\n", + "RESULTS_ROOT_DIR = ROOT_DIR / \"folktexts-results\" / \"2024-06-05_2\"\n", + "\n", + "DATA_DIR = ROOT_DIR / \"data\"\n", + "\n", + "## Local paths\n", + "def correct_path(p):\n", + " finder_str = \"folktexts-results\"\n", + " new_p = ROOT_DIR / p[p.find(finder_str):]\n", + " return new_p.resolve()" + ] + }, + { + "cell_type": "markdown", + "id": "db7c98c5-2942-4f88-984a-8c9014afe761", + "metadata": {}, + "source": [ + "Important results columns:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e96f0c4f-5683-4150-8cca-93a883f20154", + "metadata": {}, + "outputs": [], + "source": [ + "model_col = \"config_model_name\"\n", + "# model_col = \"model_name\"\n", + "feature_subset_col = \"config_feature_subset\"\n", + "population_subset_col = \"config_population_filter\"\n", + "predictions_path_col = \"predictions_path\"\n", + "\n", + "uses_all_features_col = \"uses_all_features\"\n", + "uses_all_samples_col = \"uses_all_samples\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0cf4a6c8-ec28-4e66-9f6d-8a4e977d7b60", + "metadata": {}, + "outputs": [], + "source": [ + "def find_files(root_folder, pattern):\n", + " # Compile the regular expression pattern\n", + " regex = re.compile(pattern)\n", + "\n", + " # Walk through the directory tree\n", + " for dirpath, dirnames, filenames in os.walk(root_folder):\n", + " for filename in filenames:\n", + " if regex.match(filename):\n", + " # If the filename matches the pattern, add it to the list\n", + " yield os.path.join(dirpath, filename)\n", + "\n", + "def parse_model_name(name: str) -> str:\n", + " name = name[name.find(\"--\")+2:]\n", + " return name\n", + "\n", + "def get_non_instruction_tuned_name(name):\n", + " name = name.replace(\"-Instruct\", \"\")\n", + " name = name.replace(\"-Chat\", \"\")\n", + " name = name.replace(\"-it\", \"\")\n", + " name = name.replace(\"-1.1\", \"\")\n", + " name = name.replace(\"-v0.2\", \"-v0.1\")\n", + " return name\n", + "\n", + "def parse_results_dict(dct) -> dict:\n", + " \"\"\"Parses results dict; brings all information to the top-level.\"\"\"\n", + " dct = dct.copy()\n", + " dct.pop(\"plots\", None)\n", + " config = dct.pop(\"config\", {})\n", + " for key, val in config.items():\n", + " dct[f\"config_{key}\"] = val\n", + "\n", + " # Parse model name\n", + " dct[model_col] = parse_model_name(dct[model_col])\n", + " dct[uses_all_features_col] = dct[feature_subset_col] is None\n", + " if dct[feature_subset_col] is None:\n", + " dct[feature_subset_col] = \"full\"\n", + "\n", + " dct[uses_all_samples_col] = dct[population_subset_col] is None\n", + "\n", + " dct[\"base_name\"] = get_non_instruction_tuned_name(dct[model_col])\n", + " dct[\"is_inst\"] = dct[\"base_name\"] != dct[model_col]\n", + "\n", + " assert not any(isinstance(val, dict) for val in dct.values()), dct\n", + " return dct" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "aaefa99d-dbd7-40a3-a3c1-7571d3811409", + "metadata": {}, + "outputs": [], + "source": [ + "# Results file name pattern\n", + "pattern = r'^results.bench-(?P\\d+)[.]json$'\n", + "\n", + "# Find results files and aggregate\n", + "results = {}\n", + "for file_path in find_files(RESULTS_ROOT_DIR, pattern):\n", + " results[Path(file_path).parent.name] = parse_results_dict(load_json(file_path))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4a1c9ffe-8e52-46fc-b324-f2455c52d4f2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "df.shape=(70, 57)\n" + ] + }, + { + "data": { + "text/html": [ + "
\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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accuracyaccuracy_diffaccuracy_ratiobalanced_accuracybalanced_accuracy_diffbalanced_accuracy_ratiobrier_score_losseceece_quantileequalized_odds_diff...config_model_nameconfig_population_filterconfig_reuse_few_shot_examplesconfig_seedconfig_task_hashconfig_task_nameuses_all_featuresuses_all_samplesbase_nameis_inst
model
Mixtral-8x7B-v0.10.6062600.2648680.6670920.5003140.0075680.9850890.2249860.1112230.1200320.016535...Mixtral-8x7B-v0.1NoneFalse42503311427ACSIncome_AGEP_COW_RAC1P_SCHLFalseTrueMixtral-8x7B-v0.1False
Mixtral-8x7B-Instruct-v0.10.7111690.1001590.8743850.6795130.2091620.7130350.2613230.2457780.2450950.703850...Mixtral-8x7B-Instruct-v0.1NoneFalse42503311427ACSIncome_AGEP_COW_RAC1P_SCHLFalseTrueMixtral-8x7B-v0.1True
Mistral-7B-Instruct-v0.20.6998920.1099070.8621400.6735500.1569300.7808450.2894750.2854420.2580330.593613...Mistral-7B-Instruct-v0.2NoneFalse421879551727ACSIncome_AGEP_COW_SCHLFalseTrueMistral-7B-v0.1True
\n", + "

3 rows × 57 columns

\n", + "
" + ], + "text/plain": [ + " accuracy accuracy_diff accuracy_ratio \\\n", + "model \n", + "Mixtral-8x7B-v0.1 0.606260 0.264868 0.667092 \n", + "Mixtral-8x7B-Instruct-v0.1 0.711169 0.100159 0.874385 \n", + "Mistral-7B-Instruct-v0.2 0.699892 0.109907 0.862140 \n", + "\n", + " balanced_accuracy balanced_accuracy_diff \\\n", + "model \n", + "Mixtral-8x7B-v0.1 0.500314 0.007568 \n", + "Mixtral-8x7B-Instruct-v0.1 0.679513 0.209162 \n", + "Mistral-7B-Instruct-v0.2 0.673550 0.156930 \n", + "\n", + " balanced_accuracy_ratio brier_score_loss \\\n", + "model \n", + "Mixtral-8x7B-v0.1 0.985089 0.224986 \n", + "Mixtral-8x7B-Instruct-v0.1 0.713035 0.261323 \n", + "Mistral-7B-Instruct-v0.2 0.780845 0.289475 \n", + "\n", + " ece ece_quantile equalized_odds_diff ... \\\n", + "model ... \n", + "Mixtral-8x7B-v0.1 0.111223 0.120032 0.016535 ... \n", + "Mixtral-8x7B-Instruct-v0.1 0.245778 0.245095 0.703850 ... \n", + "Mistral-7B-Instruct-v0.2 0.285442 0.258033 0.593613 ... \n", + "\n", + " config_model_name \\\n", + "model \n", + "Mixtral-8x7B-v0.1 Mixtral-8x7B-v0.1 \n", + "Mixtral-8x7B-Instruct-v0.1 Mixtral-8x7B-Instruct-v0.1 \n", + "Mistral-7B-Instruct-v0.2 Mistral-7B-Instruct-v0.2 \n", + "\n", + " config_population_filter \\\n", + "model \n", + "Mixtral-8x7B-v0.1 None \n", + "Mixtral-8x7B-Instruct-v0.1 None \n", + "Mistral-7B-Instruct-v0.2 None \n", + "\n", + " config_reuse_few_shot_examples config_seed \\\n", + "model \n", + "Mixtral-8x7B-v0.1 False 42 \n", + "Mixtral-8x7B-Instruct-v0.1 False 42 \n", + "Mistral-7B-Instruct-v0.2 False 42 \n", + "\n", + " config_task_hash config_task_name \\\n", + "model \n", + "Mixtral-8x7B-v0.1 503311427 ACSIncome_AGEP_COW_RAC1P_SCHL \n", + "Mixtral-8x7B-Instruct-v0.1 503311427 ACSIncome_AGEP_COW_RAC1P_SCHL \n", + "Mistral-7B-Instruct-v0.2 1879551727 ACSIncome_AGEP_COW_SCHL \n", + "\n", + " uses_all_features uses_all_samples \\\n", + "model \n", + "Mixtral-8x7B-v0.1 False True \n", + "Mixtral-8x7B-Instruct-v0.1 False True \n", + "Mistral-7B-Instruct-v0.2 False True \n", + "\n", + " base_name is_inst \n", + "model \n", + "Mixtral-8x7B-v0.1 Mixtral-8x7B-v0.1 False \n", + "Mixtral-8x7B-Instruct-v0.1 Mixtral-8x7B-v0.1 True \n", + "Mistral-7B-Instruct-v0.2 Mistral-7B-v0.1 True \n", + "\n", + "[3 rows x 57 columns]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(list(results.values()))\n", + "df = df.set_index(df[model_col].rename(\"model\"), drop=False)\n", + "\n", + "print(f\"{df.shape=}\")\n", + "df.sample(3)" + ] + }, + { + "cell_type": "markdown", + "id": "febaae27-916b-4951-8856-e8d9f5ff2f7c", + "metadata": {}, + "source": [ + "Evaluating LR and GBM:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "06e99f1e-0c84-4ee0-9c33-d65e76f04447", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading ACS data...\n", + "CPU times: user 37.8 s, sys: 13.3 s, total: 51.1 s\n", + "Wall time: 1min 26s\n" + ] + } + ], + "source": [ + "%%time\n", + "from folktexts.acs.acs_dataset import ACSDataset\n", + "acs_income_dt = ACSDataset(task=\"ACSIncome\", cache_dir=DATA_DIR)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "12ef86ad-310c-4b48-9d22-b53b6c179737", + "metadata": {}, + "outputs": [], + "source": [ + "X_train, y_train = acs_income_dt.get_train()\n", + "X_test, y_test = acs_income_dt.get_test()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cbf93e50-f60b-4834-be9f-022c0ae827bf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 25.4 s, sys: 30 s, total: 55.4 s\n", + "Wall time: 6.54 s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/acruz/opt/miniconda3/envs/folktexts/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:469: ConvergenceWarning: lbfgs failed to converge (status=1):\n", + "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n", + "\n", + "Increase the number of iterations (max_iter) or scale the data as shown in:\n", + " https://scikit-learn.org/stable/modules/preprocessing.html\n", + "Please also refer to the documentation for alternative solver options:\n", + " https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n", + " n_iter_i = _check_optimize_result(\n" + ] + }, + { + "data": { + "text/html": [ + "
LogisticRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LogisticRegression()" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "from sklearn.linear_model import LogisticRegression\n", + "lr = LogisticRegression()\n", + "lr.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0c9928cc-457c-498b-bfa3-72317e1eec97", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 32.5 s, sys: 14.5 s, total: 47 s\n", + "Wall time: 5.75 s\n" + ] + }, + { + "data": { + "text/html": [ + "
HistGradientBoostingClassifier()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "HistGradientBoostingClassifier()" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "from sklearn.ensemble import HistGradientBoostingClassifier\n", + "gbm = HistGradientBoostingClassifier()\n", + "gbm.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a11a361a-5f16-456a-a3a6-a30281e672d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2.34 s, sys: 2.79 s, total: 5.13 s\n", + "Wall time: 550 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "from folktexts.evaluation import evaluate_predictions\n", + "lr_scores = lr.predict_proba(X_test)[:, -1]\n", + "lr_results = evaluate_predictions(y_test.to_numpy(), lr_scores, threshold=0.5)\n", + "\n", + "gbm_scores = gbm.predict_proba(X_test)[:, -1]\n", + "gbm_results = evaluate_predictions(y_test.to_numpy(), gbm_scores, threshold=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a9e0ee6b-e37f-4de9-99b2-b13eba2f5dc3", + "metadata": {}, + "outputs": [], + "source": [ + "lr_results[model_col] = \"LR\"\n", + "gbm_results[model_col] = \"GBM\"\n", + "\n", + "for r in [lr_results, gbm_results]:\n", + " r[uses_all_features_col] = True\n", + " r[uses_all_samples_col] = True\n", + " r[\"base_name\"] = r[model_col]" + ] + }, + { + "cell_type": "markdown", + "id": "c5ce614e-d6fc-4c6e-8e6d-b4e72ca2fbfe", + "metadata": {}, + "source": [ + "Add LR and GBM results to table:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "bbd0f7f9-29ca-4aa3-ac23-663ca1e86c6e", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.concat((df, pd.DataFrame([gbm_results, lr_results], index=[\"GBM\", \"LR\"])))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "89d4b656-aae6-4a59-83c6-5cc3f60df1db", + "metadata": {}, + "outputs": [], + "source": [ + "def _helper(val):\n", + " try:\n", + " return len(val)\n", + " except Exception:\n", + " return 10\n", + "\n", + "df[\"num_features\"] = df[feature_subset_col].map(_helper)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9725afa2-b6f8-46b1-86e7-57ae82ef05d9", + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime\n", + "def get_current_timestamp() -> str:\n", + " \"\"\"Return a timestamp representing the current time up to the second.\"\"\"\n", + " return datetime.now().strftime(\"%Y.%m.%d-%H.%M.%S\")\n", + "\n", + "df.to_csv(Path(RESULTS_ROOT_DIR) / f\"aggregated_results.{get_current_timestamp()}.csv\")" + ] + }, + { + "cell_type": "markdown", + "id": "67d816e1-9114-451a-9bca-44c2864d14b6", + "metadata": {}, + "source": [ + "# Analyze results" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "2ba5adb0-459c-4847-a14c-61297de4b03f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "df_full_data.shape=(16, 58)\n" + ] + }, + { + "data": { + "text/html": [ + "
\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", + " \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", + " \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", + "
accuracyaccuracy_diffaccuracy_ratiobalanced_accuracybalanced_accuracy_diffbalanced_accuracy_ratiobrier_score_losseceece_quantileequalized_odds_diff...config_population_filterconfig_reuse_few_shot_examplesconfig_seedconfig_task_hashconfig_task_nameuses_all_featuresuses_all_samplesbase_nameis_instnum_features
Meta-Llama-3-8B-Instruct0.6027880.0819960.8772890.6682260.1089360.8546700.3129750.3420650.3420650.318946...NoneFalse42.0843421931.0ACSIncomeTrueTrueMeta-Llama-3-8BTrue4
Meta-Llama-3-70B0.7272750.0949780.8828970.7578230.1066350.8665870.1958090.1923760.1921590.331146...NoneFalse42.0843421931.0ACSIncomeTrueTrueMeta-Llama-3-70BFalse4
\n", + "

2 rows × 58 columns

\n", + "
" + ], + "text/plain": [ + " accuracy accuracy_diff accuracy_ratio \\\n", + "Meta-Llama-3-8B-Instruct 0.602788 0.081996 0.877289 \n", + "Meta-Llama-3-70B 0.727275 0.094978 0.882897 \n", + "\n", + " balanced_accuracy balanced_accuracy_diff \\\n", + "Meta-Llama-3-8B-Instruct 0.668226 0.108936 \n", + "Meta-Llama-3-70B 0.757823 0.106635 \n", + "\n", + " balanced_accuracy_ratio brier_score_loss ece \\\n", + "Meta-Llama-3-8B-Instruct 0.854670 0.312975 0.342065 \n", + "Meta-Llama-3-70B 0.866587 0.195809 0.192376 \n", + "\n", + " ece_quantile equalized_odds_diff ... \\\n", + "Meta-Llama-3-8B-Instruct 0.342065 0.318946 ... \n", + "Meta-Llama-3-70B 0.192159 0.331146 ... \n", + "\n", + " config_population_filter \\\n", + "Meta-Llama-3-8B-Instruct None \n", + "Meta-Llama-3-70B None \n", + "\n", + " config_reuse_few_shot_examples config_seed \\\n", + "Meta-Llama-3-8B-Instruct False 42.0 \n", + "Meta-Llama-3-70B False 42.0 \n", + "\n", + " config_task_hash config_task_name \\\n", + "Meta-Llama-3-8B-Instruct 843421931.0 ACSIncome \n", + "Meta-Llama-3-70B 843421931.0 ACSIncome \n", + "\n", + " uses_all_features uses_all_samples \\\n", + "Meta-Llama-3-8B-Instruct True True \n", + "Meta-Llama-3-70B True True \n", + "\n", + " base_name is_inst num_features \n", + "Meta-Llama-3-8B-Instruct Meta-Llama-3-8B True 4 \n", + "Meta-Llama-3-70B Meta-Llama-3-70B False 4 \n", + "\n", + "[2 rows x 58 columns]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_full_data = df[df[uses_all_features_col] & df[uses_all_samples_col]]\n", + "# df_full_data = df[df[feature_subset_col].isna()]\n", + "print(f\"{df_full_data.shape=}\")\n", + "df_full_data.head(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "31a1836c-4231-4534-b6af-69a4480cd543", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\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", + " \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", + " \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", + "
config_model_nameconfig_feature_subsetece
GBMGBMNaN0.008511
LRLRNaN0.031498
Mixtral-8x7B-v0.1Mixtral-8x7B-v0.1[AGEP, COW]0.041188
Mixtral-8x7B-v0.1Mixtral-8x7B-v0.1[AGEP, COW, SCHL, RAC1P, SEX]0.088267
Mixtral-8x7B-v0.1Mixtral-8x7B-v0.1[AGEP, COW, SCHL]0.089387
............
gemma-1.1-2b-itgemma-1.1-2b-itfull0.600910
gemma-1.1-2b-itgemma-1.1-2b-it[AGEP, COW, SCHL, RAC1P]0.601208
gemma-1.1-2b-itgemma-1.1-2b-it[AGEP, COW, SCHL]0.601924
gemma-1.1-2b-itgemma-1.1-2b-it[AGEP, COW]0.603736
gemma-1.1-7b-itgemma-1.1-7b-it[AGEP, COW]0.604511
\n", + "

72 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " config_model_name config_feature_subset ece\n", + "GBM GBM NaN 0.008511\n", + "LR LR NaN 0.031498\n", + "Mixtral-8x7B-v0.1 Mixtral-8x7B-v0.1 [AGEP, COW] 0.041188\n", + "Mixtral-8x7B-v0.1 Mixtral-8x7B-v0.1 [AGEP, COW, SCHL, RAC1P, SEX] 0.088267\n", + "Mixtral-8x7B-v0.1 Mixtral-8x7B-v0.1 [AGEP, COW, SCHL] 0.089387\n", + "... ... ... ...\n", + "gemma-1.1-2b-it gemma-1.1-2b-it full 0.600910\n", + "gemma-1.1-2b-it gemma-1.1-2b-it [AGEP, COW, SCHL, RAC1P] 0.601208\n", + "gemma-1.1-2b-it gemma-1.1-2b-it [AGEP, COW, SCHL] 0.601924\n", + "gemma-1.1-2b-it gemma-1.1-2b-it [AGEP, COW] 0.603736\n", + "gemma-1.1-7b-it gemma-1.1-7b-it [AGEP, COW] 0.604511\n", + "\n", + "[72 rows x 3 columns]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.sort_values(\"ece\")[[model_col, feature_subset_col, \"ece\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "4a4eba2a-c395-4069-80b8-1e4593c4fbc3", + "metadata": {}, + "outputs": [], + "source": [ + "metrics = [\"ece\", \"brier_score_loss\", \"log_loss\", \"roc_auc\", \"accuracy\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "4a86eab4-fa77-4a21-a6b3-c95864ffd956", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\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", + " \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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ecebrier score losslog lossroc aucaccuracy
GBM0.00850.13030.40250.89190.8098
LR0.03150.18130.54120.78900.7335
Meta-Llama-3-70B0.19240.19580.57960.86160.7273
Meta-Llama-3-70B-Instruct0.26650.26321.39440.86390.6887
Meta-Llama-3-8B-Instruct0.34210.31301.07720.85620.6028
Meta-Llama-3-8B0.22630.26450.72180.80300.3946
Mistral-7B-Instruct-v0.20.22060.22971.95630.84130.7516
Mistral-7B-v0.10.20360.23410.66130.78550.7301
Mixtral-8x7B-Instruct-v0.10.17600.19500.94100.85340.7699
Mixtral-8x7B-v0.10.17540.21850.62720.80870.6120
Yi-34B-Chat0.25880.23100.72720.85800.6659
Yi-34B0.24160.22540.63930.85580.6034
gemma-1.1-2b-it0.60090.59893.19000.71630.3940
gemma-2b0.10560.24610.68530.63840.5558
gemma-7b0.21560.27070.73560.64430.3940
gemma-1.1-7b-it0.58840.57483.18840.83890.3941
\n", + "
" + ], + "text/plain": [ + " ece brier score loss log loss roc auc \\\n", + "GBM 0.0085 0.1303 0.4025 0.8919 \n", + "LR 0.0315 0.1813 0.5412 0.7890 \n", + "Meta-Llama-3-70B 0.1924 0.1958 0.5796 0.8616 \n", + "Meta-Llama-3-70B-Instruct 0.2665 0.2632 1.3944 0.8639 \n", + "Meta-Llama-3-8B-Instruct 0.3421 0.3130 1.0772 0.8562 \n", + "Meta-Llama-3-8B 0.2263 0.2645 0.7218 0.8030 \n", + "Mistral-7B-Instruct-v0.2 0.2206 0.2297 1.9563 0.8413 \n", + "Mistral-7B-v0.1 0.2036 0.2341 0.6613 0.7855 \n", + "Mixtral-8x7B-Instruct-v0.1 0.1760 0.1950 0.9410 0.8534 \n", + "Mixtral-8x7B-v0.1 0.1754 0.2185 0.6272 0.8087 \n", + "Yi-34B-Chat 0.2588 0.2310 0.7272 0.8580 \n", + "Yi-34B 0.2416 0.2254 0.6393 0.8558 \n", + "gemma-1.1-2b-it 0.6009 0.5989 3.1900 0.7163 \n", + "gemma-2b 0.1056 0.2461 0.6853 0.6384 \n", + "gemma-7b 0.2156 0.2707 0.7356 0.6443 \n", + "gemma-1.1-7b-it 0.5884 0.5748 3.1884 0.8389 \n", + "\n", + " accuracy \n", + "GBM 0.8098 \n", + "LR 0.7335 \n", + "Meta-Llama-3-70B 0.7273 \n", + "Meta-Llama-3-70B-Instruct 0.6887 \n", + "Meta-Llama-3-8B-Instruct 0.6028 \n", + "Meta-Llama-3-8B 0.3946 \n", + "Mistral-7B-Instruct-v0.2 0.7516 \n", + "Mistral-7B-v0.1 0.7301 \n", + "Mixtral-8x7B-Instruct-v0.1 0.7699 \n", + "Mixtral-8x7B-v0.1 0.6120 \n", + "Yi-34B-Chat 0.6659 \n", + "Yi-34B 0.6034 \n", + "gemma-1.1-2b-it 0.3940 \n", + "gemma-2b 0.5558 \n", + "gemma-7b 0.3940 \n", + "gemma-1.1-7b-it 0.3941 " + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "latex_table = df_full_data.sort_values(\"base_name\")[metrics].round(4)\n", + "latex_table = latex_table.rename(columns=lambda col: col.replace(\"_\", \" \"))\n", + "latex_table" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "37689953-b2aa-45f0-87f1-ce3e5119df1a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\begin{tabular}{lrrrrr}\n", + "\\toprule\n", + " & ece & brier score loss & log loss & roc auc & accuracy \\\\\n", + "\\midrule\n", + "GBM & 0.01 & 0.13 & 0.40 & 0.89 & 0.81 \\\\\n", + "LR & 0.03 & 0.18 & 0.54 & 0.79 & 0.73 \\\\\n", + "Meta-Llama-3-70B & 0.19 & 0.20 & 0.58 & 0.86 & 0.73 \\\\\n", + "Meta-Llama-3-70B-Instruct & 0.27 & 0.26 & 1.39 & 0.86 & 0.69 \\\\\n", + "Meta-Llama-3-8B-Instruct & 0.34 & 0.31 & 1.08 & 0.86 & 0.60 \\\\\n", + "Meta-Llama-3-8B & 0.23 & 0.26 & 0.72 & 0.80 & 0.39 \\\\\n", + "Mistral-7B-Instruct-v0.2 & 0.22 & 0.23 & 1.96 & 0.84 & 0.75 \\\\\n", + "Mistral-7B-v0.1 & 0.20 & 0.23 & 0.66 & 0.79 & 0.73 \\\\\n", + "Mixtral-8x7B-Instruct-v0.1 & 0.18 & 0.20 & 0.94 & 0.85 & 0.77 \\\\\n", + "Mixtral-8x7B-v0.1 & 0.18 & 0.22 & 0.63 & 0.81 & 0.61 \\\\\n", + "Yi-34B-Chat & 0.26 & 0.23 & 0.73 & 0.86 & 0.67 \\\\\n", + "Yi-34B & 0.24 & 0.23 & 0.64 & 0.86 & 0.60 \\\\\n", + "gemma-1.1-2b-it & 0.60 & 0.60 & 3.19 & 0.72 & 0.39 \\\\\n", + "gemma-2b & 0.11 & 0.25 & 0.69 & 0.64 & 0.56 \\\\\n", + "gemma-7b & 0.22 & 0.27 & 0.74 & 0.64 & 0.39 \\\\\n", + "gemma-1.1-7b-it & 0.59 & 0.57 & 3.19 & 0.84 & 0.39 \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n" + ] + } + ], + "source": [ + "print(latex_table.to_latex(float_format=\"%.2f\"))" + ] + }, + { + "cell_type": "markdown", + "id": "1cc15539-afda-4e6d-bb93-326ef566b25e", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "5b7b141d-a5f2-4a5e-bf4b-fbd94e02caa5", + "metadata": {}, + "source": [ + "## Score distribution plot" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "f4dd87d8-039e-4c84-9175-f3b415868166", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "[(0.00392156862745098, 0.45098039215686275, 0.6980392156862745),\n", + " (0.8705882352941177, 0.5607843137254902, 0.0196078431372549),\n", + " (0.00784313725490196, 0.6196078431372549, 0.45098039215686275),\n", + " (0.8352941176470589, 0.3686274509803922, 0.0),\n", + " (0.8, 0.47058823529411764, 0.7372549019607844),\n", + " (0.792156862745098, 0.5686274509803921, 0.3803921568627451),\n", + " (0.984313725490196, 0.6862745098039216, 0.8941176470588236),\n", + " (0.5803921568627451, 0.5803921568627451, 0.5803921568627451),\n", + " (0.9254901960784314, 0.8823529411764706, 0.2),\n", + " (0.33725490196078434, 0.7058823529411765, 0.9137254901960784)]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "sns.set_style(\"whitegrid\", rc={\"grid.linestyle\": \"--\"})\n", + "sns.color_palette(\"colorblind\")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "9f0b9634-b554-4e6d-a4ed-0dbe96f26412", + "metadata": {}, + "outputs": [], + "source": [ + "model_scores = {\n", + " row[model_col]: pd.read_csv(correct_path(row[predictions_path_col]), index_col=0)\n", + " for _, row in df_full_data.iterrows()\n", + " if not pd.isna(row[predictions_path_col])\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "796f52b2-9b84-4752-b69d-413208db7f80", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('Meta-Llama-3-70B', 'Meta-Llama-3-70B-Instruct'),\n", + " ('Meta-Llama-3-8B', 'Meta-Llama-3-8B-Instruct'),\n", + " ('gemma-7b', 'gemma-1.1-7b-it'),\n", + " ('Yi-34B', 'Yi-34B-Chat'),\n", + " ('Mixtral-8x7B-v0.1', 'Mixtral-8x7B-Instruct-v0.1'),\n", + " ('Mistral-7B-v0.1', 'Mistral-7B-Instruct-v0.2'),\n", + " ('gemma-2b', 'gemma-1.1-2b-it')]" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from itertools import product\n", + "\n", + "model_pairs = [\n", + " (name_a, name_b)\n", + " for name_a, name_b in product(df_full_data[model_col].unique(), df_full_data[model_col].unique())\n", + " if name_a == get_non_instruction_tuned_name(name_b) and name_a != name_b\n", + "]\n", + "model_pairs" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "a7ba564c-a705-4252-a0e7-bf712437e3c7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('Meta-Llama-3-8B', 'Meta-Llama-3-8B-Instruct'),\n", + " ('Meta-Llama-3-70B', 'Meta-Llama-3-70B-Instruct'),\n", + " ('Yi-34B', 'Yi-34B-Chat'),\n", + " ('Mistral-7B-v0.1', 'Mistral-7B-Instruct-v0.2'),\n", + " ('Mixtral-8x7B-v0.1', 'Mixtral-8x7B-Instruct-v0.1')]" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# model_pairs_to_plot = model_pairs\n", + "# model_pairs_to_plot = model_pairs[:4]\n", + "model_pairs_to_plot = [model_pairs[1], model_pairs[0], model_pairs[3], model_pairs[5], model_pairs[4]]\n", + "model_pairs_to_plot" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "ba54e64a-883c-465a-8aa3-2e58b1b316f0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(ncols=len(model_pairs_to_plot), sharey=True, figsize=(12, 2.5), gridspec_kw=dict(wspace=0.05))\n", + "\n", + "for idx, (base_model, it_model) in enumerate(model_pairs_to_plot):\n", + " ax = axes[idx]\n", + " \n", + " base_scores = model_scores[base_model][\"risk_score\"]\n", + " it_scores = model_scores[it_model][\"risk_score\"]\n", + " \n", + " n_bins = 20\n", + " plot_config = dict(\n", + " bins=n_bins,\n", + " binrange=(0, 1),\n", + " stat=\"percent\",\n", + " ax=ax,\n", + " )\n", + " \n", + " ax.set_xlabel(\"risk scores\")\n", + " if idx == 0:\n", + " ax.set_ylabel(\"density (%)\")\n", + " \n", + " def get_label(model_name, base: bool):\n", + " return (\n", + " # f\"{model_name}\\n\" \n", + " (\"Base\" if base else \"Instruction-tuned\")\n", + " # + \"\\n\"\n", + " # + r\"($\\text{ece}=\" + f\"{df_full_data.loc[model_name]['ece']:.2f}\"\n", + " # + r\", \\text{roc}=\" + f\"{df_full_data.loc[model_name]['roc_auc']:.2f}\"\n", + " # + r\"$)\"\n", + " )\n", + "\n", + " ax.set_title(base_model.replace(\"-\", \" \"))\n", + "\n", + " sns.histplot(base_scores,label=get_label(base_model, base=True), **plot_config)\n", + " sns.histplot(it_scores, label=get_label(it_model, base=False), **plot_config)\n", + " # sns.histplot(gbm_scores, label=\"GBM\", **plot_config, alpha=0.3) # Plot GBM results as proxy for Bayes optimal?\n", + "\n", + " if idx == 0 or idx == len(model_pairs_to_plot) - 1:\n", + " ax.legend()\n", + "\n", + "plt.savefig(Path(RESULTS_ROOT_DIR) / \"score-distribution.pdf\", bbox_inches=\"tight\")" + ] + }, + { + "cell_type": "markdown", + "id": "3637772b-7cd1-4c73-b04a-6a4c9fcb8ef7", + "metadata": {}, + "source": [ + "## Plot on subsets of features" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "41b12610-71dd-4959-a392-f2ee3ce7aa28", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "config_model_name\n", + "GBM 0\n", + "LR 0\n", + "Meta-Llama-3-70B 5\n", + "Meta-Llama-3-70B-Instruct 5\n", + "Meta-Llama-3-8B 5\n", + "Meta-Llama-3-8B-Instruct 5\n", + "Mistral-7B-Instruct-v0.2 5\n", + "Mistral-7B-v0.1 5\n", + "Mixtral-8x7B-Instruct-v0.1 5\n", + "Mixtral-8x7B-v0.1 5\n", + "Yi-34B 5\n", + "Yi-34B-Chat 5\n", + "gemma-1.1-2b-it 5\n", + "gemma-1.1-7b-it 5\n", + "gemma-2b 5\n", + "gemma-7b 5\n", + "Name: config_feature_subset, dtype: int64" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.groupby(model_col).count()[feature_subset_col]" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "adc23e5b-246b-4314-9f3b-34e9c9dd3393", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scatter_data = df[((df[\"is_inst\"] == False) | (df[\"is_inst\"].isna())) & (df[\"num_features\"] > 2)]\n", + "\n", + "plt.figure(figsize=(3.5,3.5))\n", + "sns.scatterplot(scatter_data, x=\"ece\", y=\"roc_auc\", hue=\"base_name\")\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)\n", + "\n", + "plt.xlabel(\"Calibration (ECE)\")\n", + "plt.ylabel(\"Predictive Signal (ROC)\")\n", + "\n", + "plt.title(\"Evaluation on subsets of features\")\n", + "\n", + "# TODO: use different style for non-LLM markers\n", + "\n", + "plt.savefig(Path(RESULTS_ROOT_DIR) / \"features-subsets.pdf\", bbox_inches=\"tight\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "47f26d31-701e-46d5-9ddc-7becd63a9f80", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce47335e-d274-48e5-b1c5-07f0722df26e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 94bf219..8945ab4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,15 +24,16 @@ classifiers = [ "Topic :: Scientific/Engineering :: Artificial Intelligence", "Natural Language :: English", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.8", - "Programming Language :: Python :: 3.9", + # "Programming Language :: Python :: 3.8", # TODO: add compatibility with py3.8 + # "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", ] version = "0.0.4" -requires-python = ">=3.8" +# requires-python = ">=3.8" +requires-python = ">=3.10" dynamic = [ "readme", "dependencies", @@ -104,8 +105,8 @@ exclude = ["build", "doc"] legacy_tox_ini = """ [tox] env_list = - py38 - py39 + # py38 + # py39 py310 py311 py312