AI-based Modeling and Data-driven Evaluation for Smart Manufacturing Processes

In plain words

Factories that make chips record hundreds of sensor readings for every wafer they produce, and only a few wafers fail. The problem is to find which of those readings actually matter for predicting a failure, so engineers can see the likely causes and the model does not drown in noise.

The paper treats this as a search. It starts with many random guesses, each being a yes-or-no choice for every sensor. Each guess is scored by training a small neural network on the chosen sensors and measuring its error, with a penalty for every sensor kept. Good guesses are mixed and slightly changed to create new guesses, and the best ones survive into the next round. The same idea is in the spirit of nature's selection, which is where the genetic algorithm name comes from.

Before the search, the data are cleaned: unusual rows are removed using a distance measure, and the rare failure cases are multiplied with a synthetic-sample method so the classifier sees enough of them. The authors report that the features chosen this way let a classifier predict better on held-out data than several standard ways of choosing features.

TL;DR

• A binary genetic algorithm chooses which input features to keep for a semiconductor failure classifier §4 alg. 1.
• Each candidate subset is scored by the error of a small MLP fitted on it, multiplied by a penalty per kept feature §4.1 eq. 5.
• Author-reported on SECOM: 36 features, 93.7% train and 90.2% test accuracy, versus 41.5% to 81.5% test accuracy for ten baseline feature methods tab. 2.
• Many details that an implementer needs are not stated: the split, the penalty weight, the number of iterations, the mutation operator and the crossover probabilities.

Problem

Semiconductor production logs many sensor and process measurements per wafer, and failures are rare. The data have 590 features, with missing values, noise and outliers, and only 104 failure cases §3 §3.2. The paper argues that common approaches (PCA-based projection, KNN, and filter or embedded selection) either lose interpretability, ignore dependencies between features, or are unstable §2 §5.1. It wants a method that keeps the original features so the chosen sensors can be read by an engineer §3.3.

Method

The pipeline has three stages.

1. Data cleaning §3 §3.1. Each observation is scored by its squared Mahalanobis distance from the mean, using the sample covariance of all features eq. 3 eq. 4. Observations above a threshold are removed. The text sets the threshold from a chi-squared quantile, given as an example of the 97.5% quantile, but the mapping between the confidence level α and the cut-off is not clearly stated (see Pitfalls).

2. Imbalance handling §3.2. The failure class is oversampled with a density-based SMOTE variant, DBSMOTE §3.2. The paper also says misclassifying a defective product should cost more than the reverse §1, but no cost value is given.

3. Feature selection with GA and an MLP §4 alg. 1 app. A.

