# 🏆 9th Place Solution - Synthetic Image Attribution

Thank You!
First, I would like to thank the organizers for creating such an enjoyable and educational competition.
At the beginning, I approached this challenge as a standard image classification problem. My initial assumption was that selecting a strong architecture and training it well would be enough to achieve competitive performance.
However, after studying the competition setup more closely, it became clear that the real challenge was not simply recognizing generator-specific patterns. The challenge was recognizing those patterns after the images had been compressed, resized, cropped, blurred, rotated, or otherwise modified.
This changed how I approached the competition.
Instead of focusing primarily on model architecture, I focused on making the training data resemble the hidden test conditions as closely as possible.
That decision ultimately became the foundation of my entire solution.
Summary
My final solution achieved:
Metric
Score
Public LB
0.987333
Private LB
0.990000
Final Rank
9 / 92
The solution combined:
EfficientNet-B4
ConvNeXt-Tiny
Post-processing simulation
MixUp augmentation
Label smoothing
Horizontal Flip TTA
Weighted soft-voting
One practical constraint throughout the competition was hardware availability. Rather than relying on extremely large models, I focused on maximizing performance through robust training strategies, realistic post-processing simulation, and complementary CNN architectures.
This ultimately proved more valuable than simply increasing model size and allowed me to achieve a Top 10 finish using computationally efficient backbones.
Solution Pipeline
Training Images
        ↓
Post-Processing Simulation
        ↓
EfficientNet-B4 Training
        ↓
ConvNeXt-Tiny Training
        ↓
Horizontal Flip TTA
        ↓
Weighted Soft Voting
        ↓
Final Predictions
Understanding the Challenge
One observation quickly became apparent:
The training images were relatively clean, but the hidden test images were intentionally degraded through various post-processing operations.
These included:
JPEG compression
WebP compression
Cropping
Resizing
Rotation
Brightness and contrast adjustment
Gaussian blur
Grayscale conversion
Super-resolution
A model trained exclusively on clean images could easily learn shortcuts that disappear after these transformations.
Instead of learning fragile pixel-level patterns, the model needed to learn generator-specific characteristics that remained stable after repeated image manipulations.
This realization ultimately shaped the entire training pipeline.
EfficientNet-B4 Baseline
My first competitive model was
EfficientNet-B4
.
The model was trained using:
Input size: 384×384
AdamW
Label smoothing (0.1)
MixUp (α = 0.2)
Cosine Annealing Warm Restarts
Results
Validation Accuracy:
98.36%
Test Accuracy:
98.07%
Public LB:
0.981333
Private LB:
0.979333
![](assets/91a4793aa197887ab58c5ef9.png)
One encouraging sign was the small gap between validation and testing performance. This suggested that the augmentation strategy was helping the model generalize rather than simply memorize training samples.
![](assets/3676d719dbf4fef98c9a2a17.png)
Most mistakes occurred between
Stable Diffusion 3
and
Stable Diffusion 3.5
, which was not particularly surprising given their architectural similarity and overlapping visual characteristics.
Why I Added ConvNeXt
Although EfficientNet-B4 was already performing well, I wanted to determine whether a different architecture could learn complementary representations from the same data.
Rather than changing the augmentation pipeline, I kept everything identical and replaced only the backbone.
This allowed me to isolate the effect of architecture.
ConvNeXt-Tiny Results
Validation Accuracy:
99.21%
![](assets/11fe23db86b4f800d97ace5f.png)
Interestingly, ConvNeXt-Tiny achieved a higher validation accuracy than EfficientNet-B4 despite using the exact same preprocessing and augmentation pipeline.
This suggested that the training strategy generalized effectively across architectures and that ConvNeXt was capturing information not fully represented by EfficientNet-B4.
What Contributed Most to Performance?
Throughout the competition, I experimented with different architectures and ensemble configurations.
One of the most important observations was that the largest improvements did not come from increasing model complexity.
They came from improving robustness.
1. Post-Processing Simulation (Largest Contribution)
The biggest breakthrough came when I stopped treating the problem as a standard image classification task and started treating it as a robustness problem.
The hidden test images were intentionally modified through compression, resizing, blurring, and other transformations. As a result, models trained only on clean images risked learning shortcuts that would disappear during evaluation.
To bridge this gap, I created a post-processing simulator that exposed the models to realistic image degradations throughout training:
operations = [
    ('jpeg', lambda x: self.apply_jpeg_compression(x)),
    ('webp', lambda x: self.apply_webp_compression(x)),
    ('crop', lambda x: self.apply_random_crop(x)),
    ('resize', lambda x: self.apply_resizing(x)),
    ('rotate', lambda x: self.apply_rotation_crop(x)),
    ('blur', lambda x: self.apply_blur(x)),
    ('brightness', lambda x: self.apply_brightness_contrast(x)),
    ('grayscale', lambda x: self.apply_grayscale(x)),
    ('superres', lambda x: self.apply_super_resolution(x)),
]

num_ops = np.random.randint(1, 3)
selected = np.random.choice(len(operations), num_ops, replace=False)

