CharNetwork Acter-Level Bengali OCR Using a Custom Convolutional Neural

1. Introduction

Bengali is one of the world’s most widely spoken languages, but the development of digital tools for processing Bengali text is still limited compared to languages that use the Latin alphabet. Optical Character Recognition (OCR) is an important technology that converts printed or handwritten documents into editable digital text, making document storage, searching, and language processing much easier. Earlier OCR systems mainly depended on manually designed features and traditional machine learning methods for character recognition. In recent years, Convolutional Neural Networks (CNNs) have significantly improved OCR by automatically learning useful image features from training data. Despite these advances, building accurate and efficient OCR systems for Bengali remains difficult because the script contains complex character shapes, similar-looking letters, and various modifiers. Developing lightweight and reliable deep learning models for Bengali character recognition is therefore an important area of research.

Recognizing Bengali characters is a difficult task because the script contains many complex shapes, attached modifiers, and the Matra (horizontal headline) that joins characters within a word. In addition, several Bengali letters have very similar appearances, where even a small difference in a stroke or dot can change one character into another. These characteristics increase the chances of recognition errors. Although advanced pre-trained deep learning models such as ResNet and VGG provide excellent recognition performance, they require a large number of parameters and significant computational resources. As a result, they are not well suited for real-time OCR applications, mobile devices, or systems with limited processing power. Therefore, there is a need for a lightweight and efficient CNN model that can accurately recognize Bengali characters while reducing computational cost.

The development of a compact CNN model designed specifically for Bengali characters is important for achieving efficient and accurate OCR. Instead of using large and computationally expensive deep learning networks, a lightweight architecture can reduce memory usage and processing time while still capturing the fine details of Bengali characters, including small modifiers and diacritical marks. Techniques such as Batch Normalization and Dropout help improve training stability and reduce overfitting, leading to better generalization. Testing the proposed model on the Bengali Character Recognition Dataset (BCRD) provides a reliable way to evaluate its performance and demonstrates its suitability for resource-constrained Bengali OCR applications.

The main goal of this research is to develop and assess a lightweight Convolutional Neural Network (CNN) for recognizing individual Bengali characters in Optical Character Recognition (OCR) systems. The study focuses on creating an efficient model that provides high recognition accuracy while requiring fewer computational resources. The specific objectives of this research are:

• To prepare the input images through preprocessing techniques such as grayscale conversion, image binarization, and data augmentation.
• To design and implement a compact CNN architecture that performs effective feature extraction without using large pre-trained models.
• To measure the model’s performance on the Bengali Character Recognition Dataset (BCRD) using evaluation metrics including accuracy, precision, recall, and F1-score.
• To examine the classification errors and identify common misclassified characters, providing insights for future improvements such as word-level recognition and text line segmentation.

This study offers valuable contributions from both technical and practical perspectives. From a technical standpoint, it shows that a lightweight CNN developed from scratch can effectively recognize complex Bengali characters without depending on large pre-trained models. The findings also highlight that high classification performance can be achieved with a simple and computationally efficient architecture. From a practical perspective, the proposed approach is well suited for real-world applications, including mobile OCR systems, digital document preservation, educational platforms, and low-resource edge devices. The research can also support future advancements in Bengali text digitization and intelligent document processing.

2. Literature Review

Research on automatic recognition of Bengali text has grown significantly over the years as the demand for digitizing printed documents continues to increase. Unlike Latin-based languages, Bengali script is more difficult to process because it contains a large number of characters, vowel signs, consonant modifiers, compound letters, and the Matra, a horizontal line that connects many characters within a word. These unique characteristics make character segmentation and recognition more challenging.

In the early stages of Bengali Optical Character Recognition (OCR), researchers mainly used traditional image processing techniques together with manually designed features. Methods such as projection profiles, contour analysis, and stroke-based feature extraction were commonly combined with machine learning algorithms including Support Vector Machines (SVM), K-Nearest Neighbors (KNN), and Artificial Neural Networks (ANN). Although these approaches achieved reasonable results under controlled conditions, their performance often decreased when images contained noise, different fonts, low scanning quality, or slight rotations. Since the extracted features had to be designed manually, the systems lacked flexibility and were unable to generalize well to different types of documents.

