Evaluation benchmark for vision-language models (VLMs) on welding imagery. Four held-out test sets, one repository, one schema. It is the evaluation counterpart of the training set jujeongho/Weld-Instruct; nothing in Weld-Bench may be used for training.

Subset	Task	Rows	Image modality	Main metric	Setting
`RIAWELC`	4-way defect classification	2,443	X-ray radiograph patches, 227×227 grayscale	accuracy	zero-shot
`LoHi-WELD`	defect detection (boxes)	205	robotic MAG weld-bead crops (high-resolution subset), RGB	mAP@0.5 (fine / coarse)	zero-shot
`Khvatskii`	weld acceptability judgement per use context	459 (153 images × 3 contexts)	field / web photos of welds	precision · recall · F1	zero-shot, 2-turn, 3 seeds
`RefWeld`	referring grounding (box) + segmentation (8-point polygon)	790 (396 + 394)	screenshots of welding videos	box accuracy (IoU > 0.5) · polygon Precision@0.5	zero-shot

Prompts name the classes but give no class definitions: the benchmark measures whether a model already knows what these welding terms look like.

Access and loading

The repository is public but gated (manual approval). After approval:

from datasets import load_dataset
riawelc = load_dataset("jujeongho/Weld-Bench", "RIAWELC", split="test")
lohi    = load_dataset("jujeongho/Weld-Bench", "LoHi-WELD", split="test")
khv     = load_dataset("jujeongho/Weld-Bench", "Khvatskii", split="test")
refweld = load_dataset("jujeongho/Weld-Bench", "RefWeld", split="test")

