diff --git a/README.md b/README.md index cb5e8ad4..05b04c2b 100644 --- a/README.md +++ b/README.md @@ -275,6 +275,15 @@ dynamic benchmarks. between the two executions. **Note**: this is a beta feature and will need some adaptation for your own agent. +## Variables +Here's a list of relevant env. variables that are used by AgentLab: +- `OPEAI_API_KEY` which is used by default for OpenAI LLMs. +- `AZURE_OPENAI_API_KEY`, used by default for AzureOpenAI LLMs. +- `AZURE_OPENAI_ENDPOINT` to specify your Azure endpoint. +- `OPENAI_API_VERSION` for the Azure API. +- `OPENROUTER_API_KEY` for the Openrouter API +- `AGENTLAB_EXP_ROOT`, desired path for your experiments to be stored, defaults to `~/agentlab-results`. +- `AGENTXRAY_SHARE_GRADIO`, which prompts AgentXRay to open a public tunnel on launch. ## Misc diff --git a/pyproject.toml b/pyproject.toml index 2a1e06c3..1292836a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,10 +13,11 @@ authors = [ {name = "Alex Lacoste", email = "alex.lacoste@servicenow.com"}, {name = "Tom Marty", email = "tom.marty@polymtl.ca"}, {name = "Massimo Caccia", email = "massimo.caccia1@servicenow.com"}, - {name = "Thibault Le Sellier de Chezelles", email = "thibault.de.chezelles@gmail.com"} + {name = "Thibault Le Sellier de Chezelles", email = "thibault.de.chezelles@gmail.com"}, + {name = "Aman Jaiswal", email = "aman.jaiswal@servicenow.com"}, ] readme = "README.md" -requires-python = ">3.7" +requires-python = ">3.10" license = {text = "Apache-2.0"} classifiers = [ "Development Status :: 2 - Pre-Alpha", diff --git a/reproducibility_journal.csv b/reproducibility_journal.csv index b42d39ee..371e5426 100644 --- a/reproducibility_journal.csv +++ b/reproducibility_journal.csv @@ -74,3 +74,5 @@ Leo Boisvert,GenericAgent-openai_o1-mini-2024-09-12,workarena_l1,0.4.1,2025-02-0 M: src/agentlab/analyze/agent_xray.py M: src/agentlab/llm/llm_configs.py",0.13.3,1d2d7160e5b7ec9954ecb48988f71eb56288dd29," Leo Boisvert,GenericAgent-anthropic_claude-3.7-sonnet,workarena_l1,0.4.1,2025-02-25_02-32-09,d4f900c2-1de1-4e4b-a3ab-495ff2675fff,0.515,0.028,0,330/330,None,Linux (#68-Ubuntu SMP Mon Oct 7 14:34:20 UTC 2024),3.12.3,1.44.0,v0.4.0,c9d2ef9648435ef1119950ecb1a0734497ccc33b,,0.13.3,1d2d7160e5b7ec9954ecb48988f71eb56288dd29, +agentlabtraces,GenericAgent-meta-llama_llama-4-maverick,workarena_l1,0.4.1,2025-04-14_17-15-56,a6dc4022-2bb7-4b46-8b37-f62c010defc1,0.27,0.024,0,330/330,None,Linux (#135-Ubuntu SMP Fri Sep 27 13:53:58 UTC 2024),3.12.7,1.39.0,v0.4.0,5eb2ecb5e5b293170230bcbed8b17fe192af214a,,0.13.3,70dac253628c476aff1af6a975f27f8563453ad2, +agentlabtraces,GenericAgent-meta-llama_llama-4-maverick,workarena_l2_agent_curriculum_eval,0.4.1,2025-04-22_15-38-44,d62fed39-caac-4ef3-92ac-b29897c69f88,0.085,0.018,1,235/235,None,Linux (#68-Ubuntu SMP Mon Oct 7 14:34:20 UTC 2024),3.12.7,1.39.0,v0.4.0,43bafbcfbe398fca39e4ffdc57b2f226d2c6d3e1,,0.13.3,70dac253628c476aff1af6a975f27f8563453ad2, diff --git a/src/agentlab/agents/generic_agent/__init__.py b/src/agentlab/agents/generic_agent/__init__.py index 92c9996d..ad9b0348 100644 --- a/src/agentlab/agents/generic_agent/__init__.py +++ b/src/agentlab/agents/generic_agent/__init__.py @@ -10,6 +10,7 @@ AGENT_3_5, AGENT_8B, AGENT_CUSTOM, + AGENT_LLAMA4_17B_INSTRUCT, AGENT_LLAMA3_70B, AGENT_LLAMA31_70B, RANDOM_SEARCH_AGENT, @@ -31,6 +32,7 @@ "AGENT_4o_VISION", "AGENT_o3_MINI", "AGENT_o1_MINI", + "AGENT_LLAMA4_17B_INSTRUCT", "AGENT_LLAMA3_70B", "AGENT_LLAMA31_70B", "AGENT_8B", diff --git a/src/agentlab/agents/generic_agent/agent_configs.py b/src/agentlab/agents/generic_agent/agent_configs.py index 789f350a..914e3249 100644 --- a/src/agentlab/agents/generic_agent/agent_configs.py +++ b/src/agentlab/agents/generic_agent/agent_configs.py @@ -10,6 +10,7 @@ from .generic_agent import GenericAgentArgs from .generic_agent_prompt import GenericPromptFlags +from .tmlr_config import BASE_FLAGS FLAGS_CUSTOM = GenericPromptFlags( obs=dp.ObsFlags( @@ -296,7 +297,10 @@ chat_model_args=CHAT_MODEL_ARGS_DICT["openrouter/anthropic/claude-3.5-sonnet:beta"], flags=FLAGS_GPT_4o_VISION, ) - +AGENT_LLAMA4_17B_INSTRUCT = GenericAgentArgs( + chat_model_args=CHAT_MODEL_ARGS_DICT["openrouter/meta-llama/llama-4-maverick"], + flags=BASE_FLAGS, +) DEFAULT_RS_FLAGS = GenericPromptFlags( flag_group="default_rs", diff --git a/src/agentlab/analyze/agent_xray.py b/src/agentlab/analyze/agent_xray.py index 8cd7961c..6154007e 100644 --- a/src/agentlab/analyze/agent_xray.py +++ b/src/agentlab/analyze/agent_xray.py @@ -550,7 +550,7 @@ def tag_screenshot_with_action(screenshot: Image, action: str) -> Image: try: coords = action[action.index("(") + 1 : action.index(")")].split(",") coords = [c.strip() for c in coords] - if len(coords) != 2: + if len(coords) not in [2, 3]: raise ValueError(f"Invalid coordinate format: {coords}") if coords[0].startswith("x="): coords[0] = coords[0][2:] diff --git a/src/agentlab/analyze/covariate_std_err.py b/src/agentlab/analyze/covariate_std_err.py new file mode 100644 index 00000000..a989da30 --- /dev/null +++ b/src/agentlab/analyze/covariate_std_err.py @@ -0,0 +1,458 @@ +from typing import Callable, Sequence, Tuple + +import numpy as np +import statsmodels.api as sm +from sklearn.model_selection import KFold +from statsmodels.genmod.families import Binomial + + +def aggregate_std_err( + run_rewards: Sequence[np.ndarray], + baseline_rewards: np.ndarray, + std_err_fn: Callable[[np.ndarray, np.ndarray], Tuple[float, float]] = None, +) -> Tuple[float, float]: + """ + Args: + run_rewards: list of length k, each an array of shape (n,) + baseline_rewards: array of shape (m, n) holding m covariate-baselines + std_err_fn: function that, given (rewards: np.ndarray of shape (n,), + baselines: np.ndarray of shape (m, n)), + returns (mean: float, se: float) + Returns: + (overall_mean, overall_se) + """ + + if std_err_fn is None: + std_err_fn = std_err_ancova + + # 1) call the low-level routine on each run + stats = [std_err_fn(r, baseline_rewards) for r in run_rewards] + means = np.array([mu for mu, _ in stats]) + ses = np.array([sigma for _, sigma in stats]) + + k = len(means) + # 2) overall mean of the per-run means + overall_mean = means.mean() + + # 3) decompose variance: between-runs + within-runs + var_between = means.var(ddof=1) / k + var_within = (ses**2).mean() / k + + overall_se = np.sqrt(var_between + var_within) + return overall_mean, overall_se + + +def std_err_clt(rewards: np.array) -> tuple[float, float]: + """ + Computes the mean and standard error of the rewards. + + Parameters: + - rewards: array-like of shape (n,) + Observed rewards for each sample. + + Returns: + - reward_mean: float + Mean of the rewards. + - se: float + Standard error of the mean. + """ + rewards = np.asarray(rewards, dtype=float) + n = rewards.size + if n == 0: + raise ValueError("The input array is empty.") + + reward_mean = rewards.mean() + se = np.std(rewards, ddof=1) / np.sqrt(n) + + return reward_mean, se + + +def std_err_bootstrap(rewards: np.array, n_boot: int = 1000) -> tuple[float, float]: + """ + Computes the mean and standard error of the rewards using bootstrap. + + Parameters: + - rewards: array-like of shape (n,) + Observed rewards for each sample. + - n_boot: int, default=1000 + Number of bootstrap samples. + + Returns: + - reward_mean: float + Mean of the rewards. + - se: float + Standard error of the mean. + """ + rewards = np.asarray(rewards, dtype=float) + n = rewards.size + if n == 0: + raise ValueError("The input array is empty.") + + boot_means = [] + rng = np.random.default_rng() + for _ in range(n_boot): + idx = rng.integers(0, n, n) + boot_means.append(rewards[idx].mean()) + + reward_mean = np.mean(boot_means) + se = np.std(boot_means, ddof=1) + + return reward_mean, se + + +def _replace_nans_by_average(baselines): + """ + Impute NaNs in each column of the baselines matrix with that column's mean. + + Parameters: + - baselines: array-like of shape (n, k) + Baseline estimates per sample and baseline index. + + Returns: + - imputed: np.ndarray of shape (n, k) + Baselines with NaNs replaced by their column means. + """ + baselines = np.asarray(baselines, dtype=float) + # Compute column means ignoring NaNs + col_means = np.nanmean(baselines, axis=0) + # Broadcast and fill NaNs + imputed = np.where(np.isnan(baselines), col_means, baselines) + return imputed + + +def _select_best_baseline(rewards, baselines): + """ + Select the best baseline based on the total absolute error. + """ + errors = np.abs(baselines - rewards[:, None]).sum(axis=0) + j_star = int(np.argmin(errors)) + return baselines[:, j_star] + + +def std_err_diff_baselines(rewards, baselines): + """ + Find the best baseline and compute the adjusted mean and SE. + + Parameters: + - rewards: array-like of shape (n,) + Observed rewards (may contain NaN). + - baselines: array-like of shape (n, k) + k baseline estimates per sample (may contain NaN). + + Returns: + - adjusted_reward_mean: float + Mean of valid rewards. + - adjusted_se: float∫ + SE of the adjusted mean (differences) using the selected baseline. + - selected_baseline: np.ndarray of shape (n,) + The values of the chosen baseline with NaNs filled. + """ + rewards = np.asarray(rewards, dtype=float) + baselines = _replace_nans_by_average(baselines) + + if rewards.shape[0] != baselines.shape[0]: + raise ValueError("rewards and baselines must have the same length.") + + # Identify valid reward samples + valid = ~np.isnan(rewards) + reward_valid = rewards[valid] + if reward_valid.size == 0: + return np.nan, np.nan + + selected_baseline_valid = _select_best_baseline(reward_valid, baselines[valid]) + diffs = reward_valid - selected_baseline_valid + adjusted_se = np.std(diffs, ddof=1) / np.sqrt(diffs.size) + + # Adjusted mean reward is the raw mean of valid rewards + adjusted_reward_mean = reward_valid.mean() + + return adjusted_reward_mean, adjusted_se + + +def _clean_input(rewards, baselines): + rewards = np.asarray(rewards) + baselines = np.asarray(baselines) + baselines = _replace_nans_by_average(baselines) + if rewards.shape[0] != baselines.shape[0]: + raise ValueError("rewards and baselines must have the same length.") + if rewards.ndim != 1: + raise ValueError("rewards must be a 1D array.") + if baselines.ndim != 2: + raise ValueError("baselines must be a 2D array.") + + # remove nan rows + valid = ~np.isnan(rewards) + rewards = rewards[valid] + baselines = baselines[valid] + if rewards.size == 0: + raise ValueError("No valid rewards after filtering.") + if baselines.shape[0] != rewards.shape[0]: + raise ValueError("rewards and baselines must have the same length after filtering.") + + return rewards, baselines + + +def std_err_ancova(rewards, baselines): + """ + Parameters: + - rewards: array-like of shape (n,) + Observed rewards per sample + - baselines: array-like of shape (n, k) + k baseline estimates per sample + + Returns: + - adjusted_mean: float + Mean reward adjusted to the average baseline levels + - standard_error: float + Standard error of the adjusted mean + """ + rewards, baselines = _clean_input(rewards, baselines) + + # Center the baselines + baseline_means = baselines.mean(axis=0) + centered_baselines = baselines - baseline_means + + # Build design matrix with intercept + design_matrix = sm.add_constant(centered_baselines) + + # Fit the model + results = sm.OLS(rewards, design_matrix).fit() + + # Extract the adjusted mean (intercept) and its SE + adjusted_mean = results.params[0] + standard_error = results.bse[0] + + # print rsquared + print(f"R-squared: {results.rsquared:.4f}") + + return adjusted_mean, standard_error + + +def std_err_glm_cv_regularized( + rewards, baselines, lambda_grid=None, n_splits=5, n_boot=200, random_state=None +): + """ + Fit a logistic GLM with L2 regularization, selecting the penalty strength via k-fold CV, + and estimate SE of the adjusted mean via bootstrap. + + Parameters + ---------- + rewards : array-like, shape (n,) + Observed binary outcomes (0 or 1). + baselines : array-like, shape (n, k) + k baseline estimates per sample. + lambda_grid : list or array-like of floats + Candidate L2 penalty strengths (alpha values) for cv. + n_splits : int, default=5 + Number of folds for cross-validation. + n_boot : int, default=200 + Number of bootstrap replicates for SE estimation. + random_state : int or None, default=None + Seed for reproducibility in CV splits and bootstrap. + + Returns + ------- + adjusted_mean : float + Mean predicted probability across all samples under the final model. + adjusted_se : float + Bootstrap-based SE of the adjusted mean. + best_lambda : float + The selected regularization strength (alpha). + """ + + if lambda_grid is None: + lambda_grid = np.logspace(-4, 3, 10) + + # Prepare data + y = np.asarray(rewards) + B = np.asarray(baselines) + Bc = B - B.mean(axis=0) # center covariates + X = sm.add_constant(Bc) # design matrix + + # Cross-validate to pick lambda + kf = KFold(n_splits=n_splits, shuffle=True, random_state=random_state) + best_lambda = None + best_score = np.inf + for lam in lambda_grid: + fold_scores = [] + for train_idx, val_idx in kf.split(X): + model = sm.GLM(y[train_idx], X[train_idx], family=Binomial()) + res = model.fit_regularized(alpha=lam, L1_wt=0) + p_val = res.predict(X[val_idx]) + p_val = np.clip(p_val, 1e-6, 1 - 1e-6) + # Negative log-likelihood per sample + nll = -np.mean(y[val_idx] * np.log(p_val) + (1 - y[val_idx]) * np.log(1 - p_val)) + fold_scores.append(nll) + avg_score = np.mean(fold_scores) + if avg_score < best_score: + best_score, best_lambda = avg_score, lam + + print(f"Best lambda std_err_glm_cv_regularized: {best_lambda:.4f} with NLL: {best_score:.4f}") + + # Fit final model on full data + final_model = sm.GLM(y, X, family=Binomial()).fit_regularized(alpha=best_lambda, L1_wt=0) + p_hat = final_model.predict(X) + adjusted_mean = np.mean(p_hat) + + # Bootstrap SE estimation + rng = np.random.RandomState(random_state) + boot_means = [] + n = len(y) + for _ in range(n_boot): + idx = rng.randint(0, n, n) + res_boot = sm.GLM(y[idx], X[idx], family=Binomial()).fit_regularized( + alpha=best_lambda, L1_wt=0 + ) + p_boot = res_boot.predict(X) + boot_means.append(np.mean(p_boot)) + adjusted_se = np.std(boot_means, ddof=1) + + return adjusted_mean, adjusted_se + + +def std_err_glm_crossfit_bootstrap( + rewards, baselines, lambda_grid=None, K=5, B=200, random_state=None +): + """ + 1) Tune lambda once on the full data via K-fold CV + 2) Bootstrap: for each replicate, cross-fit GLM with the fixed lambda and compute the mean + 3) Report the point estimate (cross-fitted mean on original data) and bootstrap SE + + Parameters + ---------- + rewards : array-like, shape (n,) + Binary outcomes (0 or 1). + baselines : array-like, shape (n, k) + Baseline covariates per observation. + lambda_grid : array-like, optional + Candidate L2 penalties for CV. Defaults to logspace(-4, 3, 10). + K : int, default=5 + Number of folds for CV and cross-fit. + B : int, default=200 + Number of bootstrap replicates. + random_state : int or None + Seed for reproducibility. + + Returns + ------- + mu_hat : float + Cross-fitted mean predicted probability on the original data. + se : float + Bootstrap-based standard error of the mean. + best_lambda : float + Selected regularization strength. + """ + y = np.asarray(rewards) + X = sm.add_constant(np.asarray(baselines) - np.asarray(baselines).mean(axis=0)) + n = len(y) + + # 1) Tune lambda on full data + if lambda_grid is None: + lambda_grid = np.logspace(-4, 3, 10) + kf_inner = KFold(n_splits=K, shuffle=True, random_state=random_state) + best_lambda, best_score = None, np.inf + for lam in lambda_grid: + scores = [] + for train_idx, val_idx in kf_inner.split(X): + model = sm.GLM(y[train_idx], X[train_idx], family=sm.families.Binomial()) + res = model.fit_regularized(alpha=lam, L1_wt=0) + p_val = np.clip(res.predict(X[val_idx]), 1e-6, 1 - 1e-6) + nll = -np.mean(y[val_idx] * np.log(p_val) + (1 - y[val_idx]) * np.log(1 - p_val)) + scores.append(nll) + if np.mean(scores) < best_score: + best_score, best_lambda = np.mean(scores), lam + + # 2) Cross-fitted point estimate on original data + kf = KFold(n_splits=K, shuffle=True, random_state=random_state) + p_full = np.zeros(n) + for train_idx, val_idx in kf.split(X): + model = sm.GLM(y[train_idx], X[train_idx], family=sm.families.Binomial()) + res = model.fit_regularized(alpha=best_lambda, L1_wt=0) + p_full[val_idx] = res.predict(X[val_idx]) + mu_hat = p_full.mean() + + # 3) Bootstrap SE via cross-fitted means + rng = np.random.RandomState(random_state) + mu_boot = np.zeros(B) + for b in range(B): + idx = rng.randint(0, n, size=n) + yb, Xb = y[idx], X[idx] + p_b = np.zeros(n) + for train_idx, val_idx in kf.split(Xb): + model = sm.GLM(yb[train_idx], Xb[train_idx], family=sm.families.Binomial()) + res = model.fit_regularized(alpha=best_lambda, L1_wt=0) + p_b[val_idx] = res.predict(Xb[val_idx]) + mu_boot[b] = p_b.mean() + + print( + f"Best lambda std_err_glm_crossfit_bootstrap: {best_lambda:.4f} with NLL: {best_score:.4f}" + ) + + se = mu_boot.std(ddof=1) + return mu_hat, se + + +def crossfit_se_min_nll(rewards, baselines, lambda_grid=None, K=5, random_state=None): + """ + Cross-fit predictions for each lambda, compute out-of-sample NLL, + select lambda with min NLL, then compute SE = std(y - p)/sqrt(n). + + Parameters + ---------- + rewards : array-like, shape (n,) + Binary outcomes (0 or 1). + baselines : array-like, shape (n, k) + Baseline covariates per observation. + lambda_grid : array-like + Candidate L2 penalties for CV. + K : int, default=5 + Number of folds for cross-fit. + random_state : int or None + Seed for reproducibility. + + Returns + ------- + best_lambda : float + Lambda with minimum out-of-sample NLL. + best_p : array, shape (n,) + Cross-fitted probabilities for best_lambda. + best_se : float + Standard error = std(y - best_p) / sqrt(n). + nll_dict : dict + NLL values for each lambda. + """ + y = np.asarray(rewards) + B = np.asarray(baselines) + # center covariates + Bc = B - B.mean(axis=0) + X = sm.add_constant(Bc) + n = len(y) + kf = KFold(n_splits=K, shuffle=True, random_state=random_state) + + nll_dict = {} + p_dict = {} + + if lambda_grid is None: + lambda_grid = np.logspace(-4, 3, 10) + + for lam in lambda_grid: + p = np.zeros(n) + for train_idx, val_idx in kf.split(X): + model = sm.GLM(y[train_idx], X[train_idx], family=sm.families.Binomial()) + res = model.fit_regularized(alpha=lam, L1_wt=0) + p[val_idx] = res.predict(X[val_idx]) + + p_clipped = np.clip(p, 1e-6, 1 - 1e-6) + nll = -np.mean(y * np.log(p_clipped) + (1 - y) * np.log(1 - p_clipped)) + nll_dict[lam] = nll + p_dict[lam] = p + + best_lambda = min(nll_dict, key=nll_dict.get) + best_p = p_dict[best_lambda] + best_se = np.std(y - best_p, ddof=0) / np.sqrt(n) + print( + f"Best lambda crossfit_se_min_nll: {best_lambda:.4f} with NLL: {nll_dict[best_lambda]:.4f}" + ) + + adjusted_mean = best_p.mean() + return adjusted_mean, best_se diff --git a/src/agentlab/analyze/covariate_toy_experiment/__init__.py b/src/agentlab/analyze/covariate_toy_experiment/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/agentlab/analyze/covariate_toy_experiment/covariate_toy_experiment.ipynb b/src/agentlab/analyze/covariate_toy_experiment/covariate_toy_experiment.ipynb new file mode 100644 index 00000000..1a743f59 --- /dev/null +++ b/src/agentlab/analyze/covariate_toy_experiment/covariate_toy_experiment.ipynb @@ -0,0 +1,416 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 9, + "id": "2189355d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from agentlab.analyze.covariate_toy_experiment.mock_data import (\n", + " Task,\n", + " Agent,\n", + " agent_on_benchmark,\n", + " plot_task_difficulty,\n", + " plot_gaussian,\n", + " _augment_with_average,\n", + ")\n", + "\n", + "from agentlab.analyze.covariate_std_err import (\n", + " std_err_clt,\n", + " std_err_bootstrap,\n", + " std_err_ancova,\n", + " std_err_glm_cv_regularized,\n", + " crossfit_se_min_nll,\n", + " aggregate_success,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f62a8bb6", + "metadata": {}, + "outputs": [], + "source": [ + "def _make_baselines(\n", + " benchmark, k_baselines, task_types, consistancy, rng: np.random.RandomState = np.random\n", + "):\n", + "\n", + " baseline_agents = [\n", + " Agent(\n", + " rng.beta(10, 2),\n", + " benchmark,\n", + " type=rng.choice(task_types),\n", + " consistancy=consistancy,\n", + " rng=rng,\n", + " )\n", + " for _ in range(k_baselines)\n", + " ]\n", + "\n", + " rewards_baselines = []\n", + " for i, baseline in enumerate(baseline_agents):\n", + " rewards = agent_on_benchmark(baseline, benchmark, n_samples_per_task=1, rng=rng)\n", + " rewards_baselines.append(rewards.reshape(-1))\n", + " # print(f\"Baseline {i}: {str(baseline)} \")\n", + " rewards_baselines = np.array(rewards_baselines).T\n", + "\n", + " return rewards_baselines, baseline_agents" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "950d662c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Main agent: Agent(competence=0.980, type=0, success_rate=0.586, fit_ratio=0.330)\n", + "R-squared: 0.6769\n", + "Best lambda std_err_glm_cv_regularized: 0.1292 with NLL: 0.5717\n", + "Best lambda crossfit_se_min_nll: 0.1292 with NLL: 0.5792\n" + ] + }, + { + "data": { + "text/plain": [ + "(0.0, 30.0)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_task = 100\n", + "k_baselines = 50\n", + "task_types = [0, 0, 0, 0, 1, 1, 2, 3, 4]\n", + "main_agent_type = 0\n", + "consistancy = 4\n", + "\n", + "rng = np.random.RandomState()\n", + "benchmark = [\n", + " Task(difficulty, type=rng.choice(task_types)) for difficulty in rng.beta(0.3, 0.3, n_task)\n", + "]\n", + "\n", + "main_agent = Agent(0.98, benchmark, type=main_agent_type, consistancy=consistancy, rng=rng)\n", + "print(f\"Main agent: {main_agent}\")\n", + "\n", + "rewards = agent_on_benchmark(main_agent, benchmark, n_samples_per_task=1, rng=rng).reshape(-1)\n", + "rewards_baselines, baseline_agents = _make_baselines(\n", + " benchmark, k_baselines, task_types=task_types, consistancy=consistancy, rng=rng\n", + ")\n", + "\n", + "oversampled_rewards = agent_on_benchmark(main_agent, benchmark, n_samples_per_task=1000, rng=rng)\n", + "\n", + "\n", + "# -- helper for empirical uncertainty --\n", + "def empirical_uncertainty(oversampled_rewards):\n", + " avg = np.mean(oversampled_rewards, axis=0)\n", + " return np.mean(avg), np.std(avg)\n", + "\n", + "\n", + "# list of (label, func, args)\n", + "methods = [\n", + " (\"Vanilla std_err\", std_err_clt, (rewards,)),\n", + " (\"Bootstrap std_err\", std_err_bootstrap, (rewards,)),\n", + " (\"Empirical uncertainty\", empirical_uncertainty, (oversampled_rewards,)),\n", + " # (\"Oversampled std_err\", std_err_clt, (oversampled_rewards.reshape(-1),)),\n", + " (\"Ancova std_err\", std_err_ancova, (rewards, rewards_baselines)),\n", + " (\"GLM CV-reg std_err\", std_err_glm_cv_regularized, (rewards, rewards_baselines)),\n", + " (\"GLM crossfit_se_min_nll\", crossfit_se_min_nll, (rewards, rewards_baselines)),\n", + "]\n", + "\n", + "# compute, plot and collect results\n", + "results = []\n", + "for name, func, args in methods:\n", + " mu, se = func(*args)\n", + " plot_gaussian(mu, se, label=name)\n", + " results.append((name, mu, se))\n", + "\n", + "\n", + "plt.legend(loc=\"upper right\")\n", + "plt.ylim(0, 30)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "448a398c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Method Mean SE Ratio\n", + "Vanilla std_err 0.580 0.050 1.000\n", + "Bootstrap std_err 0.582 0.048 1.026\n", + "GLM crossfit_se_min_nll 0.544 0.044 1.123\n", + "Ancova std_err 0.580 0.040 1.238\n", + "Empirical uncertainty 0.588 0.039 1.277\n", + "GLM CV-reg std_err 0.548 0.023 2.181\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# make a bar plot for the results, with error bars and x axis = name\n", + "plt.figure()\n", + "\n", + "# sort results from high to low stderr\n", + "results = sorted(results, key=lambda x: x[2], reverse=True)\n", + "\n", + "# print table\n", + "print(f\"{'Method':<30} {'Mean':>8} {'SE':>8} {'Ratio':>8}\")\n", + "for name, mu, se in results:\n", + " print(f\"{name:<30} {mu:8.3f} {se:8.3f} {results[0][2] / se:8.3f}\")\n", + "\n", + "plt.bar(\n", + " [name for name, _, _ in results],\n", + " [mu for _, mu, _ in results],\n", + " yerr=[se for _, _, se in results],\n", + " capsize=5,\n", + ")\n", + "\n", + "plt.xticks(rotation=20, ha=\"right\", fontsize=8)\n", + "plt.ylabel(\"Mean reward\")\n", + "plt.title(\"Mean reward with std_err\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8bdd8277", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R-squared: 0.5972\n", + "Best lambda std_err_glm_cv_regularized: 0.1292 with NLL: 0.5993\n", + "Best lambda crossfit_se_min_nll: 0.1292 with NLL: 0.6254\n", + "R-squared: 0.6678\n", + "Best lambda std_err_glm_cv_regularized: 0.1292 with NLL: 0.4980\n", + "Best lambda crossfit_se_min_nll: 0.1292 with NLL: 0.5068\n", + "R-squared: 0.5609\n", + "Best lambda std_err_glm_cv_regularized: 0.1292 with NLL: 0.5652\n", + "Best lambda crossfit_se_min_nll: 0.7743 with NLL: 0.5657\n", + "R-squared: 0.6464\n", + "Best lambda std_err_glm_cv_regularized: 0.7743 with NLL: 0.6104\n", + "Best lambda crossfit_se_min_nll: 0.7743 with NLL: 0.6060\n", + "R-squared: 0.6035\n", + "Best lambda std_err_glm_cv_regularized: 0.1292 with NLL: 0.5624\n", + "Best lambda crossfit_se_min_nll: 0.1292 with NLL: 0.5626\n", + "R-squared: 0.7575\n", + "Best lambda std_err_glm_cv_regularized: 0.1292 with NLL: 0.5062\n", + "Best lambda crossfit_se_min_nll: 0.1292 with NLL: 0.4981\n", + "R-squared: 0.6813\n", + "Best lambda std_err_glm_cv_regularized: 0.1292 with NLL: 0.5217\n", + "Best lambda crossfit_se_min_nll: 0.1292 with NLL: 0.5189\n", + "R-squared: 0.7169\n", + "Best lambda std_err_glm_cv_regularized: 0.0215 with NLL: 0.5005\n", + "Best lambda crossfit_se_min_nll: 0.1292 with NLL: 0.5048\n", + "R-squared: 0.6852\n", + "Best lambda std_err_glm_cv_regularized: 0.1292 with NLL: 0.5280\n", + "Best lambda crossfit_se_min_nll: 0.1292 with NLL: 0.5457\n", + "R-squared: 0.6109\n", + "Best lambda std_err_glm_cv_regularized: 0.1292 with NLL: 0.5513\n", + "Best lambda crossfit_se_min_nll: 0.1292 with NLL: 0.5522\n" + ] + } + ], + "source": [ + "from collections import defaultdict\n", + "\n", + "\n", + "results = defaultdict(list)\n", + "\n", + "for i in range(10):\n", + " rewards = agent_on_benchmark(main_agent, benchmark, n_samples_per_task=1, rng=rng).reshape(-1)\n", + " oversampled_rewards = agent_on_benchmark(\n", + " main_agent, benchmark, n_samples_per_task=1000, rng=rng\n", + " )\n", + "\n", + " methods = [\n", + " (\"Empirical uncertainty\", empirical_uncertainty, (oversampled_rewards,)),\n", + " (\"Ancova std_err\", std_err_ancova, (rewards, rewards_baselines)),\n", + " (\"GLM CV-reg std_err\", std_err_glm_cv_regularized, (rewards, rewards_baselines)),\n", + " (\"GLM crossfit_se_min_nll\", crossfit_se_min_nll, (rewards, rewards_baselines)),\n", + " ]\n", + "\n", + " for name, func, args in methods:\n", + " mu, se = func(*args)\n", + " results[name].append((mu, se))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f7382f8b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Method Avg Mean Std Mean Avg SE\n", + "Empirical uncertainty 0.585 0.001 0.039\n", + "Ancova std_err 0.579 0.025 0.041\n", + "GLM CV-reg std_err 0.548 0.017 0.021\n", + "GLM crossfit_se_min_nll 0.538 0.017 0.042\n" + ] + } + ], + "source": [ + "print(f\"{'Method':<30} {'Avg Mean':>8} {\"Std Mean\":>8} {'Avg SE':>8}\")\n", + "for name, mu_se in results.items():\n", + " mu, se = zip(*mu_se)\n", + " print(f\"{name:<30} {np.mean(mu):8.3f} {np.std(mu):8.3f} {np.mean(se):8.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4bab8645", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R-squared: 0.7398\n", + "R-squared: 0.5876\n", + "Agg mean: 0.5800000000000001, Agg se: 0.02891222719359173\n", + "Agent Agent(competence=0.980, type=0, success_rate=0.586, fit_ratio=0.330)\n" + ] + }, + { + "ename": "TypeError", + "evalue": "std_err_ancova() got an unexpected keyword argument 'baseline_rewards'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[11]\u001b[39m\u001b[32m, line 16\u001b[39m\n\u001b[32m 13\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m a, r \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(agents, rewards):\n\u001b[32m 15\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mAgent \u001b[39m\u001b[38;5;132;01m{\u001b[39;00ma\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m16\u001b[39m mean, se = \u001b[43mstd_err_ancova\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrewards\u001b[49m\u001b[43m=\u001b[49m\u001b[43mr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbaseline_rewards\u001b[49m\u001b[43m=\u001b[49m\u001b[43mrewards_baselines\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 17\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33m Mean: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmean\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m, SE: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mse\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", + "\u001b[31mTypeError\u001b[39m: std_err_ancova() got an unexpected keyword argument 'baseline_rewards'" + ] + } + ], + "source": [ + "alt_agent = Agent(0.92, benchmark, type=main_agent_type, consistancy=consistancy, rng=rng)\n", + "\n", + "agents = [main_agent, alt_agent]\n", + "rewards = [\n", + " agent_on_benchmark(a, benchmark, n_samples_per_task=1, rng=rng).reshape(-1) for a in agents\n", + "]\n", + "agg_mean, agg_se = aggregate_success(\n", + " rewards, baseline_rewards=rewards_baselines, std_err_fn=std_err_ancova\n", + ")\n", + "\n", + "\n", + "print(f\"Agg mean: {agg_mean}, Agg se: {agg_se}\")\n", + "for a, r in zip(agents, rewards):\n", + "\n", + " print(f\"Agent {a}\")\n", + " mean, se = std_err_ancova(r, rewards_baselines)\n", + " print(f\" Mean: {mean}, SE: {se}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c4ee531a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 5))\n", + "plot_task_difficulty([task.difficulty for task in benchmark])\n", + "\n", + "plt.figure(figsize=(5, 10))\n", + "rewards_baselines_ = _augment_with_average(rewards_baselines)\n", + "plt.imshow(rewards_baselines_, aspect=\"auto\", cmap=\"jet\")\n", + "plt.colorbar(label=\"Reward\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ui-assist", + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/agentlab/analyze/covariate_toy_experiment/mock_data.py b/src/agentlab/analyze/covariate_toy_experiment/mock_data.py new file mode 100644 index 00000000..38d74324 --- /dev/null +++ b/src/agentlab/analyze/covariate_toy_experiment/mock_data.py @@ -0,0 +1,124 @@ +from dataclasses import dataclass +from uuid import uuid4 + +import matplotlib.pyplot as plt +import numpy as np + + +def sigmoid(x): + return 1 / (1 + np.exp(-x)) + + +@dataclass +class Task: + difficulty: float + type: int = None + uuid: str = None + + def __post_init__(self): + self.uuid = str(uuid4()) + + +class Agent: + + def __init__( + self, + competence: float, + benchmark: list[Task], + type: int = None, + consistancy: float = 10, + rng: np.random.RandomState = np.random, + ): + self.competence = competence + self.type = type + self.task_success_rate = {} + fit_count = 0 + for task in benchmark: + + agent_task_competence = competence + if task.type is not None and type is not None: + if task.type != type: + agent_task_competence = competence * 0.5 + else: + fit_count += 1 + + # task_competence = agent_task_competence * (1.001 - task.difficulty) + task_success_rate = sigmoid(consistancy * (agent_task_competence - task.difficulty)) + + self.task_success_rate[task.uuid] = task_success_rate + self.fit_ratio = fit_count / len(benchmark) + + def get_task_success_rate(self, task: Task): + return self.task_success_rate[task.uuid] + + def get_success_rate(self): + return np.mean(list(self.task_success_rate.values())) + + def __str__(self): + + return f"Agent(competence={self.competence:.3f}, type={self.type}, success_rate={self.get_success_rate():.3f}, fit_ratio={self.fit_ratio:.3f})" + + +def agent_on_benchmark( + agent: Agent, + benchmark: list[Task], + n_samples_per_task=None, + rng: np.random.RandomState = np.random, +): + + all_rewards = [] + for task in benchmark: + task_success_rate = agent.get_task_success_rate(task) + + # sample n_samples_per_task from bernoulli distribution + rewards = rng.binomial(1, task_success_rate, n_samples_per_task) + + all_rewards.append(rewards) + return np.array(all_rewards) + + +def plot_task_difficulty(difficulties): + """ + Plot the difficulty of each task in the benchmark. + """ + + plt.hist(difficulties, bins=20) + plt.xlabel("Task Difficulty") + plt.ylabel("Frequency") + plt.title("Distribution of Task Difficulty") + + +def plot_gaussian(mu, sigma, label=None): + """ + Plot a Gaussian distribution with mean mu and standard deviation sigma. + """ + x = np.linspace(0, 1, 1000) + plt.plot( + x, 1 / (sigma * np.sqrt(2 * np.pi)) * np.exp(-0.5 * ((x - mu) / sigma) ** 2), label=label + ) + + +def _augment_with_average(matrix: np.ndarray) -> np.ndarray: + """Return a new array with row averages as the last column, + column averages as the last row, and the overall average in the bottom-right.""" + row_avg = matrix.mean(axis=1) + col_avg = matrix.mean(axis=0) + overall_avg = matrix.mean() + + # sort columns by their average + sorted_indices = np.argsort(col_avg) + matrix = matrix[:, sorted_indices] + col_avg = col_avg[sorted_indices] + + # sort rows by their average + sorted_indices = np.argsort(row_avg) + matrix = matrix[sorted_indices, :] + row_avg = row_avg[sorted_indices] + + aug = np.zeros((matrix.shape[0] + 1, matrix.shape[1] + 1)) + aug[:-1, :-1] = matrix + aug[:-1, -1] = row_avg + aug[-1, :-1] = col_avg + aug[-1, -1] = overall_avg + + return aug diff --git a/src/agentlab/llm/llm_configs.py b/src/agentlab/llm/llm_configs.py index ba0e15cc..5125801d 100644 --- a/src/agentlab/llm/llm_configs.py +++ b/src/agentlab/llm/llm_configs.py @@ -155,6 +155,14 @@ max_new_tokens=28_000, temperature=1e-1, ), + "openrouter/meta-llama/llama-4-maverick": OpenRouterModelArgs( + model_name="meta-llama/llama-4-maverick", + max_total_tokens=128_000, + max_input_tokens=100_000, + max_new_tokens=28_000, + temperature=1e-1, + vision_support=True, + ), "openrouter/meta-llama/llama-3.1-8b-instruct:free": OpenRouterModelArgs( model_name="meta-llama/llama-3.1-8b-instruct:free", max_total_tokens=128_000,