PaperlayerView exact revision on arXiv

Source-linked AI summary

NepScript Genesis: Neural Architecture Search for Handwritten Devanagari Digit Synthesis

Mausam Gurung, Prabin Neupane, Sajjan Acharya

arXiv:2608.29540v1cs.CV

TL;DR

Handwritten Devanagari digit synthesis is difficult because script-specific structure makes GAN architecture choices consequential, while systematic NAS for this setting remains limited. NepScript Genesis automates conditional GAN architecture discovery and compares five NAS strategies with a manual DCGAN baseline. Adaptive Exploration achieves the best reported quality-efficiency result, and the paper also reports benefits for low-resource recognition augmentation.

  • Problem

    Systematic NAS for GAN architecture search had not been applied to Devanagari or other Brahmic script synthesis, despite the script’s structurally demanding characters.

  • Method

    NepScript Genesis automates conditional Devanagari GAN architecture discovery, comparing five NAS strategies with a manually designed DCGAN baseline using domain-aware evaluation.

  • Results

    Adaptive Exploration achieves FID = 79.12, a 76.19% improvement over the manual baseline FID = 332.28, while matching the 56.56-minute search time of the simplest strategies.

  • Takeaways & Limitations

    The best NAS model produces digits that improve CNN accuracy from 91.0% to 96.5% when augmenting 250 real training samples per class.

  • Takeaways & Limitations

    The search space covers only five dimensions and excludes deeper networks, attention mechanisms, and alternative loss functions; each architecture also uses a single training seed.

Abstract

from arXiv · show

This paper introduces NepScript Genesis, a Neural Architecture Search (NAS) framework for automated Generative Adversarial Network (GAN) discovery, applied to conditional Devanagari handwritten digit synthesis. We compare five NAS strategies against a carefully constructed Deep Convolutional GAN (DCGAN) baseline (FID=332.28). Architecture selection utilizes a two-stage pipeline guided by a novel domain-aware evaluation metric (Enhanced Score). Results demonstrate that Adaptive Exploration achieves the optimal quality-efficiency trade-off, attaining an FID of 79.12 -- a 76.19% improvement over the baseline -- and the highest mode coverage among the NAS strategies (Recall=0.531) in under one GPU-hour. Furthermore, we demonstrate that incorporating script-specific structural heuristics into the search phase prevents early-stage mode collapse. In a downstream low-resource evaluation, augmenting 250 real training samples per class with GAN-generated digits from the best NAS model improves CNN classification accuracy from 91.0% to 96.5% (+5.5 percentage points), demonstrating that NAS-optimized synthesis produces digits of sufficient quality to benefit practical recognition pipelines when real data is scarce.

1 Introduction

NepScript Genesis addresses the underexplored challenge of synthesizing structurally faithful handwritten Devanagari digits by automating GAN architecture discovery. It compares five NAS strategies with a manual DCGAN baseline and reports improved quality under practical compute limits.

  • Motivation: Devanagari synthesis is challenging because characters contain complex stroke topologies, conjunct consonants, vowel diacritics, and a distinctive horizontal headline.Faithful reproduction is important for legibility and practical use in OCR augmentation, education, and digital preservation.
  • Motivation: Poor GAN architectural choices can cause mode collapse or failure to reproduce Devanagari stroke topology.The relevant choices include network depth, normalization, activations, latent dimensionality, and regularization.
  • Approach: NepScript Genesis automates GAN architecture discovery for conditional Devanagari digit synthesis and compares five search strategies against a manually designed DCGAN baseline.The study evaluates Random Search, Progressive Search, Adaptive Exploration, Multi-fidelity Search, and AdversarialNAS.
  • Results: 332.28 → 79.12 FID: Adaptive Exploration surpasses the manual DCGAN baseline by 76.2% while requiring 56.56 minutes of search time.Its search time is less than half the 124.50 minutes reported for AdversarialNAS.
  • Resources: The framework includes an open-source reproducible implementation for NAS experiments on Devanagari and other Brahmic scripts.The framework is publicly available through the repository identified in the paper.

2 Related Work

