BedNet

BedNet — 3D Printer Bed Occupancy Classifier

Binary image classifier that answers one question from a fixed bed-camera view: is there a printed object on the print bed? Built for autonomous 3D-print-farm fulfillment (auto-releasing completed prints without a human looking at every camera frame).

Model at a glance

What it does — example outputs

Live inference on frames from two printers never seen during training. Banner shows the model's actual output:

What it is

• Architecture: EfficientNet-B0 (ImageNet-pretrained), final layer replaced with a 2-class head (clear / occupied). Input 288×288, ImageNet normalization, bilinear resize.
• Domain: fixed-position bed cameras on FDM printers (PEI/spring-steel sheets, mixed workshop lighting). Not designed for arbitrary photos of 3D prints.
• Deployment: exported to ONNX (opset 17), runs in-process via onnxruntime-node in ~30 ms CPU / <5 ms GPU per frame. Ships as a fast-path: only confident "clear" predictions auto-release; everything else falls through to a human or an LLM reviewer.

Training data

~1,200 frames from 29 farm printers. Labels derived from operational events and then manually audited by the operator (7 corrections applied via a review tool):

Convention: clear means a clean bed — filament scraps and debris count as occupied.

Split is group-aware (all frames from one printer/camera go to exactly one split), so test frames come from devices never seen in training.

Results

Scored on the held-out test split (201 frames, unseen printers) against operator-validated labels:

In production calibration (thresholded at P(occupied) ≤ 0.15 for auto-release, on the shipped ONNX preprocessing): zero false releases across the held-out set; first false release appears at threshold 0.20. The model is used as a speed-up only — it can fast-path confident clears but never overrides other safety checks.

Before vs after fine-tuning (same held-out test set)

Honest reading: with only ~1,200 training frames, full fine-tuning beats a trivial linear probe only slightly — ImageNet's backbone already recognizes printed objects well. Fine-tuning's real gains are the calibrated probabilities (which make the zero-false-release threshold possible), Grad-CAM localization, and a small deployable model. Both rows hit the same wall: more labeled data, not more training tricks, is what moves this number.

Read these numbers with context: training data was very limited (~1,200 frames from one print farm). More labeled data would give a better model — see Limitations.

Files

Usage (PyTorch)

import torch
from torchvision import models, transforms
from PIL import Image

m = models.efficientnet_b0(weights=None)
m.classifier[1] = torch.nn.Linear(m.classifier[1].in_features, 2)
m.load_state_dict(torch.load("bednet.pt", map_location="cpu", weights_only=False)["state_dict"])
m.eval()

tfm = transforms.Compose([
    transforms.Resize((288, 288)),   # bilinear — keep the default, Lanczos shifts calibration
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])

with torch.no_grad():
    p_occupied = float(torch.softmax(m(tfm(Image.open("frame.jpg").convert("RGB"))[None]), 1)[0, 1])

print(f"P(occupied) = {p_occupied:.3f}")   # auto-release beds at <= 0.15; do not exceed ~0.2 without recalibration

Usage (ONNX Runtime)

Preprocess exactly as above (resize bilinear to 288×288 — in sharp use kernel: "linear"), normalize with ImageNet stats, NCHW float32 input named from the graph. Output is [1, 2] logits [clear, occupied].

import onnxruntime as ort, numpy as np
sess = ort.InferenceSession("bednet.onnx")
# x: (1,3,288,288) float32, ImageNet-normalized
logits = sess.run(None, {sess.get_inputs()[0].name: x})[0]
p_occupied = float(np.exp(logits[0][1]) / np.exp(logits).sum())

Grad-CAM localization

The last EfficientNet feature block supports Grad-CAM against the occupied logit; it reliably circles the part driving an occupied call (used in the operator review UI for "why is this flagged").

Limitations & honest caveats

• Very limited training data — this is the biggest constraint. The model was trained on only ~1,200 frames (~700 after deduplication), which is a tiny fraction of what an image classifier normally uses. This number is not a ceiling: with more labeled frames — even a few thousand covering more printers, parts, lighting conditions, and failure modes — the same architecture should get meaningfully better. Treat these metrics as "what's achievable with one farm's worth of data," not what this approach caps out at.
• Domain-specific. Trained on frames from one farm's fixed cameras. Expect degradation on new printer models, camera angles, or lighting; recalibrate the release threshold on your own data before automating anything.
• Not an object detector. It answers bed-level occupancy only; localization is coarse (Grad-CAM), not boxed detection.
• Glare and surface texture are the main false-positive driver; debris/small parts are the main misses.
• The 89.1% test accuracy is on a small (201-frame) holdout — confidence intervals are wide.

Intended use / out of scope

Intended: gating print-bed verification steps in a 3D-print farm where a human or another system reviews non-confident frames. Not intended: safety-critical autonomy, anything where a false "clear" causes harm without a second check.

License & attribution

This model is released under CC-BY 4.0: you are free to use, modify, and redistribute it — including commercially — as long as you credit the author. Attribution means keeping this notice visible wherever the model or its derivatives ship:

BedNet (c) SugaryCoffee — https://huggingface.co/SugaryCoffee/BedNet — licensed under CC-BY 4.0.

If you use it in a paper, cite:

@misc{bednet2026,
  author       = {SugaryCoffee},
  title        = {BedNet: 3D Printer Bed Occupancy Classifier},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/SugaryCoffee/BedNet}}
}