Breaking the Homogeneity Assumption: Specialized Multi-Generator Adversarial Learning for Rare Failure Detection in Predictive Maintenance

In plain words

Industrial machines fail rarely, so a model trained on their sensor logs sees very few failure examples and can learn to answer "normal" almost every time. The usual fixes either reweight the rare cases, throw away normal cases, or create new failure examples by blending existing ones. The authors suspect that a failure is not one kind of event: different breakdowns come from different physical causes and look different in the sensor data. A single fake-failure generator tries to imitate all of them at once and can miss some.

The paper's idea is to train a separate generative model for each failure type. Each one learns only its own kind of failure, and their outputs are combined into one larger training set. The authors compare this against four simpler ways of handling the imbalance, using one public predictive-maintenance dataset and two standard classifiers. The method gives the best precision-recall score in their tests, but it costs far more compute than the simpler methods.

TL;DR

• Task: binary machine-failure prediction on the AI4I 2020 dataset, where failures are rare §3.1. Five imbalance-handling scenarios are compared with a Random Forest and an RBF SVM §3.2 §3.4.1.
• Best reported setting: four per-failure-type WGAN-GP generators, pooled, with a Random Forest. PR-AUC 0.8574, recall 0.8824, precision 0.5696 tab. 4.
• Cost: the single-GAN scenario took about 11 h 20 min and the multi-GAN scenario about 14 h 5 min, against minutes for the classical scenarios §5.1.
• Caveats: one run per configuration, shallow tuning grids for the classifiers, one dataset, and several internal inconsistencies (see Pitfalls). Treat the gain as a promising experiment, not a settled result.

Problem

Failure events are rare and have a disproportionate operational cost, so accuracy is misleading and the paper uses precision-recall measures instead §1 §3.4.2. The authors argue that standard imbalance methods assume the minority class is one homogeneous group §1:

• Random undersampling discards majority rows that may be informative §3.2.2.
• SMOTE interpolates between minority neighbours, which can add noise or blur the decision boundary, and the paper notes it is blind to the majority class during interpolation §3.2.3.
• Cost-sensitive learning reweights errors but may not give a well-defined boundary when the minority is sparse §3.2.1.
• A single GAN trained on all failures may neglect rare failure modes or collapse onto common ones §3.2.4 tab. 2.

The paper's hypothesis is that generators specialised per failure type give a more faithful picture of each failure mode §3.2.5.

Method

The pipeline has four parts: preprocessing and splitting §3.1, five sampling scenarios §3.2, the GAN and its tuning §3.3, and classifiers with metrics §3.4. No algorithm box is given in the paper; the pseudocode below is a restatement of §3.2.5 and §3.3.

Preprocessing and splitting §3.1

1. Drop the unique identifiers UDI and Product_ID §3.1.
2. Add Temperature_difference_C = Process temperature minus Air temperature §3.1.
3. Ordinal-encode Type from L, M, H to ordered integers (the text gives 0, 1, 2 as an example) §3.1.
4. Convert temperatures from Kelvin to Celsius; the paper states this is linear and adds no information §3.1.
5. Standardise numeric features with a StandardScaler inside a ColumnTransformer, fitted on training folds only §3.1.
6. Split 70 / 15 / 15 into train, validation and test, stratified on Target. Validation is used only for GAN tuning; the test set is used once, for the final evaluation §3.1.

The dataset has 10,000 rows, 14 columns, no missing values, and a failure rate the text gives as about 3.4% §3.1 tab. 1.

Sampling scenarios §3.2

All resampling and augmentation is applied only to the training partition of each cross-validation fold §3.2.