Schema. Every subset has sample_id (string), image (PIL image, original pixels, never resized) and answer (string). RIAWELC, LoHi-WELD and RefWeld have one question (string). Khvatskii instead has system, question1, question2 (its protocol is a two-turn chat) and a narrative column (the expert's written rationale; not scored).

Common protocol

Prompt: send the question column verbatim. Do not add system prompts, few-shot examples or format hints beyond what the subset prescribes below.
Image: send the image column as is. If an engine must downscale, cap the longer side at 1536 px (only Khvatskii images exceed it) and apply the same cap to every model.
Decoding: greedy (temperature 0) unless the subset says otherwise; reasoning / "thinking" modes off for every model; generous max_tokens (≥ 2048 for detection outputs).
Coordinates: every box or polygon is in a 0–1000 frame normalized to the image (x1, y1 = left, top; x2, y2 = right, bottom), as the prompts state. Models are scored on that declared frame; the evaluator does not guess another frame and does not swap axis order.
Output parsing (lenient, lmms-eval / VLMEvalKit style): parse the whole reply as JSON; else the first fenced ```json block; else every balanced {...} object; accept the keys bbox_2d, bbox, box_2d, box for boxes and polygon_2d for polygons; as a last resort take 4-number tuples with a regex. An unparsable reply counts as a wrong answer (no prediction). Report the parse-failure rate next to every score.
Report the parse-failure rate and the model's size and decoding settings next to every score.

RIAWELC — radiograph defect classification

Source: Totino, Spagnolo, Perri, RIAWELC: A Novel Dataset of Radiographic Images for Automatic Weld Defects Classification (ICMECE 2022) and Perri et al., Welding Defects Classification Through a Convolutional Neural Network (Manufacturing Letters 2023); data from github.com/stefyste/RIAWELC. We use the authors' official test folder (2,443 patches) unchanged; their train / validation folders are not part of this benchmark.

Rows: 2,443 patches, 227×227 8-bit grayscale. Classes: crack 765, porosity 632, lack of penetration 446, no defect 600. sample_id = riawelc_<original file stem>; the stem's prefix (RRT-12R, bam5, …) is the source radiograph.
Question: 4-way multiple choice with options (A)…(D); option order is shuffled per row (seed derived from sample_id), answers are balanced across letters. The options are the four class names; no definitions are given.
Answer: (C) lack of penetration — the correct letter and option name.
Scoring: a reply is correct if the first (X) letter it contains, else a leading bare letter (C, C., C)), else a unique option name mentioned in the reply, equals the answer letter. Anything else (no option, two options) is wrong. Metric = accuracy over 2,443 rows. Chance is 25%.
Reference: the original papers report supervised CNNs trained on the RIAWELC train split (accuracy 0.93–0.999 on this same test folder). They are not comparable to zero-shot VLMs; cite them as a reference row, not a baseline.

LoHi-WELD — weld-bead defect detection

Source: Block, da Silva, Lazzaretti, Minetto, LoHi-WELD: A Novel Industrial Dataset for Weld Defect Detection and Classification, a Deep Learning Study, and Future Perspectives (IEEE Access 2024); data from github.com/SylvioBlock/LoHi-Weld (free for research and commercial use with citation). Rows are the authors' official hold-out test crops of the high-resolution subset (hweld) only; the low-resolution subset (lweld, ~200×40 px crops with ~10 px boxes) is excluded because it is beyond the localization precision of current VLMs.

Rows: test 205 crops (~785×195 px, 2048×1080 sensor), sample_id prefix lohi_high_. 1,928 ground-truth boxes (pore 86, deposit 390, discontinuity 596, stain 856); every crop has at least one.
Classes: pore, deposit, discontinuity, stain, named in the prompt without definitions. The authors define them as: pore = small fill gap from an air bubble in the melting weld material (usually in groups); deposit = excess welding material along the bead; discontinuity = partial absence of weld material along the bead; stain = slight alteration of the weld surface. These definitions are documentation only and are not shown to the model.
Question: find every defect; return a JSON list [{"bbox_2d": [x1, y1, x2, y2], "label": <class>}, ...] in the 0–1000 frame, [] if none, with the boxes listed by the x + y of their top-left corners, smallest first.
Answer: that JSON list (ground truth), in the same x + y order. Order does not affect mAP.
Setting: zero-shot. One user turn: the test image and the question; no demonstrations.
Scoring: convert every parsed box from the 0–1000 frame to pixels of the crop (clip to the image; drop boxes with zero area; labels are lower-cased and singularized, unknown labels are dropped for the fine score). Run COCO evaluation (pycocotools COCOeval, iouType="bbox", maxDets=[1,100,1000]) with every prediction's score = 1.0; mAP@0.5 = stats[1]. Compute it twice from the same predictions: fine (4 categories) and coarse (all labels, ground truth and predictions alike, merged into one category defect). Report fine and coarse, plus the truncation rate (finish_reason == length).
Reference: the paper's YOLOv7-tiny, trained on the train split, reaches mAP@0.5 fine 0.69 / coarse 0.77 on hweld — supervised, reference only. This subset is very hard for VLMs (boxes are ~30 px wide).

Khvatskii — weld acceptability per use context

Source: Khvatskii, Lee, Angst, Gibbs, Landers, Chawla, Do Multimodal Large Language Models Understand Welding? (Information Fusion 120, 2025; arXiv 2503.16537); data and prompts from github.com/x0wllaar/Do-LLMs-Understand-Welding. The protocol below is the paper's zero-shot protocol, so the paper's GPT-4o and LLaVA-1.6 numbers are directly comparable.

Rows: 459 = 153 images × 3 use contexts (RV & Marine, Aeronautical, Farming). sample_id = khv_<real|online>_<guid8>_<rvmarine|aeronautical|farming>; real = 95 photos taken by welding instructors, online = 58 web photos. Positives (acceptable): RV & Marine 78, Aeronautical 28, Farming 67.
Conversation (per row, independent): system → user [image + question1] → model turn 1 (≤ 5 sentences of plain text) → user [question2] → model turn 2 (a JSON object {"acceptable": true|false}). The prompts are the repository's config.jsonc strings with the context substituted. The context name is the only information about the acceptance criteria.
Sampling: run each row 3 times with seeds 0, 1, 2 at temperature 0.7, top_p 0.8 (the model's recommended non-thinking sampling); the row's prediction is the majority vote of the three turn-2 answers. Turn 2 is parsed with "acceptable"\s*:\s*(true|false), falling back to a bare true / false; an unparsable turn 2 counts as false.
Answer: {"acceptable": true} or {"acceptable": false}.
Scoring: positive class = acceptable. Report precision, recall and F1 for each context × source cell (6 cells) and the micro F1 over all contexts for real (285 judgements) and online (174), which are the headline numbers. ROC-AUC is not reported.
Reference (same protocol, from the paper): micro F1 real / online — GPT-4o 0.536 / 0.675, LLaVA-1.6-Mistral-7B 0.210 / 0.481.

RefWeld — referring grounding and segmentation of welding components

Own data. 85 screenshots of publicly available welding videos (torch-side camera views), annotated with polygons by four people in CVAT, reviewed and corrected by one reviewer, near-duplicate frames removed. Follows the RefCOCO protocol as evaluated in MAttNet (Yu et al., CVPR 2018): one expression refers to exactly one object; comprehension (box) and segmentation (polygon) are asked for the same (image, class) pair and scored with MAttNet's metrics.

Rows: 790 = 396 box + 394 poly, over 85 images. sample_id = refweld_img<001–085>_<class>_<box|poly>. Classes and counts per task: wire 85, nozzle 85, pool 81 (box) / 79 (poly), bead 80, arc 57, groove 5, seam 3.
Expression: the class name only (there is one instance of the class in the image); no definitions are given. For readers: wire = filler wire protruding from the nozzle; nozzle = gas nozzle / contact tip; pool = molten pool under the arc; bead = solidified weld metal; seam = joint line before welding; groove = joint gap, annotated either as the groove walls or as the groove line; arc = electric discharge at the wire tip, annotated either as the discharge spot or as the whole glare.
box (REC) — question: Locate the <class> in the image. … [{"bbox_2d": [x1, y1, x2, y2], "label": "<class>"}]; answer: that list with the tight box of the annotated polygon. Scoring (MAttNet §4.2): take the model's first box, compute IoU with the answer box in pixels; the expression is correctly comprehended if IoU > 0.5. Metric = accuracy over the 396 box rows; parse failure = wrong.
poly (RES) — question: Outline the <class> in the image with a polygon. Use exactly 8 points in clockwise order, starting from the vertex with the smallest x + y … [{"polygon_2d": [[x1, y1], …, [x8, y8]], "label": "<class>"}]; answer: the annotated polygon canonicalized to 8 points with the same rule as Weld-Instruct l4 (vertices removed by Visvalingam–Whyatt when there are more than 8, the longest edge split at its midpoint when fewer; clockwise as seen on screen, i.e. with the image y axis pointing down; start at the vertex with the smallest x + y, ties broken by the upper, then the left vertex). Two pool items whose 8-point polygon self-intersected were removed, so their box items have no poly counterpart. Scoring (MAttNet §4.3): for each of the 394 rows, rasterize the answer polygon and the model's polygon as binary masks at the image's size (pixels inside the polygon = 1) and compute their IoU (intersection pixels ÷ union pixels). Metric = Precision@0.5 = the share of rows whose IoU is at least 0.5. A reply with fewer than 3 valid points or that cannot be parsed is a miss. The model may output any number of points; the prompt asks for 8. The 8-point canonical answer keeps this much of the raw annotation (IoU, median per class): wire 0.990, nozzle 0.992, bead 0.992, groove 0.998, seam 0.957, arc 0.909, pool 0.898 — the practical ceiling of the task.
Reference: none from the literature.

Scoring pseudo-code

# RIAWELC
letter = re.search(r"\(([A-D])\)", out) or re.match(r"^\**\s*([A-D])\b", out) or unique_option_name(out, options)
correct = letter == answer_letter

# LoHi-WELD (per crop) -> COCO
for p in parse_boxes(out):                      # keys bbox_2d|bbox|box_2d|box, regex fallback
    x1, y1, x2, y2 = sorted-and-clipped(p.bbox) / 1000 * (W, H, W, H)
    det = (norm_label(p.label), x1, y1, x2, y2, score=1.0)
mAP50_fine   = COCOeval(gt, dets, categories=4).stats[1]
mAP50_coarse = COCOeval(gt_as_defect, dets_as_defect, categories=1).stats[1]

# Khvatskii (per row): votes = [parse_bool(turn2_seed_s) for s in (0,1,2)]; pred = sum(votes) >= 2
P, R, F1 per (context, source); micro F1 over contexts for real and for online

# RefWeld (MAttNet metrics)
box : correct = IoU(first_box_px, answer_box_px) > 0.5 ; accuracy = mean(correct)
poly: m1 = rasterize(poly_px); m2 = rasterize(answer_px); iou = (m1 & m2).sum() / (m1 | m2).sum()
      precision_at_0_5 = mean(iou >= 0.5 over rows)

Citation and licenses

Cite the source papers when you report a subset: RIAWELC (Totino et al. 2022; Perri et al. 2023), LoHi-WELD (Block et al. 2024), Khvatskii et al. 2025. RIAWELC and Khvatskii are redistributed from their public GitHub repositories (no license files; released for research with citation); LoHi-WELD per its README (free with citation); RefWeld images are screenshots of public welding videos used for research evaluation only. The benchmark itself is for research evaluation; do not train on any subset.

Downloads last month: 1,467

Total file size:

668 MB