CalvinBackup/remove-ai-watermarks
1
0
Fork 0
mirror of https://github.com/wiltodelta/remove-ai-watermarks.git synced 2026-06-10 12:53:56 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor(face-restore): wipe GFPGAN path, --restore-faces is PhotoMaker-only

Browse Source 
The GFPGAN `restore` extra and its `face_restore.py` module are gone. They were
oracle-confirmed to re-introduce SynthID by blending watermarked original face
pixels at fidelity weight 0.5 (clean A/B: gemini_3 controlnet 0.20 detected WITH
GFPGAN, clean WITHOUT). Keeping them as the default restore method was a footgun
for the removal pipeline. PhotoMaker-V2 (added in the previous commit) is the
single shipped restore path now -- identity-as-embedding, SynthID-safe by
construction.

Removed:
- src/remove_ai_watermarks/face_restore.py + tests/test_face_restore.py
- pyproject.toml `restore` extra (gfpgan/facexlib/basicsr + scipy/numba pins)
- pyproject.toml `[tool.uv.extra-build-dependencies] basicsr = [...]` build pin
- CLI: `--restore-faces-method` and `--restore-faces-weight` (no method choice
  to make, no GFPGAN weight knob to expose)
- InvisibleEngine._restore_faces method (only _restore_faces_photomaker remains)
- All restore-faces-method / restore-faces-weight threading through cmd_*
  signatures and _process_batch_image

Kept:
- `--restore-faces / --no-restore-faces`: now binds to PhotoMaker-V2.
- All adopted oracle findings about GFPGAN re-introducing SynthID (kept in the
  research docs as historical context that explains why the path was removed).

Docs updated: CLAUDE.md (restore extras bullet collapsed to photomaker, removed
face_restore Key-modules bullet, several inline GFPGAN refs scrubbed), README.md
(face-identity callout + install section now point to the photomaker extra),
docs/synthid.md 5.5 (net recipe), docs/controlnet-removal-pipeline-research.md
(recommendations).