With the rapid advancement of deep learning, the focus of OCR research has shifted toward Convolutional Neural Networks (CNNs). Unlike traditional methods, CNNs automatically learn important visual features directly from image pixels without requiring handcrafted feature extraction. This ability allows CNNs to capture both simple and complex character patterns, resulting in higher recognition accuracy and better robustness across different writing styles and document conditions. As a result, CNN-based approaches have become the preferred solution for modern Bengali character recognition and document image analysis.

To better understand the progress of Bengali character recognition, previous studies can be grouped into three major categories: traditional feature-based methods, transfer learning approaches, and custom deep learning models. Each category represents a different strategy for extracting image features and recognizing characters, with its own strengths and limitations.

The earliest OCR systems mainly relied on manually designed image features to identify characters. Researchers extracted information such as character shape, edge patterns, geometric structures, and texture using techniques like the Histogram of Oriented Gradients (HOG) and the Scale-Invariant Feature Transform (SIFT). These features were then classified using conventional machine learning algorithms. Several studies also focused on stroke patterns and character connectivity to distinguish Bengali letters and numerals. Although these methods performed reasonably well on clean and well-formatted images, they struggled when the input contained noise, different font styles, uneven stroke widths, or small diacritical variations. Since the feature extraction rules were fixed and manually designed, the models had limited ability to adapt to new or unseen writing patterns, reducing their effectiveness in real-world OCR applications.

The development of deep learning introduced a new approach to character recognition through transfer learning. Instead of training a model from the beginning, researchers started using well-known pre-trained convolutional neural networks such as ResNet, VGG16, DenseNet, and Xception, which had already learned general image features from large datasets like ImageNet. These models were then fine-tuned to recognize Bengali and other Indic characters.

One of the main strengths of transfer learning is that these deep networks can learn complex visual patterns at different levels, allowing them to recognize character shapes with high accuracy. Many studies using benchmark datasets such as Ekush and NumtaDB reported recognition accuracies above 95%, demonstrating the effectiveness of these architectures for OCR tasks.

Despite their excellent performance, pre-trained deep learning models also have several disadvantages. Most of these networks contain millions of trainable parameters, which require powerful GPUs, large memory capacity, and longer processing times. For character-level OCR, where the classification task is relatively simple, such large models often perform unnecessary computations. This increases computational cost and limits their use in mobile devices, embedded systems, and other low-resource environments where lightweight and efficient models are preferred.

To overcome the limitations of large transfer learning models, many recent studies have focused on developing lightweight CNN architectures specifically designed for character recognition tasks. Unlike deep pre-trained networks, these models are built from scratch and usually consist of only a few convolutional layers combined with techniques such as Batch Normalization and Dropout to improve training stability and reduce overfitting.

These compact networks are designed to work with small character images, such as 64 × 64pixel inputs, enabling them to learn important local features including curves, edges, intersections, loops, and small diacritical marks. Because the architecture is simpler and contains fewer parameters, it requires less memory, trains faster, and performs inference more efficiently without sacrificing recognition performance.

Recent research has shown that well-designed custom CNN models can achieve classification results comparable to, and in some cases better than, large pre-trained architectures for isolated Bengali character recognition. Their lower computational requirements make them a practical choice for mobile applications, embedded devices, and other resource-limited OCR systems.

Although deep learning has greatly improved the accuracy of Bengali Optical Character Recognition (OCR), several challenges still remain. Traditional OCR methods that depend on manually designed features often perform poorly when images contain noise, different fonts, or low-quality scans. On the other hand, many modern approaches rely on large pre-trained models such as ResNet and VGG, which require high computational power, large memory, and longer processing time, making them unsuitable for lightweight or real-time applications.

In addition, only a limited number of studies have investigated compact CNN models developed specifically for the Bengali Character Recognition Dataset (BCRD). The effect of lightweight architectures combined with regularization techniques such as Batch Normalization and Dropout has not been thoroughly examined, especially for recognizing Bengali characters that have very similar shapes or differ only by small diacritical marks. Therefore, there is a need for an efficient CNN model that can provide high recognition accuracy while maintaining low computational cost for practical Bengali OCR systems.

3. Theoretical and Conceptual Framework

The theoretical basis of this research is founded on the principles of Optical Character Recognition (OCR), pattern recognition, and Convolutional Neural Networks (CNNs). In character recognition, CNNs learn image features automatically by processing pixel information through multiple layers. Instead of relying on manually designed features, the network gradually builds meaningful representations of the input image from simple patterns to more complex structures.

