A Hybrid U-Net–GAN Framework for Restoring Broken Kannada Handwritten Characters

Maintaining handwritten documents has served as a key aspect of digital archiving, cultural heritage preservation, and smart information retrieval. Handwriting recognition methods have proven reliable to work with clean datasets. But the degeneration of the handwriting and the breaking of character strokes generally is not always resolvable completely reliably. More recent work focused on deep generative models has broadened the examination of recovering and enhancing degraded text images built on top of a variable cycle Generative Adversarial Network (GAN) framework. It learns to predict the deformation of handwritten text and has shown that adversarial learning can successfully recover the conformity of characters in degraded handwritten documents. Researchers have approached text enhancement for historical handwritten manuscripts addressing challenges such as ink bleed, paper degradation, and incomplete strokes. These investigations remark on bringing attention to two challenges where recovering or enhancing broken text is not a pre-processing step. It is a substantive task for providing usability in downstream tasks of retrieval and recognition of, not to mention digital archive.

Generative deep learning models have surfaced as good solutions to solve these issues. Nigam et al. [1] utilized variable cycle GAN to remove deformity in handwritten text, proposing a restoration identified by a structural fingerprint of the original writing style. Alaasam et al. [2] engaged text enhancement for historical handwritten documents to address issues such as noise from the background paper on ink and partial loss of characters. They also noted that any pre-processing and restoration of text would be informative for the downstream tasks of recognition. Rabhi et al. [3] presented a multilingual recovery framework with a convolutional denoising autoencoder that incorporated attentional mechanisms. They illustrated the importance of the focus mechanism in dealing with different scripts. However, while their model has some level of cross-linguistic generalization, it does not address the stroke discontinuities that are characteristic of Kannada.

Structural complexity is a notable challenge, characters in Kannada are very curvilinear, and they often have compound parts. They recognize the limitations of this process are on the use of incomplete or broken strokes to recognize characters, meaning that the process can be sensitive to noise degradation. Gongidi and Jawahar [4] have suggested hybrid implementations of feature extraction methods and ensemble learning for Kannada recognition. This increases their susceptibility to recognition errors when even slightly degraded. For instance, Ramesh et al. [5] have carried out Kannada recognition using the combination of manifold smoothing and label propagation. The methods can classify strokes similarly assuming a similar representation from the character, but the methods require complete samples and are not helpful if the necessary strokes are missing.

Advances in generative models using disentangled representation learning for handwritten text generation [6]. For instance, trajectory recovery attributes (AIoU and LDTW) [7] were designed for complicated handwriting. It shows how trajectory aware evaluations emphasize the importance of context in trajectory supported evaluation as a section of handwriting continuation. Their results clearly showed that incomplete and broken strokes could not be fully recovered with image enhancement as a process but required contextual trajectory prediction of the strokes. The findings of the GAN study [8] have also established that while adversarial training is strong on style preservation and realism, the method struggles with the fine-grained elements of structure fidelity, an important requirement to restore complex Kannada characters.

Many studies on written handwriting recovery and regeneration are multilingual or work mostly on Latin scripts. There are few models that engage with low-resource scripts such as Kannada, where stroke recognition can be quite sensitive to minor differences in stroke details. Elanwar and Betke [9], proposed a variable attention-based Bi-LSTM framework for Kannada script recognition which improved classification. However, it did not propose a restoration mechanism for degraded inputs. Consequently, there was an obvious gap in the research, there is currently no robust pipeline that incorporates structural stroke regeneration and recognition for Kannada handwritten documents. JokerGAN [10] outlined advancements for memory resources for congeniality of text-line aware generation for handwritten text generation respectively, but in both cases the models are used for generating new handwritten samples, not repairing broken ones.

The proposed broken character regeneration framework is designed as an image-to-image translation method, wherein incomplete Kannada characters should be regenerated in their original form prior to recognition. The proposed hybrid UNGAN-KR framework takes advantage of U-Net’s encoder–decoder architecture to support a careful and localized reconstruction of structural features. Those are necessary for stroke continuity while the GAN discriminator enforces global realism and stylistic fidelity. The potential of the proposed UNGAN-KR framework in this regard is its ability to support the regeneration of Kannada's complexity in morphology, specifically curvilinear shapes, ligatures, and composites. Comprehensive experimental work was done in evaluating our framework against Kannada recognition baselines and state-of-the-art generative handwriting approaches.

The principal contribution of the paper is summarized as follows:

• Modeled broken character regeneration as an image-to-image translation task were generating a broken character image to its original form using the structural learning properties of U-Net combined GAN adversarial refinement (UNGAN-KR).
• Designed a Framework using a U-Net backbone combined with a GAN discriminator ensuring both stroke-level correctness and contextual realism on each generated character.
• This framework is specifically designed for Kannada, targeting its complex morphology and compound character shapes.
• Compare the framework against recent Kannada recognition models and generative handwriting work, and show that the generated character images with our methodology have higher accuracy when dividing both the regeneration accuracy and recognition accuracy.

The rest of this document is organized in the following manner: In Section 2, we present a thorough survey of the Related Work on handwritten character restoration, U-Net based architectures, and GAN based inpainting approaches. Section 3 describes the Proposed Method, which includes a discussion on six step workflows for restoring Kannada handwritten broken characters along with mathematical formulations and a hybrid UNGAN-KR framework. The setup for the experiments is discussed in Section 4, which details the dataset, metrics for evaluation, implementation details, followed by Results and Discussion. Lastly, Section 5 concludes the paper and discusses future work on multi-script handwriting restoration and perceptual enhancement.

This work conceptualizes the restoration of damaged handwritten Kannada characters as an image-to-image translation problem. The architecture consists of a U-Net generator and a GAN discriminator to provide structural stroke restoration combined with texture-level realism. The U-Net operates as a structural restorer that combines local continuity and global context through its encoder-decoder with skip connections. The GAN discriminator works in conjunction with the U-Net to ensure the restored characters resemble authentic handwritten samples. This dual approach addresses both the challenges of restoring missing strokes and improving the perceptual fidelity of the restored characters.

The suggested workflow for Kannada handwritten broken character regeneration is structured in the following six steps also shown in Figure 1.

Figure 1. Proposed UNGAN-KR model design diagram

• Input Pre-processing
• U-Net Encoder–Decoder Stroke Reconstruction
• Adversarial Refinement with a GAN Discriminator
• Loss Function Integration
• Training Objective (Min–Max Optimization)
• Validation and Preservation of Character Identity

The proposed method is described as fallows: The UNGAN-KR framework proposes a new way to restore broken handwritten text in Kannada through a method called image-to-image translation. This new framework solves two major problems together: 1) recovering the original handwriting from the damaged image and 2) creating a realistic-looking final product that mimics genuine handwritten text. To prepare for image-to-image translation using our system, the original damaged images are first undergone a normalizing transformation, followed by binarization via Otsu Thresholding, then the damaged characters are processed via morphological closing so that all stroke pieces are connected, followed by normalization via image resampling so that all character images are the same size. Once the original image has been normalized and transformed, it will become the input into our U-Net generator.

Inside the U-Net generator, the encoder is utilized to extract hierarchical stroke features from the images. The encoder also encodes the overall character structure into a compressed latent representation. The decoder will use multiple up-sampling layers and skip connections to reconstruct the missing strokes from the compressed latent representation and the low-level details of the image to create a complete representation of the character. Once the U-Net generator has created an initial version of the character, the initial version is enhanced via adversarial learning, where a GAN discriminator attempts to differentiate between the original handwriting and the newly generated handwriting. This process creates a more realistic final product in terms of stroke continuity, stroke texture, and stroke style.

The neural network that we just described uses a composite loss function to guide its training, which integrates pixel-level reconstruction loss, structural similarity loss, perceptual feature loss, and adversarial loss in order to find a good balance between reconstructing the character's original appearance while also generating a realistic final product. Additionally, the GAN discriminator's gradient penalty and feature-matching losses provide additional stability to the adversarial optimization process.

A joint training process for both the generator and discriminator is performed using the Adam optimizer, applying learning rate decay, dropout regularization, and gradient clipping to facilitate convergence throughout the training process. Constraints include class consistency (a measure of how well samples from the same class can be classified) based upon prior trains learned by a CNN classifier, and stroke-level consistency through skeletal representation; resulting in a restoration of broken handwritten Kannada characters that maintain structural coherence, appear visually authentic, and preserve the identity of original Kannada characters. With this integrated system, UNGAN-KR will produce high structural accuracy as well as visually authentic restored handwritten Kannada characters while also preserving character identity.

3.1 Input preprocessing

The first and fundamental stage in regenerating broken Kannada handwritten characters is input preprocessing, which aims to standardize the raw manuscript images and prepare them for deep learning-based reconstruction. Handwritten documents often suffer from diverse distortions, including variable stroke thickness, ink smudges, missing segments, and uneven illumination, which can significantly degrade the performance of neural networks. To address these challenges, the raw character images $I(x, y)$ are initially normalized using Eq. (1), ensuring pixel intensity values are standardized with zero mean and unit variance. This normalization mitigates the impact of variations in lighting and ink density across different document sources, enabling consistent feature extraction.

$I_{n o r m}(x, y)=\frac{I(x, y)-\mu}{\sigma}$               (1)

Here, $I(x, y)$ indicates the original pixel intensity value at $(x, y)$ of the grayscale image. The term $\mu$ indicates the mean pixel intensity across the entire dataset or batch of images, which indicates that the image is zero-centered. The letter $\sigma$ indicates the standard deviation of the pixel intensities, which ensures that the pixel intensities are scaled so that the variance is normalized. The image is then normalized to yield $I_{\text {norm}}(x, y)$, where each pixel is subsequently less sensitive to changes in illumination and the thickness of writing. Normalization is important for the Kannada handwritten broken character regeneration framework because it facilitates the learning of structural patterns by the U-Net encoderdecoder and GAN discriminator without their learning being confounded by the raw intensity information.

Subsequently, we apply the binarization step (Eq. (2)) that uses Otsu's thresholding to separate foreground strokes from the background, moving from the normalized grayscale image to a binary version $I_{\text {bin}}(x, y)$. This step is crucial to isolate handwritten strokes from the background while still maintaining the important structural information of each character.

$I_{\text {bin}}(x, y)= \begin{cases}1 & \text { if } I_{\text {norm}}(x, y)>T_{\text {otsu}} \\ 0 & \text {otherwise}\end{cases}$               (2)

Next, we perform morphological operations, specifically closing operations (Eq. (3)), to reconnect broken strokes and fill small gaps within characters. Morphological operations help to enhance the continuity of strokes in handwriting, which is especially significant with Kannada characters that naturally contain many complex curves and ligatures.

$I_{\text {closed}}=\left(I_{\text {bin}} \oplus B\right) \ominus B$                 (3)

Here, $I_{\text {bin}}$ is used to define the binarized input image, where text pixels are separated from the non-text background. The symbol ⊕ refers to morphological dilation, while $\ominus$ refers to morphological erosion, both of which are done using a structuring element BBB . The image $I_{\text {closed}}$ is the morphologically closed image where gaps in strokes of Kannada text are filled, and disconnections were minimized. Eq. (4) describes the process of resizing the input character image.

$I_r=\operatorname{Resize}\left(I_c, H \times W\right)$                  (4)

Here, $I_c$ denotes the character image once cropped, and $H$ and W represent the desired resized height and width. The output image $I_r$ is the resized image for a standardized uniform image for input to the U-Net encoder.

3.2 U-Net encoder–decoder stroke reconstruction

