100 Exercises / anomaly detection / Abnormality detection: 100 Exercises

Manufacturing Anomaly Detection in Practice with Python | Eight Machine Learning Methods and Threshold Design

2020-08-20

Capturing Early Signs in Injection Molding Equipment: Multivariate Anomaly Detection with 10 Exercises Using Machine Learning (No.051–No.060)

Overview

If temperature, vibration, current, and hydraulic pressure are monitored only at individual upper limits, equipment deterioration is missed—‘all values are within the upper limit, but the combinations are unnatural.’ In this article, we use a hypothetical injection molding line as a subject, examining six unsupervised learning streams, model comparison, and threshold design for anomaly scores as a single decision-making process.

The goal is not just to choose the model with the highest precision. Establishing monitoring rules that can be maintained on-site, taking into account the number of inspections that can be inspected, losses from missed items, explainability, and the operational burden of relearning..

[!NOTE] This material is a notebook previously used by Surikoubo (or personally by the representative, Kazuyama), and has been reconstructed, edited, and published with the company’s permission.
All data listed is fictional and has no relation whatsoever to real companies, factories, or figures.

Introduction: Practical Challenges in Manufacturing Covered in This Article

At injection molding facility A-01, sensor values are collected for each shot of the product. The goal of maintenance personnel is not to definitively identify failures, but to narrow down shots that differ from usual and to identify inspection targets during planned shutdowns.

The output of the anomaly detection model is treated as a Primary screening to prioritize inspections, not as a facility shutdown command. Scores can also be high due to sensor calibration defects, product switching, or startup conditions, so cross-checking with work history and quality results is essential.

Common situations on site

There is a large amount of normal data, but few fault labels and definitions fluctuate
With the management limits of a single sensor, it is impossible to detect the breakdown of relationships among multiple variables.
There is a limit to the number of inspection personnel, and if alerts are too frequent, operations become mere formality
The distribution of ‘normal’ varies depending on variety, equipment, season, and post-conservation

Why is this issue so difficult to judge?

Unsupervised anomaly detection does not directly learn the correct label, but determines the degree of anomaly based on data sparseness, boundaries, and distribution. Therefore, even with the same data, candidates vary depending on the method and hyperparameters. Also, statistically unusual phenomena and operational abnormalities that lead to stoppages or defects are not synonymous.

Overview of Exercise covered this time

No.	Methods and Issues	On-site Verification
051	Isolation Forest	Shots prone to isolation in multivariate spaces
052	Local Outlier Factor	Locally less frequent than peripheral shots
053	One-Class SVM	Flexible boundaries of the normal domain
054	Elliptic Envelope	Elliptical normal region considering covariance
055	k Near-Distance	Transparency anomaly depending on the distance to the nearby area
056	clustering	Handling of small groups or points far from the center
057	KMeans	Candidate selection based on distance to the nearest center
058	DBSCAN	Noise points in low-density regions
059	Model Comparison	Comparison of detection performance, number of cases, and consensus
060	threshold adjustment	Reflecting inspection capability and missed costs

Preparing the Python environment

Data is handled with numpy and pandas, utilizing each model of scikit-learn. The graph uses only matplotlib. For reproducibility, the random number seed is fixed at 42.

import warnings
import numpy as np
import pandas as pd
import matplotlib
import matplotlib.pyplot as plt
import sklearn

from sklearn.cluster import DBSCAN, KMeans
from sklearn.covariance import EllipticEnvelope
from sklearn.ensemble import IsolationForest
from sklearn.metrics import precision_score, recall_score, f1_score
from sklearn.neighbors import LocalOutlierFactor, NearestNeighbors
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import OneClassSVM

warnings.filterwarnings("ignore", category=UserWarning, module="matplotlib")
SEED = 42
np.random.seed(SEED)
pd.set_option("display.max_columns", 20)

print(f"numpy       : {np.__version__}")
print(f"pandas      : {pd.__version__}")
print(f"matplotlib  : {matplotlib.__version__}")
print(f"scikit-learn: {sklearn.__version__}")

numpy       : 2.5.1
pandas      : 3.0.3
matplotlib  : 3.11.0
scikit-learn: 1.9.0

Creation of Fictional Data