In the initial convolutional layers, the CNN detects basic visual features such as edges, lines, curves, and stroke directions. These low-level features are essential for identifying the shape of Bengali characters. As the data moves through deeper layers of the network, pooling operations reduce the size of the feature maps while preserving important information. This process improves the model’s ability to recognize characters even when there are small changes in position or appearance.

The deeper layers combine the extracted low-level features to identify more complex patterns, including character loops, intersections, connected strokes, and diacritical marks. By learning these hierarchical features automatically, CNNs become highly effective for recognizing the complex structures of Bengali script, making them a strong theoretical foundation for character-level OCR systems.

The proposed research follows a structured workflow that converts input character images into accurate classification results. The process begins with image preprocessing, followed by feature extraction using a Convolutional Neural Network (CNN), and ends with the prediction of the character class.

• Data Preprocessing and Augmentation: The Bengali Character Recognition Dataset (BCRD) is first prepared before training. Each image is converted to grayscale, resized to 64 × 64 pixels, and normalized so that pixel values fall between 0 and 1. To improve the model’s ability to recognize characters under different conditions, data augmentation techniques such as small rotations and translations are applied, creating additional training samples and reducing overfitting.
• CNN-Based Feature Extraction: The preprocessed images are then passed through a series of convolution and pooling layers. These layers automatically learn important visual features, including edges, curves, stroke patterns, loops, and other structural characteristics of Bengali characters. As the information moves through the network, the extracted features become more detailed and representative of each character.
• Classification and Prediction: Finally, the learned feature maps are flattened into a one-dimensional feature vector and passed to fully connected (dense) layers. The output layer calculates the probability of each possible character class, and the class with the highest probability is selected as the final recognition result.

3.1. Mathematical Formulation

The convolution equation can be written clearly as:

$$yij=m\sum n\sum wmnx(i+m)(j+n)+b$$

ReLU Activation

The Rectified Linear Unit (ReLU) activation function introduces non-linearity into the network.

$$f\left(x\right)=max(0,x)$$

Dropout Dropout

Regularization randomly deactivates neurons during training.

This prevents overfitting and improves model generalization.

Softmax Layer:

The final layer applies the Softmax function

$$p\left(yi\right)=e^{zi}/n\sum e^{zj}j=1$$

4. Methodology & Architecture

To improve the performance and learning capability of the proposed CNN model, the input images are processed through several preprocessing steps before training. These steps help reduce noise, standardize the input data, and improve the model’s ability to recognize Bengali characters accurately.

Grayscale Conversion: The original RGB images are converted into grayscale images. Since character recognition mainly depends on the shape and stroke patterns rather than color information, using a single grayscale channel reduces computational complexity while preserving the important structural details.

Image Binarization: After grayscale conversion, Otsu’s Thresholding is applied to convert the image into a black-and-white format. This process separates the character from the background, improves image contrast, and removes unnecessary background information.

Image Resizing: All images are resized to a fixed resolution of 64 × 64 pixels. Standardizing the image size ensures that every input has the same dimensions, allowing the CNN to process the dataset consistently and efficiently.

Pixel Normalization: The pixel intensity values are normalized to the range of 0 to 1 by dividing each pixel value by 255. This normalization improves training stability, speeds up convergence, and helps the optimization algorithm learn more effectively.

Data Augmentation: To increase the diversity of the training dataset and reduce overfitting, several augmentation techniques are applied. These include small random rotations (up to ±12°), horizontal and vertical shifts, and slight shearing transformations. Data augmentation enables the model to recognize Bengali characters even when they appear slightly rotated, shifted, or distorted in real-world documents.

4.1. Custom CNN Architecture

The proposed CNN model uses a hierarchical feature extraction approach through consecutive Convolution, Batch Normalization, ReLU Activation, and Max Pooling layers. The architecture is organized into three convolutional blocks followed by a classification head.

