Deep inception neural network with residual connections for Tamil handwritten character recognition

Abstract

The research community is actively working on character recognition for various languages, including Tamil, Arabic, Chinese, Telugu, and Malayalam. It is important to digitize texts so that large-scale documents can be saved, retrieved, and analysed efficiently. This serves as a foundation for digital preservation of cultural heritage by exploring Optical Character Recognition (OCR). Tamil Handwritten Character Recognition (THCR) is challenging as there are many letters in Tamil that have only a small style difference. To address this, we have proposed a Deep Inception Neural Network framework with residual connections for efficient Tamil handwritten character recognition (TamHNet). A non-linear bilateral filter technique is used to preprocess the handwritten images, and TamHNet is employed to classify the Tamil handwritten characters. For evaluation, the proposed system is trained using our own Tamil Isolated Character Dataset (TICD), which comprises isolated Tamil handwritten characters collected from multiple individuals with diverse writing styles. These characters are uploaded to Mendeley for future research and benchmarking. The novelty of TamHNet lies in the domain-adaptive fine-tuning of the Inception-ResNet architecture for THCR.The proposed TamHNet goes beyond traditional methods by systematically finding and selectively unfreezing learnable layers to optimize weights and biases in a targeted way. Fine-tuning helps the model accurately represent the distinctive structural and complex differences in Tamil script, which leads to better feature discrimination and recognition performance. It uses the Adam optimizer, which combines first-order (momentum) and second-order (adaptive learning rate) estimations. This allows the learning rates for each parameter change over time to helps the model to converge faster and deal with sparse gradients better to stay stable when faced with complicated, non-convex loss surfaces. In THCR, adaptive parameter tuning using Adam will improve the model ability to learn small details, which makes the training process faster and more accurate. This robust framework, with a fine-tuned architecture, achieved an impressive accuracy of 99.8%, outperforming other state-of-the-art algorithms.

Introduction

More than 80 million people speak Tamil, the oldest Dravidian language. Most people live in southern India, Sri Lanka, Singapore, and Malaysia. After Hindi and Bengali, Tamil is the fifth-most-spoken language in India¹. There are 247 characters in Tamil, including 12 vowels, 18 consonants, and the unique character aayutha ezhuthu. When you combine vowels and consonants, you get 216 more vowelized consonants². Converting handwritten Tamil manuscripts into a format that machines can read is not an easy task³—Optical Character Recognition (OCR) and Scene Text Recognition. Optical Character Recognition (OCR) and Scene Text Recognition (STR) are the two primary methods employed for character recognition. Optical Character Recognition (OCR) and Scene Text Recognition (STR) utilise automated text extraction, but they have distinct goals and operate under different constraints. Traditional OCR is used to identify and translate printed or handwritten text from scanned, structured documents, such as books or forms, and convert them into machine-readable text with a consistent and regular text appearance. Conversely, STR is designed to read text found in natural scenes, such as street signs, product labels, or billboards, where text can be diverse in font, orientation, background, and illumination. STR systems commonly utilise high-level deep learning methods to reliably recognise and read text within rich and dynamic visual scenes. OCR works successfully with clean, well-composed images that contain little distortion or noise. OCR is designed for clean documents with structured content, while STR is designed for text in natural scenes and uses sequence-based, segmentation-free models⁴.

Recognising Tamil characters is very difficult as the script is cursive (vattezhuthu), has structural similarities, overlapping strokes, and different writing styles. For example, the lower portion of letters like எ and ஏ or ஒ and ஓ are only slightly different. Writers sometimes mix up letters like ல and வ or மு and ழு. Similarly, pairs such as மு/மூ, ழு/ழூ, and டு/டூ share a close resemblance in their upper portions. To address these challenges, a proposed TamHNet is implemented to recognise 246 Tamil characters by leveraging their structural uniqueness and handling overlaps. The three-dot notation symbol, called “Aayutha Eluthu, ஃ” is not included in this study.

Key contributions of the proposed model

• A comprehensive dataset of Tamil isolated characters is proposed and stored in Mendeley.

• Fine-tuned Inception Network with residual connection for Handwritten Character Recognition in Tamil (TamHNet)

• The proposed TamHNet achieved a maximum accuracy of 99.8%, marking a significant advancement in the recognition of Tamil handwritten characters.

• The proposed TamHNet achieved competitive results, outperforming other existing state-of-the-art methods.

Section "Related works" reviews the existing machine learning algorithms and deep learning methods for Tamil Character Recognition. Section "Proposed TamHNet framework" describes the proposed TamHNet model used in this work. The testing results and performance of the suggested system are further described in Section "Results and discussion". Section "Conclusion and future work" concludes the paper by identifying potential areas for further research and summarising the key findings.

Related works

Integrating deep learning models with efficient optimisation techniques has significantly improved the speed and accuracy of systems for handwritten character recognition in recent years. Raj et al.² employed a Support Vector Machine (SVM) to identify locational features for recognising the structure of Tamil characters. The SVM classifier achieves 87.41% test accuracy, 93.91% validation accuracy, and 95.22% training accuracy using a hybrid method that combines Generative Adversarial Networks (GANs) and Convolutional Neural Networks (CNNs). Kavitha et al.⁴ achieved 95.16% training accuracy and 97.71% test accuracy in Tamil character recognition. The HP Tamil dataset, comprising 82,928 samples with 500 examples for each class, is used to train the model.

The Smart Flower Gradient Descent optimisation-based Generative Adversarial Network (SFGDO-GAN) is proposed by Sasipriya et al.⁵ to recognise handwritten Tamil characters. The model adjusts the GAN’s weights to achieve 91.8% sensitivity, 92.52% specificity, and 94.13% accuracy. Vinothini et al.⁶ created the end-to-end deep learning-based Tamil handwritten document recognition (ETEDL-THDR) system. The model used a Deep Convolutional Neural Network to classify characters. MobileNet and median filtering are used for preprocessing. The model’s accuracy, precision, and F-measure are 98.48%, 98.38%, and 98.35%, respectively. Gayathri et al.⁷ utilised the Inception v3 model to develop a Transfer Learning-based THCR with an accuracy rate of 93.14%.