Prior work established major GAN architectures, stabilization techniques, and several NAS paradigms, but systematic NAS for low-resource Devanagari synthesis remained open. NepScript Genesis positions itself as the first such application to Devanagari digit generation.

  • GAN Foundations: DCGAN, Progressive GAN, StyleGAN, and BigGAN improved image quality and training stability in GANs.Wasserstein divergence, gradient penalties, spectral normalization, and normalization layers further address stability and representation quality.
  • NAS Strategies: NAS methods span random, reinforcement-learning, evolutionary, gradient-based, and multi-fidelity search strategies.These strategies differ in how architectures are proposed and how candidate performance is estimated.
  • NAS Strategies: Reinforcement-learning NAS can require thousands of GPU-hours, whereas gradient-based methods reduce search cost to tens of GPU-hours and multi-fidelity methods save computation through early stopping.The cited methods trade search cost against architectural optimization and candidate evaluation procedures.
  • NAS for Generative Models: AdversarialNAS jointly optimizes generator and discriminator architectures, while AutoGAN progressively searches generator architectures across resolutions.A survey identifies systematic NAS for low-resource script synthesis as an open problem.
  • Devanagari Synthesis: Prior Devanagari handwriting research focused mainly on recognition, with synthesis work involving DCGAN augmentation, conditional GANs, and synthetic data for recognizer improvement.These efforts provided context but did not establish systematic NAS for Devanagari digit synthesis.
  • Devanagari Synthesis: NepScript Genesis is presented as the first systematic NAS application to GAN architecture search for Devanagari digit synthesis.The paper frames this as a bridge between automated architecture search and low-resource script generation.

3 Methodology

The methodology formulates conditional Devanagari digit generation as NAS over a predefined architecture space, ranking candidates primarily by FID. A manually designed DCGAN provides the reference configuration and training setup.

  • Problem Formulation: The task learns a conditional generator that maps latent noise and digit labels to images approximating the real class-conditional distribution.The dataset consists of image-label pairs, with labels corresponding to Devanagari digit classes.
  • NAS Formulation: NAS replaces manual generator and discriminator specification with automated architecture selection over a predefined search space.Candidate architectures are evaluated through the paper’s architecture-ranking pipeline.
  • Evaluation: FID is the primary criterion for architecture ranking, with lower values indicating better performance under the stated evaluation.The methodology identifies FID as the evaluation loss used for selection.
  • Manual DCGAN Baseline: The manual DCGAN baseline uses a four-layer transposed-convolution generator and a four-layer convolutional discriminator.The generator uses latent dimension 100, BatchNorm, ReLU, and Tanh; the discriminator uses LeakyReLU, BatchNorm, and Sigmoid.
  • Manual DCGAN Baseline: The baseline is trained for 500 epochs with Adam at learning rate 0.0002, β1 = 0.5, batch size 64, and discriminator updates every two batches.This setup establishes the reference training procedure for comparison with NAS-discovered architectures.
  • Manual DCGAN Baseline: The manual DCGAN establishes the reference floor against which NAS strategies are evaluated.The paper characterizes it as the result of applying standard DCGAN conventions without architecture search.

3.3 Dataset

The study uses a balanced Devanagari handwritten-character dataset containing 20,000 digit images across ten classes. Images are resized to 32 × 32 pixels and displayed through a five-example grid for each class.

  • Dataset Composition: The dataset contains 20,000 handwritten Devanagari digit samples spanning ten digit classes, with 2,000 samples per class.The classes cover Devanagari digits 0–9.
  • Preprocessing: Images are resized to 32 × 32 pixels and normalized to [−1, 1].The dataset is class-balanced.
  • Dataset Visualization: The sample grid shows five examples per digit class, totaling 50 images across ten classes.This provides a visual overview of class-wise handwritten variation.

3.4 NAS Search Space

The NAS search space covers five architectural dimensions independently for the generator and discriminator, producing 4,096 paired configurations that are impractical to evaluate exhaustively on one GPU.

  • The search space Λ is applied independently to both the Generator G and Discriminator D.
  • 4,096 unique paired generator–discriminator configurations result from independently searching the architectural dimensions for G and D.The generator-side space contains 128 configurations before combining independently searched choices across both networks.
  • Five dimensions capture primary DCGAN-style architectural variation while keeping the search tractable for a single-GPU setting.Deeper networks, attention, and alternative losses remain future extensions.
  • All configurations use fixed learning rate, batch size, label smoothing, and Adam settings consistent with the manual DCGAN baseline.

3.5 NAS Algorithms