The demonstrated framework for regenerating handwritten broken Kannada characters is built on a U-Net encoder-decoder architecture, which is responsible for reconstructing the missing or broken strokes while also duplicating the internal structure and style of each character. The U-Net architecture is well suited for the task because of its symmetric encoder-decoder architecture with skip connections, which allows the network to capture local fine-scale stroke features and the larger structural context.

The encoder sequentially abstracts hierarchical features from the input image Iresized, which has been preprocessed, through an encoder-decoder architecture with skip connections consisting of just convolutional layers (Eq. (5)).

$f_l=\sigma\left(W_l * f_{l-1}+b_l\right)$                 (5)

Here, $f_{l-1}$ is the input feature map from the previous layer, $W_l$ and $b_l$ are the learnable convolutional weights and bias in layer $l$, and * denotes convolution. The activation function $\sigma(\cdot)$adds non-linearity, and the resulting feature map $f_l$ is a set of hierarchical representations of the character of Kannada.

Each convolutional layer is followed by a non-linear activation function, to enable the network to learn complex stroke features. Down sampling shown in Eq. (6) via maximum pooling layers reduces spatial dimensions and increases the size of the receptive field enabling the encoder to capture dependencies across the character structure.

$f_l^{\text {down}}(i, j)=f_l(i+m, j+n)$                (6)

Here, $f_l(i+m, j+n)$ represents the feature activations in the local neighborhood $\Omega$ around position $(i, j)$. The output $f_l^{\text {down}}(i, j)$ displays the maximum value in that region that maintains dominant stroke features but decreases spatial resolution. In the bottleneck layer, the network produces a compact latent representation using $z$ in Eq. (7) of the essential features of the character including stroke orientation, curvature, and connectivity.

$z=\operatorname{Encoder}\left(I_{\text {resized}}\right)$              (7)

Here, $I_{\text {resized}}$ is the input image of the Kannada character standardized impostor character, and the encoder generates a compressed feature embedding. The latent vector $z$ carries the high-level stroke pattern and graphical structure information to facilitate decoding and reconstruction. To reconstruct the character, the decoder up samples the latent representation Eq. (8).

$f_l^{u p}=$ Upsample $\left(f_{l+1}\right)$                (8)

Here, $f_{l+1}$ is the feature map from a deeper level, and the Upsample function increases its spatial resolution. The $f_l^{u p}$ feature map is able to reconstruct the fine stroke details of the Kannada character while also leveraging the essence of the encoder $f^{e n c}$ feature map. Adding skip connections to the encoder feature maps congruent to its spatial dimensions Eq. (9). The skip connection concatenates information regarding the fine-size details lost during down sampling, enabling the reconstruction of the strokes accurately.

$f_l^{\text {fusion}}=f_l^{u p} \oplus f_l^{\text {enc}}$                (9)

Here, $f_l^{u p}$ is the upsampled decoder feature map and $f_l^{\text {enc}}$ is the related feature map from the encoder. The fusion operator $\oplus$ denotes either concatenation or addition, this enables the model to mix high-level semantic information with low-level stroke information to accurately regenerate the Kannada character. The last convolutional layer produces the final reconstructed character image $I_{\text {rec}}$ Eq. (10) that is a smooth visual coherence regeneration of the original broken input.

$I_{\text {rec}}=\sigma\left(W_{\text {out}} * f_0+b_{\text {out}}\right)$                (10)

Here, $I_{\text {rec}}$ indicates the resulting regenerated image of the U-Net decoder. $f_0$ is the fused feature map of all the features, $W_{\text {out}}$ and $b_{\text {out}}$ are the learnable weights and bias for the output layer, and * indicates convolution. The activation function $\sigma(\cdot)$ ensures the resulting pixel values of $I_{\text {rec }}$ reside in the desired ranges, resulting in a regenerated character.

The U-Net reconstruction phase will provide the framework for subsequent adversarial reconstruction - and while it may be an approximation and a high-fidelity regeneration of the Kannada handwritten strokes, it is enough for the next generation of GAN based learning. The encoder's hierarchical feature extraction and the decoder's ability to reconstruct structurally provides assurance that both the macro employment of character shapes is reconstructed along with micro punctuations within strokes, allowing realistic character regeneration in future adversarial GAN stages.