Jayanthi et al. developed a CNN model for character recognition⁸. The Bayesian optimisation technique is used to modify the model’s hyperparameter values. The altered hyperparameters are used to evaluate the accuracy and performance metrics. The accuracy of the testing is 87.3%, while the accuracy of the training is 96.91%. Sasipriya et al. developed a hybrid model combining a Scrabble GAN and a CNN⁹. New training samples are generated from the old ones using the Scrabble GAN model to improve accuracy. over 6000 images in their dataset, 80% are used for training and 20% for testing, resulting in a 96.23% accuracy rate. Sonthi et al.¹¹ developed the Functional Link Neural Network (FLNN) model, which can recognise Telugu handwritten characters and provides the dataset with the right class labels. The Multi-Objective Mayfly Optimisation (MOMFO) technique is used to identify the optimal parameters. The model attained an accuracy of 99.11%, a precision of 98.74%, and a recall of 98.94%, respectively. Shaffi et al.¹³ developed the unconstrained Tamil Handwritten Character Database (uTHCD). The model utilised a Convolutional Neural Network (CNN) for recognising handwritten Tamil characters. The system’s accuracy for testing and validation is 92.32% and 93.32%, respectively.

Kaur et al.¹⁴ employed the classifiers using Support Vector Machine (SVM), k-Nearest Neighbour (KNN) and Random Forest (RF). Each classifier utilises a method based on consensus, and the AdaBoost algorithm is utilised to enhance system performance by combining the results of all the classifiers. The dataset achieves an accuracy of 88.78% for 100,000 sample records. Pande et al.¹⁵ reported an overall accuracy of 97.67% for Devanagari handwritten text recognition (DHTR) using a CNN. There are 2,000 publicly available unique images for each of the 46 classes in the Devanagari dataset.

By reformulating a local binary pattern (LBP) as a convolution layer, Wajih et al.¹⁷ deliver a novel model. The MNIST and MADBase databases are used for the model. The accuracy for the proposed Compressed Sparse Local Binary Convolutional Neural Network (CS-LBCNN) and Ternary Compressed Sparse Local Binary Convolutional Neural Network (TCS-LBCNN) is 99.50% and 99.54%, respectively. Anjum et al.¹⁸ used Contextual Attention Localisation for Offline Handwritten Text (CALTEXT) to aid in recognising meaningful characters in Arabic and Urdu datasets. The model achieved 82.06% accuracy in recognising characters and 51.97% accuracy in recognising words in the Urdu dataset. The model achieved 77.47% accuracy in character recognition and 37.66% accuracy in word recognition in the Arabic dataset. Raj et al.¹⁹ employed the Z-ordering technique to organise the structure. They employed an SVM-based hierarchical classification method to identify characters based on their attributes, utilizing a divide-and-conquer strategy. The average accuracy is 94.74%, the accuracy for extracting form and locational features is 82.42%, and the accuracy for Z-ordering is 88.31%. Dhivya et al.²² developed a GAN (Generative Adversarial Network) for image synthesis, and the proposed approach consists of two GANs, Base GANS and Hybrid Super Resolution GANs, for the efficiency of the model.

Shanmugam et al.²³ developed a hummingbird optimisation-based deep belief neural network (DBN) for recognising Tamil handwritten characters. The model attains 94.12% accuracy, and is simpler to digitize and automate documents. Maheswari et al.²⁴ developed an innovative character segmentation method that used deep learning to convert old Tamil palm leaf manuscripts into digital forms. This method accurately separates and identifies characters from old manuscripts, helping to preserve the historical writings and attaining an accuracy of 96.04%. Bhuvaneswari et al.²⁵ proposed a deep-learning method for understanding and recognising ancient Tamil inscriptions. The model achieved precision of 97.25%, recall of 95.05%, and an F1-score of 95.17%. Murugan et al.²⁶ proposed a framework for detecting, recognising, and labelling ancient Tamil inscriptions. The DR-LIFT framework utilises an interpreter to read and understand text accurately. It has a recognition rate of 98.22% and helps in the study and preservation of Tamil culture. Jayachandran et al.²⁷ employed a multi-attention-based CNN and utilizing attention methods to enhance feature extraction in convolutional layers for Tamil handwritten characters. The model achieved reasonable recognition rates using multi-scale attention fusion. The constraints include reliance on extensive annotated datasets due to variances in writing style. Rani and Bipin²⁸ proposed a lightweight deep semantic binarization network (PLM-Res-U-Net) to address issues such as fractures and discoloration in palm-leaf writings. The model improves OCR preprocessing quality by preserving fine text strokes on textured backgrounds. Some problems are poor convergence and the need for different degraded samples. Moudgil et al.²⁹ used a Capsule Networks for Devanagari manuscript character recognition, achieving an accuracy of 95.98% and outperforming ResNet through efficient spatial hierarchy modelling. However, inconsistencies in segmentation and dependence on manually produced features remain an issue.

Prashanth et al.³⁰ proposed an updated LeNet and AlexNet architectures for handwritten Devanagari recognition, attaining enhanced accuracy of 97.5%. Jindal and Ghosh³¹ developed a semi-self-supervised framework for ancient Indian scripts, which reduces the workload required for annotation while improving recognition on damaged manuscripts. Kasuba et al.³² developed PLATTER, a page-level handwritten text recognition system for several Indic scripts, which processes pages from beginning to end with several enhancements. The framework integrates layout analysis, line segmentation, and sequence modelling into a single pipeline, enabling conversion of complex handwritten pages from start to finish. An overview of state-of-the-art methods for offline handwritten character recognition is provided in Table 1.

Table 1.

State-of-the-art methods for offline Tamil handwritten recognition.

Authors	Methods used	Performance	Drawbacks
Shyni et al.3	CNN, MLP classifier	Overall, Accuray 88%	Low accuracy and high processing time due to the increase in the number of layers in the proposed model
Raj et al.2	SVM	Test accuracy- 95.2% Training accuracy-93.9% Validation accuracy-87.41%	High Misclassification rate
Sasipriya et al.5	SFGDO (Smart flower gradient decent optimisation based generative adversarial network)	Accuracy-91.8% Sensitivity-92.5% Specificity-94%	Time and space complexity perform well only with a larger number of samples
Vinotheni et al.6	Deep CNN	Accuracy-98.48% Precision- 98.38% Sensitivity- 97.98% Specificity- 98.27% F-measure- 98.35%	Low recognition accuracy
Gayathri et al.7	Transfer learning	Overall accuracy- 93.1%	Low accuracy, high training time
Jayanthi et al.8	Bayesian optimisation algorithm, CNN	Test Accuracy- 87.3% Training Accuracy- 96.9%	Characters with similarities cannot be recognised correctly
Bavani et al.10	MVGG16, VGG16	Overall accuracy- 91.8%	Time complexity, low accuracy
Sasipriya et al.9	Scrabble-GAN (Generative adversarial network and augmentation) with CNN	Overall accuracy- 96.23%	Unbalanced dataset, low accuracy, low precision
Sonthi et al.11	Objective mayfly optimisation with deep learning (MOMFO-DL)	Accuracy-99% Precision- 98.74% Recall-98.94% F-Score-98.48%	Low accuracy
Suriya et al.12	CNN	Average accuracy-97.7%	Can detect only partial Tamil alphabets (not trained with vowelized consonants)
Shaffi et al.13	Unconstrained Tamil handwritten character database(uTHCD)	Test Accuracy- 87.3% Validation accuracy-93.32%	Unbalanced dataset, low segmentation accuracy
Kaur et al.14	Experimental analysis: k-NN, SVM, Random Forest Ensemble algorithm: AdaBoost	Overall accuracy- 88.78%	Low accuracy, precision, and recall
Pandey et al.15	CNN is using transfer learning	Overall accuracy- 97.67%	Unbalanced dataset
Hidayat et al.16	CNN	Testing accuracy-97.74%	Low accuracy, low recognition rate
Wajih et al.17	CS-LBCNN, TCS-LBCNN	CS-LBCNN-99.50% TCS-LBCNN-99.54%	Low accuracy, unbalanced dataset
Anjum et al.18	CALTEXT	For the Urdu dataset: Character recognition rate- 82.06% Word recognition rate- 51.97% For the Arabic dataset: Character recognition rate- 77.47% Word recognition rate- 37.66%	Time complexity, Low accuracy
Raj et al.19	Z-ordering algorithm for addressing the structure and shape of locational features PM Quad tree	Z-ordering algorithm-88.3% PM quad tree- 82.4% Average result-94.7%	Misclassifications, Low accuracy
Kowsalya et al.20	ANN- feature extraction, Elephant herd algorithm- modifying weights	Overall accuracy-92.52%	Low accuracy, low precision, low recall

Although considerable advancements have been made in handwritten character recognition using deep learning models, several challenges remain. There is limited availability of data for Tamil written character recognition. The survey indicates that only a limited number of studies address Tamil handwritten character recognition, and Table 1 shows that most of the models provide low accuracy. Hence, there is a demand for a robust deep learning model to accurately recognise handwritten Tamil characters.²¹

Proposed TamHNet framework

The proposed framework for recognising isolated Tamil characters consists of three main phases: (1) Data collection and Augmentation, (2) Data preprocessing, and (3) The design of a fine-tuned Inception-ResNet-v2 model trained with the Adam optimiser, as shown in Fig. 1.

Fig. 1.

TamHNet Framework.

Dataset collection

The Tamil isolated character dataset is proposed for training TamHNet in efficient character recognition. In our study, we did not rely on synthetic data generation; instead, we collected real-time data samples directly from 1000 students at SASTRA Deemed University, which are available at: https://data.mendeley.com/datasets/6zcpgchvmx/1. The dataset contains 12 vowels, 18 consonants, and 214 compound characters. The labels are minimised to reduce the training samples and processing time. Labelling the vowel character ‘ஔ’ is not needed because ‘ஒ’ and ‘ள’ are already labelled. The கா series, கை series, கெ series, கே series, and கௌ series, which are the vowelised consonants, come with a modifier ா, ை, ெ, ே.

Image augmentation

The TamHNet incorporates preprocessing techniques, including denoising, background removal, binarisation, and segmentation, which are implemented. The image augmentation is incorporated in the following ways: The fiducial points f at the top and bottom image borders are initialised as 2(P + 1) and are averaged to partition the image into patches. Then, additional information is embedded in the images by randomly relocating the fiducial points within the radius while adhering to a predetermined distribution. The moving least squares-based similarity deformation is applied to the input image to generate an augmented image. The transformation for the given picture point is

1

The constraint for some scalar should be satisfied by , which is a linear transformation matrix. The weighted centroids of the initialised fiducial point and the relocated fiducial point , respectively, are represented here by and . The initialised fiducial point and the relocated fiducial point

2

The point has the form in the weight which is represented below in (3),

3

The unique minimiser is yielded in (4) by minimising the best transformation ,

4

where is the quadratic and is linear in parameter and weight matrix is positive.

As a result, the dataset is divided into 70% for training and 30% for validation in scenario 1, and into 80% for training and 20% for validation.

Design of fine-tuned Inception with residual connection

Unlike traditional Inception networks, which primarily focus on multi-scale feature aggregation and emphasise residual learning, fine-tuned Inception-ResNet-v2 combines both strategies, enabling richer hierarchical feature extraction with improved training stability and efficiency. A fine-tuned version of Inception, called Inception-ResNet-v2, exhibits significantly improved recognition performance. For improved accuracy, TamHNet utilizes a fine-tuned model based on Inception-ResNet-V2, as depicted in Fig. 2. The first layer consists of Inception layers, followed by a convolutional layer that performs the filter expansion tasks. The dimensionality scale-up has been performed at the filter bank to match the depth of the next input layer. The STEM layer is the first layer of the architecture and has fewer parameters. It has a 3×3 stride convolution filter. The primary benefit of the Inception ResNet v2 model is that it combines the best features of Inception and ResNet to create a hybrid model for an efficient character recognition system. There is a mapping between and such that the kernel size is proportional to the channel dimension . The channel dimension is typically two times its exponent. As a result, (5) shows the mapping relationship:

5

Fig. 2.

Architecture of Fine-tuned Inception ResNet-v2 model.

A function that calculates the kernel size as (6), where odd indicates the odd number of nearest neighbours, is set to 2, and is set to 1, can self-adapt the size of the neural network kernel of a one-dimensional convolution. Layers with more channels are permitted to have cross-channel interactions.

6

There are three Inception ResNet blocks, A, B, and C, which are separated by two reduction blocks, and The reduction blocks reduce the feature map size and the number of parameters, thereby automatically reducing learning time. The model’s primary objective is to establish direct connectivity to the Highway Network module. Additionally, it enables direct communication from the first input dataset to the succeeding layer. It is necessary to adjust the inputs and outputs to identify the model’s advantages and disadvantages. ReLU is employed in the network, as shown in (7), to reduce the risk of overfitting, enhance the extraction of local features, prevent gradient disappearance due to negative inputs, and improve model performance.

7

The preprocessing is done first to benefit the TamHNet in better extracting information from images of Tamil manuscripts. After normalization, each processed image has a size of 299 × 299 pixels. The colour is initially removed from the photos by greying them out, as it makes no difference in the recognition of Tamil characters. Grey scale images are used for noise reduction and smoothing by Gaussian filtering to reduce the effect of the noise on the OCR robustness and precision. The images are binarized, categorising pixel values into two groups: black pixels represent the foreground, while white pixels denote the background, facilitating the differentiation between the target and the backdrop. Set the pixel point share of the foreground to , the average grayscale to , the pixel point share of the background to , and both to to compute the interclass variance of the image’s foreground and background, as shown in (8).

8

The is represented as a triplet, which is the source domain knowledge.

9

The ImageNet dataset is represented as , the ground truth dataset is , and is the objective predictive function.

The target domain knowledge for the character images,

10

where is the dataset’s ground truth, is the classifier, and is the binary class source images with PA view.

The classifiers with can be defined as,

11

The classifier should reduce the error in the prediction,

12

It enables raising the quality of training images from the database, where the input image quality of handwritten images is low. The robustness of the fine-tuning approach in TamHNet is utilised to achieve optimal performance in character recognition, classification, and validation. Algorithm 1 explains the TamHNet workflow, which fine-tunes the Inception-ResNet-V2 model for Tamil Handwritten Character Recognition, detailing the required inputs, preprocessing steps, training procedure, and the final adapted architecture.

Algorithm 1.

TamHNet.

vSince for some scalar is a linear transformation matrix that must satisfy this constraint. The weighted centroids of the initialised fiducial point and the relocated fiducial point , respectively, are represented here by and :

13

The point has the form which is represented below.

14

The unique minimizer is obtained by minimizing the best transformation

15

Adaptive moment estimation (Adam) optimizer for training TamHNet

In our proposed TamHNet, the Adam optimiser is utilised to effectively train the model by iteratively adjusting the network weights within each epoch. Adam overcomes the limitations of the classical Stochastic Gradient Descent (SGD) by using exponentially weighted moving averages of the first moment (the mean of gradients) and second moment (uncentered variance), which permit adaptive learning rates for every parameter. Adam increases convergence speed and stability by integrating momentum with adaptive learning rates to ensuring the network optimally adjusts according to the gradients at each iteration. For each input character image, gradients are computed, first and second moments are updated, and bias-corrected estimations are calculated to change the parameters = -α* + . This method solves the large variance problem identified with SGD and is important for identifying variations in handwritten characters. The adaptive characteristic of Adam is useful for character identification, since it effectively maintains sparse gradients and noisy input data resulting from differences in handwriting style, stroke, and size. As a result, employing Adam enables the network to achieve optimal training performance and a high recognition rate with minimal memory and first-order gradients, making it an ideal choice for our model. Algorithm 2 illustrates the changes made and updates to the parameters.

Algorithm 1.

Adam optimizer algorithm for weight adjustment in each epoch.

Using the above algorithm, TamHNet is trained to 100% training accuracy and has updated weights at each epoch. The input layer is also adjusted for grayscale image input, with the ability to handle single-channel data, which is common in handwritten character recognition. The last layer is configured to have the same number of output classes (104), ensuring proper classification mapping. The TamHNet is optimised with the Adam optimiser, using a learning rate of 0.001 and categorical cross-entropy as the loss function. Training happens in batches of 32 samples for 50 epochs.

Results and discussion

This section mainly discusses the experimental setup and performance evaluation of the proposed TamHNet model. The efficiency of the TamHNet Architecture is assessed using various metrics and methods. The dataset is split into 70% for training and 30% for validation. The model was trained on 104 classes, generating a 104 × 104 confusion matrix for performance evaluation. Due to the difficulty of displaying the complete matrix at this size, the decomposed confusion plots, categorised by label subsets for enhanced interpretability and visualisation, are provided. Although the grouped visualisation may suggest overfitting, the training and validation loss curves confirm that the model converges appropriately. Although Tamil comprises 247 characters derived from 104 base symbols, the model was trained and validated using only these 104 unique symbols to avoid redundancy and ensure consistent representation. The TamHNet aims to identify handwritten characters from document images. For that background suppression is important. Therefore, the preprocessing techniques are used to eliminate background artifacts. OCR systems focus mainly on character structures, especially edges. An edge-preserving binarization technique is utilized to preserve essential stroke information while removing noise. MATLAB 2023b is used to implement the TamHNet model on a workstation computer with an NVIDIA GPU and 16 GB of RAM.

The following metrics assess the suggested model: F-measure, sensitivity, specificity, recall, accuracy, and precision. The confusion matrix assesses the effectiveness of the suggested system. Figure 3a–f shows the confusion matrix from class 1 to 101, and Fig. 3g shows the Confusion matrix from class 102 to 104.

Fig. 3.

(a) Confusion Matrix for vowels. (b) Confusion Matrix for {க, ங, ச, ஞ, ட, ண, த, ந, ப, ம, ய, ர, ல, வ, ழ, ள, ற, ன} (c) Confusion Matrix for {கி, ஙி, சி, ஞி, டி, ணி, தி, நி, பி, மி, யி, ரி, லி, வி, ழி, ளி, றி, னி}. (d) Confusion Matrix for {கீ, ஙீ, சீ, ஞீ, டீ, ணீ, தீ, நீ, பீ, மீ, யீ, ரீ, லீ, வீ, ழீ, ளீ, றீ, னீ}. (e) Confusion plot for {கு, ஙு, சு, ஞு, டு, ணு, து, நு, பு, மு, யு, ரு, லு, வு, ழு, ளு, று, னு}. (f) Confusion plot for {கூ ஙூ, சூ, ஞூ, டூ, ணூ, தூ, நூ, பூ, மூ, யூ, ரூ, லூ, வூ, ழூ, ளூ, றூ, னூ}. (g) Confusion plot for

From Fig. 3a, it is observed that the vowels இ, உ, எ, and ஓ achieved the highest recognition accuracy, corresponding to classes 3, 5, 7, and 11, respectively. Figure 3b indicates that the consonants க, ங, ஞ, ட, ந, ம, ழ, and ற attained higher accuracy levels in their respective classes 12, 13, 15, 16, 19, 21, 26, and 28. Similarly, Fig. 3c shows that the letters நி, யி, and வி, belonging to classes 37, 40, and 43, obtained the highest accuracy. Finally, from Fig. 3d, it can be inferred that the letters சீ, ஞீ, லீ, and ழீ recorded superior accuracy in classes 50, 51, 59, and 62.

The highest accuracy is achieved for the Tamil letters கு, து, மு, ௫, வு, ழு, று and their corresponding labels are 66, 72, 75, 77, 79, 80, 82 is clearly illustrated in Fig. 3e. From Fig. 3f, the letters பூ, ளூ attained the highest accuracy, and their classes are 92 and 99, respectively.

The classification outcomes for classes 102, 103, and 104, showing that all samples were accurately assigned to their respective categories with no misclassifications are shown in Fig. 3g. In particular, all 29 samples of class 102, 17 samples of class 103, and 22 samples of class 104 were correctly predicted within their corresponding classes.

To estimate the performance of a multi-class classification problem, the TamHNet is validated with the ROC curve (Receiver Operating Characteristic Curve). The ROC curve is plotted separately for each class, and true positive, false positive, sensitivity, and specificity values have been calculated for the multi-class model. The true positive and false positive rates for each class have been plotted at various threshold values using this probability curve. Measured as a summary of the ROC curve, the AUC (Area Under Curve) represents a binary classifier’s ability to discriminate between classes. Figure 4a–g shows the ROC curve for all classes, ranging from class 1 to class 104.

Fig. 4.

(a) ROC for Vowels (Class 1 to 11). (b) ROC for Consonants (Class 12 to 29). (c) ROC for class 30 to 47. (d) ROC for class 48 to 65. (e) ROC for Class 66 to 83. (f) ROC for Class 84 to 101. (g) ROC for special symbols (Class 102 to 104).

Figure 4a shows the ROC plots for classes 1, 3, 5, 7, 10, and 11, demonstrating accurate classification with an AUC of 100% and illustrating the model’s excellent separability among the vowel classes. Figure 4b then highlights the performance on classes 12 to 29, with ROC curves indicating consistent and robust classification, aligning with high specificity and precision values. Moving to Fig. 4c, the ROC curves for classes in the range 30 to 47 shows perfect discrimination, with an AUC of 100% for multiple classes, such as 31, 33, 35, and 37, further emphasising the model’s effectiveness, with the curves clustering near the ideal top-left corner characteristic of excellent sensitivity and specificity. In Fig. 4d, the ROC curves for classes 48 to 65 show that the majority of classes also achieve perfect AUC scores, reflecting the model’s continued strong performance.

Figure 4e shows the ROC curves for classes 66 to 83, which again approach the ideal, evidencing high overall accuracy and precision. Lastly, Fig. 4f shows the ROC plots for classes 86, 88, 92, 98, and 99, where perfect AUCs are achieved.

The ROC curve shown in Fig. 4g illustrates the classification performance for three special-symbol classes in the Tamil handwritten character dataset. The curves plot the True Positive Rate (TPR) against the False Positive Rate (FPR), shows how effectively the model distinguishes between each class. Class 102 and Class 104 exhibit almost perfect discrimination, each achieving an AUC of 0.998, with their curves closely hugging the top-left region of the graph. Class 103 also demonstrates strong performance with an AUC of 0.979, though its curve falls slightly below the others, indicating a slight reduction in sensitivity at certain thresholds. Collectively, Fig. 4a–f shows the classifier’s high capacity to distinguish between classes throughout the dataset, as demonstrated by the ROC curves trending towards the optimal point across all examined class segments.

The plot of training accuracy and loss over iterations reveals that the model’s accuracy rapidly increases at the start of training and then ended near 99%, signalling early and effective learning. Simultaneously, the training loss steadily declines throughout training, indicating consistent improvement in the model’s ability to minimise prediction errors as it learns from the data. This overall pattern demonstrates that the model converges efficiently and achieves robust performance on the training set, as indicated by high accuracy accompanied by persistently low loss. The blue line indicates training accuracy, while the orange line shows training loss, as shown in Fig. 5. All the performance analyses for classes 1 to 104, with micro- and macro-averaged results, are shown in Table 2.

Fig. 5.

Training accuracy and Training loss curve.

Table 2.

Performance evaluation for all classes.

Classes	True positive	False positive	False negative	True negative	Precision	Sensitivity	Specificity	Accuracy	F-measure
classes_ 1 {அ}	29	0	1	3090	1.00	0.96	1.00	0.99	0.98
classes_ 2 {ஆ}	23	1	7	3089	0.95	0.76	0.99	0.99	0.85
classes_ 3 {இ}	22	0	8	3090	1.00	0.73	1.00	0.99	0.84
classes_ 4 {ஈ}	27	6	3	3084	0.81	0.90	0.99	0.99	0.85
classes_ 5 {உ}	30	3	0	3087	0.90	1.00	0.99	0.99	0.95
classes_ 6 {ஊ}	29	6	1	3084	0.82	0.96	0.99	0.99	0.89
classes_ 7 {எ}	30	6	0	3084	0.83	1.00	0.99	0.99	0.90
classes_ 8 {ஏ}	27	2	3	3088	0.93	0.90	0.99	0.99	0.91
classes_ 9 {ஐ}	27	4	3	3086	0.87	0.90	0.99	0.99	0.88
classes_ 10 {ஒ}	28	3	2	3087	0.90	0.93	0.99	0.99	0.91
classes_ 11 {ஓ}	28	0	2	3090	1.00	0.93	1.00	0.99	0.96
classes_ 12 {க}	29	6	1	3084	0.82	0.96	0.99	0.99	0.89
classes_ 13 {ங}	30	1	0	3089	0.96	1.00	0.99	0.99	0.98
classes_ 14 {ச}	29	8	1	3082	0.78	0.96	0.99	0.99	0.86
classes_ 15 {ஞ}	29	3	1	3087	0.90	0.96	0.99	0.99	0.93
classes_ 16 {ட}	26	1	4	3089	0.96	0.86	0.99	0.99	0.91
classes_ 17 {ண}	28	5	2	3085	0.84	0.93	0.99	0.99	0.88
classes_ 18 {த}	30	1	0	3089	0.96	1.00	0.99	0.99	0.98
classes_ 19 {ந}	29	2	1	3088	0.93	0.96	0.99	0.99	0.95
classes_ 20 {ப}	29	1	1	3089	0.96	0.96	0.99	0.99	0.96
classes_ 21 {ம}	30	1	0	3089	0.96	1.00	0.99	0.99	0.98
classes_ 22 {ய}	28	1	2	3089	0.96	0.93	0.99	0.99	0.94
classes_ 23 {ர}	28	5	2	3085	0.84	0.93	0.99	0.99	0.88
classes_ 24 {ல}	19	3	11	3087	0.86	0.63	0.99	0.99	0.73
classes_ 25 {வ}	28	6	2	3084	0.82	0.93	0.99	0.99	0.87
classes_ 26 {ழ}	30	7	0	3083	0.81	1.00	0.99	0.99	0.89
classes_ 27 {ள}	23	1	7	3089	0.95	0.76	0.99	0.99	0.85
classes_ 28 {ற}	29	0	1	3090	1.00	0.96	1.00	0.99	0.98
classes_ 29 {ன}	27	2	3	3088	0.93	0.90	0.99	0.99	0.91
classes_ 30 {கி}	27	2	3	3088	0.93	0.90	0.99	0.99	0.91
classes_ 31 {ஙி}	30	2	0	3088	0.93	1.00	0.99	0.99	0.96
classes_ 32 {சி}	26	4	4	3086	0.86	0.86	0.99	0.99	0.86
classes_ 33 {ஞி}	29	9	1	3081	0.76	0.96	0.99	0.99	0.85
classes_ 34 {டி}	28	3	2	3087	0.90	0.93	0.99	0.99	0.91
classes_ 35 {ணி}	25	0	5	3090	1.00	0.83	1.00	0.99	0.90
classes_ 36 {தி}	18	0	12	3090	1.00	0.60	1.00	0.99	0.75
classes_ 37 {நி}	29	4	1	3086	0.87	0.96	0.99	0.99	0.92
classes_ 38 {பி}	28	0	2	3090	1.00	0.93	1.00	0.99	0.96
classes_ 39 {மி}	30	2	0	3088	0.93	1.00	0.99	0.99	0.96
classes_ 40 {யி}	30	0	0	3090	1.00	1.00	1.00	1.00	1.00
classes_ 41 {ரி}	30	10	0	3080	0.75	1.00	0.99	0.99	0.85
classes_ 42 {லி}	29	0	1	3090	1.00	0.96	1.00	0.99	0.98
classes_ 43 {வி}	28	1	2	3089	0.96	0.93	0.99	0.99	0.94
classes_ 44 {ழி}	29	0	1	3090	1.00	0.96	1.00	0.99	0.98
classes_ 45 {ளி}	29	8	1	3082	0.78	0.96	0.99	0.99	0.86
classes_ 46 {றி}	29	4	1	3086	0.87	0.96	0.99	0.99	0.92
classes_ 47 {னி}	25	5	5	3085	0.83	0.83	0.99	0.99	0.83
classes_ 48 {கீ}	26	0	4	3090	1.00	0.86	1.00	0.99	0.92
classes_ 49 {ஙீ}	28	0	2	3090	1.00	0.93	1.00	0.99	0.96
classes_ 50 {சீ}	28	0	2	3090	1.00	0.93	1.00	0.99	0.96
classes_ 51 {ஞீ}	29	1	1	3089	0.96	0.96	0.99	0.99	0.96
classes_ 52 {டீ}	30	11	0	3079	0.73	1.00	0.99	0.99	0.84
classes_ 53 {ணீ}	28	3	2	3087	0.90	0.93	0.99	0.99	0.91
classes_ 54 {தீ}	26	1	4	3089	0.96	0.86	0.99	0.99	0.91
classes_ 55 {நீ}	29	1	1	3089	0.96	0.96	0.99	0.99	0.96
classes_ 56 {பீ}	24	0	6	3090	1.00	0.80	1.00	0.99	0.88
classes_ 57 {மீ}	29	0	1	3090	1.00	0.96	1.00	0.99	0.98
classes_ 58 {யீ}	29	0	1	3090	1.00	0.96	1.00	0.99	0.98
classes_ 59 {ரீ}	30	0	0	3090	1.00	1.00	1.00	1.00	1.00
classes_ 60 {லீ}	30	2	0	3088	0.93	1.00	0.99	0.99	0.96
classes_ 61 {வீ}	24	0	6	3090	1.00	0.80	1.00	0.99	0.88
classes_ 62 {ழீ}	30	0	0	3090	1.00	1.00	1.00	1.00	1.00
classes_ 63 {ளீ}	30	4	0	3086	0.88	1.00	0.99	0.99	0.93
classes_ 64 {றீ}	28	1	2	3089	0.96	0.93	0.99	0.99	0.94
classes_ 65 {னீ}	28	1	2	3089	0.96	0.93	0.99	0.99	0.94
classes_ 66 {கு}	30	0	0	3090	1.00	1.00	1.00	1.00	1.00
classes_ 67 {ஙு}	30	2	0	3088	0.93	1.00	0.99	0.99	0.96
classes_ 68 {சு}	25	6	5	3084	0.80	0.83	0.99	0.99	0.81
classes_ 69 {ஞு}	27	2	3	3088	0.93	0.90	0.99	0.99	0.91
classes_ 70 {டு}	28	1	2	3089	0.96	0.93	0.99	0.99	0.94
classes_ 71 {ணு}	26	0	4	3090	1.00	0.86	1.00	0.99	0.92
classes_ 72 {து}	28	0	2	3090	1.00	0.93	1.00	0.99	0.96
classes_ 73 {நு}	27	1	3	3089	0.96	0.90	0.99	0.99	0.93
classes_ 74 {பு}	23	1	7	3089	0.95	0.76	0.99	0.99	0.85
classes_ 75 {மு}	30	3	0	3087	0.90	1.00	0.99	0.99	0.95
classes_ 76 {யு}	21	1	9	3089	0.95	0.70	0.99	0.99	0.80
classes_ 77 {ரு}	29	0	1	3090	1.00	0.96	1.00	0.99	0.98
classes_ 78 {லு}	29	3	1	3087	0.90	0.96	0.99	0.99	0.93
classes_ 79 {வு}	30	0	0	3090	1.00	1.00	1.00	1.00	1.00
classes_ 80 {ழு}	30	16	0	3074	0.65	1.00	0.99	0.99	0.78
classes_ 81 {ளு}	28	1	2	3089	0.96	0.93	0.99	0.99	0.94
classes_ 82 {று}	30	2	0	3088	0.93	1.00	0.99	0.99	0.96
classes_ 83 {னு}	27	0	3	3090	1.00	0.90	1.00	0.99	0.94
classes_ 84 {கூ}	24	3	6	3087	0.88	0.80	0.99	0.99	0.84
classes_ 85 {ஙூ}	18	1	12	3089	0.94	0.60	0.99	0.99	0.73
classes_ 86 {சூ}	30	11	0	3079	0.73	1.00	0.99	0.99	0.84
classes_ 87 {ஞூ}	26	9	4	3081	0.74	0.86	0.99	0.99	0.80
classes_ 88 {டூ}	29	0	1	3090	1.00	0.96	1.00	0.99	0.98
classes_ 89 {ணூ}	28	2	2	3088	0.93	0.93	0.99	0.99	0.93
classes_ 90 {தூ}	24	0	6	3090	1.00	0.80	1.00	0.99	0.88
classes_ 91 {நூ}	26	2	4	3088	0.92	0.86	0.99	0.99	0.89
classes_ 92 {பூ}	29	2	1	3088	0.93	0.96	0.99	0.99	0.95
classes_ 93 {மூ}	21	0	9	3090	1.00	0.70	1.00	0.99	0.82
classes_ 94 {யூ}	28	0	2	3090	1.00	0.93	1.00	0.99	0.96
classes_ 95 {ரூ}	27	0	3	3090	1.00	0.90	1.00	0.99	0.94
classes_ 96 {லூ}	28	8	2	3082	0.77	0.93	0.99	0.99	0.84
classes_ 97 {வூ}	29	4	1	3086	0.87	0.96	0.99	0.99	0.92
classes_ 98 {ழூ}	29	6	1	3084	0.82	0.96	0.99	0.99	0.89
classes_ 99 {ளூ}	28	0	2	3090	1.00	0.93	1.00	0.99	0.96
classes_100 {றூ}	26	1	4	3089	0.96	0.86	0.99	0.99	0.91
classes_101 {னூ}	28	4	2	3086	0.87	0.93	0.99	0.99	0.90
classes_102 {}	24	1	6	3089	0.96	0.80	0.99	0.99	0.87
classes_103 {}	22	3	8	3087	0.88	0.73	0.99	0.99	0.80
classes_104 {}	25	7	5	3083	0.78	0.83	0.99	0.99	0.80
macroAVG	27.43	2.56	2.5673	3087.43	0.92	0.91	0.99	0.99	0.91
microAVG	27.43	2.56	2.5673	3087.43	0.91	0.91	0.99	0.99	0.91

The classification efficiency for all 104 Tamil character classes was evaluated using essential measures, including precision, sensitivity, specificity, accuracy, and F-measure. The results show that the most of classes attained higher true positives, with few false positives and false negatives, demonstrating robust discriminative ability. Several classes showed slightly reduced sensitivity due to a rise in false negatives but still overall accuracy consistently remained higher across all categories. The micro-average scores highlight the model’s overall efficiency by capturing the contribution of each sample. The macro-average metrics provide an extensive look across all classes, validating consistent performance even for frequent or visually similar characters. Collectively, these findings demonstrate that the model shows consistent performance across all 104 characters. The micro- and macro-averaged performance metrics for classes 1 to 101 are presented, followed by the evaluation of special symbol classes 102 to 104, as shown in Figs. 6, 7, and 8.

Fig. 6.

Bar graph illustrating micro-averaged performance metrics precision, sensitivity, specificity, accuracy, and F-measure for grouped character classes from 1 to 101.

Fig. 7.

Bar graph illustrating macro-averaged performance metrics (precision, sensitivity, specificity, accuracy, and F-measure) for grouped character classes from 1 to 101.

Fig. 8.

Bar graph representing micro-averaged and macro-averaged performance metrics for classes from 102 to 104.

The micro-averaged performance metrics, including precision, sensitivity, specificity, accuracy, and F-measure, grouped across different Tamil character class ranges are shown in Fig. 6. The results show consistently high accuracy and specificity across all groups, with slight variations in precision and sensitivity for visually similar characters.