Normally, 900 shots are generated, but 40 shots are required. Normally, as the mold temperature rises, the heater current increases slightly, and it is assumed that vibration and hydraulic pressure are weakly related. The data to be verified includes multiple deterioration patterns, such as increased vibration, disrupted temperature-current relationships, and decreased hydraulic pressure.

known_issue is a label for evaluation that was later identified during inspections and quality checks. It is not used for model training. This is not a complete failure label but a limited audit result for comparison.

rng = np.random.default_rng(SEED)
n_normal, n_issue = 900, 40

mean = np.array([210.0, 2.4, 31.0, 8.0])
cov = np.array([
    [16.0, 0.7, 5.0, 1.0],
    [0.7, 0.36, 0.4, 0.3],
    [5.0, 0.4, 9.0, 1.2],
    [1.0, 0.3, 1.2, 1.0],
])
normal = rng.multivariate_normal(mean, cov, n_normal)

issue_1 = rng.multivariate_normal([211, 5.4, 33, 9.4], np.diag([9, .20, 4, .35]), 14)
issue_2 = rng.multivariate_normal([222, 2.7, 25, 8.2], np.diag([8, .25, 3, .50]), 13)
issue_3 = rng.multivariate_normal([207, 3.6, 32, 5.4], np.diag([7, .22, 4, .20]), 13)
issue = np.vstack([issue_1, issue_2, issue_3])

columns = ["mold_temp_c", "vibration_mm_s", "heater_current_a", "oil_pressure_mpa"]
df = pd.DataFrame(np.vstack([normal, issue]), columns=columns)
df.insert(0, "shot_id", [f"S{i:04d}" for i in range(1, len(df) + 1)])
df["known_issue"] = np.r_[np.zeros(n_normal, dtype=int), np.ones(n_issue, dtype=int)]
X = df[columns]
X_scaled = StandardScaler().fit_transform(X)

print(f"Number of shots: {len(df):,} / Evaluation Confirmation: {df['known_issue'].sum()}")
display(df.head())
display(df.groupby("known_issue")[columns].agg(["mean", "std"]).round(2))

Number of shots: 940 / Points to check for evaluation: 40

	shot_id	mold_temp_c	vibration_mm_s	heater_current_a	oil_pressure_mpa
0	S0001	207.579632	2.201556	32.597790	8.998515
1	S0002	215.879777	2.994548	37.801656	9.099905
2	S0003	209.024388	2.377789	32.812262	9.146080
3	S0004	211.071845	2.910164	28.307671	7.929873
4	S0005	207.416243	2.676244	32.282850	8.891665

	mold_temp_c		vibration_mm_s		heater_current_a		oil_pressure_mpa
	mean	std	mean	std	mean	std	mean	std
known_issue
0	210.04	3.88	2.4	0.59	31.04	2.99	7.98	1.02
1	213.47	6.42	3.9	1.25	30.52	4.45	7.63	1.75

fig, axes = plt.subplots(1, 2, figsize=(12, 4.5))
colors = np.where(df["known_issue"].eq(1), "tab:red", "tab:blue")
axes[0].scatter(df["mold_temp_c"], df["heater_current_a"], c=colors, alpha=.55, s=20)
axes[0].set_title("Temperature vs. heater current")
axes[0].set_xlabel("Mold temperature [C]")
axes[0].set_ylabel("Heater current [A]")
axes[0].grid(True, alpha=.3)
axes[1].scatter(df["vibration_mm_s"], df["oil_pressure_mpa"], c=colors, alpha=.55, s=20)
axes[1].set_title("Vibration vs. oil pressure")
axes[1].set_xlabel("Vibration [mm/s]")
axes[1].set_ylabel("Oil pressure [MPa]")
axes[1].grid(True, alpha=.3)
fig.tight_layout()
plt.show()

png

No.051: Using Isolation Forest

Meaning in Practice

Isolation Forest considers points where features are isolated with few splits when randomly partitioned as anomalies. Because it does not assume a strict distribution of normal states, it is suitable for early PoCs that quickly extract candidates from complex regions created by multiple sensors.

Approach to Analysis and Modeling

If the average path length of point $x$ is $E[h(x)]$ and the criterion for average path length at sample size $n$ is $c(n)$ , the typical anomalies are as follows.

$s(x,n)=2^{-E[h(x)]/c(n)}$

The closer $s$ is to 1, the more likely it is to isolate. contamination=0.05 is the operational hypothesis that “about 5% is always abnormal,” and is not an estimated failure rate.