1. Baseline (cost-sensitive). No resampling. class_weight='balanced' on the Random Forest and the SVM §3.2.1.
2. Random undersampling (RUS). imbalanced-learn RandomUnderSampler with sampling_strategy='auto', giving a 1:1 ratio, inside an ImbPipeline §3.2.2.
3. SMOTE. imbalanced-learn SMOTE with sampling_strategy='auto' and k_neighbors=5 (library default), inside an ImbPipeline §3.2.3.
4. Single GAN. One WGAN-GP trained on all failure rows of the training data, with hyperparameters tuned by Optuna §3.2.4 §5.1.
5. Multi GAN. Failure rows are partitioned by failure type (HDF, PWF, OSF, TWF). One WGAN-GP is trained per type, each with its own Optuna study. Synthetic samples are drawn from each expert in proportion to its size and the samples are pooled §3.2.5.

# Multi-GAN oversampling for one training fold  [§3.2.5] [§3.3.2]
# Input:  train_X (N, d), train_y (N,), failure_type (N_fail,)
# Output: augmented_X (M, d), augmented_y (M,)

def multi_gan_oversample(train_X, train_y, failure_type):
    # Group the failure rows by type: HDF, PWF, OSF, TWF  [§3.2.5]
    groups = split_by_type(train_X[train_y == 1], failure_type)
    synthetic_X = []
    for group in groups:
        # Tune this type's WGAN-GP with Optuna, objective PR-AUC  [§3.3.2]
        params = optuna_tune(group, train_X, train_y)
        generator = fit_wgan_gp(group, params)  # [§3.3.1]
        # Draw candidates and keep those the adversarial filter accepts  [§3.3.1]
        # The candidate count per expert is not stated  [§3.2.5]
        candidates = generator.sample(count_for(group))
        synthetic_X.append(adversarial_filter(candidates, group))
    # Pool the synthetic failures from all experts  [§3.2.5]
    augmented_X = concat(train_X, concat(synthetic_X))
    augmented_y = concat(train_y, ones(total_size(synthetic_X)))
    return augmented_X, augmented_y

GAN architecture §3.3.1

• The generator and critic come from the tabgan library, a conditional tabular GAN in the CTGAN family with a Wasserstein-GP backbone §3.3.1 [ref. 8] [ref. 42].
• The gradient penalty enforces a soft Lipschitz constraint on the critic §3.3.1.
• Continuous columns use mode-specific normalisation. Categorical columns are generated with the Gumbel-Softmax reparameterisation §3.3.1.
• Adversarial filter: a separate classifier, LightGBM by default, is trained to separate synthetic from real rows. Only synthetic rows it labels as real with high confidence are kept §3.3.1.

Hyperparameter tuning §3.3.2

Optuna's TPE sampler maximises PR-AUC of a Random Forest evaluated on the validation split §3.3.2 fig. 4. Each trial follows seven steps: propose hyperparameters, train the GAN(s), generate synthetic minority samples, augment the training data, train a lightweight Random Forest, score PR-AUC on validation, and return the score to Optuna §3.3.2.

Hyperparameters

Results

Author-reported, one run per configuration, on the held-out test split. Classifiers are a Random Forest and an RBF SVM §3.4.1. The full table is tab. 4; the rows below are the main ones.

Headline claims, in the paper's own terms:

• Multi GAN with RF gives the highest PR-AUC of all scenarios, 0.8574, against 0.835 for the RF baseline and 0.8245 for the single GAN §4.1 tab. 4 fig. 11.
• Relative to the RF baseline, multi-GAN raises recall from 0.5882 to 0.8824, at a precision of 0.5696 tab. 4. The paper describes this as identifying nearly 30% more of the actual failures §4.1.
• The RF baseline has the best precision (1.0) but misses about 41% of failures (recall 0.5882) §4.1 tab. 4.
• Random undersampling lifts recall to 0.921 but precision falls to about 0.22 §4.1 fig. 6.
• The single-GAN scenario is described as close to the baseline, not a decisive improvement §4.1.
• Across scenarios, the paper reports the t-SNE view of synthetic failures sitting in the same clusters as the real failure types for the multi-GAN case; this is qualitative only §4.2 fig. 13 fig. 14.

