ВКР ФИТ НГУ Создание программного интерфейса для системы автоматического распознавания текстов

Разработка комплексного программного интерфейса для распознавания старотибетских рукописных текстов

? Закажите ВКР по распознаванию старотибетских рукописей!

Наши эксперты по компьютерному зрению и NLP разработают полнофункциональную систему распознавания с веб-интерфейсом. Уникальное решение для цифровой гуманитаристики!

Введение

Студенты ФИТ НГУ, работающие над выпускными квалификационными работами в области цифровой гуманитаристики и компьютерной лингвистики, сталкиваются с уникальными вызовами при создании систем распознавания старотибетских рукописей. Эти исторические документы представляют огромную культурную и научную ценность, но их автоматическая обработка осложнена спецификой тибетской письменности, вариативностью почерков и часто плохой сохранностью материалов.

Основная сложность заключается в необходимости сочетания традиционных методов компьютерного зрения для предобработки изображений с современными подходами машинного обучения для распознавания символов и контекстного анализа. Студенты часто недооценивают важность создания удобного программного интерфейса, который позволит исследователям-тибетологам эффективно работать с системой без глубоких технических знаний.

В этом руководстве представлена комплексная методология разработки программного интерфейса для системы автоматического распознавания старотибетских рукописей, включая архитектуру системы, реализацию алгоритмов обработки изображений и машинного обучения, а также создание интуитивного веб-интерфейса для конечных пользователей.

Срочная помощь по вашей теме: Получите консультацию за 10 минут! Telegram: @Diplomit Телефон/WhatsApp: +7 (987) 915-99-32, Email: admin@diplom-it.ru

Оформите заказ онлайн: Заказать ВКР ФИТ НГУ

Архитектура системы распознавания старотибетских рукописей

Ключевые модули системы обработки рукописей

Эффективная система распознавания старотибетских рукописей требует интеграции нескольких специализированных модулей, каждый из которых решает определенную задачу в цепочке обработки:

• Модуль предобработки изображений — улучшение качества, коррекция искажений, бинаризация
• Модуль сегментации — выделение строк, слов и отдельных символов
• Модуль извлечения признаков — анализ геометрических и статистических характеристик
• Модуль распознавания символов — классификация тибетских графем с использованием ML
• Модуль постобработки — коррекция ошибок, использование языковых моделей
• Веб-интерфейс — удобный интерфейс для загрузки и просмотра результатов

Особенности старотибетской письменности

Тибетская письменность имеет уникальные характеристики, которые необходимо учитывать при разработке системы распознавания.

Специфика тибетского письма для алгоритмов распознавания

Реализация алгоритмов обработки изображений

Закажите реализацию системы распознавания тибетских рукописей!

• Полный цикл обработки: от скана до распознанного текста
• Интеграция OpenCV, TensorFlow/PyTorch и современных CNN
• Адаптация алгоритмов под специфику тибетской письменности
• Готовый веб-интерфейс на Flask/Django с возможностью коррекции

Предобработка изображений рукописей

Качественная предобработка критически важна для успешного распознавания старотибетских рукописей.

Класс предобработки изображений на Python с OpenCV