Check with Python

iso = IsolationForest(n_estimators=300, contamination=.05, random_state=SEED)
df["score_iso"] = -iso.fit(X_scaled).score_samples(X_scaled)
df["pred_iso"] = (iso.predict(X_scaled) == -1).astype(int)
display(df.nlargest(8, "score_iso")[["shot_id", *columns, "score_iso", "known_issue"]].round(3))

plt.figure(figsize=(8, 4.5))
plt.scatter(df["mold_temp_c"], df["vibration_mm_s"], c=df["score_iso"], cmap="viridis", s=22)
plt.colorbar(label="Isolation score")
plt.title("Isolation Forest anomaly score")
plt.xlabel("Mold temperature [C]")
plt.ylabel("Vibration [mm/s]")
plt.grid(True, alpha=.3)
plt.tight_layout()
plt.show()

	shot_id	mold_temp_c	vibration_mm_s	heater_current_a	oil_pressure_mpa	score_iso	known_issue
918	S0919	223.604	3.687	21.653	7.238	0.696	1
126	S0127	220.592	3.633	37.847	11.397	0.672	0
900	S0901	213.905	6.052	37.836	8.578	0.651	1
912	S0913	215.102	5.515	33.103	10.246	0.630	1
907	S0908	214.681	5.932	34.262	9.830	0.629	1
910	S0911	206.332	5.110	36.330	9.347	0.621	1
916	S0917	221.522	2.150	22.260	8.207	0.620	1
926	S0927	223.477	2.998	24.598	8.074	0.620	1

png

Reading the results

The upper ranks include shots with high vibration or those whose temperature-current relationship is far from the normal group. Since the overall score based solely on tree branching cannot determine the cause, the original sensor values from the top row are also recorded so that maintenance personnel can compare them with equipment history.

No.052: Using the Local Outlier Factor

Meaning in Practice

LOF evaluates ‘neglect compared to nearby operating points,’ rather than the overall evaluation. It is effective for finding shots that float only within a single driving group in sites with multiple normal groups depending on the type and load.

Approach to Analysis and Modeling

If the locally reachable density of point $p$ is $\mathrm{lrd}_k(p)$ , then LOF can be expressed as the density ratio to neighbors.

$\mathrm{LOF}_k(p)=\frac{1}{|N_k(p)|}\sum_{o\in N_k(p)}\frac{\mathrm{lrd}_k(o)}{\mathrm{lrd}_k(p)}$

If it’s roughly 1, it’s about the same as the neighborhood, and if it’s well greater than 1, it’s a local outlier. Sensitivity analysis is performed based on process continuity and lot size.

Check with Python

lof = LocalOutlierFactor(n_neighbors=25, contamination=.05)
df["pred_lof"] = (lof.fit_predict(X_scaled) == -1).astype(int)
df["score_lof"] = -lof.negative_outlier_factor_
display(df.nlargest(8, "score_lof")[["shot_id", *columns, "score_lof", "known_issue"]].round(3))

plt.figure(figsize=(8, 4.5))
plt.scatter(df["vibration_mm_s"], df["oil_pressure_mpa"], c=df["score_lof"], cmap="plasma", s=22)
plt.colorbar(label="LOF score")
plt.title("Local Outlier Factor score")
plt.xlabel("Vibration [mm/s]")
plt.ylabel("Oil pressure [MPa]")
plt.grid(True, alpha=.3)
plt.tight_layout()
plt.show()

	shot_id	mold_temp_c	vibration_mm_s	heater_current_a	oil_pressure_mpa	score_lof	known_issue
922	S0923	229.429	2.657	27.339	8.708	2.082	1
918	S0919	223.604	3.687	21.653	7.238	2.026	1
126	S0127	220.592	3.633	37.847	11.397	2.018	0
901	S0902	211.210	6.057	34.612	8.425	1.901	1
900	S0901	213.905	6.052	37.836	8.578	1.887	1
478	S0479	204.327	4.137	36.266	9.103	1.858	0
903	S0904	209.262	5.785	32.073	8.304	1.836	1
907	S0908	214.681	5.932	34.262	9.830	1.832	1

png

Reading the results

Candidates with high LOF density are those with a large difference in surrounding density. Since it is also easy to pick up the normal points at the boundary, check whether the ranking remains stable even when changing n_neighbors. Also, since LOF is generally suitable for outlier search within training data, a separate design using novelty=True is required for scoring new data.

