One-sentence Summary

Researchers propose OBSD, a conditional diffusion-based model that generates visual clues for deciphering Oracle Bone Script, offering an image-generation approach to ancient languages that lack the large textual corpora required by traditional NLP methods.

Key Contributions

• Oracle Bone Script Decipher (OBSD) is a conditional diffusion-based image generation model that produces visual clues for deciphering unknown Oracle Bone Script characters by leveraging structural relationships between ancient forms and modern Chinese characters.
• A Localized Structural Sampling technique and a zero-shot refinement module are introduced to help the model capture intricate character structures from limited historical data and improve decipherment accuracy.
• Experiments on the HUST-OBS and EVOBC datasets, supported by ablation studies and benchmark comparisons, show that OBSD is effective for AI-assisted ancient language decipherment.

Introduction

Oracle Bone Script is the ancient writing system inscribed on turtle shells and animal bones during China’s Shang Dynasty. It offers a direct window into the history, language, and culture of early Chinese civilization. Although more than 4,500 OBS characters have been identified, only about 1,600 have been deciphered and linked to modern Chinese, leaving most inscriptions unread and making OBS an important but difficult target for AI-assisted historical language reconstruction.

Most prior work has focused on recognizing already deciphered OBS characters or relying on known deciphered examples through case-based reasoning. Generative methods face additional challenges because OBS has no standard encoding scheme, survives mainly as fragmented images, and lacks a complete digital corpus. This limits text-based NLP models and makes it hard to learn the evolutionary path from ancient scripts to modern Chinese characters.

The authors leverage a conditional diffusion model for auxiliary OBS decipherment. They train Oracle Bone Script Decipher to generate possible modern Chinese character images from unseen OBS characters, using image-based generation instead of large text corpora. They also introduce Localized Structural Sampling to capture intricate character structure and a zero-shot refinement module to improve decipherment accuracy. The method offers a new path for AI-assisted ancient script decipherment and may extend to other ancient writing systems such as cuneiform and hieroglyphics.

Dataset

• The authors use the HUST-OBS and EVOBC datasets for training and evaluating their oracle bone script decipherment model. The source repository is described as one of the largest Oracle Bone Script collections, containing 71,698 images that depict 1,590 distinct characters.

• For testing, the authors use already deciphered inscriptions rather than unknown inscriptions. This avoids expert validation in the test set and allows automatic scoring. The test set is also filtered so that its character categories are not present in the training set, making the evaluation more challenging for unseen categories.

• The data are partitioned into training and test sets at a 9:1 ratio. The large training split is used to train the generation-based decipherment model, while the disjoint test split is used for objective assessment.

• The authors do not describe a specific cropping strategy, metadata construction, or data mixture ratio in the provided text beyond the 9:1 split and category filtering for testing.

• For evaluation, the authors use two OCR tools instead of conventional image similarity metrics. Their custom OBS-OCR tool is a ResNet 101 based classifier trained on 88,899 categories of modern Chinese characters and reports 99.87% recognition accuracy. They also incorporate PaddleOCR as an additional evaluation tool, allowing generated decipherment results to be compared against ground truth labels automatically.

Method

The authors formulate OBS decipherment as a conditional image transformation problem: given an oracle bone image $\tilde{X}$X~, the goal is to predict its corresponding modern Chinese character image. The training set contains pairs $(s_i, c_i)$(si​,ci​), where $s_i$si​ is an OBS instance and $c_i$ci​ is a known modern Chinese character. The model is expected to go beyond exact category matching by proposing modern forms that can explain previously unresolved inscriptions. The proposed OBSD framework consists of an Initial Decipherment stage that generates a first modern character image from the OBS input, followed by a Zero-shot Refinement stage that corrects structural defects using a reference modern character image. Refer to the overall pipeline:

The foundation of the first stage is a conditional diffusion model. During training, the modern Chinese character image is treated as the target clean image $X_0$X0​. A forward noising process gradually corrupts $X_0$X0​ through a Markov chain so that the final state approximates Gaussian noise. The full forward process is written as

$$q \left(X_{1: T} \mid X_0\right) = \prod_{t = 1}^{T} q \left(X_t \mid X_{t - 1}\right),$$q(X1:T​∣X0​)=t=1∏T​q(Xt​∣Xt−1​),

where $T$T is the total number of diffusion steps. At each step, noise is added according to

$$q \left(X_t \mid X_{t - 1}\right) = \mathcal{N} \left(X_t \mid \sqrt{\alpha_t} X_{t - 1}, (1 - \alpha_t) I\right),$$q(Xt​∣Xt−1​)=N(Xt​∣αt​​Xt−1​,(1−αt​)I),

with $\alpha_t$αt​ controlling the noise intensity and $I$I denoting the identity matrix. The cumulative noisy state can be expressed directly as

$$X_t = \sqrt{\gamma_t} X_0 + \sqrt{1 - \gamma_t} \epsilon, \quad \epsilon \sim \mathcal{N} (0, I),$$Xt​=γt​​X0​+1−γt​​ϵ,ϵ∼N(0,I),

where $\gamma_t$γt​ is the cumulative product of the $\alpha$α values up to step $t$t. A denoising U-Net $f_\theta$fθ​ is trained to predict the injected noise conditioned on the OBS input $\tilde{X}$X~ and the current noisy state $X_t$Xt​. The training objective is

$$\mathcal{L} = \mathbb{E}_{\epsilon, \gamma} \left\| \epsilon - f_{\theta} \left(\tilde{X}, X_t, \gamma\right) \right\|^2.$$L=Eϵ,γ​​ϵ−fθ​(X~,Xt​,γ)​2.

During inference, the model starts from a highly noisy state $X_T$XT​ and reverses the diffusion process step by step. The reverse update is

$$X_{t - 1} = \frac{1}{\sqrt{\alpha_t}} \left(X_t - \frac{1 - \alpha_t}{\sqrt{1 - \gamma_t}} f_{\theta} \left(\tilde{X}, X_t, \gamma_t\right)\right) + \sqrt{1 - \alpha_t} \epsilon_t,$$Xt−1​=αt​​1​(Xt​−1−γt​​1−αt​​fθ​(X~,Xt​,γt​))+1−αt​​ϵt​,

where $\epsilon_t \sim \mathcal{N}(0, I)$ϵt​∼N(0,I) introduces stochasticity to improve result diversity. The final denoised image $\hat{X}_0$X^0​ is the initial decipherment output. The diffusion process is depicted in the conditional generation diagram:

Although standard conditional diffusion is effective when the condition provides directly usable structure, direct application to OBS images is insufficient for accurate modern character synthesis. OBS forms and their modern descendants often share only partial visual cues, so a global conditional diffusion model may generate scattered stroke fragments rather than coherent characters. The authors address this by comparing the global structural evolution of characters with the more stable local radical components that persist across writing systems. Refer to the structural comparison:

This observation motivates Localized Structural Sampling. Instead of forcing the diffusion model to learn a single global mapping from an OBS image to a modern character, the method decomposes generation into patchwise local transformations. Each patch $d$d is modeled by a conditional patch generation process,

$$p_\theta (X_{0: T}^{(d)} \mid \tilde{X}^{(d)}) = p (X_T^{(d)}) \prod_{t = 1}^{T} p_\theta (X_{t - 1}^{(d)} \mid X_t^{(d)}, \tilde{X}^{(d)}),$$pθ​(X0:T(d)​∣X~(d))=p(XT(d)​)t=1∏T​pθ​(Xt−1(d)​∣Xt(d)​,X~(d)),

and the denoising loss becomes patch oriented:

$$\hat{\epsilon}_t^{(d)} = f_\theta (X_t^{(d)}, \tilde{X}^{(d)}, t), \quad \mathcal{L}' = \mathbb{E}_{t, d} \left\| \hat{\epsilon}_t^{(d)} - \epsilon_t^{(d)} \right\|^2.$$ϵ^t(d)​=fθ​(Xt(d)​,X~(d),t),L′=Et,d​​ϵ^t(d)​−ϵt(d)​​2.

During inference, the input OBS image is divided into patches through a structured sliding-window layout. The authors use patch size $64$64 and grid spacing $16$16, allowing each cell to host a $16 \times 16$16×16 structured set of patches. Patches are extracted by moving the window horizontally and vertically with step size $16$16. Overlapping regions are not repaired only after denoising. Instead, the overlapping sections are averaged at every timestep $t$t, which keeps shared areas synchronized throughout the reverse diffusion trajectory. This timestep-aware averaging prevents merging artifacts and maintains smooth transitions between independently sampled patches. The full initial decipherment training and inference process is shown in the pipeline diagram:

Even after localized diffusion, the initial decipherment stage can produce distorted strokes, broken components, and noisy structures. These defects arise because many OBS variants may be mapped to a single modern target image, and the number of modern reference forms available during diffusion training is limited. The authors treat this as a many-to-one ambiguity that confuses the generative model during initial synthesis. Generated examples exhibit such artifacts in the following figure:

To correct these imperfections, the authors introduce a zero-shot refinement module that is trained only on modern Chinese character style transformation, not on OBS-to-modern pairs. The module learns to transform one modern font style into another while preserving the underlying character structure. The authors train this component using multiple modern fonts and formulate the training task as one-to-one style-to-style reconstruction. At inference time, the initial decipherment output $X_0$X0​ is refined with a reference modern character image $X_{ref}$Xref​, producing the final output $X_F$XF​.

The refinement architecture follows a font-style transformation framework with dual encoders. A style encoder $E_s$Es​ extracts style features from the reference image $X_{ref}$Xref​. A content encoder $E_c$Ec​ extracts multi-scale content features from the source image $X_0$X0​ and the reference image $X_{ref}$Xref​:

$$F_0 = \{f_0^1, f_0^2, f_0^3\}, \quad F_{ref} = \{f_{ref}^1, f_{ref}^2, f_{ref}^3\}.$$F0​={f01​,f02​,f03​},Fref​={fref1​,fref2​,fref3​}.

These features are processed by a specialized U-Net containing Multi-scale Content Aggregation blocks and Reference-Structure Interaction blocks. The goal is to transfer the structural intent of the source image into the target style while avoiding content drift.

Cross-attention is used to align source content features with reference structure. For each feature scale, flattened reference features and source-derived features are projected into query, key, and value vectors:

$$S_{ref} = \mathrm{flatten}(f_{ref}^i), \quad S_s = \mathrm{flatten}(o_i),$$Sref​=flatten(frefi​),Ss​=flatten(oi​), $$Q = \Phi_q(S_{ref}), \quad K = \Phi_k(S_s), \quad V = \Phi_v(S_s),$$Q=Φq​(Sref​),K=Φk​(Ss​),V=Φv​(Ss​),

where $o_i$oi​ denotes the U-Net feature obtained from source content and style information, and $\Phi_q$Φq​, $\Phi_k$Φk​, and $\Phi_v$Φv​ are linear projection functions. Attention features are computed as