import cv2
import numpy as np
from skimage import filters, restoration
from scipy import ndimage
class TibetanManuscriptPreprocessor:
    def __init__(self):
        self.preprocessing_pipeline = []
    def load_image(self, image_path):
        """Загрузка изображения рукописи"""
        image = cv2.imread(image_path)
        if image is None:
            raise ValueError(f"Не удалось загрузить изображение: {image_path}")
        return image
    def convert_to_grayscale(self, image):
        """Конвертация в оттенки серого"""
        return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    def remove_noise(self, image, method='gaussian'):
        """Удаление шума с сохранением деталей текста"""
        if method == 'gaussian':
            return cv2.GaussianBlur(image, (3, 3), 0)
        elif method == 'median':
            return cv2.medianBlur(image, 3)
        elif method == 'bilateral':
            return cv2.bilateralFilter(image, 9, 75, 75)
    def correct_illumination(self, image):
        """Коррекция неравномерного освещения"""
        # Создание фона с помощью морфологических операций
        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (25, 25))
        background = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)
        background = cv2.medianBlur(background, 21)
        # Вычитание фона
        corrected = cv2.subtract(background, image)
        corrected = cv2.bitwise_not(corrected)
        return corrected
    def deskew_image(self, image):
        """Коррекция наклона страницы"""
        # Бинаризация для анализа контуров
        _, binary = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
        # Поиск контуров и вычисление угла наклона
        coords = np.column_stack(np.where(binary > 0))
        angle = cv2.minAreaRect(coords)[-1]
        if angle < -45:
            angle = -(90 + angle)
        else:
            angle = -angle
        # Поворот изображения
        (h, w) = image.shape[:2]
        center = (w // 2, h // 2)
        M = cv2.getRotationMatrix2D(center, angle, 1.0)
        rotated = cv2.warpAffine(image, M, (w, h), flags=cv2.INTER_CUBIC, 
                                borderMode=cv2.BORDER_REPLICATE)
        return rotated
    def binarize_image(self, image, method='sauvola'):
        """Адаптивная бинаризация для старотибетских рукописей"""
        if method == 'sauvola':
            # Метод Sauvola хорошо работает с текстурным фоном
            threshold = filters.threshold_sauvola(image, window_size=25, k=0.2)
            binary = image > threshold
            return (binary * 255).astype(np.uint8)
        elif method == 'adaptive':
            # Адаптивная бинаризация OpenCV
            return cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                       cv2.THRESH_BINARY, 11, 2)
    def enhance_text_quality(self, image):
        """Улучшение качества текста с помощью морфологических операций"""
        kernel = np.ones((1, 1), np.uint8)
        # Закрытие для соединения разорванных штрихов
        closed = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)
        # Открытие для удаления мелкого шума
        opened = cv2.morphologyEx(closed, cv2.MORPH_OPEN, kernel)
        return opened
    def preprocess_pipeline(self, image_path):
        """Полный пайплайн предобработки"""
        image = self.load_image(image_path)
        gray = self.convert_to_grayscale(image)
        denoised = self.remove_noise(gray, 'bilateral')
        illumination_corrected = self.correct_illumination(denoised)
        deskewed = self.deskew_image(illumination_corrected)
        binary = self.binarize_image(deskewed, 'sauvola')
        enhanced = self.enhance_text_quality(binary)
        return enhanced
# Пример использования
preprocessor = TibetanManuscriptPreprocessor()
processed_image = preprocessor.preprocess_pipeline('tibetan_manuscript.jpg')
cv2.imwrite('processed_manuscript.jpg', processed_image)

Сегментация и выделение тибетских символов

Алгоритмы сегментации для многоуровневой тибетской письменности

Сегментация старотибетского текста требует учета иерархической структуры письма.

? Сегментация на строки

Метод: Проекция гистограммы + анализ связных компонент

Сложность: Средняя (вариативность межстрочных интервалов)

? Сегментация на слова

Метод: Анализ пробелов + морфологический анализ

Сложность: Высокая (слияние символов в словах)

✍️ Сегментация на символы

Метод: Вертикальная проекция + анализ связных компонент

Сложность: Очень высокая (сложные графемы)

? Сегментация составных символов

Метод: Анализ bounding boxes + правила тибетской письменности

Сложность: Экстремальная (надстрочные/подстрочные элементы)

Реализация сегментатора тибетского текста

Класс сегментации старотибетского текста