No.053: Using One-Class SVM

Meaning in Practice

One-Class SVM learns boundaries surrounding the majority of conventional data. Using the RBF kernel, it is possible to represent nonlinear normal regions and detect relationship breakdowns that are difficult to detect with simple upper and lower limits.

Approach to Analysis and Modeling

We obtain a hyperplane that separates normal data from the origin in feature space. The conceptual optimization problem is as follows.

$\min_{w,\rho,\xi}\frac{1}{2}\|w\|^2+\frac{1}{\nu n}\sum_i\xi_i-\rho$

$\text{s.t. } w^\top\phi(x_i)\geq\rho-\xi_i,\quad \xi_i\geq0$

$\nu$ relates to the upper limit of the proportion of outbound points and the lower limit of the proportion of support vectors. Because it is sensitive to scale, standardization is essential.

Check with Python

ocsvm = OneClassSVM(kernel="rbf", gamma="scale", nu=.05)
df["score_ocsvm"] = -ocsvm.fit(X_scaled).decision_function(X_scaled)
df["pred_ocsvm"] = (ocsvm.predict(X_scaled) == -1).astype(int)
display(df.nlargest(8, "score_ocsvm")[["shot_id", *columns, "score_ocsvm", "known_issue"]].round(3))

plt.figure(figsize=(8, 4.5))
plt.hist(df.loc[df.known_issue.eq(0), "score_ocsvm"], bins=35, alpha=.65, label="audit: normal")
plt.hist(df.loc[df.known_issue.eq(1), "score_ocsvm"], bins=20, alpha=.65, label="audit: issue")
plt.axvline(0, color="black", linestyle="--", label="model boundary")
plt.title("One-Class SVM score distribution")
plt.xlabel("Anomaly score (higher = more anomalous)")
plt.ylabel("Shots")
plt.grid(True, alpha=.3)
plt.legend()
plt.tight_layout()
plt.show()

	shot_id	mold_temp_c	vibration_mm_s	heater_current_a	oil_pressure_mpa	score_ocsvm	known_issue
126	S0127	220.592	3.633	37.847	11.397	1.347	0
922	S0923	229.429	2.657	27.339	8.708	1.345	1
918	S0919	223.604	3.687	21.653	7.238	1.174	1
157	S0158	211.063	2.070	38.227	10.885	0.730	0
900	S0901	213.905	6.052	37.836	8.578	0.668	1
939	S0940	206.474	3.786	29.456	4.601	0.452	1
933	S0934	214.528	3.633	31.250	5.200	0.419	1
34	S0035	209.778	1.705	28.220	9.928	0.408	0

png

Reading the results

Score 0 is the model boundary, so the front side requires further confirmation. There is overlap in the distribution of normal and need-to-confirm in audits, and it is also clear that models alone cannot be completely separated. Be careful not to make the gamma too large, as the boundary will become finer and will react to normal fluctuations.

No.054: Using Elliptic Envelope

Meaning in Practice

Elliptic Envelope is suitable for processes where normal data is generally distributed in a single-peak, elliptical pattern. To account for covariance, even when temperature and current are within their respective ranges, it can detect states that deviate from normal correlation.

Approach to Analysis and Modeling

Mahalanobis distance using center $\mu$ and covariance matrix $\Sigma$

$D_M(x)=\sqrt{(x-\mu)^\top\Sigma^{-1}(x-\mu)}$

and points with large distances as abnormal candidates. In highly multimodal processes, the assumption of a single ellipse is broken.

Check with Python

ell = EllipticEnvelope(contamination=.05, random_state=SEED)
df["score_elliptic"] = -ell.fit(X_scaled).decision_function(X_scaled)
df["pred_elliptic"] = (ell.predict(X_scaled) == -1).astype(int)
display(df.nlargest(8, "score_elliptic")[["shot_id", *columns, "score_elliptic", "known_issue"]].round(3))

plt.figure(figsize=(8, 4.5))
plt.scatter(df["mold_temp_c"], df["heater_current_a"], c=df["score_elliptic"], cmap="cividis", s=22)
plt.colorbar(label="Robust distance score")
plt.title("Elliptic Envelope score")
plt.xlabel("Mold temperature [C]")
plt.ylabel("Heater current [A]")
plt.grid(True, alpha=.3)
plt.tight_layout()
plt.show()

	shot_id	mold_temp_c	vibration_mm_s	heater_current_a	oil_pressure_mpa	score_elliptic	known_issue