Figures 5 to 9 show confusion matrices, ROC and precision-recall curves for the RF baselines and each scenario fig. 5 fig. 6 fig. 7 fig. 8 fig. 9. Figures 10 to 12 plot precision and recall, PR-AUC and F1 for each scenario fig. 10 fig. 11 fig. 12.

Paper vs code

No official code. No repository link appears in the paper body or references, and the arXiv metadata has none. I searched the GitHub repository API for "multi-generator gan" (11 hits, none owned by an author), "Lazanas predictive maintenance" (0 hits) and "AI4I 2020 gan failure" (0 hits), and "predictive maintenance wgan-gp optuna" (0 hits). None of the hits belongs to the authors or matches this method. The paper's reference [49] is by A. Lazanas on an unrelated topic and does not link code.

Pitfalls

• Internal inconsistencies in the paper. Treat these as reading errors until resolved:
  • Section 4.1 calls the multi-GAN F1 (0.6923) the highest among all conditions, but the baseline RF F1 in tab. 4 is 0.740. The same section later says multi-GAN F1 is slightly lower than the baseline. Use the table, not the sentence.
  • RUS RF precision is 0.2156 in the text and 0.216 in fig. 10. The rendered table cell is hard to read.
  • SMOTE RF PR-AUC is 0.7522 in the text and 0.7525 in tab. 4.
  • Baseline RF PR-AUC is 0.835 in tab. 4 and 0.836 in fig. 11.
  • The failure rate is described as about 3.4% §3.1, but the Target mean in tab. 1 is 0.033.
  • The rows labelled "Wide RF grid" in tab. 4 for the baseline and RUS have values nearly identical to the SVM rows, which looks like a labelling or copy error. The text does not explain them.
• Recall claim is scenario-specific. The abstract says the multi-GAN gives higher recall than resampling and single-GAN methods. The SVM baseline recall (0.9412) is higher than the multi-GAN recall (0.8824) tab. 4.
• Single run, single seed. The Optuna sampler uses seed 42 and there are no repeats, variances or significance tests. The gap between 0.857 and 0.835 PR-AUC may be within run-to-run noise; the paper does not test it.
• Shared tuning for both classifiers. The GAN objective is the RF's PR-AUC on validation. The paper does not say whether the SVM scenarios use the same tuned GANs or re-tune them. Do not assume either.
• Unstated counts. The number of CV folds, the number of synthetic samples per scenario, the rule that sets per-expert sample counts in the multi GAN, and the Optuna trials per expert are not stated. The discussion mentions a "12 candidate" cross-validated grid for the multi GAN, but the meaning is not explained §5.1.
• Ordinal encoding. The paper says Type is encoded in the order L < M < H, but it does not state how the category order is passed to the encoder. Set it explicitly; do not rely on a default sort order.
• Scaling and GAN input. StandardScaler is fitted on training folds §3.1, but the text does not say whether the GANs are trained on scaled or raw features. The scaled space is the one the classifiers see, so check this before reimplementing.
• Expensive and hard to reproduce. The single-GAN scenario took about 11 h 20 min and the multi-GAN about 14 h 5 min, with hardware not stated §5.1. An auxiliary deeper Random Forest grid crashed the system, and the authors say a deeper search might not change the conclusions, without numbers §5.2.
• Classifier tuning is shallow. RF and SVM were tuned on shallow grids, so the baseline comparison may understate the classical methods §5.2.
• Adversarial filter defaults. The filter uses LightGBM "by default" §3.3.1. Whether the paper's configuration deviates from the library default is not stated.

Lineage

• Builds on: WGAN-GP for stable adversarial training §3.3.1 [ref. 25]; the tabgan library and CTGAN-style conditioning §3.3.1 [ref. 8] [ref. 42]; SMOTE §3.2.3 [ref. 13].
• Compared against: cost-sensitive learning (class weights), random undersampling, SMOTE, and a single WGAN-GP over all failures §3.2.
• Superseded by: not known from this wiki.