• A solution is a binary vector of length m, where 1 means the feature is kept §4.
• The initial population is random and each member is scored by the cost function alg. 1.
• Parents are drawn with Boltzmann-weighted roulette selection. The weight of an individual is exp(-β·J_i), normalised over the population §4. Algorithm 1 instead divides each cost by the largest cost before applying the same weight alg. 1.
• The paper picks β so that the half of the population with the lowest costs holds 70% of the selection probability mass §4. Solving for β is therefore a one-dimensional root search, not a published value.
• Offspring come from crossover. The text names single-point, multi-point and uniform crossover §4 app. A, chosen at random with probabilities that are not stated alg. 1.
• Mutants come from one roulette-selected parent alg. 1. The mutation operator itself is not described.
• The new population is the old population plus offspring plus mutants, sorted by cost, and truncated to the population size alg. 1.
• The cost of a subset is the MSE of an MLP trained on that subset, multiplied by (1 + Ω·|X'|) §4.1 eq. 5. The MLP has one hidden layer of 15 neurons and is trained with Levenberg-Marquardt §4.1. The authors say they chose the neuron count by trial and error §5.2.

The final classifier is trained on the selected features. Among six classifiers, Gaussian SVM is picked by its positive predictive value on the success class and its false discovery rate on the failure class §5.2 tab. 1.

The GA loop, reconstructed from Algorithm 1 alg. 1 and the text §4 §4.1:

# Binary GA feature selection with an MLP cost  [alg. 1]
# Input:  m features; cost J(mask); population size P; iterations T
# Output: best feature mask, a bit vector of length m

def select_features(m, J, P, T, theta, mu, beta):
    # 1. Random initial population, scored and sorted by cost  [alg. 1]
    population = random_bit_masks(P, m)
    costs = [J(mask) for mask in population]
    population, costs = sort_by_cost(population, costs)

    for iteration in range(T):
        # 2. Offspring and mutant counts from theta and mu  [alg. 1]
        #    (exact formula for eta_c and eta_m not stated)
        n_offspring = count_from(theta, P)
        n_mutants = count_from(mu, P)

        # 3. Selection weights: Boltzmann on costs  [§4] [alg. 1]
        #    (the scaling by the largest cost is from alg. 1 only)
        weights = boltzmann(costs / max(costs), beta)

        # 4. Crossover: roulette-pick two parents, make two children  [alg. 1]
        offspring = []
        offspring_costs = []
        for i in range(n_offspring):
            parent_a, parent_b = roulette(population, weights, 2)
            child_1, child_2 = crossover(parent_a, parent_b)  # [§4]
            offspring += [child_1, child_2]
            offspring_costs += [J(child_1), J(child_2)]

        # 5. Mutation: roulette-pick one parent, flip bits  [alg. 1]
        #    (mutation operator not described in the paper)
        mutants = []
        mutant_costs = []
        for i in range(n_mutants):
            parent = roulette(population, weights, 1)
            mutant = mutate(parent)
            mutants.append(mutant)
            mutant_costs.append(J(mutant))

        # 6. Merge, sort, keep the best P  [alg. 1]
        population = population + offspring + mutants
        costs = costs + offspring_costs + mutant_costs
        population, costs = sort_by_cost(population, costs)
        population = population[:P]
        costs = costs[:P]

    # 7. Return the best individual  [alg. 1]
    return population[0]

Hyperparameters

Cost function, as printed eq. 5:

J = \epsilon \times (1 + \Omega \times |X'|) eq. 5

Here ε is the MSE of the MLP and |X'| is the number of selected features.

Results

Author-reported. Setup: SECOM dataset (590 features, 104 failures), an MLP-based GA cost, and the stated baselines §5 tab. 2. No confidence intervals or repeated runs are reported.

Classifier choice tab. 1. Positive predictive value for the success class and false discovery rate for the failure class:

Feature selection comparison tab. 2. Selected features, train and test accuracy (%):

The text reports "over 90%" for the proposed model §5.3. The paper also shows cost versus function evaluations fig. 4, ROC curves for six classifiers fig. 5, the Lasso coefficient paths fig. 6, and ROC comparisons against PCA and Lasso fig. 7. These are described in the text, not reproduced here.

Paper vs code

No official code. The LaTeX source and the abstract contain no code or project link. A GitHub repository search by SECOM and feature-selection keywords returned only unrelated student or course projects, and a search on the author name returned nothing. A general web search for the paper title was not run in this session because the tool was not permitted. No discrepancies between paper and code can be checked.

Pitfalls

• Maximise or minimise. §4.1 says the cost is maximised and then says that this is minimising MSE. The cost is minimised eq. 5, and the wording should be read that way.
• Selection probability conflict. §4 says the wheel pies are proportional to cost, which would favour high-cost individuals, but the same section's probability formula favours low cost. Use the formula. Algorithm 1 also divides by the largest cost before exponentiating, which changes the meaning of β. Pick one form and solve β for the 0.7 target under that form.
• Stated mechanisms that are not described. §1 names a "hybrid roulette-tournament" pick operator, but §4 and Algorithm 1 use roulette only. No tournament procedure is given.
• Mutation is undefined. The paper says a mutation operator avoids premature convergence but never says how bits are flipped or at what rate per bit.
• Crossover mechanics. Single-point and multi-point crossover are described in words, and the uniform mask example is ξ = {1,1,0,0,0,1,…,0,0,1} §4. The probability of each operator is not stated.
• Outlier threshold. The text gives D > α² as the rule but then says a chi-squared quantile is considered. The degrees of freedom and whether α or the quantile is squared are not stated. The covariance is m × m with m = 590, so it can be singular unless the sample is much larger than 590. No regularisation is mentioned. The number of rows removed is not reported.
• Target encoding. The label is "encoded as 0 and 1" but the mapping is not given. The outputs of the MLP and the metrics depend on this choice.
• Cost is expensive. Every offspring and mutant needs a full MLP training run to get its cost alg. 1. The number of function evaluations per iteration grows with both rates and the population size. The paper gives no wall-clock times.
• Penalty weight. Ω sets the trade-off between error and feature count, and it is not stated. Eq. 5 with a large Ω drops almost all features, and with Ω = 0 all features are kept §4.1.
• Train and test leakage risk. The train and test split, and whether the cost MLP sees the test rows, are not stated. Table 2 reports both train and test accuracy, but the test rows may have been used for the GA's cost, which would bias the test result.
• Oversampling before the split. The paper oversamples the failure class and removes outliers before feature selection §3. If this happened before splitting, the test scores are optimistic. Order is not stated.
• "Adaptive" and "dynamic" are not defined. The text calls the GA adaptive, but no rule changes θ, μ or β during the run. The adaptive setting is therefore not reproducible from the paper.
• Single-objective scalarisation. The "multi-objective" framing reduces to one weighted cost eq. 5. The authors list dominance-based multi-objective methods as future work §6.
• Classifier metric mismatch. §5.2 describes selection by accuracy, but Table 1 reports PPV and FDR. The features used for Table 1 are not stated.
• Dataset provenance. SECOM is named but neither cited nor linked, and the data are not described beyond the feature count and failure count.

Lineage

• Builds on: none cited as a card in this wiki. The paper relies on DBSMOTE §3.2, Boltzmann selection §4 and binary GA feature selection §2.
• Compared against: Lasso, PCA, univariate FWE, FDR, select-percentile, SFS, SBS, filtration feature selection, correlation-based selection and an ensemble tab. 2 §5.3.
• Superseded by: not known from content already in this wiki.