900	S0901	213.905	6.052	37.836	8.578	36.750	1
901	S0902	211.210	6.057	34.612	8.425	36.431	1
903	S0904	209.262	5.785	32.073	8.304	30.518	1
918	S0919	223.604	3.687	21.653	7.238	28.626	1
922	S0923	229.429	2.657	27.339	8.708	28.577	1
905	S0906	211.985	5.871	31.745	8.877	27.169	1
907	S0908	214.681	5.932	34.262	9.830	24.147	1
916	S0917	221.522	2.150	22.260	8.207	20.851	1

png

Reading the results

Candidates whose temperature and current combinations deviate from the usual band score high. While the assumptions are clear and easy to explain, if the focus is divided by product type, the model is divided by product type or alternative methods are considered.

No.055: Calculating Anomaly Using the k-Neighborhood Method

Meaning in Practice

k Neighborhood distance directly shows how close a similar past shot is. The algorithm is relatively transparent, making it easy to present similar shots to maintenance personnel.

Approach to Analysis and Modeling

The normalized point $x$ and the Euclidean distance near $x_{(k)}$ $k$ th are considered anomalies.

$s_k(x)=\|x-x_{(k)}\|_2$

When the $k$ is small, it is sensitive to local noise, and when large, it is easier to handle abnormalities even in small normal groups. Here, we use the 10th Nearest Neighbor Distance and consider the top 5% as candidates.

Check with Python

knn = NearestNeighbors(n_neighbors=11).fit(X_scaled)
distances, _ = knn.kneighbors(X_scaled)
df["score_knn"] = distances[:, -1]
knn_threshold = df["score_knn"].quantile(.95)
df["pred_knn"] = (df["score_knn"] >= knn_threshold).astype(int)
display(df.nlargest(8, "score_knn")[["shot_id", *columns, "score_knn", "known_issue"]].round(3))

sorted_score = np.sort(df["score_knn"])
plt.figure(figsize=(8, 4.5))
plt.plot(np.arange(1, len(df) + 1), sorted_score)
plt.axhline(knn_threshold, color="tab:red", linestyle="--", label="95th percentile")
plt.title("Sorted 10-nearest-neighbor distance")
plt.xlabel("Shots sorted by score")
plt.ylabel("10-NN distance")
plt.grid(True, alpha=.3)
plt.legend()
plt.tight_layout()
plt.show()

	shot_id	mold_temp_c	vibration_mm_s	heater_current_a	oil_pressure_mpa	score_knn	known_issue
922	S0923	229.429	2.657	27.339	8.708	3.021	1
918	S0919	223.604	3.687	21.653	7.238	2.670	1
900	S0901	213.905	6.052	37.836	8.578	2.457	1
126	S0127	220.592	3.633	37.847	11.397	2.433	0
910	S0911	206.332	5.110	36.330	9.347	2.355	1
903	S0904	209.262	5.785	32.073	8.304	2.189	1
912	S0913	215.102	5.515	33.103	10.246	2.164	1
911	S0912	210.178	5.224	30.045	10.242	2.156	1

png

Reading the results

The point where the distance suddenly increases at the far right is a candidate with few similar histories. While quantile thresholds make it easier to control the number of inspection items, they extract a certain number even if all processes are normal. First, it is positioned as the purpose of creating a candidate list.

No.056: Detecting Data Lost Through Clustering

Meaning in Practice

By using clustering, you can organize major operating states into groups and investigate points far from the center or extremely small groups. However, a small group does not necessarily mean abnormality; it may be a small variety or a legitimate operating condition right after setup.

Approach to Analysis and Modeling

There are mainly two ways to use it for anomaly detection.

Set the anomaly level as the distance from each point to the center of the affiliated cluster
Review clusters with small affiliation scores as rare operating conditions

Clustering is not a fault detector but a tool for organizing data structures. It is necessary to assign meanings including process conditions.

Check with Python

