HARDE: रनटाइम जोखिम पहचान और निष्पादन नियंत्रण के लिए एजेंट हार्नेस का अनुकूलन

HARDE: Optimizing Agent Harnesses for Runtime Risk Detection and Execution Control के लिए कोड रिलीज़।

रिपॉज़िटरी में दो पूरक एंट्री-पॉइंट परिवार शामिल हैं:

• domains/: Meta-Harness बेसलाइन और प्रत्येक बेंचमार्क के लिए HARDE के दो चरण।
• personalized_harness/: बेंचमार्क एडाप्टर, बेसलाइन हार्नेस, सीखे गए/व्यक्तिगत हार्नेस, और मूल्यांकन पाइपलाइन।

रिपॉज़िटरी लेआउट

HARDE/
├── domains/
│   ├── agentdyn/                                  # Meta-Harness baseline
│   ├── agentdyn_component_probe/                  # HARDE Stage I
│   ├── agentdyn_adaptive_component_search/        # HARDE Stage II
│   ├── agentsafetybench/                          # Meta-Harness baseline
│   ├── agentsafetybench_component_probe/          # HARDE Stage I
│   ├── agentsafetybench_adaptive_component_search/ # HARDE Stage II
│   ├── shade_arena/                               # Meta-Harness baseline
│   ├── shade_arena_component_probe/               # HARDE Stage I
│   └── shade_arena_adaptive_component_search/     # HARDE Stage II
├── personalized_harness/
│   ├── AgentDyn/
│   ├── AgentSafetyBench/
│   └── SHADE_v2/
├── .env.example
├── .gitignore
└── requirements.txt

डोमेन नामकरण और HARDE चरण

benchmark नामक बेंचमार्क के लिए, निर्देशिकाएँ इस परंपरा का पालन करती हैं:

Directory	Method stage	Main entry point
domains/benchmark/	Meta-Harness baseline	meta_harness.py
domains/benchmark_component_probe/	HARDE Stage I: component probing	component_probe.py
domains/benchmark_adaptive_component_search/	HARDE Stage II: adaptive component search	adaptive_component_search.py

चरण I हार्नेस घटकों की जाँच करता है और एक घटक-स्तरीय रूब्रिक तैयार करता है। चरण II उस रूब्रिक का उपयोग करके खोज के दौरान एक घटक को अनुकूल रूप से चुनता और अनुकूलित करता है। इस रिपॉज़िटरी में, benchmark agentdyn, agentsafetybench, या shade_arena में से एक है।

सेटअप

Python 3.10 या नया संस्करण अनुशंसित है।

conda create -n HARDE python=3.10
conda activate HARDE
pip install -r requirements.txt
cp .env.example .env
cp model_config.example.yaml model_config.yaml

# Edit .env, then export its values into the current shell.
set -a
source .env
set +a

बाहरी बेंचमार्क

तृतीय-पक्ष बेंचमार्क कोड और डेटासेट वेंडर नहीं किए गए हैं। आपको जिस बेंचमार्क की आवश्यकता है, उसे नीचे दिए गए सटीक निर्देशिका नामों का उपयोग करके रिपॉज़िटरी रूट में क्लोन करें:

git clone https://github.com/leolee99/AgentDyn.git AgentDyn
git clone https://github.com/jkutaso/SHADE-Arena.git SHADE-Arena
git clone https://github.com/thu-coai/Agent-SafetyBench.git Agent-SafetyBench

अतिरिक्त डेटा स्रोत:

• Agent-SafetyBench डेटा: https://huggingface.co/datasets/thu-coai/Agent-SafetyBench

एडाप्टर इन रिपॉज़िटरीज़ को HARDE रूट के सापेक्ष हल करते हैं। अपेक्षित लेआउट:

HARDE/
├── AgentDyn/
├── SHADE-Arena/
├── Agent-SafetyBench/
├── domains/
└── personalized_harness/

कोड चलाना

विस्तृत बेंचमार्क-विशिष्ट कमांड और विकल्प domains/ के अंतर्गत प्रत्येक संबंधित निर्देशिका के अंदर README में प्रलेखित हैं। फिक्स्ड-हार्नेस मूल्यांकन उदाहरण personalized_harness/README.md में प्रलेखित हैं।

निम्नलिखित SHADE-Arena उदाहरण प्रत्येक विधि के लिए पूर्ण निष्पादन प्रवाह दिखाते हैं।

Meta-Harness बेसलाइन

Meta-Harness सीधे तीन पुनरावृत्तियों के लिए पूर्ण हार्नेस को अनुकूलित करता है और फिर चयनित हार्नेस का मूल्यांकन होल्ड-आउट टेस्ट सेट पर करता है:

python domains/shade_arena/meta_harness.py \
  --run-name shade_meta_seed0 \
  --fresh \
  --iterations 3 \
  --seed 0 \
  --run-final-test

परिणाम domains/shade_arena/runs/shade_meta_seed0/ में लिखे जाते हैं।

वन-शॉट हार्नेस प्रस्ताव

यह बेसलाइन असंशोधित बेंचमार्क हार्नेस का मूल्यांकन करता है, एकल LLM कॉल में एक व्यक्तिगत हार्नेस प्रस्तावित करता है, और उस प्रस्ताव का मूल्यांकन उन्हीं SHADE-Arena कार्यों पर करता है। यह पुनरावृत्तीय खोज नहीं करता:

python personalized_harness/shade_v2_pipeline.py \
  --model_config model_config.yaml \
  --tasks spam_filter_update \
  --repeat 1 \
  --output_harness personalized_harness/SHADE_v2/harnesses/one_shot_proposal.py \
  --output_dir personalized_harness/SHADE_v2/output_one_shot

--skip_generate, --skip_base, या --skip_personalized फ़्लैग के बिना, यह कमांड पूरी श्रृंखला चलाता है:

base-harness evaluation → one-shot harness proposal → proposed-harness evaluation → summary

HARDE

HARDE पहले चरण I में व्यक्तिगत हार्नेस घटकों की जाँच करता है:

python domains/shade_arena_component_probe/component_probe.py \
  --run-name shade_probe_seed0 \
  --seed 0

चरण I उत्पन्न हार्नेस गाइड को यहाँ लिखता है:

domains/shade_arena_component_probe/runs/shade_probe_seed0/experience/module_rubric.md

चरण II उस गाइड का उपयोग करता है, प्रत्येक पुनरावृत्ति पर अनुकूल रूप से एक घटक चुनता है, तीन खोज पुनरावृत्तियाँ चलाता है, और अंतिम चयनित हार्नेस का मूल्यांकन करता है:

python domains/shade_arena_adaptive_component_search/adaptive_component_search.py \
  --run-name shade_adaptive_seed0 \
  --seed 0 \
  --iterations 3 \
  --rubric domains/shade_arena_component_probe/runs/shade_probe_seed0/experience/module_rubric.md \
  --initial-components initial_components/full_trajectory_monitor \
  --run-final-test

उद्धरण

उद्धरण मेटाडेटा पेपर रिलीज़ के साथ जोड़ा जाएगा।