• Block 1 (Low-Level Features): Detects basic edges, lines, and curves.Conv2D (32 filters, 3×3) → Batch Normalization → ReLU → MaxPool2D (2×2)
• Block 2 (Mid-Level Features): Learns more detailed features such as loops and intersections.Conv2D (64 filters, 3×3) → Batch Normalization → ReLU → MaxPool2D (2×2) → Dropout (0.2)
• Block 3 (High-Level Features): Extracts complex Bengali character structures and fine details.Conv2D (128 filters, 3×3) → Batch Normalization → ReLU → MaxPool2D (2×2) → Dropout (0.3)
• Classification Head: Converts the extracted feature maps into class predictions.Flatten → Dense (256 units) → ReLU → Dropout (0.5) → Dense (50 units) → Softmax

5. Experimental Results & Analysis

The effectiveness of the proposed lightweight Convolutional Neural Network (CNN) was evaluated using the Bengali Character Recognition Dataset (BCRD), which contains isolated Bengali character images representing multiple character classes. The experiments were conducted to assess both the recognition capability and computational efficiency of the proposed architecture. Unlike many existing OCR studies that rely on computationally expensive transfer learning models, the proposed network was designed from scratch to provide high recognition accuracy while maintaining a relatively small number of trainable parameters. This design makes the model suitable for deployment in resource-constrained environments such as mobile OCR applications, embedded systems, and real-time document digitization platforms [3,4].

The model was trained using the Adam optimization algorithm with an initial learning rate of 0.001. Adam was selected because of its adaptive learning capability, which combines the advantages of momentum optimization and adaptive gradient estimation, leading to faster convergence and improved stability during training [4]. Categorical Cross-Entropy was employed as the loss function since the recognition problem involves multi-class character classification. A batch size of 64 images was used to balance computational efficiency and convergence stability, while Early Stopping was incorporated to terminate training once validation performance ceased improving, thereby reducing unnecessary computation and minimizing overfitting. The dataset was divided into 70% training, 15% validation, and 15% testing subsets to ensure an unbiased evaluation of the model’s generalization capability.

5.1. Performance Evaluation

To comprehensively evaluate the proposed CNN architecture, four widely accepted classification metrics were used: Accuracy, Precision, Recall, and F1-score. Accuracy measures the overall proportion of correctly classified characters, whereas Precision evaluates the correctness of positive predictions. Recall measures the ability of the model to correctly identify all relevant character classes, and the F1-score provides a balanced assessment by combining Precision and Recall into a single metric [3,4].

The experimental results demonstrate consistently strong performance across the training, validation, and testing datasets. The training accuracy reached 98.1%, while the validation and testing accuracies were 97.6% and 97.1%, respectively. Likewise, Precision remained above 97% for all datasets, indicating that incorrect character predictions were relatively uncommon. Recall values also exceeded 96.8%, demonstrating that the proposed CNN successfully recognized the vast majority of Bengali characters across different samples. Furthermore, the F1-score remained close to the corresponding Precision and Recall values, confirming that the classifier maintained a balanced performance without favoring particular classes. These results collectively indicate that the proposed architecture achieves high predictive reliability while preserving computational efficiency.

An important observation from the experimental results is the relatively small performance gap between the training and testing datasets. The difference between training accuracy (98.1%) and testing accuracy (97.1%) is only about one percentage point, suggesting that the proposed network generalizes well to previously unseen images. Such a small gap indicates that the combined use of Batch Normalization and Dropout effectively reduced overfitting while allowing the model to learn robust character representations [7,8].

5.2. Learning Behaviour of the CNN

The proposed CNN exhibited stable convergence throughout the training process. During the initial epochs, the model rapidly learned low-level visual features such as edges, straight lines, and stroke orientations. As training progressed, deeper convolutional layers gradually captured more sophisticated structural information, including loops, intersections, connected components, and small diacritical marks that characterize Bengali script. This hierarchical feature learning capability is one of the major strengths of CNN-based image recognition systems and explains the superior performance compared with traditional handcrafted feature extraction methods [3].

Batch Normalization significantly accelerated convergence by reducing internal covariate shift during optimization, allowing higher learning stability throughout training [7]. Simultaneously, Dropout regularization randomly deactivated neurons during each training iteration, forcing the network to learn more generalized representations rather than memorizing specific training samples [8]. Consequently, the validation accuracy closely followed the training accuracy without exhibiting the large fluctuations commonly associated with overfitting.

5.3. Recognition Performance on Bengali Characters

Bengali character recognition presents unique challenges because many characters possess nearly identical visual structures and differ only by subtle stroke variations or small diacritical marks. Traditional machine learning methods frequently struggle under these conditions because manually designed features often fail to capture such fine-grained visual distinctions [2,5].

The proposed CNN effectively learned these discriminative features through its hierarchical convolutional architecture. The first convolutional block primarily extracted low-level geometric information, while the second block learned intermediate structural features including loops and intersections. The third convolutional block captured more abstract semantic representations corresponding to complete Bengali character patterns. This progressive feature extraction enabled the classifier to distinguish visually similar characters with high reliability, contributing substantially to the overall recognition accuracy.

Moreover, preprocessing operations-including grayscale conversion, Otsu thresholding, image normalization, resizing, and data augmentation-also contributed significantly to improved classification performance. Data augmentation, particularly small rotations and translations, exposed the network to realistic variations that commonly occur in scanned documents, thereby improving robustness against minor distortions encountered in practical OCR applications.

5.4. Comparative Analysis with Existing CNN-Based OCR Systems

Although the primary objective of this study was not to outperform every existing deep learning architecture, the obtained results compare favorably with numerous CNN-based Bengali OCR studies reported in the literature. Large transfer learning models such as VGG, ResNet, and DenseNet frequently achieve recognition accuracies exceeding 98%; however, these architectures contain millions of trainable parameters and require substantial computational resources during both training and inference [3,4]. Such requirements limit their applicability in embedded devices and real-time OCR systems.

In contrast, the proposed custom CNN demonstrates that comparable recognition performance can be achieved using a considerably simpler architecture specifically designed for isolated Bengali character recognition. By reducing architectural complexity while preserving discriminative feature extraction capability, the proposed model provides an attractive balance between accuracy and computational efficiency. This finding supports recent research emphasizing that task-specific lightweight CNNs can often perform as effectively as large generic networks for character-level OCR tasks, especially when appropriate preprocessing and regularization techniques are employed [5,7].

5.5. Practical Implications

The experimental findings demonstrate that the proposed lightweight CNN has strong potential for practical deployment in real-world Bengali OCR systems. Because of its relatively low computational requirements, the model can be integrated into mobile applications, educational software, digital libraries, intelligent document management systems, and low-cost embedded devices. Furthermore, the architecture can serve as the character recognition component within larger OCR pipelines that incorporate text-line segmentation, word recognition, and document layout analysis.

Overall, the experimental evaluation confirms that the proposed CNN successfully balances recognition accuracy, computational efficiency, and generalization capability. The combination of effective preprocessing, hierarchical feature extraction, Batch Normalization, and Dropout enables the model to recognize complex Bengali characters with high reliability while maintaining a lightweight architecture suitable for practical OCR applications. These findings provide strong evidence that carefully designed custom CNN models remain a competitive alternative to large pre-trained networks for Bengali character recognition and can support future research on complete Bengali document understanding systems [2]-[8].

6. Discussion

The findings of this study demonstrate that a lightweight Convolutional Neural Network (CNN) can achieve highly accurate Bengali character recognition while maintaining computational efficiency, thereby addressing one of the primary challenges in Bengali Optical Character Recognition (OCR). The proposed model achieved consistently high classification performance across the training, validation, and testing datasets, with only a small difference between training and testing accuracy, indicating strong generalization capability rather than simple memorization of the training samples. These results support the central objective of this research, namely that carefully designed custom CNN architectures can provide recognition performance comparable to much larger deep learning models while significantly reducing computational complexity. The reported experimental outcomes therefore validate the effectiveness of the proposed architecture for practical Bengali OCR applications.

One of the most significant observations from the experimental evaluation is the ability of the proposed CNN to extract discriminative visual features from Bengali characters despite its relatively shallow architecture. Bengali script contains numerous visually similar characters, complex stroke combinations, vowel modifiers, and diacritical marks, all of which increase classification difficulty. Earlier OCR systems based on handcrafted feature extraction often struggled to distinguish such subtle structural differences because manually designed descriptors were unable to capture sufficient local variations under diverse document conditions [2,5]. In contrast, the proposed CNN automatically learned hierarchical feature representations through successive convolutional layers. The initial layers focused on detecting simple geometric structures such as edges, curves, and stroke orientations, whereas deeper layers progressively combined these low-level features into more complex representations including loops, intersections, and distinctive character shapes. This hierarchical learning mechanism, first popularized by deep convolutional networks, explains why CNNs consistently outperform traditional machine learning approaches for visual recognition tasks [3,4].