$$F_{\mathrm{attn}} = \mathrm{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V,$$Fattn​=softmax(dk​​QKT​)V,

and the deformation offset is predicted by a feedforward network:

$$\delta_{\text{offset}} = \mathrm{FFN}(F_{\mathrm{attn}}).$$δoffset​=FFN(Fattn​).

The final image feature is rendered by applying deformation convolution to the source feature using the predicted offset:

$$I_f = \mathrm{DCN}(o_i, \delta_{\text{offset}}).$$If​=DCN(oi​,δoffset​).

Because the refinement stage is adapted for a single target font style, the authors simplify the original framework by omitting style contrastive refinement and its associated contrastive loss. Training instead uses an offset regularization objective,

$$\mathcal{L}_{\text{offset}} = \mathrm{mean}(\|\delta_{\text{offset}}\|),$$Loffset​=mean(∥δoffset​∥),

which penalizes overly large deformation offsets and encourages structurally stable style transfer. After training, the refinement module is applied directly to the initial diffusion output, using a reference modern character image to restore missing strokes, correct warped components, and produce the final deciphered modern character.

Experiment

Experiments on held-out Oracle Bone Script categories used dual OCR tools to evaluate generated modern-character decipherments, testing single-round performance, multi-round iteration, component ablations, and qualitative reconstruction quality. The results show that OBSD outperforms adapted GAN-based and generic image-translation baselines, which often produce incomplete or unstructured characters, while multi-round attempts improve robustness in realistic decipherment workflows. Ablation and qualitative analyses confirm that local structure supervision and zero-shot refinement are important for producing coherent character strokes and structures, indicating that image-based generative modeling can support oracle bone language decipherment, including insight into undeciphered samples.

The proposed method achieves the highest OBS-OCR accuracy across all reported rank settings, indicating stronger immediate and relaxed decipherment performance than the compared image-to-image translation methods. Its accuracy increases steadily as the rank expands, reaching its best result at the largest rank cutoff. Diffusion-based baselines are the closest competitors, while GAN-based methods are much weaker at low ranks and improve only when larger candidate sets are considered. The proposed method leads at top-1 accuracy and remains best at top-500 accuracy. Recognition accuracy generally improves as the allowed rank increases. Diffusion-based methods provide stronger performance than GAN-based methods in this task.

The OBSD multi-round decipherment results show that allowing successive attempts steadily increases top-1 success rates. Both OBS-OCR and PaddleOCR improve across trials, with OBS-OCR reaching a plateau at a much higher level than PaddleOCR. This pattern indicates that iterative decipherment provides cumulative gains for both automatic evaluators. Success rates rise across trials rather than remaining flat at the single-attempt level OBS-OCR consistently reports higher accuracy than PaddleOCR throughout the multi-round evaluation Gains become smaller in later trials, suggesting the method approaches a stable decipherment ceiling

The ablation study shows that the basic diffusion model performs poorly for oracle bone script decipherment, producing mostly uninterpretable outputs. Adding the LSS module gives a large gain in recognition accuracy, especially for Top-1 results on both OBS-OCR and PaddleOCR. Adding zero-shot refinement provides a further improvement across all evaluated rank thresholds. The base diffusion model gives very low recognition accuracy. The LSS module substantially improves decipherment accuracy. Zero-shot refinement adds consistent gains on top of the LSS results.

The table presents qualitative comparisons of image-to-image translation results for deciphering Oracle Bone Script into modern Chinese characters. OBSD produces more complete, differentiated, and structurally coherent character reconstructions than the compared baselines. In contrast, some baselines yield overly uniform outputs or fragmented and unrecognizable characters. OBSD generates modern Chinese characters that more closely match the ground truth. Pix2Pix produces highly uniform outputs across different inputs. DRIT++ often fails to form complete and recognizable characters. OBSD better preserves intricate character strokes and structures.

Across rank-based decipherment accuracy, multi-round evaluation, component ablations, and qualitative character reconstruction comparisons, the proposed method consistently outperforms diffusion and GAN baselines. Recognition improves as more candidate ranks are allowed, and successive decipherment attempts yield cumulative but eventually diminishing gains. The ablations show that the base diffusion model is weak, while the LSS module and zero-shot refinement each provide substantial and incremental improvements. Qualitatively, the method produces more complete and structurally coherent oracle bone to modern Chinese character translations than competing models.