Experiment/red team agent tool

sdk/evaluation/azure-ai-evaluation/CHANGELOG.md

@@ -3,6 +3,7 @@
 ## 1.6.0 (Unreleased)
 
 ### Features Added
+- New `<evaluator>.binary_aggregate` field added to evaluation result metrics. This field contains the aggregated binary evaluation results for each evaluator, providing a summary of the evaluation outcomes.
 
 ### Breaking Changes
 

sdk/evaluation/azure-ai-evaluation/azure/ai/evaluation/_evaluate/_evaluate.py

@@ -19,6 +19,7 @@
 
 from .._constants import (
     CONTENT_SAFETY_DEFECT_RATE_THRESHOLD_DEFAULT,
+    EVALUATION_PASS_FAIL_MAPPING,
     EvaluationMetrics,
     DefaultOpenEncoding,
     Prefixes,
@@ -209,6 +210,48 @@ def _process_rows(row, detail_defect_rates):
     return detail_defect_rates
 
 
+def _aggregation_binary_output(df: pd.DataFrame) -> Dict[str, float]:
+    """
+    Aggregate binary output results (pass/fail) from evaluation dataframe.
+
+    For each evaluator, calculates the proportion of "pass" results.
+
+    :param df: The dataframe of evaluation results.
+    :type df: ~pandas.DataFrame
+    :return: A dictionary mapping evaluator names to the proportion of pass results.
+    :rtype: Dict[str, float]
+    """
+    results = {}
+
+    # Find all columns that end with "_result"
+    result_columns = [col for col in df.columns if col.startswith("outputs.") and col.endswith("_result")]
+
+    for col in result_columns:
+        # Extract the evaluator name from the column name
+        # (outputs.<evaluator>.<metric>_result)
+        parts = col.split(".")
+        evaluator_name = None
+        if len(parts) >= 3:
+            evaluator_name = parts[1]
+        else:
+            LOGGER.warning("Skipping column '%s' due to unexpected format. Expected at least three parts separated by '.'", col)
+            continue
+        if evaluator_name:
+            # Count the occurrences of each unique value (pass/fail)
+            value_counts = df[col].value_counts().to_dict()
+
+            # Calculate the proportion of EVALUATION_PASS_FAIL_MAPPING[True] results
+            total_rows = len(df)
+            pass_count = value_counts.get(EVALUATION_PASS_FAIL_MAPPING[True], 0)
+            proportion = pass_count / total_rows if total_rows > 0 else 0.0
+
+            # Set the result with the evaluator name as the key
+            result_key = f"{evaluator_name}.binary_aggregate"
+            results[result_key] = round(proportion, 2)
+
+    return results
+
+
 def _aggregate_metrics(df: pd.DataFrame, evaluators: Dict[str, Callable]) -> Dict[str, float]:
     """Aggregate metrics from the evaluation results.
     On top of naively calculating the mean of most metrics, this function also identifies certain columns
@@ -222,6 +265,8 @@ def _aggregate_metrics(df: pd.DataFrame, evaluators: Dict[str, Callable]) -> Dic
     :return: The aggregated metrics.
     :rtype: Dict[str, float]
     """
+    binary_metrics = _aggregation_binary_output(df)
+
     df.rename(columns={col: col.replace("outputs.", "") for col in df.columns}, inplace=True)
 
     handled_columns = []
@@ -249,6 +294,10 @@ def _aggregate_metrics(df: pd.DataFrame, evaluators: Dict[str, Callable]) -> Dic
     metrics = mean_value.to_dict()
     # Add defect rates back into metrics
     metrics.update(defect_rates)
+
+    # Add binary threshold metrics based on pass/fail results
+    metrics.update(binary_metrics)
+
     return metrics
 
 

sdk/evaluation/azure-ai-evaluation/azure/ai/evaluation/red_team/_attack_strategy.py

@@ -35,6 +35,9 @@ class AttackStrategy(Enum):
     Baseline = "baseline"
     Jailbreak = "jailbreak"
 
+    TAP = "tap"
+    Crescendo = "crescendo"
+
     @classmethod
     def Compose(cls, items: List["AttackStrategy"]) -> List["AttackStrategy"]:
         for item in items:

sdk/evaluation/azure-ai-evaluation/azure/ai/evaluation/red_team/_red_team.py

@@ -53,7 +53,7 @@
 from pyrit.models import ChatMessage
 from pyrit.memory import CentralMemory
 from pyrit.orchestrator.single_turn.prompt_sending_orchestrator import PromptSendingOrchestrator
-from pyrit.orchestrator import Orchestrator
+from pyrit.orchestrator import Orchestrator, CrescendoOrchestrator
 from pyrit.exceptions import PyritException
 from pyrit.prompt_converter import PromptConverter, MathPromptConverter, Base64Converter, FlipConverter, MorseConverter, AnsiAttackConverter, AsciiArtConverter, AsciiSmugglerConverter, AtbashConverter, BinaryConverter, CaesarConverter, CharacterSpaceConverter, CharSwapGenerator, DiacriticConverter, LeetspeakConverter, UrlConverter, UnicodeSubstitutionConverter, UnicodeConfusableConverter, SuffixAppendConverter, StringJoinConverter, ROT13Converter
 
@@ -67,6 +67,7 @@
     setup_logger, log_section_header, log_subsection_header,
     log_strategy_start, log_strategy_completion, log_error
 )
