Riskal | Handwritten Text Recognition

Vision & Otsu BinarizationBinarisasi Visi & Otsu

Raw handwriting images frequently exhibit uneven illumination and visual noise from paper textures. In this initial stage, the system applies the Inverse Otsu's Thresholding algorithm. Rather than relying on a static contrast threshold, it mathematically calculates the optimal boundary to separate ink strokes from the background. This process yields a pristine binary matrix as the foundation for neural processing.

Citra tulisan tangan mentah umumnya memiliki intensitas cahaya yang tidak merata serta derau visual dari tekstur kertas. Pada tahap awal ini, sistem menerapkan algoritma Inverse Otsu's Thresholding. Alih-alih menggunakan nilai ambang statis, algoritma ini menghitung titik kontras paling optimal secara matematis untuk memisahkan guratan tinta dari latar belakang. Proses ini menghasilkan matriks biner yang sepenuhnya bersih sebagai landasan pemrosesan jaringan saraf.

image_preprocessing.py

def apply_otsu_variance(image_matrix):
    # 1. Bersihkan noise kecil dengan Gaussian Blur
    blurred = cv2.GaussianBlur(image_matrix, (5, 5), 0)
    
    # 2. Hitung ambang batas optimal secara dinamis
    optimal_t, binary_tensor = cv2.threshold(
        blurred, 0, 255, 
        cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU
    )
    
    return (binary_tensor.astype('float32') / 255.0)

Spatial Feature Extraction Spatial Feature ExtractionEkstraksi Fitur Spasial

Once the image is clean, the computer needs to understand the curves and strokes of the letters. We run it through a 3-layer Convolutional Neural Network (CNN). The early layers pick up basic edges, while deeper layers recognize complex shapes. By the end, the visual patterns are translated into 256 distinct numerical features.

Matriks gambar yang telah dibersihkan kemudian diproses untuk mengenali pola morfologi karakter. Tahap ini memanfaatkan arsitektur Convolutional Neural Network (CNN) tiga lapis. Lapisan konvolusi awal bertugas mendeteksi pola tepi atau garis lengkung dasar, sedangkan lapisan yang lebih dalam menyusun abstraksi bentuk yang lebih kompleks. Pada akhir tahap ini, seluruh representasi visual gambar telah berhasil diekstraksi menjadi 256 fitur numerik spasial.

spatial_cnn.py

def build_cnn_extractor(input_tensor):
    # Deteksi lengkungan dasar (64 Filters)
    x = layers.Conv2D(64, (3, 3), activation='relu')(input_tensor)
    x = layers.MaxPooling2D(pool_size=(2, 2))(x)
    
    # Pemetaan bentuk yang lebih rumit (128 - 256 Channels)
    x = layers.Conv2D(128, (3, 3), activation='relu')(x)
    x = layers.MaxPooling2D(pool_size=(2, 2))(x)
    x = layers.Conv2D(256, (3, 3), activation='relu')(x)
    
    # Ubah wujud matriks ke deretan waktu (Sequence)
    return layers.Reshape(target_shape=(32, 256))(x)

Bidirectional Temporal MemoryMemori Temporal Dua Arah

Reading cursive handwriting is tricky because the letters are connected. This is where Bidirectional LSTM comes in. It scans the feature sequence from left to right, and simultaneously from right to left. By looking at the preceding and succeeding characters at the same time, the network can accurately deduce ambiguous letters based on context.

Pengenalan tulisan tegak bersambung memiliki tingkat kompleksitas tinggi akibat karakter yang saling bertumpuk dan berkesinambungan. Untuk mengatasi hal ini, sistem mengandalkan arsitektur Bidirectional Long Short-Term Memory (BiLSTM). Jaringan ini menganalisis deretan fitur spasial secara dua arah: berurutan dari kiri ke kanan dan sebaliknya. Melalui pemahaman konteks karakter sebelum dan sesudahnya secara simultan, model mampu mengklasifikasikan huruf-huruf yang ambigu dengan probabilitas yang jauh lebih akurat.

temporal_lstm.py