Another important finding concerns the effectiveness of the regularization strategies incorporated into the proposed architecture. The combination of Batch Normalization and Dropout contributed substantially to stable optimization and improved model generalization. Batch Normalization reduced internal covariate shift during training, allowing higher learning rates and faster convergence while simultaneously improving optimization stability [7]. Meanwhile, Dropout randomly deactivated neurons during each training iteration, preventing co-adaptation among feature detectors and reducing the likelihood of overfitting [8]. This behavior is reflected in the relatively small difference between the reported training and testing performance, suggesting that the model learned generalized character representations rather than memorizing individual training examples. Such stability is particularly valuable in OCR applications where deployment data often contain previously unseen document variations.

The preprocessing pipeline also played an important role in achieving high recognition accuracy. Bengali character recognition depends primarily on structural information rather than color; therefore, grayscale conversion reduced computational complexity without sacrificing informative features. Otsu’s thresholding effectively separated foreground characters from the background, improving contrast and reducing irrelevant image information before feature extraction. Image normalization and resizing further standardized the input space, enabling more stable optimization during network training. Furthermore, data augmentation techniques including small rotations, translations, and shearing introduced realistic image variations that simulated practical document acquisition conditions. As a result, the model became more robust to small geometric distortions commonly observed in scanned documents and mobile image capture. Similar observations have been reported in recent deep learning studies, where carefully designed preprocessing pipelines significantly improve OCR robustness under real-world imaging conditions [3,4].

The experimental findings further demonstrate that the proposed architecture achieves an effective balance between model complexity and predictive performance. Many contemporary OCR systems employ transfer learning using deep architectures such as VGG, ResNet, DenseNet, or EfficientNet because these models can learn highly discriminative image features from large-scale datasets. Numerous Bengali OCR studies have reported recognition accuracies exceeding 98% using such architectures. However, these networks generally contain millions of trainable parameters and require powerful Graphics Processing Units (GPUs), substantial memory resources, and relatively long inference times [3,4]. Although these requirements are acceptable in cloud-based computing environments, they restrict deployment in embedded systems, mobile devices, and edge-computing platforms where computational resources remain limited.

In contrast, the proposed CNN was specifically designed for isolated Bengali character recognition rather than general-purpose image classification. Because the recognition task involves relatively small input images and a limited number of character classes, a lightweight architecture is capable of learning sufficient discriminative information without unnecessary computational overhead. The experimental results therefore reinforce the growing research trend that task-specific compact CNN models can achieve competitive recognition performance while substantially reducing memory consumption, inference latency, and overall computational cost. This trade-off between efficiency and accuracy represents an important practical contribution of the present study and supports recent developments in lightweight deep learning for document image analysis [5,7].

Another noteworthy implication relates to the recognition of visually confusing Bengali characters. Many Bengali letters differ only by small structural variations such as short strokes, dots, or minor curve modifications. Such similarities have historically produced high misclassification rates in conventional OCR systems [2]. Although the present study does not provide a detailed confusion matrix or per-class performance analysis, the overall high Precision, Recall, and F1-score indicate that the proposed CNN successfully learned discriminative local features capable of separating these visually similar classes. Future work incorporating confusion matrix analysis would provide deeper insights into which specific character pairs remain challenging and could guide architectural refinements for further performance improvement.

The findings also have important implications for practical Bengali document digitization. Efficient OCR remains essential for preserving historical archives, government documents, newspapers, educational materials, and literary collections. Many existing Bengali OCR systems remain computationally demanding, limiting their adoption in low-resource environments. Because the proposed model combines high recognition accuracy with reduced computational complexity, it offers a promising solution for deployment in mobile scanning applications, educational software, intelligent document management systems, digital libraries, and embedded OCR devices. Such lightweight implementations are particularly valuable in developing countries where high-performance computing infrastructure may not always be readily available.

Despite these encouraging results, several limitations should be acknowledged. First, the experimental evaluation focused exclusively on isolated Bengali character recognition using the Bengali Character Recognition Dataset (BCRD). While character-level recognition provides an essential foundation for OCR, complete document recognition requires additional stages including line segmentation, word segmentation, character grouping, and language modeling. Consequently, the reported performance should not be interpreted as representing the accuracy of full document OCR systems. Second, the dataset primarily consists of normalized character images. Real-world documents often contain varying font styles, printing artifacts, illumination changes, blur, skew, and complex background noise that may reduce recognition performance. Additional evaluation on more diverse benchmark datasets would therefore provide stronger evidence of model robustness.