+from ._utils.rai_service_target import AzureRAIServiceTarget
 
 @experimental
 class RedTeam():
@@ -815,6 +816,20 @@ def _get_chat_target(self, target: Union[PromptChatTarget,Callable, AzureOpenAIM
     def _get_orchestrators_for_attack_strategies(self, attack_strategy: List[Union[AttackStrategy, List[AttackStrategy]]]) -> List[Callable]:
         # We need to modify this to use our actual _prompt_sending_orchestrator since the utility function can't access it
         call_to_orchestrators = []
+
+        # Special handling for Crescendo strategy
+        if AttackStrategy.Crescendo in attack_strategy:
+            self.logger.debug("Using Crescendo orchestrator for Crescendo strategy")
+
+            # Include both Crescendo orchestrator for the Crescendo strategy
+            # and PromptSendingOrchestrator for baseline testing
+            call_to_orchestrators.extend([
+                self._crescendo_orchestrator,  # For Crescendo strategy
+                self._prompt_sending_orchestrator  # For baseline testing
+            ])
+            return call_to_orchestrators
+
+        # Default handling for other strategies
         # Sending PromptSendingOrchestrator for each complexity level
         if AttackStrategy.EASY in attack_strategy:
             call_to_orchestrators.extend([self._prompt_sending_orchestrator])
@@ -1481,7 +1496,8 @@ async def scan(
             application_scenario: Optional[str] = None,
             parallel_execution: bool = True,
             max_parallel_tasks: int = 5,
-            timeout: int = 120
+            timeout: int = 120,
+            skip_baseline: bool = False
         ) -> RedTeamResult:
         """Run a red team scan against the target using the specified strategies.
 
@@ -1767,21 +1783,29 @@ def filter(self, record):
 
                 self.logger.debug(f"[{combo_idx+1}/{len(combinations)}] Creating task: {call_orchestrator.__name__} + {strategy_name} + {risk_category.value}")
 
-                orchestrator_tasks.append(
-                    self._process_attack(
-                        target=target,
-                        call_orchestrator=call_orchestrator,
-                        all_prompts=objectives,
-                        strategy=strategy,
-                        progress_bar=progress_bar,
-                        progress_bar_lock=progress_bar_lock,
-                        scan_name=scan_name,
-                        data_only=data_only,
-                        output_path=output_path,
-                        risk_category=risk_category,
-                        timeout=timeout
+                # Skip baseline task if skip_baseline is True and this is a baseline strategy
+                if skip_baseline and strategy == AttackStrategy.Baseline:
+                    self.logger.info(f"Skipping baseline task for {risk_category.value} as skip_baseline=True")
+                    async with progress_bar_lock:
+                        progress_bar.update(1)
+                    # Mark as completed in tracking dictionary
+                    self.red_team_info[strategy_name][risk_category.value]["status"] = TASK_STATUS["COMPLETED"]
+                else:
+                    orchestrator_tasks.append(
+                        self._process_attack(
+                            target=target,
+                            call_orchestrator=call_orchestrator,
+                            all_prompts=objectives,
+                            strategy=strategy,
+                            progress_bar=progress_bar,
+                            progress_bar_lock=progress_bar_lock,
+                            scan_name=scan_name,
+                            data_only=data_only,
+                            output_path=output_path,
+                            risk_category=risk_category,
+                            timeout=timeout
+                        )
                     )
-                )
 
             # Process tasks in parallel with optimized batching
             if parallel_execution and orchestrator_tasks: