Update app.py
Browse files
app.py
CHANGED
|
@@ -1,26 +1,26 @@
|
|
| 1 |
#!/usr/bin/env python3
|
| 2 |
-
# app.py - Background Remover v32.9.
|
| 3 |
#
|
| 4 |
-
#
|
| 5 |
-
#
|
| 6 |
-
#
|
| 7 |
-
# and very_hard
|
| 8 |
-
#
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 9 |
#
|
| 10 |
-
#
|
| 11 |
-
#
|
| 12 |
-
#
|
| 13 |
-
#
|
| 14 |
-
#
|
| 15 |
-
# • /api/warmup reports real state (+ ?fire=true).
|
| 16 |
-
# • Rate limiter total_seconds().
|
| 17 |
-
# • _header_safe strips CR/LF.
|
| 18 |
-
# • use_alpha_matting actually honored.
|
| 19 |
-
# • frames-batch honors `model` form field.
|
| 20 |
-
# • isnet matting res 384.
|
| 21 |
-
# • _image_semaphore serializes inference (SERIALIZE_INFERENCE=1 default).
|
| 22 |
-
# • RFC 5987 Content-Disposition.
|
| 23 |
-
# • cold field in /api/health.
|
| 24 |
|
| 25 |
# ============================================================
|
| 26 |
# FORCE IN-MEMORY UPLOAD PARSING
|
|
@@ -64,6 +64,15 @@ from urllib.parse import quote
|
|
| 64 |
|
| 65 |
import psutil
|
| 66 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 67 |
# ============================================================
|
| 68 |
# ONNX RUNTIME
|
| 69 |
# ============================================================
|
|
@@ -77,7 +86,7 @@ try:
|
|
| 77 |
so = _ort.SessionOptions()
|
| 78 |
so.intra_op_num_threads = 1
|
| 79 |
so.inter_op_num_threads = 1
|
| 80 |
-
so.enable_cpu_mem_arena = False
|
| 81 |
so.enable_mem_pattern = False
|
| 82 |
so.graph_optimization_level = _ort.GraphOptimizationLevel.ORT_ENABLE_ALL
|
| 83 |
kwargs['sess_options'] = so
|
|
@@ -108,6 +117,10 @@ logging.basicConfig(
|
|
| 108 |
)
|
| 109 |
logger = logging.getLogger(__name__)
|
| 110 |
|
|
|
|
|
|
|
|
|
|
|
|
|
| 111 |
|
| 112 |
# ============================================================
|
| 113 |
# HEADER SAFETY
|
|
@@ -146,13 +159,13 @@ def _content_disposition(filename: str, fallback: str = "processed") -> str:
|
|
| 146 |
# ============================================================
|
| 147 |
def trim_memory():
|
| 148 |
try:
|
| 149 |
-
|
| 150 |
-
libc.malloc_trim(0)
|
| 151 |
except Exception:
|
| 152 |
pass
|
| 153 |
|
| 154 |
|
| 155 |
def get_process_rss_mb() -> float:
|
|
|
|
| 156 |
try:
|
| 157 |
with open('/proc/self/status', 'r') as f:
|
| 158 |
for line in f:
|
|
@@ -177,14 +190,14 @@ def get_container_limit_mb() -> int:
|
|
| 177 |
try:
|
| 178 |
if os.path.exists('/sys/fs/cgroup/memory.max'):
|
| 179 |
with open('/sys/fs/cgroup/memory.max') as f:
|
| 180 |
-
|
| 181 |
-
if
|
| 182 |
-
return int(
|
| 183 |
if os.path.exists('/sys/fs/cgroup/memory/memory.limit_in_bytes'):
|
| 184 |
with open('/sys/fs/cgroup/memory/memory.limit_in_bytes') as f:
|
| 185 |
-
|
| 186 |
-
if 0 <
|
| 187 |
-
return
|
| 188 |
except Exception:
|
| 189 |
pass
|
| 190 |
try:
|
|
@@ -193,10 +206,27 @@ def get_container_limit_mb() -> int:
|
|
| 193 |
return 0
|
| 194 |
|
| 195 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 196 |
def get_container_memory() -> Dict:
|
| 197 |
limit_mb = get_container_limit_mb()
|
| 198 |
current_rss = get_process_rss_mb()
|
| 199 |
peak_rss = get_peak_rss_mb()
|
|
|
|
| 200 |
|
| 201 |
cgroup_used = 0
|
| 202 |
source = 'unknown'
|
|
@@ -218,12 +248,15 @@ def get_container_memory() -> Dict:
|
|
| 218 |
current_pct = (current_rss / limit_mb * 100) if limit_mb > 0 else 0
|
| 219 |
peak_pct = (peak_rss / limit_mb * 100) if limit_mb > 0 else 0
|
| 220 |
cgroup_pct = (cgroup_used / limit_mb * 100) if limit_mb > 0 else 0
|
|
|
|
| 221 |
|
| 222 |
return {
|
| 223 |
'total_mb': limit_mb,
|
| 224 |
'used_mb': cgroup_used,
|
| 225 |
'available_mb': max(0, limit_mb - cgroup_used),
|
| 226 |
-
'percent': cgroup_pct,
|
|
|
|
|
|
|
| 227 |
'current_rss_mb': current_rss,
|
| 228 |
'current_rss_percent': current_pct,
|
| 229 |
'peak_rss_mb': peak_rss,
|
|
@@ -237,8 +270,9 @@ def _log_rss(label: str):
|
|
| 237 |
try:
|
| 238 |
m = get_container_memory()
|
| 239 |
logger.info(
|
| 240 |
-
f"[RSS] {label}:
|
| 241 |
-
f"({m['current_rss_percent']:.1f}%)
|
|
|
|
| 242 |
)
|
| 243 |
except Exception:
|
| 244 |
pass
|
|
@@ -268,7 +302,8 @@ class ModelManager:
|
|
| 268 |
self.use_counts: Dict[str, int] = {}
|
| 269 |
self.last_use: Dict[str, float] = {}
|
| 270 |
self.max_models = max_models
|
| 271 |
-
|
|
|
|
| 272 |
|
| 273 |
def get_model(self, name, loader_func):
|
| 274 |
if name in self.models:
|
|
@@ -279,7 +314,8 @@ class ModelManager:
|
|
| 279 |
if len(self.models) >= self.max_models:
|
| 280 |
self._evict_one()
|
| 281 |
|
| 282 |
-
|
|
|
|
| 283 |
try:
|
| 284 |
session = loader_func(name)
|
| 285 |
if session is None:
|
|
@@ -287,11 +323,15 @@ class ModelManager:
|
|
| 287 |
self.models[name] = session
|
| 288 |
self.warmed[name] = False
|
| 289 |
self.last_use[name] = time.time()
|
| 290 |
-
self.load_times[name] = time.time() -
|
| 291 |
self.use_counts[name] = 1
|
| 292 |
gc.collect()
|
| 293 |
trim_memory()
|
| 294 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 295 |
return session
|
| 296 |
except Exception as e:
|
| 297 |
logger.warning(f"Loader failed for {name}: {e}")
|
|
@@ -299,9 +339,9 @@ class ModelManager:
|
|
| 299 |
return None
|
| 300 |
|
| 301 |
def _evict_one(self):
|
| 302 |
-
candidates = [k for k in self.models
|
| 303 |
if not candidates:
|
| 304 |
-
candidates = [k for k in self.models
|
| 305 |
if not candidates:
|
| 306 |
return
|
| 307 |
to_remove = min(candidates, key=lambda x: self.use_counts.get(x, 0))
|
|
@@ -318,9 +358,8 @@ class ModelManager:
|
|
| 318 |
return False
|
| 319 |
logger.info(f"Evicting {name} ({reason})")
|
| 320 |
del self.models[name]
|
| 321 |
-
self.use_counts.
|
| 322 |
-
|
| 323 |
-
self.last_use.pop(name, None)
|
| 324 |
gc.collect()
|
| 325 |
trim_memory()
|
| 326 |
_log_rss(f"after evicting {name}")
|
|
@@ -396,25 +435,25 @@ class HairRefiner:
|
|
| 396 |
def refine(self, mask):
|
| 397 |
if mask.dtype != np.uint8:
|
| 398 |
mask = (mask * 255).astype(np.uint8)
|
| 399 |
-
|
| 400 |
-
|
| 401 |
-
cleaned = self._clean(
|
| 402 |
-
feathered = self._feather(cleaned,
|
| 403 |
result = feathered.copy()
|
| 404 |
-
result[
|
| 405 |
return (np.clip(result, 0, 1) * 255).astype(np.uint8)
|
| 406 |
|
| 407 |
def _detect(self, mask):
|
| 408 |
from scipy.ndimage import convolve, binary_dilation
|
| 409 |
-
|
| 410 |
-
return binary_dilation(np.abs(convolve(mask,
|
| 411 |
|
| 412 |
def _clean(self, mask, hair_mask):
|
| 413 |
from scipy.ndimage import label
|
| 414 |
result = mask.copy()
|
| 415 |
-
labeled,
|
| 416 |
sizes = np.bincount(labeled.flatten())
|
| 417 |
-
for i in range(1,
|
| 418 |
if sizes[i] < 20:
|
| 419 |
c = labeled == i
|
| 420 |
if not np.any(c & hair_mask):
|
|
@@ -429,66 +468,10 @@ class HairRefiner:
|
|
| 429 |
dilated = binary_dilation(mask > 0.5, iterations=1)
|
| 430 |
edge = (dilated ^ eroded) & non_hair
|
| 431 |
if np.any(edge):
|
| 432 |
-
|
| 433 |
-
result[edge] = blurred[edge]
|
| 434 |
return result
|
| 435 |
|
| 436 |
|
| 437 |
-
class GraphicProcessor:
|
| 438 |
-
def __init__(self):
|
| 439 |
-
self.tolerance = 25
|
| 440 |
-
|
| 441 |
-
def remove_background(self, image):
|
| 442 |
-
if image.mode != 'RGBA':
|
| 443 |
-
image = image.convert('RGBA')
|
| 444 |
-
np_img = np.array(image)
|
| 445 |
-
h, w = np_img.shape[:2]
|
| 446 |
-
bg_colors = self._find_bg(np_img)
|
| 447 |
-
mask = np.ones((h, w), dtype=np.uint8) * 255
|
| 448 |
-
for c in bg_colors:
|
| 449 |
-
self._flood(np_img, mask, c)
|
| 450 |
-
fg_ratio = np.sum(mask > 128) / (h * w)
|
| 451 |
-
if fg_ratio < 0.05 or fg_ratio > 0.95:
|
| 452 |
-
mask = np.ones((h, w), dtype=np.uint8) * 255
|
| 453 |
-
for c in bg_colors:
|
| 454 |
-
self._flood(np_img, mask, c, tolerance=15)
|
| 455 |
-
result = np_img.copy()
|
| 456 |
-
result[mask == 0, 3] = 0
|
| 457 |
-
return Image.fromarray(result, 'RGBA')
|
| 458 |
-
|
| 459 |
-
def _find_bg(self, np_img):
|
| 460 |
-
h, w = np_img.shape[:2]
|
| 461 |
-
bp = []
|
| 462 |
-
for x in range(w):
|
| 463 |
-
bp.append(tuple(np_img[0, x][:3]))
|
| 464 |
-
bp.append(tuple(np_img[h - 1, x][:3]))
|
| 465 |
-
for y in range(h):
|
| 466 |
-
bp.append(tuple(np_img[y, 0][:3]))
|
| 467 |
-
bp.append(tuple(np_img[y, w - 1][:3]))
|
| 468 |
-
return [c for c, _ in Counter(bp).most_common(3)]
|
| 469 |
-
|
| 470 |
-
def _flood(self, np_img, mask, bg_color, tolerance=25):
|
| 471 |
-
h, w = np_img.shape[:2]
|
| 472 |
-
q = deque(); visited = set()
|
| 473 |
-
for x in range(w):
|
| 474 |
-
q.append((0, x)); q.append((h - 1, x))
|
| 475 |
-
visited.add((0, x)); visited.add((h - 1, x))
|
| 476 |
-
for y in range(h):
|
| 477 |
-
q.append((y, 0)); q.append((y, w - 1))
|
| 478 |
-
visited.add((y, 0)); visited.add((y, w - 1))
|
| 479 |
-
dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)]
|
| 480 |
-
br, bg, bb = bg_color
|
| 481 |
-
while q:
|
| 482 |
-
y, x = q.popleft()
|
| 483 |
-
r, g, b = np_img[y, x][:3]
|
| 484 |
-
if np.sqrt((r - br) ** 2 + (g - bg) ** 2 + (b - bb) ** 2) < tolerance:
|
| 485 |
-
mask[y, x] = 0
|
| 486 |
-
for dy, dx in dirs:
|
| 487 |
-
ny, nx = y + dy, x + dx
|
| 488 |
-
if 0 <= ny < h and 0 <= nx < w and (ny, nx) not in visited:
|
| 489 |
-
q.append((ny, nx)); visited.add((ny, nx))
|
| 490 |
-
|
| 491 |
-
|
| 492 |
class ContentClassifier:
|
| 493 |
def classify(self, image):
|
| 494 |
if image.mode != 'RGB':
|
|
@@ -573,9 +556,7 @@ os.environ["CUDA_VISIBLE_DEVICES"] = ""
|
|
| 573 |
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
|
| 574 |
os.environ["PYTHONUNBUFFERED"] = "1"
|
| 575 |
socket.setdefaulttimeout(60)
|
| 576 |
-
|
| 577 |
-
for d in ["/tmp/u2net_models"]:
|
| 578 |
-
os.makedirs(d, exist_ok=True)
|
| 579 |
|
| 580 |
cpu_executor = ThreadPoolExecutor(max_workers=2)
|
| 581 |
|
|
@@ -584,16 +565,18 @@ resolution_manager = ResolutionManager()
|
|
| 584 |
model_manager = ModelManager(max_models=4)
|
| 585 |
mask_checker = MaskQualityChecker()
|
| 586 |
hair_refiner = HairRefiner()
|
| 587 |
-
graphic_processor = GraphicProcessor()
|
| 588 |
|
| 589 |
|
| 590 |
# ============================================================
|
| 591 |
-
# SEMAPHORES
|
| 592 |
# ============================================================
|
| 593 |
SERIALIZE_INFERENCE = os.environ.get('SERIALIZE_INFERENCE', '1') == '1'
|
| 594 |
_image_semaphore = threading.Semaphore(1)
|
| 595 |
_birefnet_semaphore = threading.Semaphore(1)
|
| 596 |
-
|
|
|
|
|
|
|
|
|
|
| 597 |
|
| 598 |
|
| 599 |
# ============================================================
|
|
@@ -620,16 +603,16 @@ def _smooth_alpha(session_id: Optional[str], alpha: np.ndarray) -> tuple:
|
|
| 620 |
prev = None
|
| 621 |
if entry is not None:
|
| 622 |
prev_alpha, ts = entry
|
| 623 |
-
if now - ts
|
| 624 |
-
prev = None
|
| 625 |
-
else:
|
| 626 |
prev = prev_alpha
|
| 627 |
blended = False
|
| 628 |
if prev is not None and prev.shape == alpha.shape:
|
| 629 |
a = alpha.astype(np.float32)
|
| 630 |
p = prev.astype(np.float32)
|
| 631 |
-
|
| 632 |
-
|
|
|
|
|
|
|
| 633 |
blended = True
|
| 634 |
else:
|
| 635 |
smoothed = alpha
|
|
@@ -663,24 +646,22 @@ def _alpha_cache_stats() -> Dict:
|
|
| 663 |
def _purge_expired_sessions() -> int:
|
| 664 |
now = time.time()
|
| 665 |
with _alpha_cache_lock:
|
| 666 |
-
expired = [
|
| 667 |
-
|
| 668 |
-
if now - ts > ALPHA_CACHE_TTL_SECONDS
|
| 669 |
-
]
|
| 670 |
for sid in expired:
|
| 671 |
_alpha_cache.pop(sid, None)
|
| 672 |
return len(expired)
|
| 673 |
|
| 674 |
|
| 675 |
def _housekeeping():
|
| 676 |
-
# [v32.9.2] Birefnet idle eviction removed — birefnet is preloaded and
|
| 677 |
-
# must stay resident for vehicle/very_hard routing.
|
| 678 |
while True:
|
| 679 |
time.sleep(ALPHA_PURGE_INTERVAL)
|
| 680 |
try:
|
| 681 |
purged = _purge_expired_sessions()
|
| 682 |
if purged:
|
| 683 |
logger.info(f"[alpha-cache] purged {purged}")
|
|
|
|
|
|
|
| 684 |
except Exception as e:
|
| 685 |
logger.warning(f"[housekeeping] {e}")
|
| 686 |
|
|
@@ -695,48 +676,57 @@ def _start_housekeeping():
|
|
| 695 |
# VIDEO CONFIG
|
| 696 |
# ============================================================
|
| 697 |
_video_semaphore = threading.Semaphore(1)
|
| 698 |
-
VIDEO_RAM_REJECT_PERCENT =
|
| 699 |
VIDEO_SAFETY_MARGIN_PERCENT = 5.0
|
| 700 |
VIDEO_MAX_BATCH = 12
|
| 701 |
VIDEO_FORCE_MODEL = os.environ.get('VIDEO_FORCE_MODEL', 'silueta')
|
| 702 |
-
|
| 703 |
|
| 704 |
|
| 705 |
# ============================================================
|
| 706 |
-
# MODEL CONFIG — v32.
|
| 707 |
# ============================================================
|
|
|
|
|
|
|
|
|
|
| 708 |
PRELOAD_MODELS = [
|
| 709 |
-
("u2netp",
|
| 710 |
-
("silueta",
|
| 711 |
-
("
|
| 712 |
]
|
| 713 |
|
| 714 |
-
LAZY_ACTIVE_MODELS = {
|
|
|
|
|
|
|
|
|
|
|
|
|
| 715 |
|
| 716 |
VALID_REMBG_MODELS = {
|
| 717 |
'silueta', 'u2netp', 'isnet-general-use', 'birefnet-general-lite',
|
|
|
|
| 718 |
}
|
| 719 |
|
| 720 |
DORMANT_MODELS = {
|
| 721 |
'u2net': "~176 MB disk / ~800 MB RAM",
|
| 722 |
-
'u2net_human_seg': "~176 MB disk / ~800 MB RAM",
|
| 723 |
-
'isnet-anime': "~176 MB disk / ~800 MB RAM",
|
| 724 |
'birefnet-general': "~900 MB disk / ~2.5 GB RAM",
|
| 725 |
'u2net_cloth_seg': "~176 MB disk / ~800 MB RAM",
|
| 726 |
'sam': "~375 MB disk / ~1 GB RAM",
|
| 727 |
}
|
| 728 |
|
| 729 |
WARMUP_RESOLUTIONS = {
|
| 730 |
-
'silueta': (
|
| 731 |
-
'u2netp': (
|
| 732 |
'isnet-general-use': (128, 128),
|
| 733 |
'birefnet-general-lite': (128, 128),
|
|
|
|
|
|
|
| 734 |
}
|
| 735 |
|
| 736 |
MODEL_ALIASES = {
|
| 737 |
'inspyrenet': 'isnet-general-use',
|
| 738 |
'inspired': 'isnet-general-use',
|
| 739 |
'isnet': 'isnet-general-use',
|
|
|
|
| 740 |
'u2net-human-seg': 'u2net_human_seg',
|
| 741 |
'u2net-humans': 'u2net_human_seg',
|
| 742 |
'birefnet-lite': 'birefnet-general-lite',
|
|
@@ -768,17 +758,19 @@ NEURAL_CONFIGS = {
|
|
| 768 |
'sam': {'fg': 240, 'bg': 10, 'erode': 10},
|
| 769 |
}
|
| 770 |
|
| 771 |
-
#
|
| 772 |
-
#
|
|
|
|
|
|
|
|
|
|
| 773 |
MODEL_RES_CAPS = {
|
| 774 |
-
'u2netp':
|
| 775 |
-
'u2net_human_seg':
|
| 776 |
-
'birefnet-general':
|
| 777 |
-
'isnet-anime':
|
| 778 |
}
|
| 779 |
|
| 780 |
-
VEHICLE_RES_CAP =
|
| 781 |
-
FRAME_MAX_DIM = 640
|
| 782 |
|
| 783 |
CLASSICAL_PROCESSORS = {'flood_fill', 'graphic_classical'}
|
| 784 |
DEFAULT_MODEL_NAME = 'u2netp'
|
|
@@ -804,13 +796,11 @@ def _load_session(name: str):
|
|
| 804 |
from rembg import new_session
|
| 805 |
resolved = MODEL_ALIASES.get(name, name)
|
| 806 |
if resolved not in VALID_REMBG_MODELS:
|
| 807 |
-
logger.warning(f"'{resolved}' dormant/invalid. Using
|
| 808 |
-
resolved = '
|
| 809 |
logger.info(f"Loading {resolved}...")
|
| 810 |
return new_session(resolved)
|
| 811 |
-
|
| 812 |
-
|
| 813 |
-
# ============================================================
|
| 814 |
# ALPHA HELPERS
|
| 815 |
# ============================================================
|
| 816 |
def _alpha_stats(image):
|
|
@@ -831,15 +821,13 @@ def _is_noop(original, result):
|
|
| 831 |
res = np.array(result.convert('RGBA'))
|
| 832 |
if orig.shape != res.shape:
|
| 833 |
return False, 'shape-differs'
|
| 834 |
-
|
| 835 |
-
if int(
|
| 836 |
-
|
| 837 |
-
|
| 838 |
-
|
| 839 |
-
|
| 840 |
-
|
| 841 |
-
return True, f'all-opaque(diff={rgb_diff:.2f})'
|
| 842 |
-
return False, f'has-alpha(min={int(res_alpha.min())})'
|
| 843 |
except Exception as e:
|
| 844 |
return False, f'check-failed:{e}'
|
| 845 |
|
|
@@ -872,6 +860,40 @@ def _cap_output_size(size: tuple, max_size: int) -> tuple:
|
|
| 872 |
return (max(1, int(w * scale)), max(1, int(h * scale)))
|
| 873 |
|
| 874 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 875 |
# ============================================================
|
| 876 |
# NEURAL PROCESSOR
|
| 877 |
# ============================================================
|
|
@@ -914,7 +936,8 @@ def process_with_neural(image, session, model_name,
|
|
| 914 |
dt = time.time() - t0
|
| 915 |
|
| 916 |
if result is None:
|
| 917 |
-
diagnostics.append({'attempt': label, 'result': 'None',
|
|
|
|
| 918 |
continue
|
| 919 |
if result.mode != 'RGBA':
|
| 920 |
result = result.convert('RGBA')
|
|
@@ -1082,11 +1105,7 @@ def _prewarm_models():
|
|
| 1082 |
logger.warning("Cannot pre-warm: remove_func not available")
|
| 1083 |
return
|
| 1084 |
logger.info("Pre-warming preloaded models...")
|
| 1085 |
-
WARMUP_SKIP = {'birefnet-general-lite'} # heavy — skip warmup, matches v32.2.6
|
| 1086 |
for name, _desc in PRELOAD_MODELS:
|
| 1087 |
-
if name in WARMUP_SKIP:
|
| 1088 |
-
logger.info(f" {name} skipped (heavy warmup)")
|
| 1089 |
-
continue
|
| 1090 |
session = model_manager.models.get(name)
|
| 1091 |
if session is None:
|
| 1092 |
continue
|
|
@@ -1097,16 +1116,14 @@ def _prewarm_models():
|
|
| 1097 |
|
| 1098 |
|
| 1099 |
logger.info("=" * 60)
|
| 1100 |
-
logger.info("Background Remover v32.9.
|
| 1101 |
logger.info(f"Preload: {[n for n, _ in PRELOAD_MODELS]}")
|
| 1102 |
logger.info(f"Lazy active: {sorted(LAZY_ACTIVE_MODELS)}")
|
| 1103 |
logger.info(f"Dormant: {sorted(DORMANT_MODELS.keys())}")
|
| 1104 |
-
logger.info(f"
|
| 1105 |
-
logger.info(f"
|
| 1106 |
logger.info(f"SERIALIZE_INFERENCE: {SERIALIZE_INFERENCE}")
|
| 1107 |
-
logger.info("Router:
|
| 1108 |
-
logger.info("Output cap: result ≤ max_size (never upscaled to original)")
|
| 1109 |
-
logger.info("Image timeout: 32s (aligned to proxy 20s+32s)")
|
| 1110 |
logger.info("=" * 60)
|
| 1111 |
|
| 1112 |
preload_all_models()
|
|
@@ -1145,17 +1162,21 @@ def get_session_for_model(model_name):
|
|
| 1145 |
return None
|
| 1146 |
|
| 1147 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1148 |
# ============================================================
|
| 1149 |
-
# ROUTER — v32.
|
| 1150 |
# ============================================================
|
| 1151 |
def _preferred_quality_model():
|
| 1152 |
loaded = model_manager.get_stats().get('loaded_models', [])
|
| 1153 |
-
|
| 1154 |
-
|
| 1155 |
-
|
| 1156 |
-
return 'silueta'
|
| 1157 |
-
if 'birefnet-general-lite' in loaded:
|
| 1158 |
-
return 'birefnet-general-lite'
|
| 1159 |
return 'u2netp'
|
| 1160 |
|
| 1161 |
|
|
@@ -1200,8 +1221,6 @@ def analyze_image_complexity(image):
|
|
| 1200 |
em = np.sqrt(gx ** 2 + gy ** 2)
|
| 1201 |
edge = float(np.sum(em > 10) / 100)
|
| 1202 |
colors = len(np.unique(rgb.reshape(-1, 3), axis=0))
|
| 1203 |
-
|
| 1204 |
-
# [v32.9.2] v32.2.6 logic: raw unique colors, no JPEG-safe adjustment.
|
| 1205 |
is_graphic = colors < 15 and edge > 0.08
|
| 1206 |
|
| 1207 |
is_human = _skin_score(rgb) > 0.1
|
|
@@ -1210,7 +1229,6 @@ def analyze_image_complexity(image):
|
|
| 1210 |
cc_cat = cc.get('category', 'general_photo')
|
| 1211 |
cc_signals = cc.get('signals', {}) or {}
|
| 1212 |
cc_edge = float(cc_signals.get('edge_density', 0.0))
|
| 1213 |
-
cc_border = float(cc_signals.get('border_uniformity', 0.0))
|
| 1214 |
cc_colorcx = float(cc_signals.get('color_complexity', 0.5))
|
| 1215 |
|
| 1216 |
complexity = (
|
|
@@ -1222,16 +1240,21 @@ def analyze_image_complexity(image):
|
|
| 1222 |
)
|
| 1223 |
|
| 1224 |
loaded = model_manager.get_stats().get('loaded_models', [])
|
| 1225 |
-
|
| 1226 |
-
|
|
|
|
|
|
|
| 1227 |
has_silueta = 'silueta' in loaded
|
| 1228 |
-
|
|
|
|
|
|
|
| 1229 |
|
| 1230 |
tier_map = {
|
| 1231 |
'vehicle': 'VEHICLE', 'simple_graphic': 'GRAPHIC',
|
| 1232 |
'very_hard': 'VERY_HARD', 'human_hair': 'HUMAN_HAIR',
|
| 1233 |
'human': 'HUMAN', 'complex': 'COMPLEX',
|
| 1234 |
'medium': 'MEDIUM', 'simple': 'SIMPLE', 'error': 'ERROR',
|
|
|
|
| 1235 |
}
|
| 1236 |
|
| 1237 |
def _route(proc, cat, strat, reason):
|
|
@@ -1243,51 +1266,83 @@ def analyze_image_complexity(image):
|
|
| 1243 |
'is_human': is_human, 'is_graphic': is_graphic,
|
| 1244 |
'hair_complexity': hc,
|
| 1245 |
'cc_category': cc_cat, 'cc_confidence': 0.7,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1246 |
}
|
| 1247 |
|
| 1248 |
-
#
|
| 1249 |
-
|
| 1250 |
-
|
| 1251 |
-
|
| 1252 |
-
|
| 1253 |
-
|
| 1254 |
-
if
|
| 1255 |
-
|
| 1256 |
-
|
| 1257 |
-
|
| 1258 |
-
|
| 1259 |
-
|
| 1260 |
-
|
| 1261 |
-
|
| 1262 |
-
|
| 1263 |
-
|
| 1264 |
-
|
| 1265 |
-
|
| 1266 |
-
|
| 1267 |
-
|
| 1268 |
-
|
| 1269 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1270 |
is_very_hard = (
|
| 1271 |
max(image.size) > 2400
|
| 1272 |
or complexity > 78
|
| 1273 |
or (is_human and hc['route'] == 'wispy_hair' and complexity > 55)
|
| 1274 |
)
|
| 1275 |
-
if is_very_hard
|
| 1276 |
-
|
| 1277 |
-
|
| 1278 |
-
|
| 1279 |
-
|
| 1280 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1281 |
if is_human:
|
| 1282 |
-
|
| 1283 |
-
|
| 1284 |
-
|
| 1285 |
-
|
| 1286 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1287 |
if complexity > 25:
|
| 1288 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1289 |
|
| 1290 |
-
return _route('u2netp', 'simple', 'neural', 'simple')
|
| 1291 |
except Exception as e:
|
| 1292 |
logger.warning(f"Router failed: {e}")
|
| 1293 |
m = _preferred_quality_model()
|
|
@@ -1303,14 +1358,13 @@ def analyze_image_complexity(image):
|
|
| 1303 |
|
| 1304 |
def get_default_model():
|
| 1305 |
loaded = model_manager.get_stats().get('loaded_models', [])
|
| 1306 |
-
for m in ('
|
| 1307 |
if m in loaded:
|
| 1308 |
return m
|
| 1309 |
return loaded[0] if loaded else 'u2netp'
|
| 1310 |
|
| 1311 |
|
| 1312 |
def detect_fragments(image):
|
| 1313 |
-
"""Vectorized fragment detection."""
|
| 1314 |
if image.mode != 'RGBA':
|
| 1315 |
return {'fragment_ratio': 0, 'quality_score': 100,
|
| 1316 |
'has_fragments': False, 'issues': []}
|
|
@@ -1351,13 +1405,12 @@ def process_image_sync(image_data, model_name=None, transparent=True,
|
|
| 1351 |
logger.info(f"[REQ {req}] acquired")
|
| 1352 |
|
| 1353 |
try:
|
| 1354 |
-
|
|
|
|
| 1355 |
original_size = image.size
|
| 1356 |
|
| 1357 |
-
# Alpha passthrough — cap
|
| 1358 |
if _has_meaningful_alpha(image) and model_name is None:
|
| 1359 |
-
if image.mode != 'RGBA':
|
| 1360 |
-
image = image.convert('RGBA')
|
| 1361 |
target = _cap_output_size(image.size, max_size)
|
| 1362 |
if target != image.size:
|
| 1363 |
image = image.resize(target, Image.Resampling.LANCZOS)
|
|
@@ -1381,12 +1434,13 @@ def process_image_sync(image_data, model_name=None, transparent=True,
|
|
| 1381 |
'needs_reprocess': False, 'router_enabled': False,
|
| 1382 |
'router_score': 0.0, 'router_reason': 'already transparent',
|
| 1383 |
'router_tier': 'ALPHA_PASSTHROUGH',
|
| 1384 |
-
'router_category': 'alpha_passthrough',
|
|
|
|
| 1385 |
'mask_confidence': 1.0, 'mask_issues': [], 'hair_route': '',
|
| 1386 |
'hair_refined': False, 'diagnostics': [],
|
| 1387 |
'dormant_rerouted': None, 'birefnet_swapped': None}
|
| 1388 |
|
| 1389 |
-
#
|
| 1390 |
if model_name:
|
| 1391 |
resolved = MODEL_ALIASES.get(model_name, model_name)
|
| 1392 |
selected = resolved
|
|
@@ -1401,27 +1455,26 @@ def process_image_sync(image_data, model_name=None, transparent=True,
|
|
| 1401 |
selected = route_analysis['processor']
|
| 1402 |
cc_category = route_analysis.get('cc_category', 'general_photo')
|
| 1403 |
cc_confidence = route_analysis.get('cc_confidence', 0.7)
|
| 1404 |
-
|
| 1405 |
-
|
| 1406 |
-
|
| 1407 |
-
|
| 1408 |
-
else:
|
| 1409 |
-
target_res = min(
|
| 1410 |
-
resolution_manager.get_resolution(cc_category, image.size),
|
| 1411 |
-
MODEL_RES_CAPS.get(selected, max_size),
|
| 1412 |
-
)
|
| 1413 |
|
| 1414 |
-
# Birefnet RSS
|
| 1415 |
birefnet_swapped = None
|
| 1416 |
if selected == 'birefnet-general-lite':
|
| 1417 |
mem = get_container_memory()
|
| 1418 |
-
projected = mem['current_rss_percent'] +
|
| 1419 |
-
if projected >
|
|
|
|
|
|
|
|
|
|
| 1420 |
logger.warning(
|
| 1421 |
-
f"Birefnet would push RSS to {projected:.0f}%
|
|
|
|
| 1422 |
)
|
| 1423 |
-
birefnet_swapped =
|
| 1424 |
-
selected =
|
| 1425 |
target_res = min(
|
| 1426 |
resolution_manager.get_resolution(cc_category, image.size),
|
| 1427 |
MODEL_RES_CAPS.get(selected, max_size),
|
|
@@ -1433,6 +1486,7 @@ def process_image_sync(image_data, model_name=None, transparent=True,
|
|
| 1433 |
diagnostics = []
|
| 1434 |
result = None
|
| 1435 |
|
|
|
|
| 1436 |
if selected in CLASSICAL_PROCESSORS:
|
| 1437 |
t0 = time.time()
|
| 1438 |
result = process_graphic_classical(image)
|
|
@@ -1442,13 +1496,22 @@ def process_image_sync(image_data, model_name=None, transparent=True,
|
|
| 1442 |
'elapsed': round(time.time() - t0, 3),
|
| 1443 |
})
|
| 1444 |
|
|
|
|
|
|
|
|
|
|
| 1445 |
if result is None:
|
| 1446 |
-
# [v32.9.2] v32.2.6 fallback order
|
| 1447 |
tried = set()
|
| 1448 |
-
for candidate in [selected, '
|
|
|
|
| 1449 |
if candidate in tried or candidate in CLASSICAL_PROCESSORS:
|
| 1450 |
continue
|
| 1451 |
tried.add(candidate)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1452 |
cand_session = get_session_for_model(candidate)
|
| 1453 |
if cand_session is None:
|
| 1454 |
continue
|
|
@@ -1465,18 +1528,25 @@ def process_image_sync(image_data, model_name=None, transparent=True,
|
|
| 1465 |
use_alpha_matting=use_alpha_matting,
|
| 1466 |
)
|
| 1467 |
|
| 1468 |
-
diagnostics.extend([{'model_tried': candidate, **d}
|
|
|
|
| 1469 |
if cand_result is not None:
|
| 1470 |
result = cand_result
|
| 1471 |
selected = candidate
|
| 1472 |
break
|
| 1473 |
|
| 1474 |
if result is None:
|
| 1475 |
-
raise HTTPException(
|
|
|
|
|
|
|
|
|
|
| 1476 |
|
|
|
|
| 1477 |
hair_refined = False
|
| 1478 |
mask_quality = {'confidence': 1.0, 'issues': [], 'passed': True}
|
| 1479 |
-
if result.mode == 'RGBA'
|
|
|
|
|
|
|
| 1480 |
try:
|
| 1481 |
alpha = np.array(result)[:, :, 3]
|
| 1482 |
q = mask_checker.check(alpha)
|
|
@@ -1491,14 +1561,14 @@ def process_image_sync(image_data, model_name=None, transparent=True,
|
|
| 1491 |
except Exception:
|
| 1492 |
pass
|
| 1493 |
|
| 1494 |
-
#
|
| 1495 |
if selected in ('u2netp', 'silueta'):
|
| 1496 |
frag = {'fragment_ratio': 0.0, 'quality_score': 100.0,
|
| 1497 |
'has_fragments': False, 'issues': []}
|
| 1498 |
else:
|
| 1499 |
frag = detect_fragments(result)
|
| 1500 |
|
| 1501 |
-
#
|
| 1502 |
target_output = _cap_output_size(original_size, max_size)
|
| 1503 |
if result.size != target_output:
|
| 1504 |
result = result.resize(target_output, Image.Resampling.LANCZOS)
|
|
@@ -1658,7 +1728,7 @@ def _process_frames_sync(raw_frames, resolved_model, transparent,
|
|
| 1658 |
# ============================================================
|
| 1659 |
# FASTAPI
|
| 1660 |
# ============================================================
|
| 1661 |
-
app = FastAPI(title="Background Remover", version="32.9.
|
| 1662 |
app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
|
| 1663 |
allow_methods=["*"], allow_headers=["*"])
|
| 1664 |
|
|
@@ -1679,7 +1749,7 @@ async def rate_limit_middleware(request, call_next):
|
|
| 1679 |
if request.url.path in (
|
| 1680 |
"/api/health", "/", "/docs", "/redoc", "/openapi.json",
|
| 1681 |
"/api/warmup", "/api/debug/env", "/api/debug/memory", "/api/debug/tmp",
|
| 1682 |
-
"/api/debug/route", "/api/models",
|
| 1683 |
"/api/process/frames-batch",
|
| 1684 |
"/api/frames/session/reset",
|
| 1685 |
"/api/frames/session/stats",
|
|
@@ -1687,12 +1757,11 @@ async def rate_limit_middleware(request, call_next):
|
|
| 1687 |
return await call_next(request)
|
| 1688 |
cid = _get_client_ip(request)
|
| 1689 |
now = datetime.now()
|
| 1690 |
-
rate_limits[cid] = [
|
| 1691 |
-
|
| 1692 |
-
if (now - t).total_seconds() < 60
|
| 1693 |
-
]
|
| 1694 |
if len(rate_limits[cid]) >= RATE_LIMIT:
|
| 1695 |
-
return JSONResponse(status_code=429,
|
|
|
|
| 1696 |
rate_limits[cid].append(now)
|
| 1697 |
return await call_next(request)
|
| 1698 |
|
|
@@ -1740,8 +1809,6 @@ async def process_image_api(
|
|
| 1740 |
elif resolved in DORMANT_MODELS:
|
| 1741 |
dormant_requested = resolved
|
| 1742 |
user_model = None
|
| 1743 |
-
else:
|
| 1744 |
-
user_model = None
|
| 1745 |
|
| 1746 |
loop = asyncio.get_event_loop()
|
| 1747 |
pf = functools.partial(process_image_sync, image_data=contents,
|
|
@@ -1770,9 +1837,14 @@ async def process_image_api(
|
|
| 1770 |
),
|
| 1771 |
}
|
| 1772 |
if dormant_requested:
|
| 1773 |
-
headers['X-Dormant-Rerouted'] =
|
|
|
|
|
|
|
|
|
|
| 1774 |
if result_data.get('birefnet_swapped'):
|
| 1775 |
-
headers['X-Birefnet-Swapped'] =
|
|
|
|
|
|
|
| 1776 |
return StreamingResponse(io.BytesIO(result_data['data']),
|
| 1777 |
media_type=result_data['media_type'],
|
| 1778 |
headers=headers)
|
|
@@ -1878,6 +1950,36 @@ async def warmup(fire: bool = Query(False)):
|
|
| 1878 |
}
|
| 1879 |
|
| 1880 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1881 |
@app.get("/api/models")
|
| 1882 |
async def list_models_endpoint():
|
| 1883 |
stats = model_manager.get_stats()
|
|
@@ -1913,6 +2015,8 @@ async def list_models_endpoint():
|
|
| 1913 |
'memory': {
|
| 1914 |
'current_rss_mb': mem['current_rss_mb'],
|
| 1915 |
'current_rss_percent': round(mem['current_rss_percent'], 1),
|
|
|
|
|
|
|
| 1916 |
'peak_rss_mb': mem['peak_rss_mb'],
|
| 1917 |
},
|
| 1918 |
}
|
|
@@ -1926,10 +2030,14 @@ async def debug_memory():
|
|
| 1926 |
'container': mem,
|
| 1927 |
'current_rss_mb': mem['current_rss_mb'],
|
| 1928 |
'current_rss_percent': round(mem['current_rss_percent'], 1),
|
|
|
|
|
|
|
| 1929 |
'peak_rss_mb': mem['peak_rss_mb'],
|
| 1930 |
'peak_rss_percent': round(mem['peak_rss_percent'], 1),
|
| 1931 |
'rss_gap_mb': mem['rss_gap_mb'],
|
| 1932 |
-
'note': '
|
|
|
|
|
|
|
| 1933 |
'models_loaded': stats['loaded_models'],
|
| 1934 |
'models_warmed': stats['warmed'],
|
| 1935 |
'last_use_seconds_ago': stats['last_use_seconds_ago'],
|
|
@@ -1938,6 +2046,11 @@ async def debug_memory():
|
|
| 1938 |
'dormant_models': sorted(DORMANT_MODELS.keys()),
|
| 1939 |
'alpha_cache': _alpha_cache_stats(),
|
| 1940 |
'serialize_inference': SERIALIZE_INFERENCE,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1941 |
}
|
| 1942 |
|
| 1943 |
|
|
@@ -1945,7 +2058,7 @@ async def debug_memory():
|
|
| 1945 |
async def debug_route(file: UploadFile = File(...)):
|
| 1946 |
try:
|
| 1947 |
contents = await file.read()
|
| 1948 |
-
image =
|
| 1949 |
if image.mode not in ('RGB', 'L'):
|
| 1950 |
image = image.convert('RGB')
|
| 1951 |
analysis = analyze_image_complexity(image)
|
|
@@ -1959,14 +2072,18 @@ async def debug_route(file: UploadFile = File(...)):
|
|
| 1959 |
'complexity': analysis.get('score'),
|
| 1960 |
'is_graphic': analysis.get('is_graphic'),
|
| 1961 |
'is_human': analysis.get('is_human'),
|
|
|
|
| 1962 |
},
|
| 1963 |
'memory': {
|
| 1964 |
'current_rss_percent': round(mem['current_rss_percent'], 1),
|
|
|
|
| 1965 |
'birefnet_loaded': 'birefnet-general-lite' in model_manager.models,
|
| 1966 |
-
'birefnet_viable':
|
| 1967 |
},
|
| 1968 |
'image': {'size': list(image.size)},
|
| 1969 |
}
|
|
|
|
|
|
|
| 1970 |
except Exception as e:
|
| 1971 |
raise HTTPException(500, str(e)[:200])
|
| 1972 |
|
|
@@ -2003,6 +2120,8 @@ async def debug_env():
|
|
| 2003 |
'used_mb': mem['used_mb'],
|
| 2004 |
'available_mb': mem['available_mb'],
|
| 2005 |
'container_percent': round(mem['percent'], 1),
|
|
|
|
|
|
|
| 2006 |
'current_rss_mb': mem['current_rss_mb'],
|
| 2007 |
'current_rss_percent': round(mem['current_rss_percent'], 1),
|
| 2008 |
'peak_rss_mb': mem['peak_rss_mb'],
|
|
@@ -2023,7 +2142,7 @@ async def debug_env():
|
|
| 2023 |
'preload_models': [n for n, _ in PRELOAD_MODELS],
|
| 2024 |
'torch_loaded': 'torch' in sys.modules,
|
| 2025 |
'onnx_threads': 1,
|
| 2026 |
-
'version': '32.9.
|
| 2027 |
'serialize_inference': SERIALIZE_INFERENCE,
|
| 2028 |
}
|
| 2029 |
|
|
@@ -2035,7 +2154,7 @@ async def home():
|
|
| 2035 |
warmed = sum(1 for w in stats['warmed'].values() if w)
|
| 2036 |
return HTMLResponse(f"""
|
| 2037 |
<!DOCTYPE html><html><head><meta charset="UTF-8">
|
| 2038 |
-
<title>Background Remover v32.9.
|
| 2039 |
<style>body{{font-family:system-ui;background:#0A0A0A;color:#fff;
|
| 2040 |
min-height:100vh;display:flex;align-items:center;justify-content:center;
|
| 2041 |
margin:0;padding:20px}}.c{{max-width:900px;background:#111;
|
|
@@ -2043,12 +2162,13 @@ async def home():
|
|
| 2043 |
.s{{padding:15px;border-radius:12px;margin:20px 0;background:#1a1a1a}}
|
| 2044 |
a{{color:#7ED957}}</style>
|
| 2045 |
</head><body><div class="c">
|
| 2046 |
-
<h1>Background Remover v32.9.
|
| 2047 |
<div class="s">AI online. {len(stats['loaded_models'])} models loaded ({warmed} warmed).<br>
|
| 2048 |
-
|
|
|
|
| 2049 |
Peak {mem['peak_rss_percent']:.0f}%</div>
|
| 2050 |
-
<p>Preload: u2netp · silueta ·
|
| 2051 |
-
<p>Lazy:
|
| 2052 |
<p><a href="/docs">API Docs</a> ·
|
| 2053 |
<a href="/api/models">Models</a> ·
|
| 2054 |
<a href="/api/debug/memory">Memory</a> ·
|
|
@@ -2070,6 +2190,10 @@ async def health_check():
|
|
| 2070 |
'silueta' in stats['loaded_models']
|
| 2071 |
and stats['warmed'].get('silueta', False)
|
| 2072 |
)
|
|
|
|
|
|
|
|
|
|
|
|
|
| 2073 |
video_safe = (
|
| 2074 |
silueta_ready
|
| 2075 |
and mem['current_rss_percent'] < (VIDEO_RAM_REJECT_PERCENT - VIDEO_SAFETY_MARGIN_PERCENT)
|
|
@@ -2099,12 +2223,15 @@ async def health_check():
|
|
| 2099 |
'all_preloaded_loaded': all_preloaded_loaded,
|
| 2100 |
'all_preloaded_warmed': all_preloaded_warmed,
|
| 2101 |
'silueta_ready': silueta_ready,
|
|
|
|
| 2102 |
'birefnet_loaded': 'birefnet-general-lite' in stats['loaded_models'],
|
| 2103 |
'preloaded_models': preload_names,
|
| 2104 |
'lazy_active_models': sorted(LAZY_ACTIVE_MODELS),
|
| 2105 |
'dormant_models': sorted(DORMANT_MODELS.keys()),
|
| 2106 |
'current_rss_percent': round(mem['current_rss_percent'], 1),
|
| 2107 |
'current_rss_mb': mem['current_rss_mb'],
|
|
|
|
|
|
|
| 2108 |
'peak_rss_percent': round(mem['peak_rss_percent'], 1),
|
| 2109 |
'peak_rss_mb': mem['peak_rss_mb'],
|
| 2110 |
'container_percent': round(mem['percent'], 1),
|
|
@@ -2114,7 +2241,7 @@ async def health_check():
|
|
| 2114 |
'video_force_model': VIDEO_FORCE_MODEL,
|
| 2115 |
'birefnet_res_cap': MODEL_RES_CAPS.get('birefnet-general-lite'),
|
| 2116 |
'birefnet_rss_gate': BIREFNET_RSS_GATE_PERCENT,
|
| 2117 |
-
'version': '32.9.
|
| 2118 |
'alpha_smoothing': _alpha_cache_stats(),
|
| 2119 |
'onnx_threads': 1,
|
| 2120 |
'torch_loaded': 'torch' in sys.modules,
|
|
@@ -2138,15 +2265,17 @@ async def gen_exc(request, exc):
|
|
| 2138 |
@app.on_event("startup")
|
| 2139 |
async def startup():
|
| 2140 |
logger.info("=" * 60)
|
| 2141 |
-
logger.info("v32.9.
|
| 2142 |
logger.info(f"Preload: {[n for n, _ in PRELOAD_MODELS]}")
|
| 2143 |
logger.info(f"Lazy active: {sorted(LAZY_ACTIVE_MODELS)}")
|
| 2144 |
logger.info(f"Dormant: {sorted(DORMANT_MODELS.keys())}")
|
| 2145 |
logger.info(f"SERIALIZE_INFERENCE: {SERIALIZE_INFERENCE}")
|
| 2146 |
-
logger.info("
|
| 2147 |
-
|
| 2148 |
-
|
| 2149 |
-
logger.info("
|
|
|
|
|
|
|
| 2150 |
logger.info("=" * 60)
|
| 2151 |
_log_rss("startup")
|
| 2152 |
|
|
|
|
| 1 |
#!/usr/bin/env python3
|
| 2 |
+
# app.py - Background Remover v32.9.4
|
| 3 |
#
|
| 4 |
+
# ===== CHANGES vs v32.9.2 =====
|
| 5 |
+
# 1. isnet-general-use is the WORKHORSE: preloaded, native 1024px, routes
|
| 6 |
+
# human / vehicle / product / medium / complex. birefnet-general-lite is
|
| 7 |
+
# LAZY and only used for genuinely very_hard inputs when RSS allows.
|
| 8 |
+
# 2. MODEL_RES_CAPS matched to each model's native resolution. v32.9.2
|
| 9 |
+
# capped isnet at 384px (native 1024) which discarded detail before
|
| 10 |
+
# rembg's internal 1024px resize.
|
| 11 |
+
# 3. Memory: pixel-count guard before decode, JPEG draft() reduced-scale
|
| 12 |
+
# decode, MALLOC_TRIM/MMAP_THRESHOLD env, explicit del of large buffers,
|
| 13 |
+
# accurate 'anon' cgroup reporting. Fixes 12.5GB RSS blow-up.
|
| 14 |
+
# 4. Router rewritten with clean lanes (see analyze_image_complexity).
|
| 15 |
+
# 5. Fallback chain never lazy-loads birefnet on the request path
|
| 16 |
+
# (would cost 20s and blow the 32s timeout).
|
| 17 |
+
# 6. /api/debug/reset endpoint to reclaim memory without a Space restart.
|
| 18 |
#
|
| 19 |
+
# ===== PRESERVED from v32.9.2 =====
|
| 20 |
+
# Output cap at max_size, vectorized detect_fragments, 32s image timeout,
|
| 21 |
+
# real /api/warmup, rate-limit total_seconds(), CR/LF header strip,
|
| 22 |
+
# use_alpha_matting honored, frames-batch honors model, RFC 5987 filenames,
|
| 23 |
+
# alpha cache, SERIALIZE_INFERENCE.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 24 |
|
| 25 |
# ============================================================
|
| 26 |
# FORCE IN-MEMORY UPLOAD PARSING
|
|
|
|
| 64 |
|
| 65 |
import psutil
|
| 66 |
|
| 67 |
+
# ============================================================
|
| 68 |
+
# GLIBC TUNING — return memory to OS instead of hoarding it.
|
| 69 |
+
# Must be set before any large allocation. malloc_trim() alone is not
|
| 70 |
+
# enough; the mmap threshold determines when large blocks bypass the heap.
|
| 71 |
+
# ============================================================
|
| 72 |
+
os.environ.setdefault('MALLOC_TRIM_THRESHOLD_', '131072') # 128 KB
|
| 73 |
+
os.environ.setdefault('MALLOC_MMAP_THRESHOLD_', '131072') # 128 KB
|
| 74 |
+
os.environ.setdefault('MALLOC_ARENA_MAX', '1') # one arena, less fragmentation
|
| 75 |
+
|
| 76 |
# ============================================================
|
| 77 |
# ONNX RUNTIME
|
| 78 |
# ============================================================
|
|
|
|
| 86 |
so = _ort.SessionOptions()
|
| 87 |
so.intra_op_num_threads = 1
|
| 88 |
so.inter_op_num_threads = 1
|
| 89 |
+
so.enable_cpu_mem_arena = False # arena pre-allocates and never releases
|
| 90 |
so.enable_mem_pattern = False
|
| 91 |
so.graph_optimization_level = _ort.GraphOptimizationLevel.ORT_ENABLE_ALL
|
| 92 |
kwargs['sess_options'] = so
|
|
|
|
| 117 |
)
|
| 118 |
logger = logging.getLogger(__name__)
|
| 119 |
|
| 120 |
+
# Reject absurd images before decode. 40 MP is generous (a 6K photo is 36 MP).
|
| 121 |
+
MAX_IMAGE_PIXELS = 40_000_000
|
| 122 |
+
Image.MAX_IMAGE_PIXELS = MAX_IMAGE_PIXELS * 2 # PIL only *warns* below 2x
|
| 123 |
+
|
| 124 |
|
| 125 |
# ============================================================
|
| 126 |
# HEADER SAFETY
|
|
|
|
| 159 |
# ============================================================
|
| 160 |
def trim_memory():
|
| 161 |
try:
|
| 162 |
+
ctypes.CDLL("libc.so.6").malloc_trim(0)
|
|
|
|
| 163 |
except Exception:
|
| 164 |
pass
|
| 165 |
|
| 166 |
|
| 167 |
def get_process_rss_mb() -> float:
|
| 168 |
+
"""Current RSS from /proc/self/status VmRSS (not peak)."""
|
| 169 |
try:
|
| 170 |
with open('/proc/self/status', 'r') as f:
|
| 171 |
for line in f:
|
|
|
|
| 190 |
try:
|
| 191 |
if os.path.exists('/sys/fs/cgroup/memory.max'):
|
| 192 |
with open('/sys/fs/cgroup/memory.max') as f:
|
| 193 |
+
s = f.read().strip()
|
| 194 |
+
if s != 'max':
|
| 195 |
+
return int(s) // 1024 // 1024
|
| 196 |
if os.path.exists('/sys/fs/cgroup/memory/memory.limit_in_bytes'):
|
| 197 |
with open('/sys/fs/cgroup/memory/memory.limit_in_bytes') as f:
|
| 198 |
+
n = int(f.read().strip())
|
| 199 |
+
if 0 < n < (1 << 60):
|
| 200 |
+
return n // 1024 // 1024
|
| 201 |
except Exception:
|
| 202 |
pass
|
| 203 |
try:
|
|
|
|
| 206 |
return 0
|
| 207 |
|
| 208 |
|
| 209 |
+
def _cgroup_anon_mb() -> int:
|
| 210 |
+
"""Actual anonymous (process) pages — excludes page cache.
|
| 211 |
+
|
| 212 |
+
This is the honest number. cgroup memory.current includes page cache,
|
| 213 |
+
which is why /api/health could show 82% while the process was fine.
|
| 214 |
+
"""
|
| 215 |
+
try:
|
| 216 |
+
with open('/sys/fs/cgroup/memory.stat', 'r') as f:
|
| 217 |
+
for line in f:
|
| 218 |
+
if line.startswith('anon '):
|
| 219 |
+
return int(line.split()[1]) // 1024 // 1024
|
| 220 |
+
except Exception:
|
| 221 |
+
pass
|
| 222 |
+
return 0
|
| 223 |
+
|
| 224 |
+
|
| 225 |
def get_container_memory() -> Dict:
|
| 226 |
limit_mb = get_container_limit_mb()
|
| 227 |
current_rss = get_process_rss_mb()
|
| 228 |
peak_rss = get_peak_rss_mb()
|
| 229 |
+
anon_mb = _cgroup_anon_mb()
|
| 230 |
|
| 231 |
cgroup_used = 0
|
| 232 |
source = 'unknown'
|
|
|
|
| 248 |
current_pct = (current_rss / limit_mb * 100) if limit_mb > 0 else 0
|
| 249 |
peak_pct = (peak_rss / limit_mb * 100) if limit_mb > 0 else 0
|
| 250 |
cgroup_pct = (cgroup_used / limit_mb * 100) if limit_mb > 0 else 0
|
| 251 |
+
anon_pct = (anon_mb / limit_mb * 100) if limit_mb > 0 else 0
|
| 252 |
|
| 253 |
return {
|
| 254 |
'total_mb': limit_mb,
|
| 255 |
'used_mb': cgroup_used,
|
| 256 |
'available_mb': max(0, limit_mb - cgroup_used),
|
| 257 |
+
'percent': cgroup_pct, # includes page cache — pessimistic
|
| 258 |
+
'anon_mb': anon_mb,
|
| 259 |
+
'anon_percent': anon_pct, # real process memory
|
| 260 |
'current_rss_mb': current_rss,
|
| 261 |
'current_rss_percent': current_pct,
|
| 262 |
'peak_rss_mb': peak_rss,
|
|
|
|
| 270 |
try:
|
| 271 |
m = get_container_memory()
|
| 272 |
logger.info(
|
| 273 |
+
f"[RSS] {label}: rss={m['current_rss_mb']}MB "
|
| 274 |
+
f"({m['current_rss_percent']:.1f}%) anon={m['anon_mb']}MB "
|
| 275 |
+
f"peak={m['peak_rss_mb']}MB"
|
| 276 |
)
|
| 277 |
except Exception:
|
| 278 |
pass
|
|
|
|
| 302 |
self.use_counts: Dict[str, int] = {}
|
| 303 |
self.last_use: Dict[str, float] = {}
|
| 304 |
self.max_models = max_models
|
| 305 |
+
# birefnet is NOT protected — it's lazy and evictable under pressure.
|
| 306 |
+
self.protected = {'silueta', 'u2netp', 'isnet-general-use'}
|
| 307 |
|
| 308 |
def get_model(self, name, loader_func):
|
| 309 |
if name in self.models:
|
|
|
|
| 314 |
if len(self.models) >= self.max_models:
|
| 315 |
self._evict_one()
|
| 316 |
|
| 317 |
+
before = get_process_rss_mb()
|
| 318 |
+
t0 = time.time()
|
| 319 |
try:
|
| 320 |
session = loader_func(name)
|
| 321 |
if session is None:
|
|
|
|
| 323 |
self.models[name] = session
|
| 324 |
self.warmed[name] = False
|
| 325 |
self.last_use[name] = time.time()
|
| 326 |
+
self.load_times[name] = time.time() - t0
|
| 327 |
self.use_counts[name] = 1
|
| 328 |
gc.collect()
|
| 329 |
trim_memory()
|
| 330 |
+
after = get_process_rss_mb()
|
| 331 |
+
logger.info(
|
| 332 |
+
f"[ModelManager] {name} loaded in {time.time()-t0:.1f}s, "
|
| 333 |
+
f"RSS {before:.0f}->{after:.0f}MB (+{after-before:.0f})"
|
| 334 |
+
)
|
| 335 |
return session
|
| 336 |
except Exception as e:
|
| 337 |
logger.warning(f"Loader failed for {name}: {e}")
|
|
|
|
| 339 |
return None
|
| 340 |
|
| 341 |
def _evict_one(self):
|
| 342 |
+
candidates = [k for k in self.models if k not in self.protected]
|
| 343 |
if not candidates:
|
| 344 |
+
candidates = [k for k in self.models if k != 'silueta']
|
| 345 |
if not candidates:
|
| 346 |
return
|
| 347 |
to_remove = min(candidates, key=lambda x: self.use_counts.get(x, 0))
|
|
|
|
| 358 |
return False
|
| 359 |
logger.info(f"Evicting {name} ({reason})")
|
| 360 |
del self.models[name]
|
| 361 |
+
for d in (self.use_counts, self.warmed, self.last_use):
|
| 362 |
+
d.pop(name, None)
|
|
|
|
| 363 |
gc.collect()
|
| 364 |
trim_memory()
|
| 365 |
_log_rss(f"after evicting {name}")
|
|
|
|
| 435 |
def refine(self, mask):
|
| 436 |
if mask.dtype != np.uint8:
|
| 437 |
mask = (mask * 255).astype(np.uint8)
|
| 438 |
+
mf = mask.astype(np.float32) / 255.0
|
| 439 |
+
hm = self._detect(mf)
|
| 440 |
+
cleaned = self._clean(mf, hm)
|
| 441 |
+
feathered = self._feather(cleaned, hm)
|
| 442 |
result = feathered.copy()
|
| 443 |
+
result[hm] = mf[hm]
|
| 444 |
return (np.clip(result, 0, 1) * 255).astype(np.uint8)
|
| 445 |
|
| 446 |
def _detect(self, mask):
|
| 447 |
from scipy.ndimage import convolve, binary_dilation
|
| 448 |
+
k = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], dtype=np.float32)
|
| 449 |
+
return binary_dilation(np.abs(convolve(mask, k)) > 0.06, iterations=1)
|
| 450 |
|
| 451 |
def _clean(self, mask, hair_mask):
|
| 452 |
from scipy.ndimage import label
|
| 453 |
result = mask.copy()
|
| 454 |
+
labeled, n = label(mask > 0.5)
|
| 455 |
sizes = np.bincount(labeled.flatten())
|
| 456 |
+
for i in range(1, n + 1):
|
| 457 |
if sizes[i] < 20:
|
| 458 |
c = labeled == i
|
| 459 |
if not np.any(c & hair_mask):
|
|
|
|
| 468 |
dilated = binary_dilation(mask > 0.5, iterations=1)
|
| 469 |
edge = (dilated ^ eroded) & non_hair
|
| 470 |
if np.any(edge):
|
| 471 |
+
result[edge] = gaussian_filter(mask, sigma=0.5)[edge]
|
|
|
|
| 472 |
return result
|
| 473 |
|
| 474 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 475 |
class ContentClassifier:
|
| 476 |
def classify(self, image):
|
| 477 |
if image.mode != 'RGB':
|
|
|
|
| 556 |
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
|
| 557 |
os.environ["PYTHONUNBUFFERED"] = "1"
|
| 558 |
socket.setdefaulttimeout(60)
|
| 559 |
+
os.makedirs("/tmp/u2net_models", exist_ok=True)
|
|
|
|
|
|
|
| 560 |
|
| 561 |
cpu_executor = ThreadPoolExecutor(max_workers=2)
|
| 562 |
|
|
|
|
| 565 |
model_manager = ModelManager(max_models=4)
|
| 566 |
mask_checker = MaskQualityChecker()
|
| 567 |
hair_refiner = HairRefiner()
|
|
|
|
| 568 |
|
| 569 |
|
| 570 |
# ============================================================
|
| 571 |
+
# SEMAPHORES + RSS GATE
|
| 572 |
# ============================================================
|
| 573 |
SERIALIZE_INFERENCE = os.environ.get('SERIALIZE_INFERENCE', '1') == '1'
|
| 574 |
_image_semaphore = threading.Semaphore(1)
|
| 575 |
_birefnet_semaphore = threading.Semaphore(1)
|
| 576 |
+
# 88% leaves headroom for one 768px birefnet inference (~60MB transient)
|
| 577 |
+
# plus the output buffer, without breaching the 90% video reject.
|
| 578 |
+
BIREFNET_RSS_GATE_PERCENT = 88.0
|
| 579 |
+
BIREFNET_INFERENCE_RSS_MB = 60
|
| 580 |
|
| 581 |
|
| 582 |
# ============================================================
|
|
|
|
| 603 |
prev = None
|
| 604 |
if entry is not None:
|
| 605 |
prev_alpha, ts = entry
|
| 606 |
+
if now - ts <= ALPHA_CACHE_TTL_SECONDS:
|
|
|
|
|
|
|
| 607 |
prev = prev_alpha
|
| 608 |
blended = False
|
| 609 |
if prev is not None and prev.shape == alpha.shape:
|
| 610 |
a = alpha.astype(np.float32)
|
| 611 |
p = prev.astype(np.float32)
|
| 612 |
+
smoothed = np.clip(
|
| 613 |
+
a * (1.0 - ALPHA_SMOOTH_WEIGHT) + p * ALPHA_SMOOTH_WEIGHT,
|
| 614 |
+
0, 255
|
| 615 |
+
).astype(np.uint8)
|
| 616 |
blended = True
|
| 617 |
else:
|
| 618 |
smoothed = alpha
|
|
|
|
| 646 |
def _purge_expired_sessions() -> int:
|
| 647 |
now = time.time()
|
| 648 |
with _alpha_cache_lock:
|
| 649 |
+
expired = [sid for sid, (_, ts) in _alpha_cache.items()
|
| 650 |
+
if now - ts > ALPHA_CACHE_TTL_SECONDS]
|
|
|
|
|
|
|
| 651 |
for sid in expired:
|
| 652 |
_alpha_cache.pop(sid, None)
|
| 653 |
return len(expired)
|
| 654 |
|
| 655 |
|
| 656 |
def _housekeeping():
|
|
|
|
|
|
|
| 657 |
while True:
|
| 658 |
time.sleep(ALPHA_PURGE_INTERVAL)
|
| 659 |
try:
|
| 660 |
purged = _purge_expired_sessions()
|
| 661 |
if purged:
|
| 662 |
logger.info(f"[alpha-cache] purged {purged}")
|
| 663 |
+
gc.collect()
|
| 664 |
+
trim_memory()
|
| 665 |
except Exception as e:
|
| 666 |
logger.warning(f"[housekeeping] {e}")
|
| 667 |
|
|
|
|
| 676 |
# VIDEO CONFIG
|
| 677 |
# ============================================================
|
| 678 |
_video_semaphore = threading.Semaphore(1)
|
| 679 |
+
VIDEO_RAM_REJECT_PERCENT = 92.0
|
| 680 |
VIDEO_SAFETY_MARGIN_PERCENT = 5.0
|
| 681 |
VIDEO_MAX_BATCH = 12
|
| 682 |
VIDEO_FORCE_MODEL = os.environ.get('VIDEO_FORCE_MODEL', 'silueta')
|
| 683 |
+
FRAME_MAX_DIM = 640
|
| 684 |
|
| 685 |
|
| 686 |
# ============================================================
|
| 687 |
+
# MODEL CONFIG — v32.9.4
|
| 688 |
# ============================================================
|
| 689 |
+
# isnet is the workhorse (preloaded, 1s, native 1024px, handles human/product/
|
| 690 |
+
# vehicle/medium/complex per rembg benchmarks). birefnet is a 6x-slower
|
| 691 |
+
# specialist, lazy, used only for genuinely very_hard input.
|
| 692 |
PRELOAD_MODELS = [
|
| 693 |
+
("u2netp", "trivial fast lane"),
|
| 694 |
+
("silueta", "video only"),
|
| 695 |
+
("isnet-general-use", "human / vehicle / product / medium / complex"),
|
| 696 |
]
|
| 697 |
|
| 698 |
+
LAZY_ACTIVE_MODELS = {
|
| 699 |
+
'birefnet-general-lite',
|
| 700 |
+
'isnet-anime',
|
| 701 |
+
'u2net_human_seg',
|
| 702 |
+
}
|
| 703 |
|
| 704 |
VALID_REMBG_MODELS = {
|
| 705 |
'silueta', 'u2netp', 'isnet-general-use', 'birefnet-general-lite',
|
| 706 |
+
'isnet-anime', 'u2net_human_seg',
|
| 707 |
}
|
| 708 |
|
| 709 |
DORMANT_MODELS = {
|
| 710 |
'u2net': "~176 MB disk / ~800 MB RAM",
|
|
|
|
|
|
|
| 711 |
'birefnet-general': "~900 MB disk / ~2.5 GB RAM",
|
| 712 |
'u2net_cloth_seg': "~176 MB disk / ~800 MB RAM",
|
| 713 |
'sam': "~375 MB disk / ~1 GB RAM",
|
| 714 |
}
|
| 715 |
|
| 716 |
WARMUP_RESOLUTIONS = {
|
| 717 |
+
'silueta': (320, 320),
|
| 718 |
+
'u2netp': (320, 320),
|
| 719 |
'isnet-general-use': (128, 128),
|
| 720 |
'birefnet-general-lite': (128, 128),
|
| 721 |
+
'isnet-anime': (128, 128),
|
| 722 |
+
'u2net_human_seg': (128, 128),
|
| 723 |
}
|
| 724 |
|
| 725 |
MODEL_ALIASES = {
|
| 726 |
'inspyrenet': 'isnet-general-use',
|
| 727 |
'inspired': 'isnet-general-use',
|
| 728 |
'isnet': 'isnet-general-use',
|
| 729 |
+
'rmbg2': 'isnet-general-use',
|
| 730 |
'u2net-human-seg': 'u2net_human_seg',
|
| 731 |
'u2net-humans': 'u2net_human_seg',
|
| 732 |
'birefnet-lite': 'birefnet-general-lite',
|
|
|
|
| 758 |
'sam': {'fg': 240, 'bg': 10, 'erode': 10},
|
| 759 |
}
|
| 760 |
|
| 761 |
+
# Native resolutions:
|
| 762 |
+
# u2netp 320, silueta 320, isnet 1024, u2net_human_seg 1024,
|
| 763 |
+
# isnet-anime 1024, birefnet 1024.
|
| 764 |
+
# Capping below native loses detail BEFORE rembg's internal resize, so match
|
| 765 |
+
# native where compute allows. birefnet at 768 balances its 6x CPU cost.
|
| 766 |
MODEL_RES_CAPS = {
|
| 767 |
+
'u2netp': 384, 'silueta': 384, 'u2net': 640,
|
| 768 |
+
'u2net_human_seg': 1024, 'birefnet-general-lite': 768,
|
| 769 |
+
'birefnet-general': 768, 'isnet-general-use': 1024,
|
| 770 |
+
'isnet-anime': 768, 'u2net_cloth_seg': 512, 'sam': 512,
|
| 771 |
}
|
| 772 |
|
| 773 |
+
VEHICLE_RES_CAP = MODEL_RES_CAPS['birefnet-general-lite']
|
|
|
|
| 774 |
|
| 775 |
CLASSICAL_PROCESSORS = {'flood_fill', 'graphic_classical'}
|
| 776 |
DEFAULT_MODEL_NAME = 'u2netp'
|
|
|
|
| 796 |
from rembg import new_session
|
| 797 |
resolved = MODEL_ALIASES.get(name, name)
|
| 798 |
if resolved not in VALID_REMBG_MODELS:
|
| 799 |
+
logger.warning(f"'{resolved}' dormant/invalid. Using isnet-general-use.")
|
| 800 |
+
resolved = 'isnet-general-use'
|
| 801 |
logger.info(f"Loading {resolved}...")
|
| 802 |
return new_session(resolved)
|
| 803 |
+
# ============================================================
|
|
|
|
|
|
|
| 804 |
# ALPHA HELPERS
|
| 805 |
# ============================================================
|
| 806 |
def _alpha_stats(image):
|
|
|
|
| 821 |
res = np.array(result.convert('RGBA'))
|
| 822 |
if orig.shape != res.shape:
|
| 823 |
return False, 'shape-differs'
|
| 824 |
+
ra = res[:, :, 3]
|
| 825 |
+
if int(ra.min()) > 250:
|
| 826 |
+
diff = np.abs(orig[:, :, :3].astype(np.int16) - res[:, :, :3].astype(np.int16)).mean()
|
| 827 |
+
if diff < 2:
|
| 828 |
+
return True, f'all-opaque-rgb-identical(diff={diff:.2f})'
|
| 829 |
+
return True, f'all-opaque(diff={diff:.2f})'
|
| 830 |
+
return False, f'has-alpha(min={int(ra.min())})'
|
|
|
|
|
|
|
| 831 |
except Exception as e:
|
| 832 |
return False, f'check-failed:{e}'
|
| 833 |
|
|
|
|
| 860 |
return (max(1, int(w * scale)), max(1, int(h * scale)))
|
| 861 |
|
| 862 |
|
| 863 |
+
def _safe_open_image(data: bytes, draft_target: int = 2048) -> Image.Image:
|
| 864 |
+
"""Open image with pixel-count guard and JPEG draft-decode.
|
| 865 |
+
|
| 866 |
+
Decodes JPEGs at reduced DCT scale so a 4000x6000 photo doesn't cost
|
| 867 |
+
72 MB of peak decode memory. Pixel guard rejects decompression bombs
|
| 868 |
+
before the decoder allocates.
|
| 869 |
+
"""
|
| 870 |
+
try:
|
| 871 |
+
img = Image.open(io.BytesIO(data))
|
| 872 |
+
except Exception as e:
|
| 873 |
+
raise HTTPException(400, f"Cannot decode image: {str(e)[:100]}")
|
| 874 |
+
|
| 875 |
+
w, h = img.size
|
| 876 |
+
if w * h > MAX_IMAGE_PIXELS:
|
| 877 |
+
raise HTTPException(
|
| 878 |
+
413,
|
| 879 |
+
f"Image too large: {w}x{h} = {w*h/1_000_000:.1f}MP "
|
| 880 |
+
f"(server max {MAX_IMAGE_PIXELS//1_000_000}MP)"
|
| 881 |
+
)
|
| 882 |
+
|
| 883 |
+
# JPEG: pick a smaller DCT scale so peak decode memory is bounded.
|
| 884 |
+
# draft() is a no-op for PNG/WebP/GIF (they don't have DCT levels).
|
| 885 |
+
if img.format == 'JPEG':
|
| 886 |
+
try:
|
| 887 |
+
img.draft('RGB', (draft_target, draft_target))
|
| 888 |
+
except Exception:
|
| 889 |
+
pass
|
| 890 |
+
|
| 891 |
+
if img.mode != 'RGBA':
|
| 892 |
+
img = img.convert('RGBA')
|
| 893 |
+
img.load()
|
| 894 |
+
return img
|
| 895 |
+
|
| 896 |
+
|
| 897 |
# ============================================================
|
| 898 |
# NEURAL PROCESSOR
|
| 899 |
# ============================================================
|
|
|
|
| 936 |
dt = time.time() - t0
|
| 937 |
|
| 938 |
if result is None:
|
| 939 |
+
diagnostics.append({'attempt': label, 'result': 'None',
|
| 940 |
+
'elapsed': round(dt, 3)})
|
| 941 |
continue
|
| 942 |
if result.mode != 'RGBA':
|
| 943 |
result = result.convert('RGBA')
|
|
|
|
| 1105 |
logger.warning("Cannot pre-warm: remove_func not available")
|
| 1106 |
return
|
| 1107 |
logger.info("Pre-warming preloaded models...")
|
|
|
|
| 1108 |
for name, _desc in PRELOAD_MODELS:
|
|
|
|
|
|
|
|
|
|
| 1109 |
session = model_manager.models.get(name)
|
| 1110 |
if session is None:
|
| 1111 |
continue
|
|
|
|
| 1116 |
|
| 1117 |
|
| 1118 |
logger.info("=" * 60)
|
| 1119 |
+
logger.info("Background Remover v32.9.4")
|
| 1120 |
logger.info(f"Preload: {[n for n, _ in PRELOAD_MODELS]}")
|
| 1121 |
logger.info(f"Lazy active: {sorted(LAZY_ACTIVE_MODELS)}")
|
| 1122 |
logger.info(f"Dormant: {sorted(DORMANT_MODELS.keys())}")
|
| 1123 |
+
logger.info(f"MODEL_RES_CAPS: {MODEL_RES_CAPS}")
|
| 1124 |
+
logger.info(f"BIREFNET_RSS_GATE_PERCENT: {BIREFNET_RSS_GATE_PERCENT}")
|
| 1125 |
logger.info(f"SERIALIZE_INFERENCE: {SERIALIZE_INFERENCE}")
|
| 1126 |
+
logger.info("Router: isnet is workhorse; birefnet only for very_hard when viable")
|
|
|
|
|
|
|
| 1127 |
logger.info("=" * 60)
|
| 1128 |
|
| 1129 |
preload_all_models()
|
|
|
|
| 1162 |
return None
|
| 1163 |
|
| 1164 |
|
| 1165 |
+
def _birefnet_viable() -> bool:
|
| 1166 |
+
"""Running birefnet would fit within RSS budget."""
|
| 1167 |
+
mem = get_container_memory()
|
| 1168 |
+
projected = mem['current_rss_percent'] + BIREFNET_INFERENCE_RSS_MB
|
| 1169 |
+
return projected <= BIREFNET_RSS_GATE_PERCENT
|
| 1170 |
+
|
| 1171 |
+
|
| 1172 |
# ============================================================
|
| 1173 |
+
# ROUTER — v32.9.4 (isnet workhorse, birefnet specialist)
|
| 1174 |
# ============================================================
|
| 1175 |
def _preferred_quality_model():
|
| 1176 |
loaded = model_manager.get_stats().get('loaded_models', [])
|
| 1177 |
+
for m in ('isnet-general-use', 'silueta', 'birefnet-general-lite', 'u2netp'):
|
| 1178 |
+
if m in loaded:
|
| 1179 |
+
return m
|
|
|
|
|
|
|
|
|
|
| 1180 |
return 'u2netp'
|
| 1181 |
|
| 1182 |
|
|
|
|
| 1221 |
em = np.sqrt(gx ** 2 + gy ** 2)
|
| 1222 |
edge = float(np.sum(em > 10) / 100)
|
| 1223 |
colors = len(np.unique(rgb.reshape(-1, 3), axis=0))
|
|
|
|
|
|
|
| 1224 |
is_graphic = colors < 15 and edge > 0.08
|
| 1225 |
|
| 1226 |
is_human = _skin_score(rgb) > 0.1
|
|
|
|
| 1229 |
cc_cat = cc.get('category', 'general_photo')
|
| 1230 |
cc_signals = cc.get('signals', {}) or {}
|
| 1231 |
cc_edge = float(cc_signals.get('edge_density', 0.0))
|
|
|
|
| 1232 |
cc_colorcx = float(cc_signals.get('color_complexity', 0.5))
|
| 1233 |
|
| 1234 |
complexity = (
|
|
|
|
| 1240 |
)
|
| 1241 |
|
| 1242 |
loaded = model_manager.get_stats().get('loaded_models', [])
|
| 1243 |
+
has_isnet = 'isnet-general-use' in loaded
|
| 1244 |
+
has_birefnet_viable = (
|
| 1245 |
+
'birefnet-general-lite' in loaded and _birefnet_viable()
|
| 1246 |
+
)
|
| 1247 |
has_silueta = 'silueta' in loaded
|
| 1248 |
+
has_anime = 'isnet-anime' in loaded
|
| 1249 |
+
has_u2net_human = 'u2net_human_seg' in loaded
|
| 1250 |
+
rss_pct = round(get_container_memory()['current_rss_percent'], 1)
|
| 1251 |
|
| 1252 |
tier_map = {
|
| 1253 |
'vehicle': 'VEHICLE', 'simple_graphic': 'GRAPHIC',
|
| 1254 |
'very_hard': 'VERY_HARD', 'human_hair': 'HUMAN_HAIR',
|
| 1255 |
'human': 'HUMAN', 'complex': 'COMPLEX',
|
| 1256 |
'medium': 'MEDIUM', 'simple': 'SIMPLE', 'error': 'ERROR',
|
| 1257 |
+
'anime': 'ANIME',
|
| 1258 |
}
|
| 1259 |
|
| 1260 |
def _route(proc, cat, strat, reason):
|
|
|
|
| 1266 |
'is_human': is_human, 'is_graphic': is_graphic,
|
| 1267 |
'hair_complexity': hc,
|
| 1268 |
'cc_category': cc_cat, 'cc_confidence': 0.7,
|
| 1269 |
+
'available': {
|
| 1270 |
+
'isnet': has_isnet,
|
| 1271 |
+
'birefnet_viable': has_birefnet_viable,
|
| 1272 |
+
'silueta': has_silueta,
|
| 1273 |
+
'anime': has_anime,
|
| 1274 |
+
},
|
| 1275 |
+
'rss_percent': rss_pct,
|
| 1276 |
}
|
| 1277 |
|
| 1278 |
+
# ── Priority 1: anime — purpose-built model ──
|
| 1279 |
+
if cc_cat == 'anime' and has_anime:
|
| 1280 |
+
return _route('isnet-anime', 'anime', 'neural',
|
| 1281 |
+
f'anime content (cx={cc_colorcx:.2f})')
|
| 1282 |
+
|
| 1283 |
+
# ── Priority 2: simple graphic — classical path ──
|
| 1284 |
+
if is_graphic:
|
| 1285 |
+
return _route('flood_fill', 'simple_graphic', 'classical',
|
| 1286 |
+
'simple graphic')
|
| 1287 |
+
|
| 1288 |
+
# ── Priority 3: human with complex hair + real complexity ──
|
| 1289 |
+
# birefnet's hair detail is genuinely better than isnet here.
|
| 1290 |
+
if (is_human
|
| 1291 |
+
and hc['route'] in ('wispy_hair', 'complex_hair')
|
| 1292 |
+
and complexity > 45):
|
| 1293 |
+
if has_birefnet_viable:
|
| 1294 |
+
return _route('birefnet-general-lite', 'human_hair', 'neural',
|
| 1295 |
+
f'human+{hc["route"]}+cx{complexity:.0f} → birefnet')
|
| 1296 |
+
if has_isnet:
|
| 1297 |
+
return _route('isnet-general-use', 'human_hair', 'neural',
|
| 1298 |
+
f'human+{hc["route"]}+cx{complexity:.0f} → isnet '
|
| 1299 |
+
f'(birefnet not viable at {rss_pct}% RSS)')
|
| 1300 |
+
return _route('silueta', 'human_hair', 'neural',
|
| 1301 |
+
f'human+{hc["route"]} → silueta (last resort)')
|
| 1302 |
+
|
| 1303 |
+
# ── Priority 4: very hard — birefnet only justified case ──
|
| 1304 |
is_very_hard = (
|
| 1305 |
max(image.size) > 2400
|
| 1306 |
or complexity > 78
|
| 1307 |
or (is_human and hc['route'] == 'wispy_hair' and complexity > 55)
|
| 1308 |
)
|
| 1309 |
+
if is_very_hard:
|
| 1310 |
+
if has_birefnet_viable:
|
| 1311 |
+
return _route('birefnet-general-lite', 'very_hard', 'neural',
|
| 1312 |
+
f'very hard+cx{complexity:.0f} → birefnet')
|
| 1313 |
+
if has_isnet:
|
| 1314 |
+
return _route('isnet-general-use', 'very_hard', 'neural',
|
| 1315 |
+
f'very hard+cx{complexity:.0f} → isnet '
|
| 1316 |
+
f'(birefnet not viable at {rss_pct}% RSS)')
|
| 1317 |
+
return _route('silueta', 'very_hard', 'neural',
|
| 1318 |
+
f'very hard → silueta (last resort)')
|
| 1319 |
+
|
| 1320 |
+
# ── Priority 5: human (any) — isnet's home turf ──
|
| 1321 |
if is_human:
|
| 1322 |
+
if has_isnet:
|
| 1323 |
+
return _route('isnet-general-use', 'human', 'neural',
|
| 1324 |
+
f'human+cx{complexity:.0f} → isnet')
|
| 1325 |
+
if has_u2net_human:
|
| 1326 |
+
return _route('u2net_human_seg', 'human', 'neural',
|
| 1327 |
+
'human → u2net_human_seg')
|
| 1328 |
+
return _route('silueta', 'human', 'neural', 'human → silueta')
|
| 1329 |
+
|
| 1330 |
+
# ── Priority 6: medium / complex non-human — isnet's daily driver ──
|
| 1331 |
if complexity > 25:
|
| 1332 |
+
cat = 'complex' if complexity > 55 else 'medium'
|
| 1333 |
+
if has_isnet:
|
| 1334 |
+
return _route('isnet-general-use', cat, 'neural',
|
| 1335 |
+
f'{cat}+cx{complexity:.0f} → isnet')
|
| 1336 |
+
if has_birefnet_viable:
|
| 1337 |
+
return _route('birefnet-general-lite', cat, 'neural',
|
| 1338 |
+
f'{cat} → birefnet (isnet unavailable)')
|
| 1339 |
+
return _route('silueta', cat, 'neural',
|
| 1340 |
+
f'{cat} → silueta (last resort)')
|
| 1341 |
+
|
| 1342 |
+
# ── Priority 7: trivial — u2netp fast lane ──
|
| 1343 |
+
return _route('u2netp', 'simple', 'neural',
|
| 1344 |
+
f'simple+cx{complexity:.0f} → u2netp')
|
| 1345 |
|
|
|
|
| 1346 |
except Exception as e:
|
| 1347 |
logger.warning(f"Router failed: {e}")
|
| 1348 |
m = _preferred_quality_model()
|
|
|
|
| 1358 |
|
| 1359 |
def get_default_model():
|
| 1360 |
loaded = model_manager.get_stats().get('loaded_models', [])
|
| 1361 |
+
for m in ('isnet-general-use', 'u2netp', 'silueta'):
|
| 1362 |
if m in loaded:
|
| 1363 |
return m
|
| 1364 |
return loaded[0] if loaded else 'u2netp'
|
| 1365 |
|
| 1366 |
|
| 1367 |
def detect_fragments(image):
|
|
|
|
| 1368 |
if image.mode != 'RGBA':
|
| 1369 |
return {'fragment_ratio': 0, 'quality_score': 100,
|
| 1370 |
'has_fragments': False, 'issues': []}
|
|
|
|
| 1405 |
logger.info(f"[REQ {req}] acquired")
|
| 1406 |
|
| 1407 |
try:
|
| 1408 |
+
# Guard against huge decode + JPEG draft at 2× target output.
|
| 1409 |
+
image = _safe_open_image(image_data, draft_target=max(1024, max_size * 2))
|
| 1410 |
original_size = image.size
|
| 1411 |
|
| 1412 |
+
# ── Alpha passthrough — cap at max_size ──
|
| 1413 |
if _has_meaningful_alpha(image) and model_name is None:
|
|
|
|
|
|
|
| 1414 |
target = _cap_output_size(image.size, max_size)
|
| 1415 |
if target != image.size:
|
| 1416 |
image = image.resize(target, Image.Resampling.LANCZOS)
|
|
|
|
| 1434 |
'needs_reprocess': False, 'router_enabled': False,
|
| 1435 |
'router_score': 0.0, 'router_reason': 'already transparent',
|
| 1436 |
'router_tier': 'ALPHA_PASSTHROUGH',
|
| 1437 |
+
'router_category': 'alpha_passthrough',
|
| 1438 |
+
'router_confidence': 1.0,
|
| 1439 |
'mask_confidence': 1.0, 'mask_issues': [], 'hair_route': '',
|
| 1440 |
'hair_refined': False, 'diagnostics': [],
|
| 1441 |
'dormant_rerouted': None, 'birefnet_swapped': None}
|
| 1442 |
|
| 1443 |
+
# ── Route ──
|
| 1444 |
if model_name:
|
| 1445 |
resolved = MODEL_ALIASES.get(model_name, model_name)
|
| 1446 |
selected = resolved
|
|
|
|
| 1455 |
selected = route_analysis['processor']
|
| 1456 |
cc_category = route_analysis.get('cc_category', 'general_photo')
|
| 1457 |
cc_confidence = route_analysis.get('cc_confidence', 0.7)
|
| 1458 |
+
target_res = min(
|
| 1459 |
+
resolution_manager.get_resolution(cc_category, image.size),
|
| 1460 |
+
MODEL_RES_CAPS.get(selected, max_size),
|
| 1461 |
+
)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1462 |
|
| 1463 |
+
# ── Birefnet RSS re-check (race: router said viable, but RSS grew) ──
|
| 1464 |
birefnet_swapped = None
|
| 1465 |
if selected == 'birefnet-general-lite':
|
| 1466 |
mem = get_container_memory()
|
| 1467 |
+
projected = mem['current_rss_percent'] + BIREFNET_INFERENCE_RSS_MB
|
| 1468 |
+
if projected > BIREFNET_RSS_GATE_PERCENT:
|
| 1469 |
+
fallback = ('isnet-general-use'
|
| 1470 |
+
if 'isnet-general-use' in model_manager.models
|
| 1471 |
+
else 'silueta')
|
| 1472 |
logger.warning(
|
| 1473 |
+
f"Birefnet would push RSS to {projected:.0f}% "
|
| 1474 |
+
f"(gate {BIREFNET_RSS_GATE_PERCENT}%) → {fallback}"
|
| 1475 |
)
|
| 1476 |
+
birefnet_swapped = fallback
|
| 1477 |
+
selected = fallback
|
| 1478 |
target_res = min(
|
| 1479 |
resolution_manager.get_resolution(cc_category, image.size),
|
| 1480 |
MODEL_RES_CAPS.get(selected, max_size),
|
|
|
|
| 1486 |
diagnostics = []
|
| 1487 |
result = None
|
| 1488 |
|
| 1489 |
+
# ── Classical path ──
|
| 1490 |
if selected in CLASSICAL_PROCESSORS:
|
| 1491 |
t0 = time.time()
|
| 1492 |
result = process_graphic_classical(image)
|
|
|
|
| 1496 |
'elapsed': round(time.time() - t0, 3),
|
| 1497 |
})
|
| 1498 |
|
| 1499 |
+
# ── Neural path with fallback chain ──
|
| 1500 |
+
# Never lazy-load birefnet on the request path (6s + 20s cold load
|
| 1501 |
+
# would breach the 32s timeout). Only try models already resident.
|
| 1502 |
if result is None:
|
|
|
|
| 1503 |
tried = set()
|
| 1504 |
+
for candidate in [selected, 'isnet-general-use', 'silueta',
|
| 1505 |
+
'birefnet-general-lite', 'u2netp']:
|
| 1506 |
if candidate in tried or candidate in CLASSICAL_PROCESSORS:
|
| 1507 |
continue
|
| 1508 |
tried.add(candidate)
|
| 1509 |
+
|
| 1510 |
+
# Skip birefnet if not loaded — cold-load cost is fatal here.
|
| 1511 |
+
if candidate == 'birefnet-general-lite' and \
|
| 1512 |
+
candidate not in model_manager.models:
|
| 1513 |
+
continue
|
| 1514 |
+
|
| 1515 |
cand_session = get_session_for_model(candidate)
|
| 1516 |
if cand_session is None:
|
| 1517 |
continue
|
|
|
|
| 1528 |
use_alpha_matting=use_alpha_matting,
|
| 1529 |
)
|
| 1530 |
|
| 1531 |
+
diagnostics.extend([{'model_tried': candidate, **d}
|
| 1532 |
+
for d in cand_diag])
|
| 1533 |
if cand_result is not None:
|
| 1534 |
result = cand_result
|
| 1535 |
selected = candidate
|
| 1536 |
break
|
| 1537 |
|
| 1538 |
if result is None:
|
| 1539 |
+
raise HTTPException(
|
| 1540 |
+
500,
|
| 1541 |
+
f"All models failed. First: {json.dumps(diagnostics[:2])[:400]}"
|
| 1542 |
+
)
|
| 1543 |
|
| 1544 |
+
# ── Hair refinement ──
|
| 1545 |
hair_refined = False
|
| 1546 |
mask_quality = {'confidence': 1.0, 'issues': [], 'passed': True}
|
| 1547 |
+
if (result.mode == 'RGBA'
|
| 1548 |
+
and preserve_hair
|
| 1549 |
+
and cc_category in ('human_hair', 'human')):
|
| 1550 |
try:
|
| 1551 |
alpha = np.array(result)[:, :, 3]
|
| 1552 |
q = mask_checker.check(alpha)
|
|
|
|
| 1561 |
except Exception:
|
| 1562 |
pass
|
| 1563 |
|
| 1564 |
+
# ── Fragment check ──
|
| 1565 |
if selected in ('u2netp', 'silueta'):
|
| 1566 |
frag = {'fragment_ratio': 0.0, 'quality_score': 100.0,
|
| 1567 |
'has_fragments': False, 'issues': []}
|
| 1568 |
else:
|
| 1569 |
frag = detect_fragments(result)
|
| 1570 |
|
| 1571 |
+
# ── Output cap ──
|
| 1572 |
target_output = _cap_output_size(original_size, max_size)
|
| 1573 |
if result.size != target_output:
|
| 1574 |
result = result.resize(target_output, Image.Resampling.LANCZOS)
|
|
|
|
| 1728 |
# ============================================================
|
| 1729 |
# FASTAPI
|
| 1730 |
# ============================================================
|
| 1731 |
+
app = FastAPI(title="Background Remover", version="32.9.4")
|
| 1732 |
app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
|
| 1733 |
allow_methods=["*"], allow_headers=["*"])
|
| 1734 |
|
|
|
|
| 1749 |
if request.url.path in (
|
| 1750 |
"/api/health", "/", "/docs", "/redoc", "/openapi.json",
|
| 1751 |
"/api/warmup", "/api/debug/env", "/api/debug/memory", "/api/debug/tmp",
|
| 1752 |
+
"/api/debug/route", "/api/debug/reset", "/api/models",
|
| 1753 |
"/api/process/frames-batch",
|
| 1754 |
"/api/frames/session/reset",
|
| 1755 |
"/api/frames/session/stats",
|
|
|
|
| 1757 |
return await call_next(request)
|
| 1758 |
cid = _get_client_ip(request)
|
| 1759 |
now = datetime.now()
|
| 1760 |
+
rate_limits[cid] = [t for t in rate_limits[cid]
|
| 1761 |
+
if (now - t).total_seconds() < 60]
|
|
|
|
|
|
|
| 1762 |
if len(rate_limits[cid]) >= RATE_LIMIT:
|
| 1763 |
+
return JSONResponse(status_code=429,
|
| 1764 |
+
content={'error': f'Rate limit {RATE_LIMIT}/min'})
|
| 1765 |
rate_limits[cid].append(now)
|
| 1766 |
return await call_next(request)
|
| 1767 |
|
|
|
|
| 1809 |
elif resolved in DORMANT_MODELS:
|
| 1810 |
dormant_requested = resolved
|
| 1811 |
user_model = None
|
|
|
|
|
|
|
| 1812 |
|
| 1813 |
loop = asyncio.get_event_loop()
|
| 1814 |
pf = functools.partial(process_image_sync, image_data=contents,
|
|
|
|
| 1837 |
),
|
| 1838 |
}
|
| 1839 |
if dormant_requested:
|
| 1840 |
+
headers['X-Dormant-Rerouted'] = (
|
| 1841 |
+
f"{_header_safe(dormant_requested)}->"
|
| 1842 |
+
f"{_header_safe(result_data['model_id'])}"
|
| 1843 |
+
)
|
| 1844 |
if result_data.get('birefnet_swapped'):
|
| 1845 |
+
headers['X-Birefnet-Swapped'] = (
|
| 1846 |
+
f"birefnet-lite->{_header_safe(result_data['model_id'])}"
|
| 1847 |
+
)
|
| 1848 |
return StreamingResponse(io.BytesIO(result_data['data']),
|
| 1849 |
media_type=result_data['media_type'],
|
| 1850 |
headers=headers)
|
|
|
|
| 1950 |
}
|
| 1951 |
|
| 1952 |
|
| 1953 |
+
@app.post("/api/debug/reset")
|
| 1954 |
+
async def debug_reset(evict_optional: bool = Query(False)):
|
| 1955 |
+
"""Force GC + trim. Optional: evict non-protected models too.
|
| 1956 |
+
|
| 1957 |
+
Use this when RSS has crept up and you don't want to restart the
|
| 1958 |
+
Space. Everything in `model_manager.protected` stays loaded.
|
| 1959 |
+
"""
|
| 1960 |
+
before = get_container_memory()
|
| 1961 |
+
evicted = []
|
| 1962 |
+
if evict_optional:
|
| 1963 |
+
for name in list(model_manager.models.keys()):
|
| 1964 |
+
if name not in model_manager.protected:
|
| 1965 |
+
if model_manager.evict_model(name, 'manual reset'):
|
| 1966 |
+
evicted.append(name)
|
| 1967 |
+
for _ in range(2):
|
| 1968 |
+
gc.collect()
|
| 1969 |
+
trim_memory()
|
| 1970 |
+
after = get_container_memory()
|
| 1971 |
+
return {
|
| 1972 |
+
'ok': True,
|
| 1973 |
+
'rss_before_mb': before['current_rss_mb'],
|
| 1974 |
+
'rss_after_mb': after['current_rss_mb'],
|
| 1975 |
+
'freed_mb': round(before['current_rss_mb'] - after['current_rss_mb'], 1),
|
| 1976 |
+
'anon_before_mb': before['anon_mb'],
|
| 1977 |
+
'anon_after_mb': after['anon_mb'],
|
| 1978 |
+
'evicted': evicted,
|
| 1979 |
+
'loaded_models': list(model_manager.models.keys()),
|
| 1980 |
+
}
|
| 1981 |
+
|
| 1982 |
+
|
| 1983 |
@app.get("/api/models")
|
| 1984 |
async def list_models_endpoint():
|
| 1985 |
stats = model_manager.get_stats()
|
|
|
|
| 2015 |
'memory': {
|
| 2016 |
'current_rss_mb': mem['current_rss_mb'],
|
| 2017 |
'current_rss_percent': round(mem['current_rss_percent'], 1),
|
| 2018 |
+
'anon_mb': mem['anon_mb'],
|
| 2019 |
+
'anon_percent': round(mem['anon_percent'], 1),
|
| 2020 |
'peak_rss_mb': mem['peak_rss_mb'],
|
| 2021 |
},
|
| 2022 |
}
|
|
|
|
| 2030 |
'container': mem,
|
| 2031 |
'current_rss_mb': mem['current_rss_mb'],
|
| 2032 |
'current_rss_percent': round(mem['current_rss_percent'], 1),
|
| 2033 |
+
'anon_mb': mem['anon_mb'],
|
| 2034 |
+
'anon_percent': round(mem['anon_percent'], 1),
|
| 2035 |
'peak_rss_mb': mem['peak_rss_mb'],
|
| 2036 |
'peak_rss_percent': round(mem['peak_rss_percent'], 1),
|
| 2037 |
'rss_gap_mb': mem['rss_gap_mb'],
|
| 2038 |
+
'note': 'anon is real process memory. current_rss includes any heap '
|
| 2039 |
+
'fragmentation glibc has not returned. If rss >> anon, run '
|
| 2040 |
+
'POST /api/debug/reset to trim.',
|
| 2041 |
'models_loaded': stats['loaded_models'],
|
| 2042 |
'models_warmed': stats['warmed'],
|
| 2043 |
'last_use_seconds_ago': stats['last_use_seconds_ago'],
|
|
|
|
| 2046 |
'dormant_models': sorted(DORMANT_MODELS.keys()),
|
| 2047 |
'alpha_cache': _alpha_cache_stats(),
|
| 2048 |
'serialize_inference': SERIALIZE_INFERENCE,
|
| 2049 |
+
'malloc_env': {
|
| 2050 |
+
'MALLOC_ARENA_MAX': os.environ.get('MALLOC_ARENA_MAX'),
|
| 2051 |
+
'MALLOC_TRIM_THRESHOLD_': os.environ.get('MALLOC_TRIM_THRESHOLD_'),
|
| 2052 |
+
'MALLOC_MMAP_THRESHOLD_': os.environ.get('MALLOC_MMAP_THRESHOLD_'),
|
| 2053 |
+
},
|
| 2054 |
}
|
| 2055 |
|
| 2056 |
|
|
|
|
| 2058 |
async def debug_route(file: UploadFile = File(...)):
|
| 2059 |
try:
|
| 2060 |
contents = await file.read()
|
| 2061 |
+
image = _safe_open_image(contents, draft_target=1024)
|
| 2062 |
if image.mode not in ('RGB', 'L'):
|
| 2063 |
image = image.convert('RGB')
|
| 2064 |
analysis = analyze_image_complexity(image)
|
|
|
|
| 2072 |
'complexity': analysis.get('score'),
|
| 2073 |
'is_graphic': analysis.get('is_graphic'),
|
| 2074 |
'is_human': analysis.get('is_human'),
|
| 2075 |
+
'available': analysis.get('available'),
|
| 2076 |
},
|
| 2077 |
'memory': {
|
| 2078 |
'current_rss_percent': round(mem['current_rss_percent'], 1),
|
| 2079 |
+
'anon_percent': round(mem['anon_percent'], 1),
|
| 2080 |
'birefnet_loaded': 'birefnet-general-lite' in model_manager.models,
|
| 2081 |
+
'birefnet_viable': _birefnet_viable(),
|
| 2082 |
},
|
| 2083 |
'image': {'size': list(image.size)},
|
| 2084 |
}
|
| 2085 |
+
except HTTPException:
|
| 2086 |
+
raise
|
| 2087 |
except Exception as e:
|
| 2088 |
raise HTTPException(500, str(e)[:200])
|
| 2089 |
|
|
|
|
| 2120 |
'used_mb': mem['used_mb'],
|
| 2121 |
'available_mb': mem['available_mb'],
|
| 2122 |
'container_percent': round(mem['percent'], 1),
|
| 2123 |
+
'anon_mb': mem['anon_mb'],
|
| 2124 |
+
'anon_percent': round(mem['anon_percent'], 1),
|
| 2125 |
'current_rss_mb': mem['current_rss_mb'],
|
| 2126 |
'current_rss_percent': round(mem['current_rss_percent'], 1),
|
| 2127 |
'peak_rss_mb': mem['peak_rss_mb'],
|
|
|
|
| 2142 |
'preload_models': [n for n, _ in PRELOAD_MODELS],
|
| 2143 |
'torch_loaded': 'torch' in sys.modules,
|
| 2144 |
'onnx_threads': 1,
|
| 2145 |
+
'version': '32.9.4',
|
| 2146 |
'serialize_inference': SERIALIZE_INFERENCE,
|
| 2147 |
}
|
| 2148 |
|
|
|
|
| 2154 |
warmed = sum(1 for w in stats['warmed'].values() if w)
|
| 2155 |
return HTMLResponse(f"""
|
| 2156 |
<!DOCTYPE html><html><head><meta charset="UTF-8">
|
| 2157 |
+
<title>Background Remover v32.9.4</title>
|
| 2158 |
<style>body{{font-family:system-ui;background:#0A0A0A;color:#fff;
|
| 2159 |
min-height:100vh;display:flex;align-items:center;justify-content:center;
|
| 2160 |
margin:0;padding:20px}}.c{{max-width:900px;background:#111;
|
|
|
|
| 2162 |
.s{{padding:15px;border-radius:12px;margin:20px 0;background:#1a1a1a}}
|
| 2163 |
a{{color:#7ED957}}</style>
|
| 2164 |
</head><body><div class="c">
|
| 2165 |
+
<h1>Background Remover v32.9.4</h1>
|
| 2166 |
<div class="s">AI online. {len(stats['loaded_models'])} models loaded ({warmed} warmed).<br>
|
| 2167 |
+
RSS {mem['current_rss_percent']:.1f}% ({mem['current_rss_mb']}MB) ·
|
| 2168 |
+
anon {mem['anon_percent']:.1f}% ({mem['anon_mb']}MB) ·
|
| 2169 |
Peak {mem['peak_rss_percent']:.0f}%</div>
|
| 2170 |
+
<p>Preload: u2netp · silueta · isnet (workhorse)</p>
|
| 2171 |
+
<p>Lazy: birefnet-lite · isnet-anime · u2net-human-seg</p>
|
| 2172 |
<p><a href="/docs">API Docs</a> ·
|
| 2173 |
<a href="/api/models">Models</a> ·
|
| 2174 |
<a href="/api/debug/memory">Memory</a> ·
|
|
|
|
| 2190 |
'silueta' in stats['loaded_models']
|
| 2191 |
and stats['warmed'].get('silueta', False)
|
| 2192 |
)
|
| 2193 |
+
isnet_ready = (
|
| 2194 |
+
'isnet-general-use' in stats['loaded_models']
|
| 2195 |
+
and stats['warmed'].get('isnet-general-use', False)
|
| 2196 |
+
)
|
| 2197 |
video_safe = (
|
| 2198 |
silueta_ready
|
| 2199 |
and mem['current_rss_percent'] < (VIDEO_RAM_REJECT_PERCENT - VIDEO_SAFETY_MARGIN_PERCENT)
|
|
|
|
| 2223 |
'all_preloaded_loaded': all_preloaded_loaded,
|
| 2224 |
'all_preloaded_warmed': all_preloaded_warmed,
|
| 2225 |
'silueta_ready': silueta_ready,
|
| 2226 |
+
'isnet_ready': isnet_ready,
|
| 2227 |
'birefnet_loaded': 'birefnet-general-lite' in stats['loaded_models'],
|
| 2228 |
'preloaded_models': preload_names,
|
| 2229 |
'lazy_active_models': sorted(LAZY_ACTIVE_MODELS),
|
| 2230 |
'dormant_models': sorted(DORMANT_MODELS.keys()),
|
| 2231 |
'current_rss_percent': round(mem['current_rss_percent'], 1),
|
| 2232 |
'current_rss_mb': mem['current_rss_mb'],
|
| 2233 |
+
'anon_mb': mem['anon_mb'],
|
| 2234 |
+
'anon_percent': round(mem['anon_percent'], 1),
|
| 2235 |
'peak_rss_percent': round(mem['peak_rss_percent'], 1),
|
| 2236 |
'peak_rss_mb': mem['peak_rss_mb'],
|
| 2237 |
'container_percent': round(mem['percent'], 1),
|
|
|
|
| 2241 |
'video_force_model': VIDEO_FORCE_MODEL,
|
| 2242 |
'birefnet_res_cap': MODEL_RES_CAPS.get('birefnet-general-lite'),
|
| 2243 |
'birefnet_rss_gate': BIREFNET_RSS_GATE_PERCENT,
|
| 2244 |
+
'version': '32.9.4',
|
| 2245 |
'alpha_smoothing': _alpha_cache_stats(),
|
| 2246 |
'onnx_threads': 1,
|
| 2247 |
'torch_loaded': 'torch' in sys.modules,
|
|
|
|
| 2265 |
@app.on_event("startup")
|
| 2266 |
async def startup():
|
| 2267 |
logger.info("=" * 60)
|
| 2268 |
+
logger.info("v32.9.4 ready")
|
| 2269 |
logger.info(f"Preload: {[n for n, _ in PRELOAD_MODELS]}")
|
| 2270 |
logger.info(f"Lazy active: {sorted(LAZY_ACTIVE_MODELS)}")
|
| 2271 |
logger.info(f"Dormant: {sorted(DORMANT_MODELS.keys())}")
|
| 2272 |
logger.info(f"SERIALIZE_INFERENCE: {SERIALIZE_INFERENCE}")
|
| 2273 |
+
logger.info(f"MALLOC env: ARENA_MAX={os.environ.get('MALLOC_ARENA_MAX')}, "
|
| 2274 |
+
f"TRIM={os.environ.get('MALLOC_TRIM_THRESHOLD_')}, "
|
| 2275 |
+
f"MMAP={os.environ.get('MALLOC_MMAP_THRESHOLD_')}")
|
| 2276 |
+
logger.info("Router: isnet workhorse; birefnet only for very_hard + viable")
|
| 2277 |
+
logger.info("Output cap: result <= max_size")
|
| 2278 |
+
logger.info("Image timeout: 32s")
|
| 2279 |
logger.info("=" * 60)
|
| 2280 |
_log_rss("startup")
|
| 2281 |
|