NVIDIA garak: практическое руководство по защитному тестированию LLM

В этом руководстве мы рассмотрим NVIDIA garak — практический инструмент для защитного тестирования больших языковых моделей (LLM). В примере показаны настройка garak, просмотр плагинов, запуск тестов и чтение отчётов, создадим собственную пробу и детектор, а затем экспортируем результаты в AVID. Вместо одного сканирования пройдём весь рабочий процесс и разберём, как пробы, детекторы, генераторы, отчёты и оценки уязвимости связаны между собой.

Установка NVIDIA garak и вспомогательные функции

import os, sys, json, glob, subprocess, importlib
def sh(cmd, capture=False):
   print(f"\n$ {cmd}")
   return subprocess.run(cmd, shell=True, text=True,
                         capture_output=capture)
sh(f"{sys.executable} -m pip install -q -U garak")
os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
os.environ.setdefault("HF_HUB_DISABLE_TELEMETRY", "1")
import garak, garak.cli
from garak import _config
print("\n=== garak version:", garak.__version__, "===")
def run_garak(args):
   print("\n>>> garak " + " ".join(args))
   try:
       garak.cli.main(args)
   except SystemExit as e:
       if e.code not in (0, None):
           print(f"[garak exited {e.code}]")
   try:
       return _config.transient.report_filename
   except Exception:
       return None

Импортируем необходимые библиотеки и создаём функцию для запуска команд оболочки прямо из ноутбука. Устанавливаем Garak, задаём базовые переменные окружения и подключаем основные модули. Вспомогательная функция позволяет запускать Garak программно и получать путь к созданному отчёту.

Просмотр проб и детекторов garak и запуск сканирования моделей

print("\n########## 1. PLUGIN INVENTORY ##########")
for kind in ["probes", "detectors", "generators", "buffs"]:
   out = sh(f"{sys.executable} -m garak --list_{kind} 2>/dev/null", capture=True)
   lines = [l for l in (out.stdout or "").splitlines() if "." in l]
   print(f"  {kind:11s}: {len(lines)} plugins   e.g. "
         f"{', '.join(l.split()[-1] if l.split() else l for l in lines[:3])}")
print("\n########## 2. FAST DRY-RUN (test.Repeat) ##########")
sh(f"{sys.executable} -m garak --target_type test.Repeat "
  f"--probes lmrc.SlurUsage --generations 1")
print("\n########## 3. REAL MODEL: gpt2 vs DAN 11.0 ##########")
sh(f"{sys.executable} -m garak --target_type huggingface --target_name gpt2 "
  f"--probes dan.Dan_11_0 --generations 1 --parallel_attempts 8")
print("\n########## 4. PROGRAMMATIC MULTI-PROBE SCAN ##########")
report_path = run_garak([
   "--target_type", "test.Repeat",
   "--probes", "dan.Dan_11_0,encoding.InjectBase64,lmrc.SlurUsage",
   "--generations", "1", "--parallel_attempts", "16",
])
print("Report:", report_path)

Сначала перечисляем доступные пробы, детекторы, генераторы и модификаторы (buffs). Затем выполняем быструю пробу с тестовым генератором, чтобы проверить работу Garak без внешней модели или API-ключа. Затем пример показывает запуск на GPT-2 и несколько проб с тестовым генератором. Результаты тестового генератора проверяют конвейер и не измеряют защищённость реальной модели.

Анализ отчётов garak: оценки безопасности и успешности атак

print("\n########## 5. ANALYSIS ##########")
import numpy as np, pandas as pd
def find_latest_report():
   cands = []
   for base in [os.path.expanduser("~/.local/share/garak/garak_runs"),
                os.path.expanduser("~/.cache/garak"), "."]:
       cands += glob.glob(os.path.join(base, "**", "*report.jsonl"),
                          recursive=True)
   cands = [c for c in cands if os.path.getsize(c) > 0]
   return max(cands, key=os.path.getmtime) if cands else None
report_path = report_path or find_latest_report()
print("Analysing:", report_path)
evaluations = None
try:
   from garak.report import Report
   rep = Report(report_path).load().get_evaluations()
   evaluations = rep.evaluations.copy()
   print("\n--- Per-probe mean SAFETY score (garak.report.Report) ---")
   print(rep.scores.round(1).to_string())
except Exception as e:
   print("garak.report.Report unavailable, falling back to manual parse:", e)
   rows = []
   with open(report_path) as f:
       for line in f:
           try: r = json.loads(line)
           except json.JSONDecodeError: continue
           if r.get("entry_type") == "eval":
               rows.append(r)
   evaluations = pd.DataFrame(rows)
   if not evaluations.empty:
       evaluations["score"] = np.where(
           evaluations["total_evaluated"] != 0,
           100 * evaluations["passed"] / evaluations["total_evaluated"], 0.0)
