andevs commited on
Commit
e1e389d
·
verified ·
1 Parent(s): c9e2a5f

Update app.py

Browse files
Files changed (1) hide show
  1. app.py +401 -272
app.py CHANGED
@@ -1,26 +1,26 @@
1
  #!/usr/bin/env python3
2
- # app.py - Background Remover v32.9.2
3
  #
4
- # Router: v32.2.6 verbatim. Vehicle check runs BEFORE graphic check.
5
- # is_graphic uses raw colors < 15 AND edge > 0.08 (as in v32.2.6).
6
- # birefnet-general-lite is preloaded → has_birefnet always True → vehicle
7
- # and very_hard images route to birefnet.
8
- # Fallback: selected → birefnet → silueta → isnet → u2netp (v32.2.6 order).
 
 
 
 
 
 
 
 
 
9
  #
10
- # All v32.9.1 fixes preserved:
11
- # • process_image_sync caps output at max_size (no LANCZOS upscale to
12
- # original). Fixes 504 on full-res photos. Also applies to alpha passthrough.
13
- # • detect_fragments vectorized with NumPy.
14
- # • /api/process/image timeout 32s (proxy budget 20s+32s).
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
- libc = ctypes.CDLL("libc.so.6")
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
- limit_str = f.read().strip()
181
- if limit_str != 'max':
182
- return int(limit_str) // 1024 // 1024
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
- limit = int(f.read().strip())
186
- if 0 < limit < (1 << 60):
187
- return limit // 1024 // 1024
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}: current={m['current_rss_mb']}MB "
241
- f"({m['current_rss_percent']:.1f}%) peak={m['peak_rss_mb']}MB"
 
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
- self.protected = {'silueta', 'u2netp', 'isnet-general-use', 'birefnet-general-lite'}
 
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
- start = time.time()
 
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() - start
291
  self.use_counts[name] = 1
292
  gc.collect()
293
  trim_memory()
294
- _log_rss(f"after loading {name}")
 
 
 
 
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.keys() if k not in self.protected]
303
  if not candidates:
304
- candidates = [k for k in self.models.keys() if k != 'silueta']
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.pop(name, None)
322
- self.warmed.pop(name, None)
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
- mask_float = mask.astype(np.float32) / 255.0
400
- hair_mask = self._detect(mask_float)
401
- cleaned = self._clean(mask_float, hair_mask)
402
- feathered = self._feather(cleaned, hair_mask)
403
  result = feathered.copy()
404
- result[hair_mask] = mask_float[hair_mask]
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
- kernel = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], dtype=np.float32)
410
- return binary_dilation(np.abs(convolve(mask, kernel)) > 0.06, iterations=1)
411
 
412
  def _clean(self, mask, hair_mask):
413
  from scipy.ndimage import label
414
  result = mask.copy()
415
- labeled, num_features = label(mask > 0.5)
416
  sizes = np.bincount(labeled.flatten())
