Upload 133 files

app.py

@@ -3143,6 +3143,33 @@ def _tourney_gpu_run(fn, *args, **kwargs):
     return fn(*args, **kwargs)
 
 
+class _TourneyLogger:
+    """Picklable log collector for tournament progress.
+
+    Gradio's queue system pickles generator frames, so closures like
+    ``lambda msg: log_lines.append(msg)`` cause PicklingError.  This
+    simple class is picklable and serves the same purpose.
+    """
+
+    def __init__(self):
+        self.lines: list[str] = []
+
+    def __call__(self, msg: str):
+        self.lines.append(msg)
+
+    def tail(self, n: int = 100) -> str:
+        """Return the last *n* log lines joined by newlines.  ``n=0`` returns all."""
+        if n <= 0:
+            return "\n".join(self.lines)
+        return "\n".join(self.lines[-n:])
+
+
+def _tourney_gpu_wrapper(fn, *args, **kwargs):
+    """Indirection so the @spaces.GPU-wrapped function is resolved at call
+    time rather than captured in the generator frame (which Gradio pickles)."""
+    return _tourney_gpu_run(fn, *args, **kwargs)
+
+
 def run_tourney(model_choice, dataset, quantization):
     """Run an elimination tournament across all abliteration methods.
 
@@ -3169,10 +3196,7 @@ def run_tourney(model_choice, dataset, quantization):
 
     quant = quantization if quantization != "none" else None
 
-    log_lines: list[str] = []
-
-    def on_log(msg):
-        log_lines.append(msg)
+    logger = _TourneyLogger()
 
     dataset_key = get_source_key_from_label(dataset) if dataset else "builtin"
 
@@ -3191,7 +3215,7 @@ def run_tourney(model_choice, dataset, quantization):
             hub_repo=None,
             dataset_key=dataset_key,
             quantization=quant,
-            on_log=on_log,
+            on_log=logger,
             resume=resume,
         )
     except Exception as e:
@@ -3218,16 +3242,16 @@ def run_tourney(model_choice, dataset, quantization):
 
     result = None
     try:
-        for status_msg, partial_result in runner.run_iter(gpu_wrapper=_tourney_gpu_run):
+        for status_msg, partial_result in runner.run_iter(gpu_wrapper=_tourney_gpu_wrapper):
             result = partial_result
             yield (
                 status_msg,
                 "",
-                "\n".join(log_lines[-100:]),
+                logger.tail(),
             )
     except Exception as e:
         tb = traceback.format_exc()
-        log_lines.append(f"\nTRACEBACK:\n{tb}")
+        logger(f"\nTRACEBACK:\n{tb}")
         if _is_quota_error(e):
             # Provide a helpful message for ZeroGPU quota exhaustion
             bracket_md = ""
@@ -3242,18 +3266,18 @@ def run_tourney(model_choice, dataset, quantization):
                 "HuggingFace Pro subscribers get 7x more daily quota.\n\n"
                 "**Tip:** use quantization to reduce per-method GPU time.",
                 bracket_md,
-                "\n".join(log_lines),
+                logger.tail(0),
             )
         else:
             yield (
                 f"**Error:** {type(e).__name__}: {e}",
                 "",
-                "\n".join(log_lines),
+                logger.tail(0),
             )
         return
 
     if not result:
-        yield ("**Error:** Tournament produced no result.", "", "\n".join(log_lines))
+        yield ("**Error:** Tournament produced no result.", "", logger.tail(0))
         return
 
     winner = result.winner
@@ -3306,7 +3330,7 @@ def run_tourney(model_choice, dataset, quantization):
             f"(score: {winner.score:.4f})\n"
             f"Push it to HuggingFace Hub from the **Push to Hub** tab.",
             bracket_md,
-            "\n".join(log_lines),
+            logger.tail(0),
         )
     else:
         n_errors = sum(
@@ -3320,7 +3344,7 @@ def run_tourney(model_choice, dataset, quantization):
         yield (
             msg,
             bracket_md,
-            "\n".join(log_lines),
+            logger.tail(0),
         )
 
 

obliteratus/tourney.py

@@ -727,6 +727,33 @@ tokenizer = AutoTokenizer.from_pretrained("{result.hub_repo or 'this-repo'}")
 """
 
 
+def _noop_log(msg: str) -> None:
+    """Picklable no-op log callback (lambdas can't be pickled by ZeroGPU)."""
+    pass
+
+
+def _noop_round(r: TourneyRound) -> None:
+    """Picklable no-op round callback."""
+    pass
+
+
+class _MethodLogger:
+    """Picklable per-method log adapter that prefixes messages.
+
+    ZeroGPU pickles bound methods (and their ``self``) when shipping work to
+    the GPU worker process.  Plain lambdas like
+    ``lambda msg: self.log(f"  [{method}] {msg}")`` can't survive that, so
+    this small class replaces them.
+    """
+
+    def __init__(self, parent_log: Callable[[str], None], method: str):
+        self._parent = parent_log
+        self._method = method
+
+    def __call__(self, msg: str):
+        self._parent(f"  [{self._method}] {msg}")
+
+
 # ---------------------------------------------------------------------------
 # Core runner
 # ---------------------------------------------------------------------------
@@ -773,8 +800,8 @@ class TourneyRunner:
             if self.output_dir.exists():
                 shutil.rmtree(self.output_dir, ignore_errors=True)
         self.output_dir.mkdir(parents=True, exist_ok=True)
-        self._on_log = on_log or (lambda msg: None)
-        self._on_round = on_round or (lambda r: None)
+        self._on_log = on_log or _noop_log
+        self._on_round = on_round or _noop_round
 
     def log(self, msg: str):
         self._on_log(msg)
@@ -801,6 +828,8 @@ class TourneyRunner:
 
         try:
             # Use informed pipeline for 'informed' method
+            method_log = _MethodLogger(self._on_log, method)
+
             if method == "informed":
                 from obliteratus.informed_pipeline import InformedAbliterationPipeline
                 pipeline = InformedAbliterationPipeline(
@@ -812,7 +841,7 @@ class TourneyRunner:
                     trust_remote_code=True,
                     harmful_prompts=harmful,
                     harmless_prompts=harmless,
-                    on_log=lambda msg: self.log(f"  [{method}] {msg}"),
+                    on_log=method_log,
                 )
                 pipeline.run_informed()
             else:
@@ -828,7 +857,7 @@ class TourneyRunner:
                     harmful_prompts=harmful,
                     harmless_prompts=harmless,
                     verify_sample_size=verify_sample_size,
-                    on_log=lambda msg: self.log(f"  [{method}] {msg}"),
+                    on_log=method_log,
                 )
                 pipeline.run()