Pictograph-SceneParse150-2XL

Pictograph Research · Instance segmentation · Trained 6d ago · BSD-3-Clause

Use this model

Environment

Weights

ONNX SafeTensors PyTorch ExecuTorch TensorRT Engine

Precision

FP32 FP16

Model weights141 MB Model config

from pictograph import Client, get_model, InstanceSegmentationModel, InstanceSegmentationResult

client = Client(api_key="pk_live_...")   # Settings -> API Keys

# Downloads + caches the weights on first use
model: InstanceSegmentationModel = get_model(
    name="Pictograph-SceneParse150-2XL",
    task="instance_segmentation",
    format="onnx",
    client=client,
)
result: InstanceSegmentationResult = model.predict(image="photo.jpg")

for p in result.predictions:
    print(p.name, round(p.confidence, 2), p.bounding_box)

from pictograph import load_model, InstanceSegmentationModel, InstanceSegmentationResult

# Download the weights + config with the buttons above
model: InstanceSegmentationModel = load_model(
    weights="/path/to/weights.onnx",
    config="/path/to/config.json",
    task="instance_segmentation",
    format="onnx",
    device="auto",
)
result: InstanceSegmentationResult = model.predict(image="photo.jpg")

for p in result.predictions:
    print(p.name, round(p.confidence, 2), p.bounding_box)

Deploy this model to Pictograph for an always-on, autoscaling /predict endpoint. Then call it from anywhere:

curl -X POST "https://workflows.pictograph.io/your-endpoint/predict" \
  -H "Authorization: Bearer pk_deploy_..." \
  -F "file=@frame.jpg"

from pictograph import DeploymentClient, InstanceSegmentationResult

client = DeploymentClient(
    endpoint="https://workflows.pictograph.io/your-endpoint/predict",
    api_key="pk_deploy_...",  # from your deployment's settings
    task="instance_segmentation",
)
result: InstanceSegmentationResult = client.infer(image="frame.jpg")

for p in result.predictions:
    print(p.name, round(p.confidence, 2), p.bounding_box)

pictograph deployments predict \
  <deployment-id> \
  frame.jpg \
  --token pk_deploy_... \
  --endpoint "https://workflows.pictograph.io/your-endpoint/predict"

Details

TaskInstance segmentation
ArchitectureRF-DETR Seg 2Xlarge
Precisionfp32
Version1.0.0
Weights141 MB
Trained6d ago
OrganizationPictograph Research

Evaluation

28.3%MAP

43.3%MAP50

Classes 150

wall building sky floor tree ceiling road bed windowpane grass cabinet sidewalk person earth door table mountain plant curtain chair car water painting sofa shelf house sea mirror rug field armchair seat fence desk rock wardrobe lamp bathtub railing cushion base box column signboard chest_of_drawers counter sand sink skyscraper fireplace refrigerator grandstand path stairs runway case pool_table pillow screen_door stairway

⚡ Inference

Runs free on shared CPU, right in the app.

Drop an image to try it

Confidence ≥ 0.50

Model Card

Pictograph-SceneParse150-2XL

An instance segmentation model (RF-DETR Seg 2Xlarge), trained on 150 classes, scoring 28.3% mAP.

Pictograph Research · Instance Segmentation · RF-DETR Seg 2Xlarge · FP32 · BSD-3-Clause · Public

Overview

This is an instance segmentation model built on RF-DETR Seg 2Xlarge, trained on the ADE-20K dataset. It expects 768x768 input and runs in FP32 precision. It predicts wall, building, sky, floor, tree, ceiling, and 144 more.

Performance

Headline: 28.3% mAP.

Metric	Value
mAP	28.3%
mAP@50	43.3%

Classes

Class index matches the model's output order.

#	Class
0	wall
1	building
2	sky
3	floor
4	tree
5	ceiling
6	road
7	bed
8	windowpane
9	grass
10	cabinet
11	sidewalk
12	person
13	earth
14	door
15	table
16	mountain
17	plant
18	curtain
19	chair
20	car
21	water
22	painting
23	sofa
24	shelf
25	house
26	sea
27	mirror
28	rug
29	field
30	armchair
31	seat
32	fence
33	desk
34	rock
35	wardrobe
36	lamp
37	bathtub
38	railing
39	cushion
40	base
41	box
42	column
43	signboard
44	chest_of_drawers
45	counter
46	sand
47	sink
48	skyscraper
49	fireplace
50	refrigerator
51	grandstand
52	path
53	stairs
54	runway
55	case
56	pool_table
57	pillow
58	screen_door
59	stairway
60	river
61	bridge
62	bookcase
63	blind
64	coffee_table
65	toilet
66	flower
67	book
68	hill
69	bench
70	countertop
71	stove
72	palm
73	kitchen_island
74	computer
75	swivel_chair
76	boat
77	bar
78	arcade_machine
79	hovel
80	bus
81	towel
82	light
83	truck
84	tower
85	chandelier
86	awning
87	streetlight
88	booth
89	television_receiver
90	airplane
91	dirt_track
92	apparel
93	pole
94	land
95	bannister
96	escalator
97	ottoman
98	bottle
99	buffet
100	poster
101	stage
102	van
103	ship
104	fountain
105	conveyer_belt
106	canopy
107	washer
108	plaything
109	swimming_pool
110	stool
111	barrel
112	basket
113	waterfall
114	tent
115	bag
116	minibike
117	cradle
118	oven
119	ball
120	food
121	step
122	tank
123	trade_name
124	microwave
125	pot
126	animal
127	bicycle
128	lake
129	dishwasher
130	screen
131	blanket
132	sculpture
133	hood
134	sconce
135	vase
136	traffic_light
137	tray
138	ashcan
139	fan
140	pier
141	crt_screen
142	plate
143	monitor
144	bulletin_board
145	shower
146	radiator
147	glass
148	clock
149	flag

Training

Setting	Value
Base dataset	ADE-20K
Export	ADE-20K-base
Dataset size	22,207 images
Input size	768x768
Epochs	12
Batch size	4
Learning rate	0.0002
Model size	2xlarge
Precision	FP32
Version	1.0.0

Use this model

Run inference with the Pictograph SDK:

from pictograph import Client, get_model, InstanceSegmentationModel, InstanceSegmentationResult

client = Client(api_key="pk_live_...")  # Settings -> API Keys

# Downloads + caches the weights on first use
model: InstanceSegmentationModel = get_model(
    name="Pictograph-SceneParse150-2XL",
    task="instance_segmentation",
    format="onnx",
    precision="fp32",
    device="cpu",
    client=client,
)
result: InstanceSegmentationResult = model.predict(image="photo.jpg")
print(result)

# Fully offline (no API key) once you have the weights + config.json
from pictograph import load_model, InstanceSegmentationModel, InstanceSegmentationResult

model: InstanceSegmentationModel = load_model(
    "/path/to/weights.onnx",
    "/path/to/config.json",
    task="instance_segmentation",
    format="onnx",
)
result: InstanceSegmentationResult = model.predict(image="photo.jpg")