for idx in selected:
    _, op_func = operations[idx]
    img = op_func(img)
By repeatedly exposing the models to transformed versions of the same image, they were forced to learn generator-specific fingerprints that remained stable across image degradations.
Looking back, this ended up being the most important part of the solution.
2. MixUp and Label Smoothing
To further improve generalization, I combined MixUp augmentation and label smoothing.
MixUp
def mixup_data(x, y, alpha=0.2):
    lam = np.random.beta(alpha, alpha)

    index = torch.randperm(x.size(0)).to(x.device)

    mixed_x = lam * x + (1 - lam) * x[index]

    y_a, y_b = y, y[index]

    return mixed_x, y_a, y_b, lam
Label Smoothing
criterion = nn.CrossEntropyLoss(
    label_smoothing=0.1
)
These techniques improved generalization, reduced overconfidence, and helped the models distinguish visually similar generators.
3. Test-Time Augmentation (TTA)
During inference, I used horizontal flip test-time augmentation.
Predictions from the original image and its horizontally flipped version were averaged before generating the final prediction.
def predict_with_tta(model, images):
    outputs = model(images)

    outputs_flip = model(
        torch.flip(images, dims=[3])
    )

    return (outputs + outputs_flip) / 2
While the improvement was modest compared to post-processing simulation, TTA consistently produced more stable predictions and provided a useful boost to the final ensemble.
Ensemble Strategy
After establishing strong individual models, I explored combining EfficientNet-B4 and ConvNeXt-Tiny through weighted soft-voting.
Although both models were CNN-based architectures, they learned different representations of the data and produced slightly different prediction patterns.
Several weight combinations were evaluated:
EfficientNet-B4
ConvNeXt-Tiny
Validation Accuracy
0.7
0.3
99.07%
0.6
0.4
99.21%
0.5
0.5
99.29%
0.4
0.6
99.36%
0.3
0.7
99.36%
The final ensemble used:
EfficientNet-B4: 30%
ConvNeXt-Tiny: 70%
ensemble_out = (
    0.30 * efficientnet_output +
    0.70 * convnext_output
)
Final Ensemble Results
Validation Accuracy:
99.36%
Public LB:
0.987333
Private LB:
0.990000
The ensemble consistently outperformed both individual models and proved more stable across validation and leaderboard evaluations.
Leaderboard Progression
Version
Model
Public LB
Private LB
V4
EfficientNet-B4
0.981333
0.979333
V5
Initial Ensemble
0.982666
0.988000
V6
EfficientNet-B4 + ConvNeXt-Tiny
0.987333
0.990000
Each iteration built upon the previous one, with the final ensemble delivering the strongest overall performance.
Key Observations
Several observations stood out during the competition.
Post-processing simulation was the biggest contributor
The largest gains came from exposing the models to realistic image transformations during training rather than increasing model complexity.
Training on compressed, resized, cropped, blurred, and grayscale images forced the models to learn generator-specific fingerprints that remained detectable even after heavy image manipulation.
Most errors were concentrated in a few generator pairs
The confusion matrix showed that errors were not evenly distributed across all classes.
Most misclassifications occurred between Stable Diffusion 3 and Stable Diffusion 3.5, while several classes achieved near-perfect or perfect classification accuracy.
This suggests that the model successfully learned distinctive generator fingerprints but still struggled when generators shared highly similar architectural characteristics.
ConvNeXt and EfficientNet learned different patterns
ConvNeXt-Tiny achieved higher standalone validation accuracy, but EfficientNet-B4 continued to contribute useful information during ensembling.
The improvement from V4 (0.979333 Private LB) to V6 (0.990000 Private LB) suggests that the two models were making different mistakes and provided complementary predictions.
Simple inference techniques were enough
Horizontal flip TTA consistently improved prediction stability without introducing significant computational overhead.
More importantly, most of the performance gains came from the training pipeline itself rather than complex inference tricks.
Efficient architectures remained competitive
A major goal throughout the competition was achieving strong performance without relying on extremely large models.
EfficientNet-B4 and ConvNeXt-Tiny provided an effective balance between computational cost and accuracy, ultimately achieving a Top 10 finish while remaining practical to train on limited hardware.
Final Takeaways
The most valuable lesson from this competition was that strong solutions are not always the result of larger models.
In this challenge, the largest improvements came from understanding the evaluation conditions and designing a training pipeline that reflected those conditions as closely as possible.
Post-processing simulation proved far more impactful than increasing model complexity, while ConvNeXt-Tiny and EfficientNet-B4 demonstrated that efficient CNN architectures can still achieve highly competitive results when paired with robust augmentation strategies.
By combining realistic image transformations, MixUp, label smoothing, horizontal-flip TTA, and weighted soft-voting, I was able to improve from a
0.979333 Private Leaderboard baseline
to a final score of
0.990000
, securing
9th place out of 92 teams
.
This competition was a great reminder that understanding the data distribution often matters more than simply scaling the model.
Thank you again to the organizers for creating such a challenging and educational competition.