DeepTeam is a framework to red team LLMs and AI agents.
async mode support for assess method
A-Vamshif81069baf4d9
diff --git a/deepteam/vulnerabilities/bias/bias.py b/deepteam/vulnerabilities/bias/bias.pyindex 1ca4b26e..d8447d9e 100644--- a/deepteam/vulnerabilities/bias/bias.py+++ b/deepteam/vulnerabilities/bias/bias.py@@ -1,7 +1,10 @@from typing import List, Literal, Optional, Union, Dict+import inspect+import asynciofrom deepeval.models import DeepEvalBaseLLMfrom deepeval.metrics.utils import initialize_model+from deepeval.utils import get_or_create_event_loopfrom deepeval.test_case import LLMTestCasefrom deepteam.vulnerabilities import BaseVulnerability@@ -53,6 +56,24 @@ class Bias(BaseVulnerability):RiskAssessment,)+ if self.async_mode:+ assert inspect.iscoroutinefunction(+ model_callback+ ), "`model_callback` needs to be async. `async_mode` has been set to True."+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attack=attack,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ ignore_errors=ignore_errors,+ )+ )+ else:+ assert not inspect.iscoroutinefunction(+ model_callback+ ), "`model_callback` needs to be sync. `async_mode` has been set to False."+self.simulator_model, _ = initialize_model(self.simulator_model)self.evaluation_model, _ = initialize_model(self.evaluation_model)self.attack_simulator = AttackSimulator(@@ -90,10 +111,7 @@ class Bias(BaseVulnerability):red_teaming_test_cases: List[RedTeamingTestCase] = []for vulnerability_type in self.types:- for simulated_attack in simulated_attacks:-- if simulated_attack.vulnerability_type != vulnerability_type:- continue+ for simulated_attack in vulnerability_type_to_attacks_map.get(vulnerability_type, []):metric = self._get_metric(vulnerability_type@@ -159,6 +177,119 @@ class Bias(BaseVulnerability):)return self.risk_assessment++ async def a_assess(+ self,+ model_callback: CallbackType,+ attack: BaseAttack,+ attacks_per_vulnerability_type: int = 1,+ max_concurrent: int = 10,+ ignore_errors: bool = False,+ ):+ from deepteam.red_teamer.risk_assessment import (+ construct_risk_assessment_overview,+ RedTeamingTestCase,+ RiskAssessment,+ )++ self.simulator_model, _ = initialize_model(self.simulator_model)+ self.evaluation_model, _ = initialize_model(self.evaluation_model)+ self.attack_simulator = AttackSimulator(+ simulator_model=self.simulator_model,+ purpose=self.purpose,+ max_concurrent=max_concurrent,+ )++ self.attack_simulator.model_callback = model_callback+ simulated_attacks: List[SimulatedAttack] = (+ await self.attack_simulator.a_simulate(+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ vulnerabilities=[self],+ attacks=[attack],+ ignore_errors=ignore_errors,+ )+ )++ # Map vulnerabilities to attacks+ vulnerability_type_to_attacks_map: Dict[BiasType, List[SimulatedAttack]] = {}+ for simulated_attack in simulated_attacks:+ if simulated_attack.vulnerability_type not in vulnerability_type_to_attacks_map:+ vulnerability_type_to_attacks_map[simulated_attack.vulnerability_type] = [simulated_attack]+ else:+ vulnerability_type_to_attacks_map[simulated_attack.vulnerability_type].append(simulated_attack)++ semaphore = asyncio.Semaphore(max_concurrent)+ tasks = []++ for vulnerability_type in self.types:+ for simulated_attack in vulnerability_type_to_attacks_map.get(vulnerability_type, []):++ metric = self._get_metric(vulnerability_type)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ metadata=simulated_attack.metadata,+ )++ # If there's a simulation error, record and skip evaluation+ if simulated_attack.error:+ red_teaming_test_case.error = simulated_attack.error+ tasks.append(asyncio.sleep(0, result=red_teaming_test_case)) # dummy async task+ continue++ # Create a coroutine task for this test case+ async def run_case(+ simulated_attack=simulated_attack,+ red_teaming_test_case=red_teaming_test_case,+ metric=metric,+ vulnerability_type=vulnerability_type,+ ):+ try:+ async with semaphore:+ target_output = await model_callback(simulated_attack.input)+ red_teaming_test_case.actual_output = target_output+ except Exception:+ if ignore_errors:+ red_teaming_test_case.error = "Error generating output from target LLM"+ return red_teaming_test_case+ else:+ raise++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ try:+ await metric.a_measure(test_case)+ red_teaming_test_case.score = metric.score+ red_teaming_test_case.reason = metric.reason+ except Exception:+ if ignore_errors:+ red_teaming_test_case.error = f"Error evaluating target LLM output for the '{vulnerability_type.value}' vulnerability"+ return red_teaming_test_case+ else:+ raise++ return red_teaming_test_case++ tasks.append(run_case())++ red_teaming_test_cases_all = await asyncio.gather(*tasks)+ red_teaming_test_cases = [tc for tc in red_teaming_test_cases_all if tc is not None]++ self.risk_assessment = RiskAssessment(+ overview=construct_risk_assessment_overview(+ red_teaming_test_cases=red_teaming_test_cases+ ),+ test_cases=red_teaming_test_cases,+ )++ return self.risk_assessmentdef _get_metric(self,