Five NAS strategies search the same 128-configuration space using 30-epoch Enhanced Score evaluations, spanning random, progressive, adaptive, multi-fidelity, and gradient-based approaches.

  • Five NAS strategies are compared under a fixed evaluation budget using the Enhanced Score after 30-epoch training.The strategies are Random Search, Progressive Search, Adaptive Exploration, Multi-fidelity Search, and AdversarialNAS.
  • Random Search: Random Search samples configurations uniformly without learning between evaluations and serves as a surrogate-free NAS baseline.
  • Progressive Search: Progressive Search evaluates 15 architectures across conservative, moderate, and aggressive phases with increasing complexity.
  • Adaptive Exploration: Adaptive Exploration mutates successful configurations with probability 0.7 while retaining random exploration.Configurations scoring at least 0.5 are stored, with only the last 10 retained.
  • Multi-fidelity Search: Multi-fidelity Search evaluates candidates at 10, 20, and 30 epochs, eliminating candidates below 0.5 and 0.7 thresholds before full evaluation.
  • AdversarialNAS: AdversarialNAS jointly optimizes continuous architecture parameters and network weights, using training batches for weights and validation batches for architecture updates.Gumbel-Softmax enables gradient flow through discrete selections, after which arg max yields the final architecture.

3.6 Evaluation Metrics

A two-stage pipeline filters architectures after 30 epochs with a weighted Enhanced Score, then retrains the best architecture for 500 epochs and evaluates standard generative metrics.

  • The two-stage pipeline separates 30-epoch architecture filtering from 500-epoch full training and final evaluation.The selected architecture is retrained from scratch before final reporting.
  • The Enhanced Score combines training health, diversity, consistency, efficiency, and script-specific visual quality to rank candidates.Base Score combines Stability, Balance, and Quality; the score also includes Diversity and domain-aware Nepali Quality.
  • Consistency rewards coherent label-conditional outputs while Diversity rewards cross-sample variation, so equal weighting favors recognizable yet varied digits.
  • Efficiency contributes 15% of the Enhanced Score and softly prefers fast convergence and compact latent spaces.Changing latent dimension from 64 to 128 shifts the total score by approximately 0.01, and Adaptive Exploration still selected 128.
  • Nepali Quality rewards stroke integrity and variance-based sharpness to discard topologically unsound architectures before full convergence.Stroke integrity is based on the number of connected components.
  • Stage 2 reports FID, Inception Score, Precision, and Recall, with FID computed on 20,000 samples and Recall representing mode coverage.

3.7 CNN Classifier for Downstream Evaluation

The downstream evaluation tests whether GAN-generated digits improve recognition when a lightweight CNN receives only 250 real samples per class, comparing real-only and GAN-augmented training.

  • The low-resource experiment limits real training data to 250 samples per class and evaluates both real-only and GAN-augmented conditions.Both conditions use the same held-out test set of 3,000 samples, with 300 per class.
  • The classifier is intentionally lightweight, using one convolutional layer, a 32-unit hidden layer, dropout, and a 10-class output.
  • The test set contains 3,000 held-out samples, while validation is used only for monitoring during CNN training.
  • The baseline trains the CNN on 2,500 real samples, while the augmented condition adds approximately 1,000 GAN-generated samples per class from Adaptive Exploration.The augmented set contains 9,935 total samples, or approximately 1,250 training samples per class.
  • Both training conditions use identical architecture, hyperparameters, and training protocol.

4 Experiments and Results

