A cross-process welding penetration status prediction algorithm based on unsupervised domain adaptation in laser and TIG welding

Overview§

This paper addresses the domain shift problem in welding penetration state classification when transferring models between different welding processes (TIG vs. laser). The authors propose an unsupervised domain adaptation (UDA) framework enhanced by a gradual source domain expansion (GSDE) strategy, enabling cross-process transfer without target labels. The method achieves high accuracy in both same-process (90.65% on TIGFH, 90.72% on LSPS) and cross-process (80.48% TIG→Laser, 81.13% Laser→TIG) settings, significantly outperforming supervised baselines.

Methodology§

Unsupervised Domain Adaptation§

A standard adversarial UDA approach is adopted, consisting of:

• A feature extractor $G$ (CNN backbone) that maps input images to feature space.
• A label classifier $C$ that predicts weld penetration states (e.g., incomplete, partial, full).
• A domain classifier $D$ that distinguishes source vs. target domains.

Training minimizes:

• Classification loss on source data: $$\mathcal{L}_c = \frac{1}{N_s} \sum_{i=1}^{N_s} \ell(C(G(x_i^s)), y_i^s)$$
• Domain adversarial loss via gradient reversal layer (GRL) to make $G$ produce domain-invariant features:

$$\mathcal{L}_d = -\frac{1}{N_s+N_t} \sum_{j=1}^{N_s+N_t} [d_j \log D(G(x_j)) + (1-d_j) \log(1-D(G(x_j)))]$$ Overall objective: $$\mathcal{L} = \mathcal{L}_c + \lambda \mathcal{L}_d$$

Gradual Source Domain Expansion (GSDE)§

To further align domains, GSDE iteratively expands the source domain by incorporating high-confidence target samples with pseudo-labels. Steps: 1. Train UDA model on original source $\mathcal{D}_s$ and all target $\mathcal{D}_t$. 2. Predict pseudo-labels for $\mathcal{D}_t$; select samples with confidence > threshold $\tau$. 3. Add selected target samples to source set: $\mathcal{D}_s \leftarrow \mathcal{D}_s \cup \{(x_t, \hat{y}_t)\}$. 4. Retrain model on expanded source (with real labels) and remaining target (unlabeled). 5. Repeat for $K$ rounds.

Implementation Details§

• Datasets: TIGFH (TIG welding) and LSPS (laser welding) with three penetration states: incomplete, partial, full.
• Network: Custom CNN architecture (likely ResNet-18 or simpler) with GRL before domain classifier.
• Training: Batch size 32, Adam optimizer, learning rate 1e-4, $\lambda=0.1$, $\tau=0.9$, $K=5$.
• Evaluation: Accuracy on target domain with true labels.

Code Snippet (PyTorch-style)§

import torch
import torch.nn as nn
from torch.autograd import Function

class GradientReversalLayer(Function):
    @staticmethod
    def forward(ctx, x, alpha):
        ctx.alpha = alpha
        return x.view_as(x)
    @staticmethod
    def backward(ctx, grad_output):
        return -ctx.alpha * grad_output, None

class FeatureExtractor(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 32, 3, 1), nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, 1), nn.ReLU(),
            nn.AdaptiveAvgPool2d(1)
        )
    def forward(self, x):
        return self.conv(x).view(x.size(0), -1)

class LabelClassifier(nn.Module):
    def __init__(self, num_classes=3):
        super().__init__()
        self.fc = nn.Linear(64, num_classes)
    def forward(self, x):
        return self.fc(x)

class DomainClassifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Sequential(
            nn.Linear(64, 32), nn.ReLU(),
            nn.Linear(32, 2)
        )
    def forward(self, x):
        return self.fc(x)

# Training loop (simplified)
model = FeatureExtractor()
label_clf = LabelClassifier()
domain_clf = DomainClassifier()
optimizer = torch.optim.Adam(list(model.parameters()) + list(label_clf.parameters()) + list(domain_clf.parameters()), lr=1e-4)

for epoch in range(num_epochs):
    for (xs, ys), (xt, _) in zip(source_loader, target_loader):
        batch_size = xs.size(0)
        # source and target features
        fs = model(xs)
        ft = model(xt)
        # label loss on source
        label_logits = label_clf(fs)
        loss_c = nn.CrossEntropyLoss()(label_logits, ys)
        # domain loss
        combined_features = torch.cat([fs, ft], dim=0)
        domain_labels = torch.cat([torch.zeros(batch_size, dtype=torch.long), torch.ones(batch_size, dtype=torch.long)])
        # gradient reversal
        alpha = 0.1
        reversed_features = GradientReversalLayer.apply(combined_features, alpha)
        domain_logits = domain_clf(reversed_features)
        loss_d = nn.CrossEntropyLoss()(domain_logits, domain_labels)
        # total loss
        loss = loss_c + 0.1 * loss_d
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Key Results§

• Same-process: Outperforms supervised baseline by >35% (e.g., 90.65% vs 54.82% on TIGFH).
• Cross-process: Achieves ~80% accuracy, improving by >43% over baseline.
• UMAP visualizations confirm domain-invariant feature learning with clear class separation.

Conclusion§

The UDA + GSDE framework effectively enables cross-process weld penetration monitoring, drastically reducing the need for labeled data in new welding processes.