417
- for i in range(1, num_features + 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
- blurred = gaussian_filter(mask, sigma=0.5)
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
- BIREFNET_RSS_GATE_PERCENT = 75.0
 
 
 
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 > ALPHA_CACHE_TTL_SECONDS:
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
- out = a * (1.0 - ALPHA_SMOOTH_WEIGHT) + p * ALPHA_SMOOTH_WEIGHT
632
- smoothed = np.clip(out, 0, 255).astype(np.uint8)
 
 
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
- sid for sid, (_, ts) in _alpha_cache.items()
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 = 90.0
699
  VIDEO_SAFETY_MARGIN_PERCENT = 5.0
700
  VIDEO_MAX_BATCH = 12
701
  VIDEO_FORCE_MODEL = os.environ.get('VIDEO_FORCE_MODEL', 'silueta')
702
- BIREFNET_MAX_DIM = 512
703
 
704
 
705
  # ============================================================
706
- # MODEL CONFIG — v32.2.6 preload layout
707
  # ============================================================
 
 
 
708
  PRELOAD_MODELS = [
709
- ("u2netp", "easy/flat"),
710
- ("silueta", "video only"),
711
- ("birefnet-general-lite", "vehicles / very hard"),
712
  ]
713
 
714
- LAZY_ACTIVE_MODELS = {'isnet-general-use'}
 
 
 
 
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': (384, 384),
731
- 'u2netp': (384, 384),
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
- # birefnet 512 (matches v32.2.6 VEHICLE_RES_CAP).
772
- # isnet 384 (v32.9.1 fix — 576 → 384).
 
 
 
773
  MODEL_RES_CAPS = {
774
- 'u2netp': 512, 'silueta': 640, 'u2net': 640,
775
- 'u2net_human_seg': 640, 'birefnet-general-lite': 512,
776
- 'birefnet-general': 640, 'isnet-general-use': 384,
777
- 'isnet-anime': 640, 'u2net_cloth_seg': 512, 'sam': 512,
778
  }
779
 
780
- VEHICLE_RES_CAP = BIREFNET_MAX_DIM
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 u2netp.")
808
- resolved = 'u2netp'
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
- res_alpha = res[:, :, 3]
835
- if int(res_alpha.min()) > 250:
836
- rgb_diff = np.abs(
837
- orig[:, :, :3].astype(np.int16) - res[:, :, :3].astype(np.int16)
838
- ).mean()
839
- if rgb_diff < 2:
840
- return True, f'all-opaque-rgb-identical(diff={rgb_diff:.2f})'
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', 'elapsed': round(dt, 3)})
 
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.2")
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"isnet matting res: {MODEL_RES_CAPS['isnet-general-use']}")
1105
- logger.info(f"birefnet res cap: {MODEL_RES_CAPS['birefnet-general-lite']}")
1106
  logger.info(f"SERIALIZE_INFERENCE: {SERIALIZE_INFERENCE}")
1107
- logger.info("Router: vehicle → graphic → very_hard → human (v32.2.6 order)")
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.2.6 logic
1150
  # ============================================================
1151
  def _preferred_quality_model():
1152
  loaded = model_manager.get_stats().get('loaded_models', [])
1153
- if 'isnet-general-use' in loaded:
1154
- return 'isnet-general-use'
1155
- if 'silueta' in loaded:
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
- # birefnet is preloaded → this is always True
1226
- has_birefnet = 'birefnet-general-lite' in loaded
 
 
1227
  has_silueta = 'silueta' in loaded
1228
- quality = _preferred_quality_model()
 
 
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
- # [v32.9.2] Vehicle FIRST (v32.2.6 order)
1249
- is_vehicle_like = (
1250
- not is_human
1251
- and cc_cat in ('general_photo', 'product_white_bg', 'complex')
1252
- and cc_edge > 0.04
1253
- )
1254
- if is_vehicle_like:
1255
- if has_birefnet:
1256
- return _route(
1257
- 'birefnet-general-lite', 'vehicle', 'neural',
1258
- f"vehicle/object (cc={cc_cat}, edge={cc_edge:.2f}, "
1259
- f"border={cc_border:.2f}, cx={cc_colorcx:.2f})"
1260
- )
1261
- if has_silueta:
1262
- return _route('silueta', 'vehicle', 'neural',
1263
- 'vehicle (silueta fallback)')
1264
-
1265
- # Then graphic
1266
- if is_graphic and not is_vehicle_like:
1267
- return _route('flood_fill', 'simple_graphic', 'classical', 'simple graphic')
1268
-
1269
- # Then very hard
 
 
 
 
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 and has_birefnet:
1276
- return _route('birefnet-general-lite', 'very_hard', 'neural', 'very hard')
1277
-
1278
- if is_human and hc['route'] in ('wispy_hair', 'complex_hair'):
1279
- return _route(quality, 'human_hair', 'neural', f'human+{hc["route"]}')
1280
-
 
 
 
 
 
 
1281
  if is_human:
1282
- return _route(quality, 'human', 'neural', 'human')
1283
-
1284
- if complexity > 55:
1285
- return _route(quality, 'complex', 'neural', 'complex')
1286
-
 
 
 
 
1287
  if complexity > 25:
1288
- return _route(quality, 'medium', 'neural', 'medium')
 
 
 
 
 
 
 
 
 
 
 
 
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 ('u2netp', 'isnet-general-use', 'silueta'):
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
- image = Image.open(io.BytesIO(image_data))
 
1355
  original_size = image.size
1356
 
1357
- # Alpha passthrough — cap output at max_size
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', 'router_confidence': 1.0,
 
1385
  'mask_confidence': 1.0, 'mask_issues': [], 'hair_route': '',
1386
  'hair_refined': False, 'diagnostics': [],
1387
  'dormant_rerouted': None, 'birefnet_swapped': None}
1388
 
1389
- # Routing
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
- router_cat = route_analysis.get('category', '')
1405
-
1406
- if selected == 'birefnet-general-lite' and router_cat in ('vehicle', 'very_hard'):
1407
- target_res = min(max_size, VEHICLE_RES_CAP)
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 gate (edge case: birefnet resident but RAM tight)
1415
  birefnet_swapped = None
1416
  if selected == 'birefnet-general-lite':
1417
  mem = get_container_memory()
1418
- projected = mem['current_rss_percent'] + 25
1419
- if projected > 88:
 
 
 
1420
  logger.warning(
1421
- f"Birefnet would push RSS to {projected:.0f}% — falling back to silueta"
 
1422
  )
1423
- birefnet_swapped = 'silueta'
1424
- selected = 'silueta'
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, 'birefnet-general-lite', 'silueta', 'isnet-general-use', 'u2netp']:
 
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} for d in cand_diag])
 
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(500, f"All models failed. First: {json.dumps(diagnostics[:2])[:400]}")
 
 
 
1476
 
 
1477
  hair_refined = False
1478
  mask_quality = {'confidence': 1.0, 'issues': [], 'passed': True}
1479
- if result.mode == 'RGBA' and preserve_hair and cc_category in ('human_hair', 'human'):
 
 
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
- # [v32.9.2] Fragment skip: u2netp, silueta only (matches v32.2.6)
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
- # Cap output at max_size — DO NOT upscale to original
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.2")
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
- t for t in rate_limits[cid]
1692
- if (now - t).total_seconds() < 60
1693
- ]
1694
  if len(rate_limits[cid]) >= RATE_LIMIT:
1695
- return JSONResponse(status_code=429, content={'error': f'Rate limit {RATE_LIMIT}/min'})
 
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'] = f"{_header_safe(dormant_requested)}->{_header_safe(result_data['model_id'])}"
 
 
 
1774
  if result_data.get('birefnet_swapped'):
1775
- headers['X-Birefnet-Swapped'] = f"birefnet-lite->{_header_safe(result_data['model_id'])}"
 
 
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': 'current_rss is live. peak_rss is historical. cgroup includes page cache.',
 
 
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 = Image.open(io.BytesIO(contents))
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': mem['current_rss_percent'] + 25 <= 88,
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.2',
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.2</title>
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.2</h1>
2047
  <div class="s">AI online. {len(stats['loaded_models'])} models loaded ({warmed} warmed).<br>
2048
- Current RSS {mem['current_rss_percent']:.0f}% ({mem['current_rss_mb']}MB) ·
 
2049
  Peak {mem['peak_rss_percent']:.0f}%</div>
2050
- <p>Preload: u2netp · silueta · birefnet-lite</p>
2051
- <p>Lazy: isnet · Serialize: {'ON' if SERIALIZE_INFERENCE else 'OFF'}</p>
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.2',
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.2 ready")
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("Router: vehicle → graphic → very_hard → human")
2147
- logger.info("Output cap: result ≤ max_size (never upscaled to original)")
2148
- logger.info("Image timeout: 32s (aligned to proxy 20s+32s)")
2149
- logger.info("Header safety: RFC 5987 Content-Disposition (UTF-8 filenames)")
 
 
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