kmeans_review = KMeans(n_clusters=4, n_init=20, random_state=SEED).fit(X_scaled)
df["cluster_review"] = kmeans_review.labels_
cluster_review = df.groupby("cluster_review").agg(
    shots=("shot_id", "size"),
    issue_rate=("known_issue", "mean"),
    temp_mean=("mold_temp_c", "mean"),
    vibration_mean=("vibration_mm_s", "mean"),
    pressure_mean=("oil_pressure_mpa", "mean"),
).round(3)
display(cluster_review)

plt.figure(figsize=(8, 4.5))
for c in sorted(df["cluster_review"].unique()):
    part = df[df["cluster_review"].eq(c)]
    plt.scatter(part["vibration_mm_s"], part["oil_pressure_mpa"], s=22, alpha=.6, label=f"cluster {c}")
plt.title("Operating-state clusters")
plt.xlabel("Vibration [mm/s]")
plt.ylabel("Oil pressure [MPa]")
plt.grid(True, alpha=.3)
plt.legend()
plt.tight_layout()
plt.show()

	shots	issue_rate	temp_mean	vibration_mean	pressure_mean
cluster_review
0	213	0.038	207.104	1.957	6.738
1	211	0.066	212.647	3.125	9.144
2	254	0.071	213.386	2.451	7.632
3	262	0.000	207.592	2.367	8.339

png

Reading the results

By looking at the number of cases by cluster and the rate requiring audit confirmation, you can organize which driving groups should be prioritized for review. However, instead of making the group with a high confirmation rate the stop condition as is, we first check whether the product type, mold, and working conditions are uneven.

No.057: Extracting anomalous candidates with KMeans

Meaning in Practice

KMeans creates a representative driving center of gravity and extracts shots far from any center of gravity. Even if there are multiple steady operation modes, the distance from the overall average may match the actual conditions.

Approach to Analysis and Modeling

KMeans sum of squares within the cluster

$\sum_{i=1}^{n}\min_{j\in\{1,\ldots,K\}}\|x_i-\mu_j\|_2^2$

Minimize it. After learning, $s(x)=\min_j\|x-\mu_j\|_2$ is considered abnormal. The number of clusters $K$ and quantile thresholds are determined based on the number of operating modes and inspection capability.

Check with Python

kmeans = KMeans(n_clusters=4, n_init=20, random_state=SEED).fit(X_scaled)
distance_matrix = kmeans.transform(X_scaled)
df["score_kmeans"] = distance_matrix.min(axis=1)
kmeans_threshold = df["score_kmeans"].quantile(.95)
df["pred_kmeans"] = (df["score_kmeans"] >= kmeans_threshold).astype(int)
display(df.nlargest(8, "score_kmeans")[["shot_id", *columns, "score_kmeans", "known_issue"]].round(3))

plt.figure(figsize=(8, 4.5))
plt.scatter(df["mold_temp_c"], df["vibration_mm_s"], c=df["score_kmeans"], cmap="magma", s=22)
plt.colorbar(label="Distance to nearest centroid")
plt.title("KMeans distance-based anomaly score")
plt.xlabel("Mold temperature [C]")
plt.ylabel("Vibration [mm/s]")
plt.grid(True, alpha=.3)
plt.tight_layout()
plt.show()

	shot_id	mold_temp_c	vibration_mm_s	heater_current_a	oil_pressure_mpa	score_kmeans	known_issue
918	S0919	223.604	3.687	21.653	7.238	4.484	1
900	S0901	213.905	6.052	37.836	8.578	4.456	1
922	S0923	229.429	2.657	27.339	8.708	4.304	1
901	S0902	211.210	6.057	34.612	8.425	4.285	1
907	S0908	214.681	5.932	34.262	9.830	4.114	1
903	S0904	209.262	5.785	32.073	8.304	4.020	1
905	S0906	211.985	5.871	31.745	8.877	4.001	1
916	S0917	221.522	2.150	22.260	8.207	3.709	1

png

Reading the results

Recently, shots farther from the center of gravity have been ranked higher. Since the center of gravity is average, it is affected by outliers. In production, obvious sensor failures are excluded through pretreatment, and if the product composition changes, a reassessment of the center of gravity is necessary.

No.058: Detecting Noise Points with DBSCAN

Meaning in Practice

DBSCAN classifies clusters of sufficiently dense areas and judges them as noise if they do not belong to any densely packed area. It is characterized by the ability to handle non-spherical operating areas without pre-deciding on the number of clusters.

Approach to Analysis and Modeling