A further limitation concerns compound Bengali characters (Juktakkhor), which constitute one of the most difficult components of Bengali OCR. The present study primarily considers isolated characters and does not evaluate recognition performance for the large number of conjunct characters frequently encountered in printed Bengali documents. Future research should therefore extend the proposed architecture to larger multi-class datasets incorporating common compound characters, thereby improving the applicability of the model for complete Bengali text recognition. Similarly, handwritten Bengali OCR presents substantially greater variability than printed text and represents another important direction for future investigation.

Future work may also explore hybrid deep learning architectures that combine CNN-based feature extraction with sequential learning models such as Long Short-Term Memory (LSTM) networks, Transformer architectures, or attention mechanisms for end-to-end document recognition. Furthermore, model compression techniques including knowledge distillation, network pruning, and quantization could further reduce computational requirements while preserving recognition accuracy, making the architecture even more suitable for deployment on resource-constrained edge devices. Integration with document layout analysis and multilingual OCR frameworks could also broaden the practical applicability of the proposed approach.

Overall, the experimental findings confirm that a carefully designed lightweight CNN provides an effective solution for Bengali character recognition. The proposed architecture successfully balances recognition accuracy, computational efficiency, and generalization capability through the combined use of hierarchical feature extraction, effective preprocessing, Batch Normalization, and Dropout regularization. Rather than relying on large transfer learning models, the study demonstrates that a compact CNN developed specifically for the characteristics of Bengali script can achieve reliable recognition performance while substantially reducing computational cost. These findings contribute to the growing body of research on efficient deep learning-based OCR and establish a strong foundation for future investigations into complete Bengali document understanding, multilingual OCR, and intelligent document digitization systems [2]-[8].

7. Conclusion

This study presented a lightweight Convolutional Neural Network (CNN) for isolated Bengali character recognition, addressing one of the major challenges in Bengali Optical Character Recognition (OCR): achieving high recognition accuracy while maintaining low computational complexity. Unlike many contemporary OCR systems that rely on large transfer learning models with millions of trainable parameters, the proposed architecture was developed specifically for Bengali character classification using a compact network capable of learning discriminative visual features efficiently. The integration of grayscale conversion, image binarization, normalization, resizing, and data augmentation, together with Batch Normalization and Dropout regularization, enabled the model to learn robust feature representations while minimizing overfitting and improving generalization.

The experimental evaluation demonstrated that the proposed model achieved 97.1% testing accuracy, accompanied by high Precision, Recall, and F1-score values, confirming its ability to accurately recognize isolated Bengali characters under diverse image conditions. The relatively small performance gap between the training and testing datasets further indicates that the network generalizes effectively to unseen data, reflecting the stability of the proposed learning framework. These findings demonstrate that lightweight CNN architectures can deliver competitive recognition performance without requiring the extensive computational resources typically associated with deep transfer learning models. As a result, the proposed system offers a practical solution for real-time OCR applications, mobile computing, embedded devices, digital libraries, educational platforms, and intelligent document management systems.

From a broader perspective, this research contributes to the growing body of work on efficient deep learning for low-resource languages by demonstrating that carefully designed task-specific CNN architectures remain highly competitive for character-level OCR. The findings further suggest that computational efficiency and recognition accuracy are not necessarily conflicting objectives when the network architecture is optimized for the characteristics of the target script.

Despite these promising outcomes, several opportunities remain for future research. The proposed framework can be extended to recognize compound Bengali characters (Juktakkhor), handwritten text, and complete words or document pages through the integration of segmentation algorithms and sequence-learning models such as Long Short-Term Memory (LSTM) networks or Transformer-based architectures. Future investigations may also explore attention mechanisms, model compression, knowledge distillation, and multilingual OCR frameworks to further improve recognition accuracy, inference speed, and deployment efficiency. Overall, the proposed lightweight CNN establishes a strong foundation for the development of practical, scalable, and computationally efficient Bengali OCR systems capable of supporting large-scale document digitization and intelligent language technologies.