3.3 Adversarial refinement with Generative Adversarial Network discriminator

Although the U-Net encoder–decoder generates an initial reconstruction of broken Kannada handwritten characters, it may still incorporate minor artifacts or unrealistic stroke connection, especially within complex ligatures or occluded areas. Therefore, to improve realism and enforce structural consistency, the generated characters are further refined using a GAN framework. In this adversarial scenario, the generator G will correspond to the U-Net reconstruction network and we introduce an additional discriminator D to assess the realism of characters generated.

The discriminator $D$ will output a probability score $D(I)$ given an image $I$, representing the probability that the image was real from the ground-truth dataset rather than generated. This can also be formally expressed as Eq. (11).

$D(I)=\sigma\left(W_d * I+b_d\right)$                (11)

Here $W_d$ is the convolutional kernels of the discriminator, $b_d$ is the bias term, * is convolution notation, and $\sigma$ is simply a non-linear activation. The GAN's adversarial objective is the usual min-max problem given in Eq. (12).

$\begin{aligned} V(D, G)=E_{I \sim \text { pdata}} & {[\log D(I)]} +E_{I(\text {rec} \sim p G)}\left[\log \left(1-D\left(I_{\text {rec}}\right)\right)\right]\end{aligned}$                 (12)

Here, $D$ is the discriminator, $G$ is the generator, $I$ is the true images from the true data distribution $p_{\text {data}}$ and $I_{\text {rec}}$ are the reconstructed images from the U-Net passed to the generator. This formulation trains $G$ to generate realistic images $I_{g e n}$ and $D$ to distinguish real and synthetic samples. Here, Eq. (13) the generator output.

$I_{g e n}=G\left(I_{r e c}, z\right)$                (13)

Here, $I_{\text {rec}}$ is the U-Net reconstructed image and $z$ is the latent noise vector used to generate outputs. The output $I_{g e n}$ is the adversarial refined Kannada character image that has both perceptual realism and restored stroke details. To ensure stability during training and to enhance convergence, we incorporate extra refinements including a gradient penalty as shown Eq. (14).

$L_{g p}=\lambda\left(\left\|\nabla_{\hat{I}} D(\hat{I})\right\|_2-1\right)^2$                  (14)

Here, $\hat{I}$ denotes an interpolated image from the real and generated samples, $D(\hat{I})$ denotes the output from the discriminator, $\nabla_{\hat{I}}$ denotes the gradient with respect to $I$ and $\lambda$ denotes a weighting factor. This loss functions to impose the Lipschitz constraint so that the discriminator does not become too powerful, which would create irregularities in adversarial training. Eq. (15) denotes the feature matching loss, which matches the intermediate feature maps of the discriminator.

$L_{f m}=\left\|\sum_l^L D^l(I)-D^l\left(I_{g e n}\right)\right\|_2^2$              (15)

Here, $D^{l(\cdot)}$ represents the feature maps from layer $l$ of the discriminator, $I$ is the real image, and $I_{g e n}$ is the generated image. This loss promotes the $I_{\text {gen}}$ to match structural as well as perceptual similarity to the real character beyond pixel-wise differences. With these adversarial constraints imposed, the GAN-based refinement promotes the generator to create regenerated Kannada characters that are both visually realistic and structurally faithful in order to mitigate typically observed reconstruction issues such as broken strokes, awkward junctions, and overall style inconsistency. At this stage, the GAN etiquette complements the previously described U-Netreconstruction by incorporating a discriminator-driven quality check that combines the initial coarse reconstruction to derive a regenerated handwritten character with high fidelity.

3.4 Loss function integration

To ensure that Kannada handwritten characters are accurately regenerated, our framework uses multiple loss components that instruct the generator to create visually coherent, structurally faithful, and identity-preserving reconstructions of the handwritten characters. These losses include pixel-level reconstruction loss, structural similarity loss, perceptual loss, and adversarial loss that together provide an appropriate balance between fidelity, stroke correctness, and realism.