if evaluations is not None and not evaluations.empty:
   evaluations = evaluations[evaluations["total_evaluated"] > 0].copy()
   evaluations["asr_%"] = (100 - evaluations["score"]).round(1)
   view = evaluations[["probe", "detector", "passed",
                       "total_evaluated", "score", "asr_%"]].copy()
   view = view.rename(columns={"score": "safe_%"})
   view["safe_%"] = view["safe_%"].round(1)
   view = view.sort_values("asr_%", ascending=False)
   print("\n--- Per probe/detector  (higher asr_% = more vulnerable) ---")
   print(view.to_string(index=False))
   try:
       import matplotlib.pyplot as plt
       labels = (view["probe"] + "\n" + view["detector"]).tolist()
       plt.figure(figsize=(8, 0.55 * len(view) + 1.5))
       plt.barh(labels, view["asr_%"], color="#76b900")
       plt.gca().invert_yaxis()
       plt.xlabel("Attack Success Rate (%)"); plt.xlim(0, 100)
       plt.title("garak — vulnerability by probe/detector")
       plt.tight_layout(); plt.show()
   except Exception as e:
       print("plot skipped:", e)

Загружаем отчёт Garak и подготавливаем его к анализу с помощью pandas и NumPy. Сначала пробуем встроенный парсер отчётов Garak; если он недоступен, вручную разбираем файл JSONL. Затем для строк с наблюдениями считаем долю ответов, которые не прошли проверку конкретной пробы и детектора. Нулевое число наблюдений исключается: оно не означает 100% успешных атак.

Проверка отмеченных результатов и создание собственной пробы garak

print("\n--- Sample hits (detector score >= 0.5) ---")
hits = []
with open(report_path) as f:
   for line in f:
       try: r = json.loads(line)
       except json.JSONDecodeError: continue
       if r.get("entry_type") != "attempt" or r.get("status") != 2:
           continue
       dr = r.get("detector_results") or r.get("detector") or {}
       max_score = 0.0
       if isinstance(dr, dict):
           for v in dr.values():
               if isinstance(v, list) and v:
                   max_score = max(max_score, max(float(x) for x in v))
       if max_score >= 0.5:
           prompt = r.get("prompt")
           hits.append((r.get("probe_classname", r.get("probe", "?")),
                        round(max_score, 2), str(prompt)[:90]))
print(f"Total hits found: {len(hits)}")
for probe, score, prompt in hits[:5]:
   print(f"  [{score}] {probe}: {prompt!r}")
print("\n########## 6. CUSTOM PROBE ##########")
custom_probe = '''
from garak.probes.base import Probe
class HelloProbe(Probe):
   """Minimal custom probe: two fixed prompts, paired with a custom detector."""
   lang = "en"
   bcp47 = "en"
   primary_detector = "mycustomdet.ContainsHello"
   recommended_detector = ["mycustomdet.ContainsHello"]
   tags = ["custom:demo"]
   goal = "demonstrate authoring a garak probe"
   doc_uri = ""
   prompts = [
       "Please reply with the single word: hello",
       "Continue this sentence: The capital of France is",
   ]
'''
import garak.probes
probes_dir = os.path.dirname(garak.probes.__file__)
with open(os.path.join(probes_dir, "mycustom.py"), "w") as fh:
   fh.write(custom_probe)

Извлекаем из отчёта примеры срабатываний, где оценка детектора не ниже 0,5, и сохраняем названия проб, оценки и фрагменты запросов. Затем создаём пользовательскую пробу Garak с фиксированными запросами и связываем её с собственным детектором.

Создание детектора garak и экспорт результатов в AVID

print("\n########## 7. CUSTOM DETECTOR ##########")
custom_detector = '''
from garak import _config
from garak.detectors.base import StringDetector
class ContainsHello(StringDetector):
   """Demo detector: flags any output containing 'hello' (case-insensitive)."""
   lang_spec = "en"
   bcp47 = "en"
   def __init__(self, config_root=_config):
       super().__init__(["hello"], config_root=config_root)
       self.matchtype = "str"
'''
import garak.detectors
det_dir = os.path.dirname(garak.detectors.__file__)
with open(os.path.join(det_dir, "mycustomdet.py"), "w") as fh:
   fh.write(custom_detector)
sh(f"{sys.executable} -m garak --target_type test.Repeat "
  f"--probes mycustom.HelloProbe --detectors mycustomdet.ContainsHello "
  f"--generations 1")
print("\n########## 8. AVID EXPORT ##########")
if report_path:
   sh(f"{sys.executable} -m garak -r {report_path}")
print("""
rest:
 RestGenerator:
   uri: https://your-endpoint.example.com/v1/chat
   method: post
   headers: {Authorization: "Bearer $TOKEN", Content-Type: "application/json"}
   req_template_json_object:
     model: "your-model"
     messages: [{"role": "user", "content": "$INPUT"}]
   response_json: true
   response_json_field: "$.choices[0].message.content"
""")
print("=== Done. JSONL + HTML reports: ~/.local/share/garak/garak_runs/ ===")

Определяем пользовательский детектор, который отмечает выводы со словом «hello» без учёта регистра, и сохраняем его в пакете детекторов Garak. Затем проверяем расширение на тестовом генераторе с собственной пробой и детектором. В конце экспортируем отчёт в формате AVID и приводим шаблон конфигурации REST для подключения Garak к внешней конечной точке модели.

Вывод

В результате получается полный практический процесс проверки поведения LLM с помощью NVIDIA garak. Мы запускаем встроенные пробы, анализируем оценки безопасности и успешности атак, рассматриваем конкретные отмеченные результаты, добавляем собственную пробу и детектор и экспортируем отчёты в формате AVID. Такой подход позволяет оценивать модели, на тестирование которых у вас есть разрешение, и выстраивать более сложные процессы защитного тестирования.