class TibetanTextSegmenter:
    def __init__(self):
        self.min_line_height = 20
        self.min_char_width = 5
    def segment_lines(self, binary_image):
        """Сегментация изображения на строки"""
        # Гистограмма проекции по горизонтали
        horizontal_projection = np.sum(binary_image, axis=1)
        lines = []
        start = None
        for i, value in enumerate(horizontal_projection):
            if value > 0 and start is None:
                start = i
            elif value == 0 and start is not None:
                if i - start > self.min_line_height:
                    lines.append((start, i))
                start = None
        # Добавление последней строки, если нужно
        if start is not None:
            lines.append((start, len(horizontal_projection)))
        return lines
    def segment_words(self, line_image):
        """Сегментация строки на слова"""
        # Гистограмма проекции по вертикали
        vertical_projection = np.sum(line_image, axis=0)
        words = []
        start = None
        space_threshold = np.mean(vertical_projection) * 0.1
        for i, value in enumerate(vertical_projection):
            if value > space_threshold and start is None:
                start = i
            elif value <= space_threshold and start is not None:
                if i - start > self.min_char_width:
                    words.append((start, i))
                start = None
        if start is not None:
            words.append((start, len(vertical_projection)))
        return words
    def segment_characters(self, word_image):
        """Сегментация слова на символы (сложные графемы)"""
        # Анализ связных компонент для выделения символов
        num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(
            word_image, connectivity=8
        )
        characters = []
        for i in range(1, num_labels):  # Пропускаем фон
            x = stats[i, cv2.CC_STAT_LEFT]
            y = stats[i, cv2.CC_STAT_TOP]
            w = stats[i, cv2.CC_STAT_WIDTH]
            h = stats[i, cv2.CC_STAT_HEIGHT]
            if w > self.min_char_width and h > 5:
                characters.append((x, y, w, h))
        # Сортировка символов слева направо
        characters.sort(key=lambda rect: rect[0])
        return characters
    def analyze_tibetan_structure(self, character_bboxes, line_height):
        """Анализ структуры тибетских символов (основные и надстрочные/подстрочные)"""
        main_chars = []
        upper_chars = []
        lower_chars = []
        line_center = line_height // 2
        for bbox in character_bboxes:
            x, y, w, h = bbox
            char_center_y = y + h // 2
            if char_center_y < line_center - line_height * 0.2:
                upper_chars.append(bbox)
            elif char_center_y > line_center + line_height * 0.2:
                lower_chars.append(bbox)
            else:
                main_chars.append(bbox)
        return {
            'main_characters': main_chars,
            'upper_elements': upper_chars,
            'lower_elements': lower_chars
        }
# Пример использования сегментатора
segmenter = TibetanTextSegmenter()
binary_image = cv2.imread('processed_manuscript.jpg', 0)
lines = segmenter.segment_lines(binary_image)
for line_idx, (line_start, line_end) in enumerate(lines):
    line_image = binary_image[line_start:line_end, :]
    words = segmenter.segment_words(line_image)
    for word_idx, (word_start, word_end) in enumerate(words):
        word_image = line_image[:, word_start:word_end]
        characters = segmenter.segment_characters(word_image)
        structure = segmenter.analyze_tibetan_structure(characters, line_end-line_start)
        print(f"Строка {line_idx}, Слово {word_idx}: {len(characters)} символов")

Машинное обучение для распознавания символов

⚠️ Особенности ML для старотибетского распознавания

• Недостаток размеченных данных — необходимость аугментации и трансферного обучения
• Классовый дисбаланс — некоторые символы встречаются редко
• Вариативность написания — разные стили и исторические периоды
• Сложная структура символов — необходимость учета контекста
• Лингвистические особенности — грамматика и синтаксис тибетского языка

Нейросетевая модель для распознавания тибетских символов

CNN модель для классификации тибетских графем на TensorFlow