The reconstruction loss $L_{\text {rec}}$ encourages the generator to minimize the pixel-wise difference between original character $I_{\text {orig}}$ Iorig and the regenerated output image $I_{\text {gen}}$ as shown in Eq. (16).

$L_{r e c}=\left\|I_{o r i g}-I_{g e n}\right\|_1$                (16)

In this equation, $I_{\text {orig}}$ is the ground-truth Kannada character image and $I_{\text {gen}}$ is the image reconstructed through the hybrid U-Net + GAN framework. L1 norm ensures that the regenerated image closely relates to the original strokes which promote the coherent reconstruction of fragmented characters. The L1-norm criterion diminishes blur artifacts while retaining clear details of fine strokes. To preserve the overall structure fidelity, we additionally use a structural similarity loss, referred to as SSIM as given Eq. (17).

$L_{\text {ssim}}=1-\operatorname{SSIM}\left(I_{\text {orig}}, I_{\text {gen}}\right)$               (17)

Here, $I_{\text {orig}}$ denotes the ground-truth Kannada character image while $I_{g e n}$ denotes the generated image coming from the framework. We subtract the SSIM index from 1 to penalize structural differences in the loss allowing the different stroke shapes and characters geometric structures to be preserved upon regeneration. In order to capture higher-level semantic features as opposed to pixel values. We also define a perceptual loss $L_{\text {perc}}$ over intermediate layers of a pretrained convolutional network VGG) as Eq. (18).

$L_{\text {perc}}=\sum_i^I\left\|\phi_i\left(I_{\text {orig}}\right)-\phi_i\left(I_{\text {gen}}\right)\right\|_2^2$                    (18)

Here, $\phi_i(\cdot)$ denotes the feature map from the $I^{\text {th}}$ layer of a pretrained CNN. The perceptual loss captures higher-level semantic divergences to enhance stroke realism. Finally, the adversarial loss $L_{a d v}$ complements these, which also encourages realism using the discriminator's feedback as shown in Eq. (19).

$L_{a d v}=-E\left[\log D\left(I_{g e n}\right)\right]$                (19)

Here, $D(\cdot)$ is the discriminator, $I_{g e n}$ is the generated image. The adversarial loss encourages realistic-looking handwriting textures with respect to discriminator feedback. In this synthesis, all of these components combine as follows into the combined generator loss given in Eq. (20).

$L_G=\alpha L_{r e c}+\beta L_{s s i m}+\gamma L_{p e r c}+\delta L_{a d v}$                   (20)

Here, $\alpha, \beta, \gamma$, and $\delta$ are hyperparameters weighting reconstruction, structural, perceptual, and adversarial contributions, respectively. $L_G$ is the overall generator loss used to train the U-Net + GAN generator. The discriminator will have a similar loss set to maximize its ability to distinguish real characters from generated characters. $L_D$ is the discriminator loss defined as Eq. (21).

$L_D=-\left(E\left[\log D\left(I_{\text {orig}}\right)\right]+E\left[\log \left(1-D\left(I_{\text {gen}}\right)\right)\right]\right)$                  (21)

Here, $I_{\text {orig}}$ represents the real image while $I_{\text {gen}}$ is generated. LD maximizes the discriminator's ability to distinguish real from generated Kannada characters. By combining reconstruction, structural, perceptual, and adversarial objectives, this integrated loss is developed to maximize pixel accuracy of the regenerated Kannada characters, visual authenticity, and structural validity, in order to lay a sound optimization and validation framework.

3.5 Training objective with min–max optimization

