Quantum scheduling optimization visualization
    Quantum Support Vector Machine

    Quantum Quality Control in Additive Manufacturingwith a Trainable QSVM

    One quantum kernel, two worked cases: flag anomalous melt pools and classify their defect mode, both benchmarked against classical baselines.

    What you get: two QSVM quality-control cases for additive manufacturing on the same melt-pool data family — binary anomaly detection and multi-class melt-pool shape classification

    How it's delivered: downloadable research-style report and run-ready Python code

    Why trust it: seed-controlled reproducibility, classical baselines, and hardware notes

    Quality Control for Additive Manufacturing, Two Ways

    Metal powder-bed fusion — electron-beam and laser powder-bed fusion (EPBF/LPBF) — builds parts layer by layer from a molten pool of metal, and an unstable melt pool is the root cause behind porosity, lack-of-fusion voids, and rough surfaces. Catching an unstable melt pool late, after a build finishes, means a scrapped part and a repeated build cycle; catching it from in-process signal means a cheaper correction, or a decision to stop a build before it wastes material and machine time. The same melt-pool process data supports two different quality-control questions: is this melt pool behaving normally at all, and, if not, which defect regime is it in. We answer both with the same modeling approach — a Quantum Support Vector Machine (QSVM) with a trainable quantum kernel — applied to two worked cases below: binary anomaly detection and multi-class melt-pool shape classification.

    The Shared Approach: Quantum Support Vector Machine

    Both cases start from a classical SVM pipeline: the model seeks a separating hyperplane in feature space, \mathbf{w}^\top \phi(\mathbf{x}) + b = 0, maximizing the geometric margin between classes. When linear separation is difficult, we map data to a higher-dimensional space and apply the kernel trick: instead of building \phi(\cdot) explicitly, we compute inner products k(\mathbf{x},\mathbf{x}')=\langle \phi(\mathbf{x}), \phi(\mathbf{x}')\rangle, which lets the SVM operate implicitly in a Hilbert space \mathcal{H}.

    The quantum kernel replaces that classical map with a circuit: input \mathbf{x} is encoded into a quantum state |\phi(\mathbf{x})\rangle=U(\mathbf{x})|0\rangle^{\otimes n}, and the state overlap (inner product or fidelity) becomes k(\mathbf{x},\mathbf{x}'). Data-dependent single-qubit rotations and entangling gates induce a nonlinear embedding; the overlaps are estimated by running U(\mathbf{x}')^\dagger U(\mathbf{x}), and the resulting Gram matrix feeds directly into the standard SVM pipeline. Adding trainable parameters \boldsymbol{\theta} to the encoding circuit — used in the anomaly-detection case below — lets the kernel geometry adapt to the data, by maximizing target alignment, minimizing a margin-based surrogate, or reducing cross-validated risk.

    Both circuits below use the same shape: 4 qubits and 2 repeated layers of data-dependent rotations and entangling gates. That depth is deliberately shallow — a design choice that keeps the number of two-qubit gates, and with it the accumulated gate error, low enough for the kernel to be evaluated on both a classical simulator and today's noisy quantum hardware, at the cost of a less expressive feature map than a deeper circuit could offer.

    Both cases below benchmark the quantum kernel against a classical SVM baseline on the same data. For a same-dataset, side-by-side benchmark of QSVM against a classical kernel SVM, see our QSVM vs. classical SVM comparison.

    Case 1 — Binary Anomaly Detection

    Dataset: a metal additive-manufacturing dataset covering EPBF and LPBF across several metals, originally labeled across five melt-pool modes — "LOF", "balling", "desirable", "keyhole", and "spatter formation". The three smallest classes were removed (447 of the original 1,250 datapoints), leaving an 803-sample, 38-column subset that we treat as a two-class problem: desirable melt pools versus anomalous ones.

    The 38 columns span process parameters (laser/beam power, scan velocity, hatch spacing, layer thickness, beam diameter), material and thermal properties (density, specific heat, thermal conductivity, melting temperature, absorption coefficient, minimal absorptivity), several dimensionless process-parameter ratios used in melt-pool physics (p/lb, p/l, p/b2, p/b, vb, vl), alloy composition in weight percent (Zn, Mg, Si, Al, Sn, Zr, W, Ti, V, Co, Cu, Ta, Nb, Ni, Cr, Fe, Mn, Mo), and porosity and relative density measurements. The binary target — the label a desirable versus anomalous melt pool — is close to balanced across the 803 rows.

    Setup: a trainable-kernel QSVM circuit with 4 qubits and 2 layers, executed on a simulator with a fixed seed for reproducibility.

    What you get on the platform
    • • End-to-end QSVM (with trainable kernel) executed on simulator
    • • Results: trainable QSVM kernel reached 70% accuracy; ROC-AUC 0.81
    • • Downloadable, citable report (method, experiments, results)
    • • Executable Python code with deterministic, reproducible outputs
    • • Hardware details: encoding, circuit depth/qubits, backend/cost guidance
    • • Baseline comparisons with metrics and plots

    70%

    Accuracy

    70%

    Balanced Accuracy

    0.70

    Macro F1

    0.81

    ROC-AUC (trainable kernel)

    Case 2 — Melt-Pool Shape Classification (Multi-Class)

    Dataset: the same melt-pool defect family, kept as four classes instead of collapsed to two — "LOF", "balling", "desirable", and "keyhole" — with 1,242 samples and 35 features per sample.

    Setup: a QSVM circuit with 4 qubits and 2 layers, executed on a simulator.

    What you get on the platform
    • • End-to-end quantum support vector machine executed on simulator
    • • Results: QSVM reached 63% accuracy and 65% balanced accuracy on the 4-class dataset
    • • Downloadable, citable report (method, experiments, results)
    • • Executable Python code with deterministic, reproducible outputs
    • • Hardware details: encoding, circuit depth/qubits, backend/cost guidance
    • • Baseline comparisons with metrics and plots

    The exact feature-by-feature breakdown of this 1,242-sample, 35-feature split isn't broken out separately in our source report, but it is drawn from the same broader melt-pool defect dataset family as Case 1 above — the same kind of process parameters, thermal and material properties, and alloy composition signals — kept here as four separate labels instead of collapsed to two.

    If your defects show up as macroscopic surface faults on rolled steel rather than melt-pool sensor traces, see our steel plate fault detection with QSVM case instead.

    63%

    Accuracy

    65%

    Balanced Accuracy

    0.63

    Macro F1

    Case 1 vs. Case 2 at a Glance

    MetricCase 1: Anomaly DetectionCase 2: Shape Classification
    Classification typeBinary (2 classes)Multi-class (4 classes)
    ClassesDesirable vs. anomalousLOF, balling, desirable, keyhole
    Dataset803 samples, 38 columns1,242 samples, 35 features
    Qubits44
    Circuit layers22
    KernelTrainable quantum kernelQuantum kernel
    ExecutionSimulatorSimulator
    Accuracy70%63%
    Balanced accuracy70%65%
    Macro F10.700.63
    ROC-AUC0.81 (trainable kernel)Not reported for the multi-class case

    Read together, the two cases show an expected pattern: accuracy drops as the classification question gets harder. Separating two classes (desirable vs. anomalous) is an easier decision boundary than separating four (LOF, balling, desirable, keyhole), so the trainable-kernel binary case reaches a higher accuracy and ROC-AUC than the plain-kernel multi-class case. Which case fits your line depends on whether "something is wrong" is enough signal, or whether you need to know which defect mode you're looking at before you act on it.

    The tradeoffs below apply to both cases equally, since both rely on the same class of shallow, hardware-efficient quantum kernel circuit described above.

    Strengths

    • Quantum kernels embed data into high-dimensional Hilbert spaces, increasing the chance of linear separability and improving classification quality.
    • Parameterized quantum circuits, including data reuploading, can be tuned to the target dataset without major changes to the surrounding classical pipeline.
    • Shallow, hardware-efficient circuits keep depth, noise, and runtime low enough for practical kernel evaluation on NISQ devices.
    • On fault-tolerant quantum hardware, kernel entries over exponentially large state spaces can be estimated in polynomial quantum time for specific problem families.

    Weaknesses

    • Contemporary quantum devices exhibit non-negligible noise and gate/measurement error rates, which can degrade model or task-level accuracy.
    • Performance improvements over classical baselines are not guaranteed and typically depend on the dataset, problem structure, and parameter regime.
    • Classical simulation of quantum circuits can avoid hardware noise but incurs additional computational cost compared to purely classical approaches.

    Business Impact

    Both QSVM cases flag unstable or defective melt-pool regimes earlier than a manual review cycle, trimming engineering review time, reducing scrap/rework, and improving throughput. Projected impact differs by case, since it scales with each dataset's baseline review cost and defect rate: the anomaly-detection case models a lighter, faster review step, while the shape-classification case models a heavier inspection workflow with a larger addressable cost base, which is why its projected annual savings are higher even though its ROI percentage is lower.

    Case 1 — Anomaly Detection

    Cost Savings

    $45,500

    Annual projected savings from reduced reviews/scrap and faster throughput.

    ROI

    355%

    Return on investment based on value add vs. TCO.

    Time Saved

    35%

    Efficiency gains vs. baseline review/inspection workflows.

    Case 2 — Melt-Pool Shape Classification

    Cost Savings

    $80,000

    Annual projected savings from reduced reviews/scrap and faster throughput.

    ROI

    167%

    Return on investment based on value add vs. TCO.

    Time Saved

    35%

    Efficiency gains vs. baseline review/inspection workflows.

    How it works

    Simple and transparent: from your brief to quantum results, code, and a paper, for either quality-control case

    01

    Describe

    Map your quality-control problem to anomaly detection or shape classification

    02

    Confirm

    Confirm the quantum-classical hybrid approach and key assumptions

    03

    Run

    Download ready-to-run code; execute on simulator with a fixed seed

    04

    Review

    Review reproducible results, iterate as needed

    05

    Benchmark

    Compare against classical baseline; prepare for quantum hardware

    FAQs

    What is QSVM used for in additive manufacturing quality control?

    Quantum Support Vector Machine (QSVM) classifies melt-pool process data from metal powder-bed fusion (EPBF/LPBF) to catch quality problems before a part is scrapped. This page covers two worked cases built on the same melt-pool data family: a binary anomaly-detection model that flags a melt pool as desirable or anomalous, and a multi-class model that identifies which defect regime — LOF, balling, desirable, or keyhole — a melt pool is in.

    What's the difference between anomaly detection and melt-pool shape classification?

    Anomaly detection is a binary question: is this melt pool desirable or not. It runs on an 803-sample, 38-column two-class subset built by removing the three smallest of five original melt-pool-mode labels. Melt-pool shape classification is a harder, four-way question — which specific defect regime (LOF, balling, desirable, or keyhole) is present — run on 1,242 samples with 35 features. Both use a QSVM with 4 qubits and 2 layers on a simulator; the binary case adds a trainable quantum kernel.

    How accurate is quantum SVM for detecting melt-pool defects?

    In our reproducible simulator runs, the trainable-kernel QSVM reached 70% accuracy (Balanced Accuracy 70%, Macro F1 0.70, ROC-AUC 0.81) on the binary anomaly-detection case, and the QSVM reached 63% accuracy (Balanced Accuracy 65%, Macro F1 0.63) on the four-class shape-classification case. Whether a quantum kernel beats a classical one on your data isn't guaranteed by default — see our QSVM vs. classical SVM comparison for a same-dataset, side-by-side benchmark.

    What data do I need for QSVM-based melt-pool quality control?

    Process and sensor features recorded per melt pool or per build layer, plus a label for each sample. Our anomaly-detection case uses 803 samples across 38 columns labeled desirable or anomalous; our shape-classification case uses 1,242 samples across 35 features labeled LOF, balling, desirable, or keyhole. We'll help you map your own process parameters and defect labels onto either setup.

    Do I need access to quantum hardware to run this?

    No. Both cases on this page run on a simulator with a fixed seed for reproducibility. The delivered report and code include hardware notes — circuit depth, qubit count, and backend guidance — for teams that want to move a run onto quantum hardware later.

    How does this compare to steel plate fault detection with QSVM?

    Melt-pool anomaly detection and shape classification both work on in-process sensor and parameter data from metal powder-bed fusion. Our steel plate fault detection with QSVM case instead classifies macroscopic surface faults on finished rolled-steel plates — a different manufacturing process and a different point in the quality-control pipeline. Both share the same QSVM approach underneath.

    Run QSVM Now

    Run your first industrial task with QSVM and get transparent results within a clear report.

    Try your first case for free