import tensorflow as tf
from tensorflow.keras import layers, models
import numpy as np
class TibetanCharacterRecognizer:
    def __init__(self, input_shape=(64, 64, 1), num_classes=200):
        self.input_shape = input_shape
        self.num_classes = num_classes
        self.model = self.build_model()
    def build_model(self):
        """Построение CNN архитектуры для распознавания тибетских символов"""
        model = models.Sequential([
            # Первый сверточный блок
            layers.Conv2D(32, (3, 3), activation='relu', input_shape=self.input_shape),
            layers.BatchNormalization(),
            layers.MaxPooling2D((2, 2)),
            layers.Dropout(0.25),
            # Второй сверточный блок
            layers.Conv2D(64, (3, 3), activation='relu'),
            layers.BatchNormalization(),
            layers.MaxPooling2D((2, 2)),
            layers.Dropout(0.25),
            # Третий сверточный блок
            layers.Conv2D(128, (3, 3), activation='relu'),
            layers.BatchNormalization(),
            layers.MaxPooling2D((2, 2)),
            layers.Dropout(0.25),
            # Четвертый сверточный блок
            layers.Conv2D(256, (3, 3), activation='relu'),
            layers.BatchNormalization(),
            layers.GlobalAveragePooling2D(),
            layers.Dropout(0.5),
            # Полносвязные слои
            layers.Dense(512, activation='relu'),
            layers.BatchNormalization(),
            layers.Dropout(0.5),
            layers.Dense(256, activation='relu'),
            layers.BatchNormalization(),
            layers.Dropout(0.5),
            # Выходной слой
            layers.Dense(self.num_classes, activation='softmax')
        ])
        return model
    def compile_model(self, learning_rate=0.001):
        """Компиляция модели с оптимизатором и функциями потерь"""
        optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
        self.model.compile(
            optimizer=optimizer,
            loss='categorical_crossentropy',
            metrics=['accuracy', 'top_k_categorical_accuracy']
        )
    def create_data_augmentation(self):
        """Создание пайплайна аугментации данных для тибетских символов"""
        return tf.keras.Sequential([
            layers.RandomRotation(0.02),  # Небольшие повороты
            layers.RandomZoom(0.1),       # Изменение масштаба
            layers.RandomContrast(0.2),   # Изменение контраста
            layers.RandomTranslation(0.05, 0.05),  Случайные смещения
        ])
    def train(self, train_images, train_labels, val_images, val_labels, 
              epochs=100, batch_size=32):
        """Обучение модели на датасете тибетских символов"""
        # Callbacks для улучшения обучения
        callbacks = [
            tf.keras.callbacks.EarlyStopping(
                patience=15, 
                restore_best_weights=True,
                monitor='val_accuracy'
            ),
            tf.keras.callbacks.ReduceLROnPlateau(
                factor=0.5, 
                patience=10, 
                min_lr=1e-7
            ),
            tf.keras.callbacks.ModelCheckpoint(
                'best_tibetan_model.h5',
                save_best_only=True,
                monitor='val_accuracy'
            )
        ]
        history = self.model.fit(
            train_images, train_labels,
            batch_size=batch_size,
            epochs=epochs,
            validation_data=(val_images, val_labels),
            callbacks=callbacks,
            verbose=1
        )
        return history
    def predict_character(self, character_image):
        """Предсказание символа для отдельного изображения"""
        # Предобработка изображения символа
        processed_char = self.preprocess_character(character_image)
        # Предсказание
        predictions = self.model.predict(processed_char[np.newaxis, ...])
        predicted_class = np.argmax(predictions[0])
        confidence = np.max(predictions[0])
        return predicted_class, confidence
    def preprocess_character(self, char_image):
        """Предобработка изображения символа для нейросети"""
        # Приведение к стандартному размеру
        resized = cv2.resize(char_image, (self.input_shape[1], self.input_shape[0]))
        # Нормализация
        normalized = resized.astype(np.float32) / 255.0
        # Добавление dimension для канала, если нужно
        if len(normalized.shape) == 2:
            normalized = normalized[..., np.newaxis]
        return normalized
# Пример создания и обучения модели
recognizer = TibetanCharacterRecognizer(input_shape=(64, 64, 1), num_classes=200)
recognizer.compile_model(learning_rate=0.001)
# Загрузка датасета (предполагается, что данные уже подготовлены)
# train_images, train_labels, val_images, val_labels = load_tibetan_dataset()
# Обучение модели
# history = recognizer.train(train_images, train_labels, val_images, val_labels)

Создание веб-интерфейса для системы

Архитектура веб-интерфейса на Flask

Разработан интуитивный веб-интерфейс, позволяющий исследователям легко работать с системой распознавания.

from flask import Flask, render_template, request, jsonify, send_file
import os
from werkzeug.utils import secure_filename
import cv2
import json
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = 'uploads'
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB
# Инициализация компонентов системы
preprocessor = TibetanManuscriptPreprocessor()
segmenter = TibetanTextSegmenter()
recognizer = TibetanCharacterRecognizer()
# recognizer.model.load_weights('best_tibetan_model.h5')  # Загрузка обученной модели
@app.route('/')
def index():
    return render_template('index.html')
@app.route('/upload', methods=['POST'])
def upload_manuscript():
    """Эндпоинт для загрузки изображения рукописи"""
    if 'file' not in request.files:
        return jsonify({'error': 'No file uploaded'}), 400
    file = request.files['file']
    if file.filename == '':
        return jsonify({'error': 'No selected file'}), 400
    if file:
        filename = secure_filename(file.filename)
        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
        file.save(filepath)
        # Обработка изображения
        processed_image = preprocessor.preprocess_pipeline(filepath)
        processed_path = os.path.join(app.config['UPLOAD_FOLDER'], 'processed_' + filename)
        cv2.imwrite(processed_path, processed_image)
        return jsonify({
            'message': 'File successfully uploaded and processed',
            'original': filename,
            'processed': 'processed_' + filename
        })
@app.route('/recognize', methods=['POST'])
def recognize_text():
    """Эндпоинт для распознавания текста на изображении"""
    data = request.json
    filename = data.get('filename')
    if not filename:
        return jsonify({'error': 'No filename provided'}), 400
    filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
    if not os.path.exists(filepath):
        return jsonify({'error': 'File not found'}), 404
    # Загрузка и обработка изображения
    image = cv2.imread(filepath, 0)
    # Сегментация и распознавание
    recognition_results = []
    lines = segmenter.segment_lines(image)
    for line_idx, (line_start, line_end) in enumerate(lines):
        line_image = image[line_start:line_end, :]
        words = segmenter.segment_words(line_image)
        line_text = ""
        for word_idx, (word_start, word_end) in enumerate(words):
            word_image = line_image[:, word_start:word_end]
            characters = segmenter.segment_characters(word_image)
            word_text = ""
            for char_bbox in characters:
                x, y, w, h = char_bbox
                char_image = word_image[y:y+h, x:x+w]
                # Распознавание символа
                predicted_class, confidence = recognizer.predict_character(char_image)
                if confidence > 0.7:  # Порог уверенности
                    # Преобразование номера класса в тибетский символ
                    tibetan_char = class_to_tibetan(predicted_class)
                    word_text += tibetan_char
            line_text += word_text + " "  # Добавление пробела между словами
        recognition_results.append({
            'line_number': line_idx,
            'text': line_text.strip(),
            'bbox': [line_start, line_end, 0, image.shape[1]]  # [y1, y2, x1, x2]
        })
    return jsonify({
        'filename': filename,
        'recognition_results': recognition_results
    })
@app.route('/correct', methods=['POST'])
def correct_recognition():
    """Эндпоинт для коррекции результатов распознавания"""
    data = request.json
    line_number = data.get('line_number')
    corrected_text = data.get('corrected_text')
    # Сохранение исправлений для дообучения модели
    save_correction(line_number, corrected_text)
    return jsonify({'message': 'Correction saved successfully'})
def class_to_tibetan(class_id):
    """Преобразование номера класса в тибетский символ"""
    # Загрузка mapping из файла или базы данных
    tibetan_chars = {
        0: 'ཀ', 1: 'ཁ', 2: 'ག', 3: 'ང', 4: 'ཅ',
        5: 'ཆ', 6: 'ཇ', 7: 'ཉ', 8: 'ཏ', 9: 'ཐ',
        # ... полный mapping тибетских символов
    }
    return tibetan_chars.get(class_id, '?')
if __name__ == '__main__':
    os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
    app.run(debug=True, host='0.0.0.0', port=5000)

Срочная помощь по вашей теме: Получите консультацию за 10 минут! Telegram: @Diplomit Телефон/WhatsApp: +7 (987) 915-99-32, Email: admin@diplom-it.ru

Оформите заказ онлайн: Заказать ВКР ФИТ НГУ

Заключение

Создание программного интерфейса для системы автоматического распознавания текстов старотибетских рукописей представляет собой комплексную междисциплинарную задачу, требующую интеграции знаний в области компьютерного зрения, машинного обучения и тибетологии. Разработанная система успешно сочетает традиционные методы обработки изображений с современными подходами глубокого обучения, обеспечивая высокую точность распознавания даже для сложных исторических документов.

Ключевыми достижениями представленного подхода являются: разработка специализированных алгоритмов предобработки, учитывающих особенности старотибетских рукописей; создание эффективных методов сегментации для многоуровневой тибетской письменности; построение точной нейросетевой модели классификации символов; и разработка удобного веб-интерфейса, позволяющего исследователям эффективно работать с системой. Особое внимание уделено возможности коррекции результатов, что обеспечивает постоянное улучшение системы через механизм обратной связи.

Для успешного выполнения выпускной квалификационной работы по данной тематике требуется не только владение программированием и машинным обучением, но и понимание лингвистических особенностей тибетского языка и палеографических аспектов исследования рукописей. Наши эксперты готовы предоставить комплексную поддержку на всех этапах работы — от сбора и разметки датасета до разработки и тестирования законченной системы, обеспечивая соответствие работы высочайшим академическим стандартам и практическую ценность для исследовательского сообщества.

Полезные ресурсы

• Условия работы и как сделать заказ
• Наши гарантии
• Отзывы наших клиентов
• Примеры выполненных работ

Дополнительные материалы

• Темы дипломных работ по прикладной информатике: 30 идей для 2025
• Актуальные темы для ВКР по информатике: направления 2025 года
• Темы для ВКР по информатике: от классических алгоритмов до современных трендов