The UNGAN-KR framework training goal is expressed as a min-max optimization problem, a classic characteristic of Generative Adversarial Networks (GANs), where the generator $G$ and discriminator $D$ are trained jointly to achieve realistic stroke reconstruction and good preservation of character identity. More specifically, the generator is trained to minimize its total loss $L_G$, so it generates visually believable characters while providing structural consistency among all characters. Meanwhile, the discriminator is trained to maximize its assessment of the likelihood of identifying a character as either real or regenerated, which is captured using the loss $L_D$ and represents the two objectives of the discriminator as Eq. (22).

$M N F=\left(L_G+L_D\right)$                 (22)

In more detail, the generator loss $L_G$ leverages pixel-level reconstruction loss, similarity in character structure, perceptual similarity in character form between the image and the reconstruction, and adversarial feedback from the discriminator $L_D$ as given in Eq. (23).

$\theta_G=\theta_G-\eta \cdot \frac{\widehat{m_t}}{\sqrt{\widehat{v_t}}+\epsilon}$                  (23)

The discriminator loss simply assesses how well $D$ differentiates characters as either real or regenerated. To optimize these objectives, we employed gradient-based updates using the Adam optimizer as shown in Eq. (24).

$\theta_D=\theta_D-\eta \cdot \frac{\widehat{m_t}}{\sqrt{\hat{v}_t}+\epsilon}$                        (24)

where $\theta_G$ and $\theta_D$ are parameters of the generator and discriminator respectively, $\eta$ is the learning rate, and $\widehat{m_t}, \widehat{v_t}$ are bias-corrected moment estimates. Learning rate decay and gradient clipping are employed to stabilize training as shown in Eq. (25).

$\eta_t=\eta_0 \cdot \frac{1}{1+\lambda t}$                    (25)

Here, $\eta_0$ is the initial learning rate, $\lambda$ is the decay factor, and t indicates the current training step. Eq. (26) applies a decay to the learning rate, which reduces $\eta_t$ across time, and helps ensure stable convergence to the solution.

$h_l^{\text {drop}}=h_l \cdot m, \quad m \sim \operatorname{Bernoulli}(p)$                (26)

Here, $h_l$ is the activation of layer $l$, and mmm is a Bernoulli random mask with probability $p$ that indicates dropout regularization randomly deactivates neurons to mitigate overfitting. Eq. (27) is referred to as the gradient clipping mechanism.

$g_t=\frac{g_t}{\max \left(1,\left\|g_t\right\|_2 / c\right)}$                 (27)

Here, $g_t$ is the gradient at step $t$, and ccc is the threshold for clipping. Within gradient clipping, the gradient is clipped to ensure that the updates remain bounded to prevent exploding gradients that can occur during training of the generator and discriminator. Lastly, similar to dropout regularization in the generator, dropout regularization mitigates common forms of overfitting and allows the generator to generalize well across the various handwritten Kannada characters. In addressing this through a min-max optimization problem, the generator continues to learn to generate high-fidelity stroke reconstructions that can fool the discriminator into thinking it had seen the original, while the discriminator is continually learning to become better at recognizing real characters. Overall, this adversarial training occurs at a high frequency within a loop, ensuring that the recreated characters are visually representative and also similar to the original handwritten character, as the first stages of the character regeneration pipeline.

3.6 Validation and preservation of character identity

An important consideration in the regeneration of Kannada handwritten characters is the preservation of character identity such that the regenerated strokes respect the original character while providing better visual consistency. To support this, the framework incorporates identity-preserving constraints and validation metrics that direct the generator to produce structurally and semantically consistent outputs. First, apply a character classification constraint to the generator output $y_{\text {pred}}$ derived from a pre-trained classifier using Eq. (28).

$y_{\text {pred}}=\operatorname{Softmax}\left(W_c f_{\text {gen}}+b_c\right)$             (28)

Here, $f_{\text {gen }}$ is the feature map of the generated character, and $W_c$ and $b_c$ are the classifier weights and bias. The resultant cross-entropy loss preserves the label of the generated character using Eq. (29).

$L_{i d}=-\sum_i^I y_i \log y_{p r e d, i}$                 (29)

