Repository navigation
Expand file tree
/
Copy pathexp1a.py
More file actions
595 lines (527 loc) · 22.1 KB
/
Copy pathexp1a.py
File metadata and controls
595 lines (527 loc) · 22.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
#!/usr/bin/env python3
"""
Variant of exp1.py using irrelevant_true_information as extra context.
The prompt wording remains identical to exp1's misinformed prompt; generation goes through an
OpenAI-compatible endpoint (vLLM), as in the other runners.
"""
import argparse
import json
import os
import random
import re
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import Any, Callable, List, Optional, Tuple
import numpy as np
from tqdm import tqdm
from exp1 import score
from mint_data import load_mint_items
from model_server_config import (
extract_openai_message_text,
mallm_concurrency_default,
normalize_model_name,
)
from shared_utils import (
PROMPT_BASELINE,
PROMPT_BASELINE_FREE_FORM,
PROMPT_MISINFORMED,
PROMPT_MISINFORMED_FREE_FORM,
build_common_arg_parser,
format_options,
model_name_to_safe_path,
save_results,
)
def prepare_batch_prompts(batch_items: list, prompt_template: str) -> Tuple[list, list]:
"""Prepare prompts for a batch of items. Returns (prompts, info_strategies)."""
prompts = []
info_strategies = []
for item in batch_items:
is_multiple_choice = item["is_multiple_choice"]
sentence = item["sentence"]
options_text = format_options(item["options"]) if is_multiple_choice else ""
if "misinformation" in prompt_template:
extra_information = item.get("irrelevant_true_information")
if not isinstance(extra_information, str) or not extra_information.strip():
raise ValueError(
"Missing 'irrelevant_true_information' in dataset item. "
"Use the MINT_dataset_v1.2 release for exp1a."
)
if is_multiple_choice:
prompt = PROMPT_MISINFORMED.format(
sentence=sentence,
options_text=options_text,
misinformation=extra_information,
)
else:
prompt = PROMPT_MISINFORMED_FREE_FORM.format(
sentence=sentence,
misinformation=extra_information,
)
info_strategies.append("irrelevant_true_information")
else:
if is_multiple_choice:
prompt = PROMPT_BASELINE.format(
sentence=sentence,
options_text=options_text,
)
else:
prompt = PROMPT_BASELINE_FREE_FORM.format(sentence=sentence)
info_strategies.append("none")
prompts.append(prompt)
return prompts, info_strategies
def process_batch_responses(responses: List[str], batch_items: list, dataset_name: str, prompts: List[str],
info_strategies: List[str]) -> list:
"""Score a batch with the unified extractor (the rule of exp1.score) and build the stored result records."""
results = []
for response, item, prompt, strategy in zip(responses, batch_items, prompts, info_strategies):
sc = score(item, response or "")
results.append({
"sentence": item["sentence"], "mint_id": item["mint_id"], "prompt": prompt, "response": response,
"predicted_answer": sc["predicted_answer"], "correct_answer": item["gold_text"],
"is_correct": bool(sc["is_correct"]), "is_multiple_choice": item["is_multiple_choice"],
"options": item["options"] if item["is_multiple_choice"] else [item["gold_text"]] + list(item.get("gold_aliases") or []),
"misinformation_strategy": strategy, "extraction_status": sc["extraction_status"],
"extraction_method": sc["extraction_method"],
})
return results
def _openai_timeout_seconds() -> float:
raw = (os.environ.get("MALLM_OPENAI_TIMEOUT_SECONDS") or "").strip()
if raw:
try:
return float(raw)
except ValueError:
pass
return 600.0
def _openai_chat_text(
client: Any,
model_id: str,
prompt: str,
max_tokens: int,
temperature: float,
timeout: float,
max_retries: int = 4,
) -> str:
delay = 1.0
last_err: Optional[BaseException] = None
for _attempt in range(max_retries):
try:
resp = client.chat.completions.create(
model=model_id,
messages=[{"role": "user", "content": prompt}],
max_tokens=max_tokens,
temperature=temperature,
timeout=timeout,
)
return extract_openai_message_text(resp.choices[0].message)
except Exception as e:
last_err = e
time.sleep(delay)
delay = min(delay * 2, 30.0)
assert last_err is not None
raise last_err
def evaluate_model(
dataset: list,
dataset_name: str,
experimental_condition: str,
max_samples: Optional[int] = None,
batch_size: int = 8,
max_tokens: int = 512,
save_callback: Optional[Callable[..., Any]] = None,
*,
dummy: bool = False,
openai_client: Optional[Any] = None,
api_model_name: Optional[str] = None,
concurrent_requests: int = 64,
openai_timeout: Optional[float] = None,
) -> dict:
"""Evaluate the model on a dataset with a specific experimental condition."""
if max_samples:
dataset = dataset[:max_samples]
if experimental_condition == "baseline":
prompt_template = PROMPT_BASELINE
elif experimental_condition == "irrelevant_true_information":
prompt_template = PROMPT_MISINFORMED
else:
raise ValueError(f"Unknown experimental condition: {experimental_condition}")
if not dummy:
return _evaluate_model_openai(
dataset,
dataset_name,
experimental_condition,
prompt_template,
save_callback,
openai_client=openai_client,
api_model_name=api_model_name or "",
concurrent_requests=max(1, concurrent_requests),
max_tokens=max_tokens,
openai_timeout=openai_timeout or _openai_timeout_seconds(),
)
# --dummy_test: random answers without a model (pipeline check)
num_batches = (len(dataset) + batch_size - 1) // batch_size
print(f"Evaluating {len(dataset)} samples for {dataset_name} with {experimental_condition} condition [dummy]")
all_results: list = []
correct_count = 0
for i in tqdm(
range(0, len(dataset), batch_size),
desc=f"Processing {experimental_condition} [batch {batch_size}]",
total=num_batches,
):
batch_items = dataset[i : i + batch_size]
prompts, info_strategies = prepare_batch_prompts(batch_items, prompt_template)
responses = []
for prompt in prompts:
is_free_form = "Provide a clear and accurate answer" in prompt or "Always provide your final answer choice" not in prompt
if is_free_form:
response = random.choice(
[
"Real Madrid C.F.",
"Remember the Titans",
"The Twilight Saga: New Moon",
"Mysophobia",
"Albanian language, Greek Language",
"Vancouver",
"The answer is Real Madrid.",
"Based on the information, it's Remember the Titans.",
"The correct answer is Vancouver.",
]
)
else:
response = random.choice(
[
"Based on my analysis, the answer is A) First option.",
"After careful consideration, I believe the correct answer is B) Second option.",
"Looking at the evidence, the answer appears to be C) Third option.",
]
)
responses.append(response)
batch_results = process_batch_responses(
responses, batch_items, dataset_name, prompts, info_strategies
)
all_results.extend(batch_results)
correct_count += sum(1 for result in batch_results if result["is_correct"])
if save_callback:
current_accuracy = correct_count / len(all_results) if all_results else 0.0
save_callback(
experimental_condition,
{
"accuracy": current_accuracy,
"correct_count": correct_count,
"total_count": len(all_results),
"results": all_results.copy(),
},
)
accuracy = correct_count / len(all_results) if all_results else 0.0
print(f"{experimental_condition} accuracy: {accuracy:.3f} ({correct_count}/{len(all_results)})")
return {
"accuracy": accuracy,
"correct_count": correct_count,
"total_count": len(all_results),
"results": all_results,
}
def _evaluate_model_openai(
dataset: list,
dataset_name: str,
experimental_condition: str,
prompt_template: str,
save_callback: Optional[Callable[..., Any]],
*,
openai_client: Any,
api_model_name: str,
concurrent_requests: int,
max_tokens: int,
openai_timeout: float,
) -> dict:
"""Parallel OpenAI-compatible chat completions over sliding windows (like exp2 concurrency)."""
print(f"Evaluating {len(dataset)} samples for {dataset_name} with {experimental_condition} condition")
print(
f" Using inference=openai, concurrent_requests={concurrent_requests}, "
f"api_model_name={api_model_name!r}"
)
window = max(1, concurrent_requests)
num_windows = (len(dataset) + window - 1) // window
temperature = 0.7
all_results: list = []
correct_count = 0
for w in tqdm(range(num_windows), desc=f"OpenAI {experimental_condition} [win={window}]", total=num_windows):
start = w * window
chunk = dataset[start : start + window]
prompts, info_strategies = prepare_batch_prompts(chunk, prompt_template)
def _one(ix: int, prompt: str) -> Tuple[int, str]:
text = _openai_chat_text(
openai_client,
api_model_name,
prompt,
max_tokens=max_tokens,
temperature=temperature,
timeout=openai_timeout,
)
return ix, text
max_workers = min(len(prompts), concurrent_requests)
responses_ordered: List[Optional[str]] = [None] * len(prompts)
with ThreadPoolExecutor(max_workers=max(1, max_workers)) as ex:
futures = {ex.submit(_one, j, p): j for j, p in enumerate(prompts)}
for fut in as_completed(futures):
j, text = fut.result()
responses_ordered[j] = text
responses = [r if r is not None else "" for r in responses_ordered]
batch_results = process_batch_responses(
responses, chunk, dataset_name, prompts, info_strategies
)
all_results.extend(batch_results)
correct_count += sum(1 for result in batch_results if result["is_correct"])
if save_callback:
current_accuracy = correct_count / len(all_results) if all_results else 0.0
save_callback(
experimental_condition,
{
"accuracy": current_accuracy,
"correct_count": correct_count,
"total_count": len(all_results),
"results": all_results.copy(),
},
)
accuracy = correct_count / len(all_results) if all_results else 0.0
print(f"{experimental_condition} accuracy: {accuracy:.3f} ({correct_count}/{len(all_results)})")
return {
"accuracy": accuracy,
"correct_count": correct_count,
"total_count": len(all_results),
"results": all_results,
}
def run_experiment(
dataset_name: str,
dataset: list,
max_samples: Optional[int] = None,
batch_size: int = 8,
max_tokens: int = 512,
save_callback: Optional[Callable[..., Any]] = None,
conditions: Tuple[str, ...] = ("irrelevant_true_information",),
*,
dummy: bool = False,
openai_client: Optional[Any] = None,
api_model_name: Optional[str] = None,
concurrent_requests: int = 64,
openai_timeout: Optional[float] = None,
) -> dict:
"""Run selected experimental conditions (default: irrelevant_true_information only)."""
print(f"\n=== Running experiment for {dataset_name} ===")
allowed = {"baseline", "irrelevant_true_information"}
unknown = set(conditions) - allowed
if unknown:
raise ValueError(f"Unknown conditions: {sorted(unknown)}. Allowed: {sorted(allowed)}")
if not conditions:
raise ValueError("At least one condition is required.")
results = {}
for condition in ("baseline", "irrelevant_true_information"):
if condition not in conditions:
continue
results[condition] = evaluate_model(
dataset,
dataset_name,
condition,
max_samples,
batch_size,
max_tokens,
save_callback,
dummy=dummy,
openai_client=openai_client,
api_model_name=api_model_name,
concurrent_requests=concurrent_requests,
openai_timeout=openai_timeout,
)
return results
def _normalize_dataset_name(name: str) -> str:
if not isinstance(name, str):
return ""
key = name.strip().lower().replace("-", "_")
aliases = {
"ethics_commonsense": "ethics",
"ethics": "ethics",
"wino": "winogrande",
"winogrande": "winogrande",
"complex": "complex_web_questions",
"cwq": "complex_web_questions",
"complex_web_questions": "complex_web_questions",
"web_questions": "complex_web_questions",
}
return aliases.get(key, key)
def _parse_conditions(conditions_str: str) -> Tuple[str, ...]:
parts = [p.strip() for p in conditions_str.split(",") if p.strip()]
if not parts:
raise ValueError("--conditions must list at least one of: baseline, irrelevant_true_information")
return tuple(parts)
def _resolve_openai_endpoint(args: argparse.Namespace, resolved_model_name: str) -> str:
from exp2 import (
_discover_endpoint_from_mallm,
_endpoint_alive,
_env_or_default_endpoint,
_start_model_server,
)
resolved_endpoint = _env_or_default_endpoint(args.endpoint_url)
if resolved_endpoint.startswith("http") and not _endpoint_alive(resolved_endpoint, timeout=2.0):
auto = _discover_endpoint_from_mallm(resolved_model_name)
if auto:
print(f"[INFO] Endpoint '{args.endpoint_url}' unreachable; using discovered endpoint '{auto}'.")
resolved_endpoint = auto
elif not args.no_autostart:
print(f"[WARN] Endpoint '{resolved_endpoint}' unreachable; attempting local model server autostart.")
desired_port = 8080
m = re.search(r"https?://([^:/]+):(\d+)/v1", resolved_endpoint)
if m and m.group(1) in ("127.0.0.1", "localhost"):
try:
desired_port = int(m.group(2))
except ValueError:
desired_port = 8080
started = _start_model_server(resolved_model_name, desired_port=desired_port)
if started:
resolved_endpoint = started["endpoint_url"]
else:
print("[ERROR] Could not auto-start a model server. Start vLLM manually or pass --endpoint_url.")
else:
print("[INFO] Auto-start disabled (--no_autostart).")
if resolved_endpoint.startswith("http") and not _endpoint_alive(resolved_endpoint, timeout=2.5):
raise SystemExit(
f"[FATAL] No reachable model endpoint at {resolved_endpoint!r}. "
"For Slurm, launch vLLM first (see exp1a.slurm) or pass a live --endpoint_url."
)
return resolved_endpoint
def main() -> None:
parser = build_common_arg_parser("Run single agent experiment with irrelevant true information")
parser.add_argument(
"--conditions",
type=str,
default="irrelevant_true_information",
help=(
"Comma-separated conditions to run: baseline, irrelevant_true_information. "
"Default runs irrelevant_true_information only. "
"Use 'baseline,irrelevant_true_information' for the full exp1a comparison."
),
)
parser.add_argument(
"--endpoint_url",
type=str,
default="http://127.0.0.1:8080/v1",
help="OpenAI-compatible base URL including /v1.",
)
parser.add_argument(
"--no_autostart",
action="store_true",
help="Do not try to start a local vLLM process if the endpoint is down (Slurm sets this).",
)
parser.add_argument(
"--concurrent_requests",
type=int,
default=None,
help="Max parallel chat completions. "
"Default: env MALLM_CONCURRENT_API_REQUESTS or 64.",
)
parser.add_argument(
"--output_dir",
type=str,
default=None,
help=(
"Directory for exp1a_results_<dataset>_<model>.json files. "
"Default: out/ (or EXP1A_OUTPUT_DIR if set). Use a per-run dir to "
"keep replicates separate instead of overwriting."
),
)
args = parser.parse_args()
print("=== Single Agent Supplementary Experiment (Irrelevant True Information) ===")
print(f"Model: {args.model_name}")
print(f"Max samples per dataset: {args.max_samples}")
print(f"Batch size: {args.batch_size}")
print(f"Max tokens: {args.max_tokens}")
print(f"Dummy test mode: {args.dummy_test}")
if getattr(args, "datasets", None):
print(f"Selected datasets: {args.datasets}")
conditions = _parse_conditions(args.conditions)
print(f"Conditions: {', '.join(conditions)}")
random.seed(42)
np.random.seed(42)
resolved_model_name = normalize_model_name(args.model_name)
concurrent_requests = (
args.concurrent_requests
if args.concurrent_requests is not None
else mallm_concurrency_default(resolved_model_name)
)
openai_timeout = _openai_timeout_seconds()
openai_client: Optional[Any] = None
if not args.dummy_test:
resolved_endpoint = _resolve_openai_endpoint(args, resolved_model_name)
from openai import OpenAI
openai_client = OpenAI(
base_url=resolved_endpoint.rstrip("/"),
api_key=os.environ.get("OPENAI_API_KEY") or "EMPTY",
max_retries=int(os.environ.get("MALLM_OPENAI_MAX_RETRIES", "5")),
)
print(f"[INFO] OpenAI client base_url={resolved_endpoint!r} model_id={resolved_model_name!r}")
datasets = {}
selected_datasets = None
if getattr(args, "datasets", None):
selected_datasets = {
_normalize_dataset_name(x)
for x in str(args.datasets).split(",")
if str(x).strip()
}
# MINT v1.2 items (canonical gold labels); the output files keep the dataset names of the stored runs
for dataset_name, ds_key in (("winogrande", "winogrande"), ("ethics", "ethics"), ("complex_web_questions", "cwq")):
if selected_datasets is not None and dataset_name not in selected_datasets:
print(f"Skipping dataset {dataset_name} (not selected)")
continue
ds = load_mint_items(ds_key)
if not ds:
continue
if not ds[0].get("irrelevant_true_information"):
raise ValueError(f"{dataset_name}: the MINT items lack 'irrelevant_true_information'; use the MINT_dataset_v1.2 release.")
datasets[dataset_name] = ds
print(f"Loaded {len(ds)} samples from {dataset_name}")
if not datasets:
raise ValueError("No suitable datasets found with 'irrelevant_true_information'.")
model_name_suffix = "dummy_model" if args.dummy_test else model_name_to_safe_path(resolved_model_name)
# Per-run output directory (so replicates don't overwrite each other).
resolved_output_dir = (args.output_dir or os.environ.get("EXP1A_OUTPUT_DIR", "")).strip()
out_base = os.path.abspath(resolved_output_dir) if resolved_output_dir else "out"
os.makedirs(out_base, exist_ok=True)
print(f"[INFO] Saving exp1a outputs under: {os.path.abspath(out_base)}")
all_results = {}
for dataset_name, dataset in datasets.items():
output_file = os.path.join(out_base, f"exp1a_results_{dataset_name}_{model_name_suffix}.json")
def create_save_callback(target_output_file: str):
def save_callback(condition: str, condition_results: dict) -> None:
if os.path.exists(target_output_file):
try:
with open(target_output_file, "r", encoding="utf-8") as f:
existing_results = json.load(f)
except (json.JSONDecodeError, FileNotFoundError):
existing_results = {}
else:
existing_results = {}
existing_results[condition] = condition_results
save_results(existing_results, target_output_file)
print(f" Saved {condition} results to {target_output_file} (accuracy: {condition_results['accuracy']:.3f})")
return save_callback
results = run_experiment(
dataset_name,
dataset,
args.max_samples,
args.batch_size,
args.max_tokens,
create_save_callback(output_file),
conditions=conditions,
dummy=args.dummy_test,
openai_client=openai_client,
api_model_name=resolved_model_name,
concurrent_requests=concurrent_requests,
openai_timeout=openai_timeout,
)
all_results[dataset_name] = results
print("\n=== Experiment Summary ===")
for dataset_name, dataset_results in all_results.items():
print(f"\n{dataset_name}:")
for condition, condition_results in dataset_results.items():
print(
f" {condition}: {condition_results['accuracy']:.3f} "
f"({condition_results['correct_count']}/{condition_results['total_count']})"
)
if __name__ == "__main__":
main()