"""Run with the pinned Python environment. Writes only new artifacts to --out. Model binaries live separately in --model-dir, never in the evidence directories. """ import argparse import datetime import hashlib import importlib.metadata import inspect import io import json import os from pathlib import Path import platform import subprocess import sys import time parser = argparse.ArgumentParser() parser.add_argument('--out', required=True) parser.add_argument('--model-dir', required=True) parser.add_argument('--downloads-json') parser.add_argument('--prefix', default='rembg-backgroundremover-u2netp-2026-10-28-req065-a1') args = parser.parse_args() out = Path(args.out).resolve() out.mkdir(parents=True, exist_ok=False) models = Path(args.model_dir).resolve() models.mkdir(parents=True, exist_ok=True) prefix = args.prefix for key in ('OMP_NUM_THREADS', 'OPENBLAS_NUM_THREADS', 'MKL_NUM_THREADS', 'NUMEXPR_NUM_THREADS', 'VECLIB_MAXIMUM_THREADS'): os.environ[key] = '1' os.environ['XDG_CACHE_HOME'] = str(models / 'cache') os.environ['MPLCONFIGDIR'] = str(models / 'mpl') os.environ['U2NET_HOME'] = str(models) os.environ['U2NETP_PATH'] = str(models / 'u2netp.pth') def digest(data): return hashlib.sha256(data).hexdigest() def write(name, data): path = out / f'{prefix}-{name}' with path.open('xb') as handle: handle.write(data) return {'file': path.name, 'bytes': len(data), 'sha256': digest(data)} def timed(function): start = time.perf_counter_ns() result = function() ns = time.perf_counter_ns() - start return result, {'wall_ns': ns, 'seconds': ns / 1_000_000_000} specs = [ ('rembg', 'https://github.com/danielgatis/rembg/releases/download/v0.0.0/u2netp.onnx', 'u2netp.onnx', '309c8469258dda742793dce0ebea8e6dd393174f89934733ecc8b14c76f4ddd8'), ('backgroundremover', 'https://github.com/nadermx/backgroundremover/raw/main/models/u2netp.pth', 'u2netp.pth', 'e7567cde013fb64813973ce6e1ecc25a80c05c3ca7adbc5a54f3c3d90991b854'), ] if args.downloads_json: downloads = json.loads(Path(args.downloads_json).read_text()) else: downloads = [] for tool, url, name, sha in specs: path = models / name if path.exists(): raise FileExistsError(path) result, timing = timed(lambda: subprocess.run( ['curl', '--fail', '--location', '--silent', '--show-error', '--connect-timeout', '20', '--max-time', '120', '--output', str(path), url], capture_output=True, text=True, check=True)) data = path.read_bytes() downloads.append({'tool': tool, 'url': url, 'filename': name, 'download_wall_ns': timing['wall_ns'], 'bytes': len(data), 'sha256': digest(data), 'md5': hashlib.md5(data).hexdigest()}) for (tool, url, name, sha), record in zip(specs, downloads, strict=True): data = (models / name).read_bytes() assert digest(data) == sha == record['sha256'] assert len(data) == record['bytes'] record['seconds'] = record['download_wall_ns'] / 1_000_000_000 started = datetime.datetime.now(datetime.timezone(datetime.timedelta(hours=9))).isoformat() import_times = {} _, import_times['rembg'] = timed(lambda: __import__('rembg')) _, import_times['backgroundremover'] = timed(lambda: __import__('backgroundremover.bg', fromlist=['bg'])) import numpy as np from PIL import Image, ImageDraw, ImageOps import rembg import rembg.sessions.base import rembg.sessions.u2netp import onnxruntime as ort import torch from backgroundremover import bg from backgroundremover.u2net import detect, data_loader, u2net torch.set_num_threads(1) torch.set_num_interop_threads(1) assert not torch.cuda.is_available(), 'CPU-only comparison requires CUDA unavailable' # Public model files have already arrived. Refuse network sockets during loading # and inference, including DNS. No keys, account files or user images are opened. network_attempts = [] def audit(event, params): if event in ('socket.connect', 'socket.getaddrinfo', 'socket.sendto'): network_attempts.append(event) raise RuntimeError('Network prohibited during local measurement: ' + event) sys.addaudithook(audit) opts = ort.SessionOptions() opts.intra_op_num_threads = 1 opts.inter_op_num_threads = 1 session, rembg_load = timed(lambda: rembg.new_session('u2netp', sess_opts=opts, providers=['CPUExecutionProvider'])) net, bg_load = timed(lambda: detect.load_model('u2netp')) assert session.model_name == 'u2netp' assert session.inner_session.get_providers() == ['CPUExecutionProvider'] assert {str(x.device) for x in net.parameters()} == {'cpu'} assert torch.get_num_threads() == torch.get_num_interop_threads() == 1 # backgroundremover.remove() reloads its model on every call and has no session # argument. This adapter calls its unchanged predict/naive_cutout functions with # a preloaded model, following its RGB/alpha_matting=False/PNG code path. # One untimed native remove() equality check below proves this adapter's output. def backgroundremover_loaded(data): image = ImageOps.exif_transpose(Image.open(io.BytesIO(data))).convert('RGB') mask = detect.predict(net, np.array(image)).convert('L') cutout = bg.naive_cutout(image, mask) buffer = io.BytesIO() cutout.save(buffer, 'PNG') return buffer.getvalue() def rembg_loaded(data): return rembg.remove(data, session=session, alpha_matting=False, post_process_mask=False, decontaminate=False, vitmatte=False) functions = {'rembg': rembg_loaded, 'backgroundremover': backgroundremover_loaded} cases = [] inputs = {} masks = {} for kind in ('bottle', 'plant', 'toy-person'): size = (512, 512) image = Image.new('RGB', size, (235, 238, 242)) foreground = Image.new('RGB', size, (0, 0, 0)) truth = Image.new('L', size, 0) draw = ImageDraw.Draw(foreground) maskdraw = ImageDraw.Draw(truth) shapes = [] if kind == 'bottle': shapes = [('rounded_rectangle', (185, 165, 327, 437), (25, 100, 175), {'radius': 28}), ('rectangle', (222, 93, 290, 192), (25, 100, 175), {}), ('rounded_rectangle', (216, 78, 296, 111), (40, 45, 50), {'radius': 7})] elif kind == 'plant': shapes = [('rectangle', (250, 130, 262, 345), (45, 110, 50), {}), ('ellipse', (162, 145, 256, 211), (35, 130, 65), {}), ('ellipse', (257, 198, 363, 264), (35, 130, 65), {}), ('ellipse', (180, 235, 257, 294), (35, 130, 65), {}), ('ellipse', (230, 90, 280, 175), (35, 130, 65), {}), ('polygon', [(192, 328), (320, 328), (299, 441), (213, 441)], (170, 80, 45), {}), ('rectangle', (183, 317, 329, 341), (185, 90, 50), {})] else: shapes = [('rounded_rectangle', (200, 195, 312, 345), (180, 35, 60), {'radius': 22}), ('ellipse', (207, 80, 305, 185), (225, 170, 120), {}), ('rounded_rectangle', (158, 205, 199, 335), (225, 170, 120), {'radius': 17}), ('rounded_rectangle', (313, 205, 354, 335), (225, 170, 120), {'radius': 17}), ('rounded_rectangle', (203, 330, 245, 447), (35, 65, 115), {'radius': 12}), ('rounded_rectangle', (268, 330, 310, 447), (35, 65, 115), {'radius': 12})] for shape, coords, color, kwargs in shapes: getattr(draw, shape)(coords, fill=color, **kwargs) getattr(maskdraw, shape)(coords, fill=255, **kwargs) image.paste(foreground, (0, 0), truth) if kind == 'bottle': ImageDraw.Draw(image).rectangle((199, 257, 313, 338), fill=(245, 215, 80)) elif kind == 'toy-person': d = ImageDraw.Draw(image) d.ellipse((230, 119, 236, 125), fill=(40, 30, 20)) d.ellipse((276, 119, 282, 125), fill=(40, 30, 20)) d.arc((237, 134, 276, 160), 0, 180, fill=(100, 45, 35), width=3) buf = io.BytesIO() image.save(buf, 'PNG') inputs[kind] = buf.getvalue() masks[kind] = np.asarray(truth) == 255 inp = write(f'{kind}-input.png', buf.getvalue()) buf = io.BytesIO() truth.save(buf, 'PNG') gt = write(f'{kind}-truth.png', buf.getvalue()) count = int(np.count_nonzero(masks[kind])) cases.append({'id': kind, 'width': 512, 'height': 512, 'mode': 'RGB', 'foreground_pixels': count, 'background_pixels': 512*512-count, 'input': inp, 'ground_truth': gt}) def metrics(data, truth): output = Image.open(io.BytesIO(data)) assert output.mode == 'RGBA' and output.size == (512, 512) alpha = np.asarray(output)[:, :, 3] fg = int(np.count_nonzero(truth)) bg_pixels = truth.size - fg retained = int(np.count_nonzero((alpha >= 128) & truth)) cleared = int(np.count_nonzero((alpha == 0) & ~truth)) mostly_clear = int(np.count_nonzero((alpha < 128) & ~truth)) return {'foreground_pixels': fg, 'foreground_retained_pixels': retained, 'foreground_retention_percent': retained / fg * 100, 'background_pixels': bg_pixels, 'background_fully_transparent_pixels': cleared, 'background_transparency_percent': cleared / bg_pixels * 100, 'background_alpha_below_128_pixels': mostly_clear, 'background_alpha_below_128_percent': mostly_clear / bg_pixels * 100, 'output_png_bytes': len(data)} warmups = [] trials = [] checks = [] for case in cases: kind = case['id'] for tool, function in functions.items(): data, timing = timed(lambda: function(inputs[kind])) artifact = write(f'{kind}-{tool}-warmup.png', data) warmups.append({'tool': tool, 'case': kind, **timing, **metrics(data, masks[kind]), 'output': artifact}) if tool == 'backgroundremover': native = bytes(bg.remove(inputs[kind], model_name='u2netp', alpha_matting=False)) assert native == data, 'Preloaded adapter differs from native backgroundremover.remove' checks.append({'case': kind, 'native_sha256': digest(native), 'adapter_sha256': digest(data), 'identical_bytes': True}) for repeat in range(1, 6): order = list(functions) if repeat % 2 else list(reversed(functions)) for case in cases: kind = case['id'] for tool in order: data, timing = timed(lambda: functions[tool](inputs[kind])) artifact = write(f'{kind}-{tool}-r{repeat}.png', data) trials.append({'id': f'{kind}-{tool}-r{repeat}', 'tool': tool, 'case': kind, 'repeat': repeat, **timing, **metrics(data, masks[kind]), 'output': artifact}) print(json.dumps({'case': kind, 'tool': tool, 'repeat': repeat, **timing}), flush=True) assert not network_attempts sources = {} for name, module in [('rembg-bg', __import__('rembg.bg', fromlist=['bg'])), ('rembg-base', rembg.sessions.base), ('rembg-u2netp', rembg.sessions.u2netp), ('backgroundremover-bg', bg), ('backgroundremover-detect', detect), ('backgroundremover-data-loader', data_loader), ('backgroundremover-u2net', u2net)]: sources[name] = write(f'source-{name}.txt', Path(inspect.getfile(module)).read_bytes()) versions = {dist.metadata['Name']: dist.version for dist in importlib.metadata.distributions()} requirements = '\n'.join(f'{name}=={version}' for name, version in sorted(versions.items(), key=lambda item:item[0].lower())) + '\n' write('requirements.txt', requirements.encode()) write('replay.txt', Path(__file__).read_bytes()) unit_map = {} for group in ('trials', 'warmups'): for field, unit in [('seconds','秒'), ('wall_ns','ns'), ('foreground_retention_percent','%'), ('background_transparency_percent','%'), ('background_alpha_below_128_percent','%'), ('output_png_bytes','バイト'), ('foreground_pixels','ピクセル'), ('foreground_retained_pixels','ピクセル'), ('background_pixels','ピクセル'), ('background_fully_transparent_pixels','ピクセル'), ('background_alpha_below_128_pixels','ピクセル')]: unit_map[f'{group}[].{field}'] = unit for name in ('rembg', 'backgroundremover'): unit_map[f'model_load.{name}.seconds'] = '秒' unit_map[f'import_times.{name}.seconds'] = '秒' unit_map['downloads[].seconds'] = '秒' unit_map['downloads[].bytes'] = 'バイト' result = {'topic_id': 'rembg-backgroundremover-u2netp-hikaku', 'request_id': 'req-20261022-065', 'started_at': started, 'finished_at': datetime.datetime.now(datetime.timezone(datetime.timedelta(hours=9))).isoformat(), 'environment': {'platform': platform.platform(), 'machine': platform.machine(), 'python': sys.version, 'cpu_hardware_name': 'Not collected; sysctl blocked by execution sandbox', 'packages': versions, 'torch_intra_op_threads': torch.get_num_threads(), 'torch_inter_op_threads': torch.get_num_interop_threads(), 'onnx_intra_op_threads': opts.intra_op_num_threads, 'onnx_inter_op_threads': opts.inter_op_num_threads, 'onnx_active_providers': session.inner_session.get_providers(), 'torch_parameter_devices': sorted({str(x.device) for x in net.parameters()}), 'cuda_available': torch.cuda.is_available(), 'mps_available': torch.backends.mps.is_available()}, 'conditions': {'model': 'u2netp', 'input_size': [512,512], 'network_size': [320,320], 'input_mode': 'RGB', 'alpha_matting': False, 'warmup_calls_per_tool_per_image': 1, 'measured_calls_per_tool_per_image': 5, 'timing_boundary': 'perf_counter_ns around resident-model function: PNG bytes decode, tool preprocessing, actual CPU inference, tool postprocessing, PNG encode; excludes disk IO and scoring', 'foreground_retained': 'ground-truth foreground with output alpha >=128', 'background_transparent': 'ground-truth background with output alpha ==0 (strict full transparency)', 'background_below_128': 'separate threshold metric; not full transparency', 'backgroundremover_adapter': 'native detect.predict + naive_cutout + PNG encode with resident model; native remove byte equality checked on every image; unmodified native remove normally reloads weights per call', 'network_during_measurement': 'Python audit hook refuses socket connect, DNS resolution and sendto after imports and before model load', 'same_model_limit': 'Both official u2netp distributions, ONNX versus PyTorch; exact cross-format weight equality not verified; native preprocessing intentionally retained', 'download_boundary': 'curl subprocess wall time to fetch fresh model path, includes redirect/network/TLS/file-write; not package installation or model loading'}, 'downloads': downloads, 'import_times': import_times, 'model_load': {'rembg': rembg_load, 'backgroundremover': bg_load}, 'cases': cases, 'warmups': warmups, 'native_adapter_checks': checks, 'trials': trials, 'network_attempts_during_measurement': network_attempts, 'installed_source_artifacts': sources, 'unit_map': unit_map} write('raw.json', (json.dumps(result, ensure_ascii=False, indent=2, allow_nan=False)+'\n').encode()) print('COMPLETE', out, flush=True)