Here, $y_i$ corresponds to the ground-truth one-hot label for class $i$, and $y_{\text {pred}, i}$ denotes the predicted probability for that class. This loss guarantees that the regenerated Kannada character retains its original class identity during training. To promote stroke-level consistency, a skeletonization operator, denoted ${{\mathrm{S}}}(\cdot)$, is utilized, and a stroke consistency loss is defined as Eq. (30).

$L_{\text {stroke}}=\left\|S\left(I_{\text {orig}}\right)-S\left(I_{\text {gen}}\right)\right\|_2^2$                   (30)

Here, $S(\cdot)$ indicates a stroke extraction function capturing the skeletal or structural representation of the Kannada character strokes. This loss guarantees that the regenerated image $I_{\text {gen}}$ reproduces the original strokes from $I_{\text {orig}}$. This loss guarantees that the regenerated strokes follow the same trajectory as the original strokes, which is particularly important for complex Kannada ligatures and diacritics. Additionally, to prevent jagged and unnatural stroke connections, curve smoothness is imposed via Eq. (31).

$L_{\text {smoot}}=\sum_t^T\left\|\Delta^2 x_t\right\|^2+\left\|\Delta^2 y_t\right\|^2$                (31)

where, $\left(x_t, y_t\right)$ represents a stroke coordinate at time step $t$, and $\Delta^2$ computes the second-order differences along the stroke curve. Lastly, a style consistency loss defined with respect to Gram matrices $G_j$ ensures that the overall visual style of the handwritten character is preserved using Eq. (32).

$L_{\text {style}}=\sum_j^J\left\|G_j\left(I_{\text {orig}}\right)-G_j\left(I_{\text {gen}}\right)\right\|_F^2$               (32)

Incorporating these criteria, the ultimate generator loss with respect to identity preservation is expressed as Eq. (33).

$L_G^{\text {final}}=L_G+\lambda_{i d} L_{i d}+\lambda_{\text {stroke}} L_{\text {stroke}}$                  (33)

where, $\lambda_{i d} \lambda_{\text {stroke}} L_{i d}$ and $L_{\text {stroke}}$ are trade-offs that balance the importance of each identity preserving criterion. The training goal now shifts as Eq. (34).

$F_{\text {opt}}=L_G^{\text {Final}}+L_D$                  (34)

This provides assurance that the generator not only outwits the discriminator but also produces characters that remain correct, clear, and visually true to the original handwritten Kannada characters. Furthermore, aspects of the quality of regeneration are assessed using quantitative metrics of reconstruction accuracy, FID score, PSNR, and stroke-level precision and recall to ensure visual realism and semantic correctness. By combining these validation processes and identity preservation processes, the presented framework facilitates robust regeneration of broken handwritten Kannada characters while preserving all unique stroke patterns, ligature structures, and overall handwritten style, which is enormously important for subsequent applications such as OCR and historical document digitization.

This paper has introduced a U-Net + GAN hybrid model to regenerate broken Kannada handwritten characters. It is an important problem in manuscript preservation as well as for handwriting capture systems. The proposed UNGAN-KR model adopts stroke reconstruction based on U-Net encoder–decoder architecture together with adversarial refinement to restore missing or degraded strokes while maintaining the original handwriting style. Experimental results using a dataset of 71,149 Kannada handwritten character images demonstrate that the proposed framework consistently outperforms. A set of base line approaches including CNN autoencoders, U-Net, and GAN-based inpainting methods. The framework proposed achieved a recognition accuracy of 97.8%, which is 8.4% more than the baseline mechanisms. This confirms the efficacy of the adversarial refined continuous U-Net encoder–decoder for fine-grained reconstruction of Kannada strokes. In the future, it can be extended the proposed framework to multi-script handwritten datasets to test its generalizability across multiple Indian scripts. The inclusion of transformer-based attention models and semi-supervised training may improve stroke reconstruction by reducing reliance on large annotated datasets. Additionally, employing diffusion-based generative models may improve the realism and perceptual quality of the character’s regeneration, especially for more poorly degraded or visually stylized handwriting.