The macro-average figure shows the overall performance trends across grouped Tamil character classes by averaging each metric uniformly across all classes. The results show increased specificity and accuracy among all categories, but precision and sensitivity indicate slight variations due to inter-class visual similarities, as shown in Fig. 7. The model shows consistent performance across all character categories, irrespective of class frequency. The consistently high values across all class groups indicate the model’s strong and balanced recognition performance.

The distribution of true positives and true negatives for Classes 102, 103, and 104, along with their macro- and micro-averaged values are shown in Fig. 8. The actual negative counts are consistently increased across all categories, showing that the model effectively separates non-target samples. The strong relation between macroAVG and microAVG shows the consistent performance across individual classes and the overall dataset performance. Table 3 presents an overview of the accuracy percentages achieved by different researchers and their models in Tamil handwritten character recognition.

Table 3.

Performance of the TamHNet model can be evaluated with comparison to other cutting-edge models.

Author	Methodology	Accuracy%
Raj et al.2	Directional algorithmic approach, SVM	87.41
Anjun et al.18	Contextual attention localisation for offline handwritten text	82.06
Sasipriya et al.5	Bilateral filter, KNN, SVM	91.80
Kowsalya et al.20	MNN, Optimal neural network	92.52
Vinothini et al.6	ETEDL-THDR and Convolutional Neural Network	88.12
Jayanthi et al.8	CNN-Convolutional Neural Network	87.30
Karuba et al.32	PLATTER: A Page-Level Handwritten Text Recognition System for Indic Scripts	98.11
Raj et al.19	Z-ordering algorithm	88.30
TamHNet	Fine-tuned Inception Resnet v2	99.84

The accuracy rates vary across experiments, with most models attaining high performance over 80% and few reaching 90%. The TamHNet model achieves 99.8% accuracy, indicating outstanding results. This comparison highlights advances in recognition methods and demonstrates significant progress in the field, showing that the TamHNet model achieves higher accuracy in Tamil handwriting recognition tasks.

Conclusion and future work

This study focuses on developing a handwritten Tamil character recognition system that utilises the TamHNet architecture. By incorporating suitable preprocessing techniques, an Adam optimiser with a fine-tuning approach provides a simple and effective solution for creating a robust Tamil Handwritten Character Recognition (THCR) system that classifies all characters efficiently. The validation accuracy of 99.8% is achieved by tuning the hyperparameters. Our experimental results show that the proposed TamHNet model outperforms other state-of-the-art models in character recognition. A significant limitation of this work is that the connected-based segmentation approach ignores isolated dots. Consequently, the special character containing three dots “Aayutha Ezhuthu (ஃ)” is not detected. In the future, will focus on improving the segmentation pipeline and recognition model to accurately capture these dot-based components. Additionally, because the TamHNet model was trained only on modern Tamil script, it lacks the ability to identify characters from older script variants. To address this, future extensions will incorporate datasets that include both ancient and modern Tamil characters, enabling comprehensive script recognition.

Author contributions

Hariharan P: Conceptualization, Methodology, Software, Data curation, Writing- Original draft preparation. Sasikaladevi N: Validation, Visualization, Investigation, Data curation, Supervision. Rengarajan Amirtharajan: Writing- Reviewing and Editing. All authors reviewed the manuscript.

Funding

We have not received any funding for this project.

Data availability

All data generated or analysed during this study are included in this published article.

Declarations

Competing interests

Authors declare no competing interests

Ethical approval

The above work does not involve animal or real-time human data. It is based on data from the public repository.

Consent for publications

We declare that we did the above work, which is neither published nor considered for any other publications.