Points with min_samples or more points within radius $\varepsilon$ are considered core points, and density-reachable points are grouped into the same cluster. If the eps is too small, it triggers excessive alerts; if too large, abnormalities are absorbed into the normal group. Set at the standardized distance.

Check with Python

dbscan = DBSCAN(eps=.62, min_samples=12).fit(X_scaled)
df["dbscan_label"] = dbscan.labels_
df["pred_dbscan"] = (df["dbscan_label"] == -1).astype(int)
dbscan_summary = df.groupby("dbscan_label").agg(shots=("shot_id", "size"), issue_rate=("known_issue", "mean")).round(3)
display(dbscan_summary)

plt.figure(figsize=(8, 4.5))
plot_colors = np.where(df["pred_dbscan"].eq(1), "tab:red", "tab:blue")
plt.scatter(df["vibration_mm_s"], df["oil_pressure_mpa"], c=plot_colors, alpha=.6, s=22)
plt.title("DBSCAN noise detection (red = noise)")
plt.xlabel("Vibration [mm/s]")
plt.ylabel("Oil pressure [MPa]")
plt.grid(True, alpha=.3)
plt.tight_layout()
plt.show()

	shots	issue_rate
dbscan_label
-1	503	0.08
0	398	0.00
1	26	0.00
2	8	0.00
3	5	0.00

png

Reading the results

The red noise point is outside the dense normal area. DBSCAN does not return direct continuous scores and has high parameter sensitivity, allowing it to check whether the number of noise incidents meets the on-site inspection capacity and whether known rare normal operations are involved.

No.059: Comparing Anomaly Detection Results by Model

Meaning in Practice

Model selection compares not only accuracy but also the number of alerts, missed cases, agreement between models, and ease of explanation. When evaluation labels are limited, it is practical to prioritize auditing candidates commonly cited by multiple models rather than treating numerical rankings as absolute.

Approach to Analysis and Modeling

For audited data, we will check the following:

Manufacturing Anomaly Detection in Practice with Python | Eight Machine Learning Methods and Threshold Design

Capturing Early Signs in Injection Molding Equipment: Multivariate Anomaly Detection with 10 Exercises Using Machine Learning (No.051–No.060)

Overview

Introduction: Practical Challenges in Manufacturing Covered in This Article

Common situations on site

Why is this issue so difficult to judge?

Overview of Exercise covered this time

Preparing the Python environment

Creation of Fictional Data

No.051: Using Isolation Forest

Meaning in Practice

Approach to Analysis and Modeling

Check with Python

Reading the results

No.052: Using the Local Outlier Factor

Meaning in Practice

Approach to Analysis and Modeling

Check with Python

Reading the results

No.053: Using One-Class SVM

Meaning in Practice

Approach to Analysis and Modeling

Check with Python

Reading the results

No.054: Using Elliptic Envelope

Meaning in Practice

Approach to Analysis and Modeling

Check with Python

Reading the results

No.055: Calculating Anomaly Using the k-Neighborhood Method

Meaning in Practice

Approach to Analysis and Modeling

Check with Python

Reading the results

No.056: Detecting Data Lost Through Clustering

Meaning in Practice

Approach to Analysis and Modeling

Check with Python

Reading the results

No.057: Extracting anomalous candidates with KMeans

Meaning in Practice

Approach to Analysis and Modeling

Check with Python

Reading the results

No.058: Detecting Noise Points with DBSCAN

Meaning in Practice

Approach to Analysis and Modeling

Check with Python

Reading the results

No.059: Comparing Anomaly Detection Results by Model

Meaning in Practice

Approach to Analysis and Modeling

Related Posts

Bringing Abnormality Detection in Manufacturing to Production | 10 Practical Practices for Model Storage, API, and Degradation Monitoring

Using Abnormality Detection in Manufacturing Industry in Practice | 10 Exercise-On Design for Evaluation Indicators, Thresholds, and Alerts

Implementing Abnormality Detection in Manufacturing with Autoencoder | Python Explanation of Reconstruction Errors, Thresholds, and Time Series

Introduction to Multivariate Anomaly Detection in Manufacturing | Practicing PCA and Mahala Novis Distances with Python

Introduction to Sensor Data Anomaly Detection in Manufacturing | Practical Changes in Sudden Changes, Sticking, and Relationship Breakdown Using Python