ruff + strict pyright (src/) clean; 578 tests pass (the 9 GFPGAN tests are gone,
the 9 PhotoMaker tests stay green).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Victor Kuznetsov
2026-06-08 15:35:37 -07:00
parent 1439eb0714
commit 439eeadc07
11 changed files with 64 additions and 1638 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/remove_ai_watermarks/auto_config.py
+1 -1
View File
@@ -8,7 +8,7 @@ host (image work there OOM-crashes the container).
Routing is **quality-priority**: ControlNet (text/face-structure preservation) is the
default; it is only skipped for a clearly structure-less image (no face, no text,
near-zero edges), where plain SDXL is cheaper and just as good. GFPGAN face
near-zero edges), where plain SDXL is cheaper and just as good. PhotoMaker face
restoration is enabled when a face is present. When a smoothing pass (controlnet or
face restore) ran, the **adaptive polish** (``humanizer.adaptive_polish``) restores
the input's detail level -- a capped unsharp + edge-masked grain targeting the input's
src/remove_ai_watermarks/cli.py
+13 -40
View File
@@ -236,32 +236,21 @@ def _warn_if_esrgan_unavailable(upscaler: str) -> None:
def _restore_faces_options(f: Any) -> Any:
"""Attach the shared face-restoration flags to an invisible-pipeline command."""
restore_flag = click.option(
"""Attach the face-restoration flag to an invisible-pipeline command.
PhotoMaker-V2 is the only restoration method shipped (the prior GFPGAN path was
oracle-confirmed to re-introduce SynthID by partial pixel blending and has been
removed). PhotoMaker carries identity in a SynthID-invariant OpenCLIP embedding
and regenerates fresh face pixels conditioned on it -- see
``docs/synthid-robust-identity-research.md``.
"""
return click.option(
"--restore-faces/--no-restore-faces",
default=False,
help="EXPERIMENTAL, opt-in. Restore face identity with a post-pass when faces are "
"present; off by default, auto-skips when no face is detected or the chosen extra "
"is absent.",
)
method_flag = click.option(
"--restore-faces-method",
type=click.Choice(["gfpgan", "photomaker"]),
default="gfpgan",
help="Face-restore mechanism: 'gfpgan' (cheap, needs 'restore' extra, BUT runs on "
"the watermarked original and re-introduces SynthID) or 'photomaker' (PhotoMaker-V2, "
"needs the 'photomaker' extra; carries identity via a SynthID-invariant OpenCLIP "
"embedding so the regenerated face pixels are watermark-free). Default: gfpgan.",
)
weight_flag = click.option(
"--restore-faces-weight",
type=float,
default=0.5,
help="GFPGAN fidelity weight (0-1); lower = more GAN regeneration (cleaner "
"watermark scrub), higher = closer to the input. Ignored when "
"--restore-faces-method=photomaker.",
)
return restore_flag(method_flag(weight_flag(f)))
help="EXPERIMENTAL, opt-in. Restore face identity with the PhotoMaker-V2 post-pass "
"when faces are present (needs the 'photomaker' extra); off by default, auto-skips "
"when no face is detected or the extra is absent.",
)(f)
def _watermark_region(det: DetectionResult, width: int, height: int) -> tuple[int, int, int, int]:
@@ -612,8 +601,6 @@ def cmd_invisible(
min_resolution: int,
controlnet_scale: float,
restore_faces: bool,
restore_faces_weight: float,
restore_faces_method: str,
upscaler: str,
auto: bool,
adaptive_polish: bool,
@@ -676,8 +663,6 @@ def cmd_invisible(
upscaler=upscaler,
vendor=vendor,
restore_faces=restore_faces,
restore_faces_weight=restore_faces_weight,
restore_faces_method=restore_faces_method,
)
elapsed = time.monotonic() - t0
@@ -879,8 +864,6 @@ def cmd_all(
min_resolution: int,
controlnet_scale: float,
restore_faces: bool,
restore_faces_weight: float,
restore_faces_method: str,
upscaler: str,
auto: bool,
adaptive_polish: bool,
@@ -989,8 +972,6 @@ def cmd_all(
upscaler=upscaler,
vendor=vendor,
restore_faces=restore_faces,
restore_faces_weight=restore_faces_weight,
restore_faces_method=restore_faces_method,
)
console.print(" Invisible watermark removed")
@@ -1046,8 +1027,6 @@ def _process_batch_image(
max_resolution: int = 0,
min_resolution: int = 1024,
restore_faces: bool = False,
restore_faces_weight: float = 0.5,
restore_faces_method: str = "gfpgan",
controlnet_scale: float = 1.0,
upscaler: str = "lanczos",
auto: bool = False,
@@ -1126,8 +1105,6 @@ def _process_batch_image(
min_resolution=min_resolution,
upscaler=upscaler,
restore_faces=restore_faces,
restore_faces_weight=restore_faces_weight,
restore_faces_method=restore_faces_method,
# Detect the vendor from the pristine original (`img_path`), not the
# visible-processed `out_path` whose C2PA is already gone.
vendor=vendor_for_strength(img_path),
@@ -1210,8 +1187,6 @@ def cmd_batch(
max_resolution: int,
min_resolution: int,
restore_faces: bool,
restore_faces_weight: float,
restore_faces_method: str,
controlnet_scale: float,
upscaler: str,
auto: bool,
@@ -1271,8 +1246,6 @@ def cmd_batch(
max_resolution=max_resolution,
min_resolution=min_resolution,
restore_faces=restore_faces,
restore_faces_weight=restore_faces_weight,
restore_faces_method=restore_faces_method,
controlnet_scale=controlnet_scale,
upscaler=upscaler,
auto=auto,
src/remove_ai_watermarks/face_restore.py
-191
View File
@@ -1,191 +0,0 @@
"""Optional GFPGAN face-restoration post-pass for the invisible removal pipeline.
The diffusion removal pass scrubs the watermark everywhere but lets faces drift in
likeness (canny holds face *structure*, not *identity*). This module restores each
face's identity by running GFPGAN on the ORIGINAL (watermarked) image and
feather-compositing the restored face REGIONS into the cleaned image.
GFPGAN RE-SYNTHESIZES each face from a StyleGAN2 prior -- the composited pixels are
GAN-generated, NOT copied from the original -- so the pixel watermark is scrubbed in
the face regions too, while identity is preserved (oracle-validated at weight 0.5).
Both GFPGAN (Apache-2.0) and its RetinaFace detector (MIT) are commercial-safe.
The GFPGANv1.4 weights and the RetinaFace detector download on first use and are
never bundled. Requires the optional ``restore`` extra (gfpgan/facexlib/basicsr).
"""
# cv2/torch/gfpgan boundary: gfpgan/basicsr/facexlib ship no usable type stubs and
# this module wraps cv2 (feather composite) and torch; relax the unknown-type rules
# for this file only.
# pyright: reportUnknownMemberType=false, reportUnknownArgumentType=false, reportUnknownVariableType=false, reportUnknownParameterType=false, reportMissingTypeArgument=false, reportMissingTypeStubs=false, reportMissingImports=false, reportArgumentType=false, reportAssignmentType=false, reportReturnType=false, reportCallIssue=false, reportIndexIssue=false, reportOperatorIssue=false, reportOptionalMemberAccess=false, reportOptionalCall=false, reportOptionalSubscript=false, reportOptionalOperand=false, reportAttributeAccessIssue=false, reportPrivateImportUsage=false, reportPrivateUsage=false, reportInvalidTypeForm=false, reportConstantRedefinition=false, reportUnnecessaryComparison=false
from __future__ import annotations
import logging
import sys
import threading
from typing import TYPE_CHECKING, Any
if TYPE_CHECKING:
from numpy.typing import NDArray
logger = logging.getLogger(__name__)
# GFPGANv1.4 weights (Apache-2.0). Downloaded on first use, never bundled.
_GFPGAN_MODEL_URL = "https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth"
_GFPGAN_ARCH = "clean"
_GFPGAN_CHANNEL_MULTIPLIER = 2
_restorer: Any | None = None
_restorer_lock = threading.Lock()
def is_available() -> bool:
"""True when the optional GFPGAN face-restoration deps are importable."""
import importlib.util
return importlib.util.find_spec("gfpgan") is not None and importlib.util.find_spec("facexlib") is not None
def _apply_basicsr_shim() -> None:
"""Install the ``torchvision.transforms.functional_tensor`` compatibility shim.
basicsr (a GFPGAN dependency) imports ``rgb_to_grayscale`` from the
``torchvision.transforms.functional_tensor`` module, which newer torchvision
removed. Recreate that module pointing at the public functional API. Idempotent:
only installed when the real module is missing.
"""
import importlib.util
if importlib.util.find_spec("torchvision.transforms.functional_tensor") is not None:
return
if "torchvision.transforms.functional_tensor" in sys.modules:
return
import types
import torchvision.transforms.functional as tv_functional
shim = types.ModuleType("torchvision.transforms.functional_tensor")
shim.rgb_to_grayscale = tv_functional.rgb_to_grayscale
sys.modules["torchvision.transforms.functional_tensor"] = shim
def _select_device() -> str:
"""Pick the GFPGAN device: CUDA when present, else CPU.
The pip GFPGANer has an MPS device-mismatch bug, and this is a cheap post-pass
on a few face crops, so MPS is deliberately avoided -- CPU is the safe default
on Apple silicon.
"""
try:
import torch
if torch.cuda.is_available():
return "cuda"
except Exception as e:
logger.debug("face_restore: CUDA probe failed (%s); using CPU", e)
return "cpu"
def _get_restorer() -> Any:
"""Return the lazily-built GFPGANer singleton (downloads weights on first use)."""
global _restorer
if _restorer is not None:
return _restorer
with _restorer_lock:
if _restorer is None:
_apply_basicsr_shim()
from gfpgan import GFPGANer
_restorer = GFPGANer(
model_path=_GFPGAN_MODEL_URL,
upscale=1,
arch=_GFPGAN_ARCH,
channel_multiplier=_GFPGAN_CHANNEL_MULTIPLIER,
device=_select_device(),
)
return _restorer
def _composite_faces(
base_bgr: NDArray[Any],
restored_bgr: NDArray[Any],
boxes: list[tuple[float, float, float, float]],
pad: int = 14,
feather_div: int = 6,
) -> NDArray[Any]:
"""Feather-composite restored face regions from ``restored_bgr`` into ``base_bgr``.
Pure cv2/numpy helper (no gfpgan), so it is unit-testable without the model.
For each ``(x1, y1, x2, y2)`` box: pad and clip to the image, build a Gaussian-
feathered rectangular alpha, and blend ``restored * a + base * (1 - a)``. Boxes
that fall fully outside the image (or an empty list) leave ``base_bgr`` unchanged.
"""
import cv2
import numpy as np
out = base_bgr.astype(np.float32)
h, w = base_bgr.shape[:2]
for box in boxes:
x1 = int(box[0]) - pad
y1 = int(box[1]) - pad
x2 = int(box[2]) + pad
y2 = int(box[3]) + pad
x1 = max(0, min(x1, w))
y1 = max(0, min(y1, h))
x2 = max(0, min(x2, w))
y2 = max(0, min(y2, h))
bw = x2 - x1
bh = y2 - y1
if bw <= 0 or bh <= 0:
continue
alpha = np.zeros((h, w), dtype=np.float32)
alpha[y1:y2, x1:x2] = 1.0
k = max(3, (min(bw, bh) // feather_div) | 1) # odd kernel >= 3
alpha = cv2.GaussianBlur(alpha, (k, k), 0)
alpha = alpha[:, :, None]
out = restored_bgr.astype(np.float32) * alpha + out * (1.0 - alpha)
return np.clip(out, 0, 255).astype(np.uint8)
def restore_faces(
original_bgr: NDArray[Any],
cleaned_bgr: NDArray[Any],
weight: float = 0.5,
pad: int = 14,
feather_div: int = 6,
) -> NDArray[Any]:
"""Restore face identity in ``cleaned_bgr`` using GFPGAN on ``original_bgr``.
Runs GFPGAN on the ORIGINAL (watermarked) image to recover the true-identity,
GAN-regenerated faces plus the RetinaFace boxes, then feather-composites those
face regions into the cleaned image. The composited pixels are GFPGAN-generated
(not original), so no watermark and no pixel-copy. Returns ``cleaned_bgr``
unchanged when no face is detected.
Args:
original_bgr: The original (watermarked) image as cv2 BGR.
cleaned_bgr: The diffusion-cleaned image as cv2 BGR (faces drifted).
weight: GFPGAN fidelity weight (0-1); lower = more GAN regeneration.
pad: Pixels to grow each face box before compositing.
feather_div: Larger = sharper composite edge (box-min // feather_div kernel).
"""
restorer = _get_restorer()
_, _, restored_img = restorer.enhance(
original_bgr,
has_aligned=False,
only_center_face=False,
paste_back=True,
weight=weight,
)
det_faces = getattr(restorer.face_helper, "det_faces", None) or []
boxes = [(float(b[0]), float(b[1]), float(b[2]), float(b[3])) for b in det_faces]
if not boxes:
logger.debug("face_restore: no faces detected; returning cleaned image unchanged")
return cleaned_bgr
return _composite_faces(cleaned_bgr, restored_img, boxes, pad=pad, feather_div=feather_div)
src/remove_ai_watermarks/invisible_engine.py
+14 -74
View File
@@ -165,8 +165,6 @@ class InvisibleEngine:
min_resolution: int = 1024,
vendor: str | None = None,
restore_faces: bool = False,
restore_faces_weight: float = 0.5,
restore_faces_method: str = "gfpgan",
unsharp: float = 0.0,
adaptive_polish: bool = False,
upscaler: str = "lanczos",
@@ -182,22 +180,16 @@ class InvisibleEngine:
guidance_scale: Classifier-free guidance scale.
seed: Random seed for reproducibility.
humanize: Intensity of Analog Humanizer film grain (0 = off).
restore_faces: EXPERIMENTAL, opt-in (default False). Run the GFPGAN
face-restoration post-pass when faces are present (needs the
``restore`` extra). Auto-skips with a debug log when the extra is
absent or no face is detected.
restore_faces_method: Which face-identity restoration mechanism to run after
the diffusion pass: ``"gfpgan"`` (default; cheap, but WARNING the GFPGAN
pass runs on the watermarked ORIGINAL and re-introduces SynthID -- see
``face_restore.py``) or ``"photomaker"`` (PhotoMaker-V2; carries identity
via a SynthID-invariant OpenCLIP embedding and regenerates fresh face
pixels conditioned on it -- SynthID-safe, but heavier and requires the
``photomaker`` extra). See ``docs/synthid-robust-identity-research.md``.
restore_faces_weight: GFPGAN fidelity weight (0-1); lower = more GAN
regeneration (cleaner watermark scrub), higher = closer to input.
restore_faces: EXPERIMENTAL, opt-in (default False). Run the PhotoMaker-V2
face-identity post-pass when faces are present (needs the
``photomaker`` extra). Carries identity via a SynthID-invariant OpenCLIP
embedding and regenerates fresh face pixels conditioned on it, so the
pixel watermark is not transported. Auto-skips with a debug log when the
extra is absent or no face is detected. See
``docs/synthid-robust-identity-research.md``.
unsharp: Final unsharp-mask sharpening strength (0 = off, default).
Applied last (after face restoration) to counter the soft,
over-smoothed look of the diffusion/GFPGAN passes; ~0.5-0.8 is a
over-smoothed look of the diffusion + restoration; ~0.5-0.8 is a
safe range, higher risks edge halos.
adaptive_polish: When True (the --auto mode default), restore the input's
detail level in the softened output instead of fixed unsharp/humanize:
@@ -320,19 +312,16 @@ class InvisibleEngine:
out_cv = cv2.resize(out_cv, orig_size, interpolation=cv2.INTER_LANCZOS4)
image_io.imwrite(out_path, out_cv)
# Optional GFPGAN face-restoration post-pass: restore face identity that
# the diffusion regeneration drifted, while still scrubbing the pixel
# watermark (GFPGAN re-synthesizes faces from a StyleGAN2 prior). Runs on
# the cleaned output at its final resolution; auto-skips when faces are
# Optional PhotoMaker-V2 face-identity post-pass: restore face identity that
# the diffusion regeneration drifted, carrying identity in a SynthID-invariant
# OpenCLIP embedding so the regenerated face pixels are watermark-free. Runs
# on the cleaned output at its final resolution; auto-skips when faces are
# absent or the optional extra is not installed.
if restore_faces:
if restore_faces_method == "photomaker":
self._restore_faces_photomaker(out_path, image, seed)
else:
self._restore_faces(out_path, image, restore_faces_weight)
self._restore_faces_photomaker(out_path, image, seed)
# Final sharpening, LAST so it crisps the face-restored result too (a
# pre-GFPGAN sharpen would be smoothed back over by the face pass).
# pre-restore sharpen would be smoothed back over by the face pass).
if unsharp > 0.0:
import cv2
@@ -368,55 +357,6 @@ class InvisibleEngine:
if _tmp_path.exists():
_tmp_path.unlink()
def _restore_faces(
self,
out_path: Path,
original_image: Any,
weight: float,
) -> None:
"""Run the GFPGAN face-restoration post-pass on the cleaned ``out_path``.
Composites GFPGAN-restored (identity-preserving, watermark-scrubbed) face
regions from the ORIGINAL image into the cleaned output. Best-effort: any
failure logs a warning and leaves the un-restored cleaned output in place;
a missing ``restore`` extra is logged at debug and skipped (the default-on
flag must never error when the extra is absent or no face is present).
"""
from remove_ai_watermarks import face_restore
if not face_restore.is_available():
logger.debug("restore_faces requested but the 'restore' extra is not installed; skipping")
return
try:
import cv2
import numpy as np
from remove_ai_watermarks import image_io
cleaned_bgr = image_io.imread(out_path, cv2.IMREAD_COLOR)
if cleaned_bgr is None:
logger.warning("restore_faces: could not read cleaned output %s; skipping", out_path)
return
# Original (EXIF-transposed) as BGR, aligned to the cleaned image so the
# GFPGAN face boxes land in the cleaned image's coordinate space. The
# cleaned output is already restored to the original resolution above, so
# this resize is normally a no-op (it only fires if a max-resolution cap
# left the source PIL image smaller).
original_rgb = original_image.convert("RGB")
original_bgr = cv2.cvtColor(np.array(original_rgb), cv2.COLOR_RGB2BGR)
cleaned_size = (cleaned_bgr.shape[1], cleaned_bgr.shape[0])
if (original_bgr.shape[1], original_bgr.shape[0]) != cleaned_size:
original_bgr = cv2.resize(original_bgr, cleaned_size, interpolation=cv2.INTER_LANCZOS4)
if self._progress_callback:
self._progress_callback("Restoring face identity (GFPGAN post-pass)...")
restored = face_restore.restore_faces(original_bgr, cleaned_bgr, weight=weight)
image_io.imwrite(out_path, restored)
except Exception as e:
logger.warning("restore_faces post-pass failed (%s); keeping un-restored output", e)
def _restore_faces_photomaker(
self,
out_path: Path,