def build_temporal_memory(sequence_tensor):
    # Baca data maju (kiri-kanan) dan mundur (kanan-kiri)
    forward_lstm = layers.LSTM(256, return_sequences=True)
    backward_lstm = layers.LSTM(256, return_sequences=True, go_backwards=True)
    
    # Satukan pemahaman kedua arah (Bi-directional)
    hidden_states = layers.Bidirectional(
        forward_lstm, 
        backward_layer=backward_lstm
    )(sequence_tensor)
    
    # Hitung kemungkinan tebakan untuk setiap 80 karakter unik
    return layers.Dense(80, activation='softmax')(hidden_states)

CTC AlignmentPerataan CTC

Because our model scans the image in tiny slices, a wide letter 'a' might be predicted multiple times as 'a-a-a'. The Connectionist Temporal Classification (CTC) algorithm cleans this up. It collapses consecutive duplicate characters and removes blank gaps, merging the raw predictions into a cohesive, readable word.

Pemindaian gambar dalam bentuk irisan tipis sering kali menyebabkan satu karakter dominan diprediksi secara berulang (misalnya 'a' diprediksi sebagai 'a-a-a'). Modul Connectionist Temporal Classification (CTC) diimplementasikan untuk melakukan normalisasi terhadap hasil keluaran tersebut. Algoritma ini menyusutkan probabilitas karakter berurutan menjadi satu entitas tunggal dan mengeliminasi token kosong, sehingga probabilitas mentah berhasil dirangkai menjadi susunan kata yang utuh.

ctc_decoder.py

def decode_ctc_matrix(probability_matrix):
    # Tetapkan batas maksimal irisan pembacaan
    sequence_length = np.ones(probability_matrix.shape[0]) * 32
    
    # Greedy Decoder: cari rute probabilitas tertinggi
    decoded_indices, _ = tf.keras.backend.ctc_decode(
        probability_matrix, 
        input_length=sequence_length, 
        greedy=True
    )
    
    # Hapus duplikat berturut-turut dan buang token kosong (ID: 79)
    return map_indices_to_charset(decoded_indices[0])

Lexical AlignmentPenyelarasan Leksikal

Sometimes, the network might still misjudge a character (e.g., predicting 'DlassiC' instead of 'classic'). Rather than relying on simple spellcheckers, we engineered a custom Dynamic Programming matrix (Levenshtein Distance). It mathematically calculates the similarity between the raw prediction and our lexical corpus, guaranteeing that the final output is a perfectly valid word.

Walaupun jaringan saraf telah mengklasifikasikan karakter, probabilitas kesalahan minor akibat kemiripan visual masih berpotensi terjadi (seperti 'classic' diprediksi 'DlassiC'). Guna memitigasi hal ini, sistem memanfaatkan optimasi matematis melalui matriks Pemrograman Dinamis (Levenshtein Distance). Algoritma ini mengevaluasi jarak kedekatan string hasil prediksi dengan korpus linguistik yang valid secara komputasional. Hal ini menjamin bahwa seluruh teks keluaran memiliki integritas leksikal berstandar tinggi.

lexical_alignment.py

def lexical_dp_alignment(raw_string, lexical_corpus):
    optimal_string = raw_string
    min_distance = float('inf')
    
    # Uji setiap kata dari kamus referensi bahasa
    for valid_token in lexical_corpus:
        # Hitung seberapa jauh jarak/selisih matriks hurufnya (D[i,j])
        matrix_dist = compute_levenshtein_distance(raw_string, valid_token)
        
        if matrix_dist < min_distance:
            min_distance = matrix_dist
            optimal_string = valid_token
            
    return optimal_string

Handwritten Text RecognitionPengenalan Tulisan Tangan

Input ImageInput Gambar

Prediction ResultHasil Prediksi

Pipeline Architecture HTR Pipeline ArchitectureArsitektur Pipeline HTR

Vision & Otsu BinarizationBinarisasi Visi & Otsu

Spatial Feature Extraction Spatial Feature ExtractionEkstraksi Fitur Spasial

Bidirectional Temporal MemoryMemori Temporal Dua Arah

CTC AlignmentPerataan CTC

Lexical AlignmentPenyelarasan Leksikal

1. Vision Pre-processing

2. Spatial Feature Extraction

3. Sequence Reshape

4. Bidirectional Temporal Memory

5. CTC Alignment

6. Lexical Alignment