Experiments compare five NAS strategies with a manual DCGAN baseline across search efficiency, synthesis quality, architecture design, qualitative fidelity, and downstream classification utility. Adaptive Exploration provides the strongest reported FID improvement within a sub-hour filtering budget, while generated data improves low-resource CNN recognition.

  • Experimental Setup: The experiments report one run per architecture on an NVIDIA RTX 4050 because of compute constraints, leaving multi-seed estimation for future work.The stated aim is to quantify automated search against a manual design point rather than claim state-of-the-art synthesis.
  • NAS vs. Manual DCGAN Baseline: All five NAS strategies improve FID over the manual DCGAN baseline, with Random Search reducing FID by 62.59% in under 58 minutes.The comparison uses a fixed evaluation budget and reports the manual baseline as the reference architecture.
  • NAS vs. Manual DCGAN Baseline: 76.19% FID improvement: Adaptive Exploration reduces FID from 332.28 to 79.12 in 56.56 minutes and achieves NAS-best Recall of 0.531.Its search time matches Random and Progressive Search and remains below the 60-minute threshold.
  • NAS vs. Manual DCGAN Baseline: Multi-fidelity Search records the highest IS at 2.08, while the manual baseline records IS 2.00 and remains competitive on this metric despite worse FID.The paper identifies FID as the primary criterion and describes the FID–IS divergence as a distinction between distributional distance and confident class predictions.
  • Computational Efficiency: Adaptive Exploration, Random, and Progressive Search finish within 56–58 minutes, whereas Multi-fidelity Search takes 125.88 minutes and AdversarialNAS takes 124.50 minutes.AdversarialNAS optimizes one architecture through gradient-based iterations, so its search time is not directly comparable to sampling strategies.
  • Architecture: The best Adaptive Exploration architecture uses a 128-dimensional latent vector with a one-hot class label, residual blocks, transposed convolutions, and a 1 × 32 × 32 output.The discriminator mirrors the generator’s structure and produces a scalar real/fake score; its first block uses fixed raw-pixel processing without normalization.
  • Qualitative Results: Adaptive Exploration generates legible digits across all ten classes, consistently reproducing the shirorekha and preserving inter-class boundaries.The reported Precision is 0.980 and Recall is 0.531, with visible within-class stroke-thickness variation.
  • Downstream Classification Utility of GAN-Generated Data: 96.5% CNN accuracy results when GAN-generated digits augment 250 real samples per class, up from 91.0%.The gain is reported across precision, recall, and F1 and is measured on top of conventional image augmentation.

5 Discussion

Adaptive Exploration offers the strongest overall balance of distributional quality, coverage, and search efficiency, while metric-specific winners reveal a quality-diversity trade-off. The domain-aware Enhanced Score and explicit scope limitations frame how these results should be interpreted.

  • Quality-diversity trade-off: 76.19% FID improvement makes Adaptive Exploration the clear distributional-quality leader over the manual baseline.Its FID is 79.12 versus 332.28 for the manual baseline.
  • Quality-diversity trade-off: 2.08 IS is achieved by Multi-fidelity Search, illustrating that high Inception Score can coexist with weaker distributional coverage than Adaptive Exploration.The discussion therefore treats FID as the more reliable metric for overall distributional quality.
  • Quality-diversity trade-off: 1.00 Precision is achieved by AdversarialNAS and Multi-fidelity Search, but both incur a Recall cost relative to Adaptive Exploration.These methods suppress low-fidelity samples through gradient-based or multi-stage filtering.
  • Quality-diversity trade-off: 0.531 Recall makes Adaptive Exploration the strongest NAS strategy for mode coverage, although the manual baseline reaches 0.552.AdversarialNAS has the lowest Recall at 0.504, consistent with narrower high-confidence optimization.
  • Evaluation design: The Enhanced Score filters architectures after 30 epochs by combining training-health signals with diversity, consistency, efficiency, and script-specific visual quality.Its Nepali Quality component rewards legible Devanagari strokes that generic metrics such as IS do not capture.
  • Limitations: The search is limited by a five-dimension, 128-configuration space, single-seed evaluations, Devanagari-digit scope, and FID sensitivity to sample and Inception-network choices.The paper notes that broader scripts, other Brahmic scripts, additional architectural dimensions, and multi-seed variance require further validation.

6 Conclusion

NepScript Genesis applies NAS to conditional Devanagari handwritten digit synthesis, replacing reliance on a single manual GAN design with automated architecture discovery. Adaptive Exploration achieves the best reported overall result, while the two-stage domain-aware evaluation supports efficient selection and synthetic data improves low-resource classification.

  • Conclusion: NepScript Genesis applies NAS to automate GAN architecture discovery for conditional Devanagari handwritten digit synthesis.The framework compares five NAS strategies with a manually designed DCGAN baseline.
  • Conclusion: 76.19% FID improvement is achieved by Adaptive Exploration over the manual baseline, with FID 79.12 versus 332.28 and 56.56 minutes of search time.AdversarialNAS reaches Precision 1.00, while Multi-fidelity Search reaches IS 2.08.
  • Conclusion: The two-stage pipeline combines 30-epoch Enhanced Score filtering with 500-epoch full training and includes Nepali Quality to reward Devanagari stroke characteristics.This provides an efficient, domain-aware mechanism for architecture selection.
  • Conclusion: Augmenting 250 real training samples per class with GAN-generated digits improves CNN classification accuracy from 91.0% to 96.5%.The downstream evaluation demonstrates practical utility in a low-resource recognition setting.
Loading 2608.29540v1…