c++/main.cpp - master - cedric/ComputerVision

c++/main.cpp
290 строк11 KB
cedric
first_commit
25 дек 2025, 17:32
25 дек 2025, 17:3223e9d7e
#include <iostream>
#include <vector>
#include <string>
#include <chrono>
#include <opencv2/opencv.hpp>
#include <mlpack/core.hpp>
#include <mlpack/methods/neighbor_search/neighbor_search.hpp>
#include <mlpack/methods/knn/knn.hpp>

using namespace std;
using namespace cv;
using namespace mlpack;
using namespace mlpack::neighbor;
using namespace mlpack::data;
using namespace std::chrono;

class PatternRecognitionDemo {
private:
    arma::mat X_train, X_test;
    arma::Row<size_t> y_train, y_test;
    KNN* knnModel;
    
public:
    PatternRecognitionDemo() : knnModel(nullptr) {
        loadData();
    }
    
    ~PatternRecognitionDemo() {
        if (knnModel) delete knnModel;
    }
    
    void loadData() {
        cout << "1. ЗАГРУЗКА И ПОДГОТОВКА ДАННЫХ" << endl;
        cout << string(50, '=') << endl;
        
        // Для реального использования нужно загрузить данные MNIST
        // Здесь создаем синтетические данные для демонстрации
        const int num_samples = 1797;
        const int num_features = 64;
        const int num_classes = 10;
        
        arma::mat X(num_features, num_samples, arma::fill::randu);
        arma::Row<size_t> y(num_samples);
        
        for(size_t i = 0; i < num_samples; i++) {
            y[i] = i % num_classes;
        }
        
        cout << "Количество объектов: " << X.n_cols << endl;
        cout << "Количество признаков на объект: " << X.n_rows << endl;
        cout << "Количество классов: " << num_classes << endl;
        
        // Нормализация данных
        arma::mat X_normalized = X;
        for(size_t i = 0; i < X.n_rows; i++) {
            double min_val = X.row(i).min();
            double max_val = X.row(i).max();
            X_normalized.row(i) = (X.row(i) - min_val) / (max_val - min_val);
        }
        
        // Разделение на обучающую и тестовую выборки
        const double test_ratio = 0.3;
        const size_t test_size = num_samples * test_ratio;
        const size_t train_size = num_samples - test_size;
        
        X_train = X_normalized.cols(0, train_size-1);
        X_test = X_normalized.cols(train_size, num_samples-1);
        y_train = y.subvec(0, train_size-1);
        y_test = y.subvec(train_size, num_samples-1);
        
        cout << "\nРазмер обучающей выборки: " << X_train.n_cols << endl;
        cout << "Размер тестовой выборки: " << X_test.n_cols << endl;
        
        // Визуализация (в C++ это сложнее, используем консольный вывод)
        visualizeSamples();
    }
    
    void visualizeSamples() {
        cout << "\nПримеры изображений цифр (симуляция):" << endl;
        for(int i = 0; i < 5; i++) {
            cout << "Образец " << i << ", класс: " << y_train[i] << endl;
        }
    }
    
    void extractFeaturesInfo() {
        cout << "\n2. АНАЛИЗ ПРИЗНАКОВ" << endl;
        cout << string(50, '=') << endl;
        
        if(X_train.n_cols == 0) return;
        
        arma::vec first_image_features = X_train.col(0);
        
        cout << "Признаки первого изображения (первые 10 из 64):" << endl;
        for(int i = 0; i < 10; i++) {
            cout << first_image_features[i] << " ";
        }
        cout << endl;
        
        cout << "\nСтатистика по признакам:" << endl;
        cout << "Минимальное значение: " << arma::min(first_image_features) << endl;
        cout << "Максимальное значение: " << arma::max(first_image_features) << endl;
        cout << "Среднее значение: " << arma::mean(first_image_features) << endl;
    }
    
    void trainModel() {
        cout << "\n3. ОБУЧЕНИЕ МОДЕЛИ РАСПОЗНАВАНИЯ" << endl;
        cout << string(50, '=') << endl;
        
        if(knnModel) delete knnModel;
        
        knnModel = new KNN();
        
        // Параметры модели
        const size_t k = 5;
        
        cout << "Модель: k-ближайших соседей (k-NN)" << endl;
        cout << "Параметр: k=" << k << endl;
        
        auto start = high_resolution_clock::now();
        
        // Обучение модели
        knnModel->Train(X_train, y_train);
        
        auto stop = high_resolution_clock::now();
        auto duration = duration_cast<milliseconds>(stop - start);
        
        cout << "Обучение завершено за " << duration.count() << " миллисекунд" << endl;
        
        // Оценка на обучающей выборке
        arma::Row<size_t> train_predictions;
        knnModel->Predict(X_train, train_predictions);
        
        size_t correct = 0;
        for(size_t i = 0; i < y_train.n_elem; i++) {
            if(y_train[i] == train_predictions[i]) correct++;
        }
        double train_accuracy = (double)correct / y_train.n_elem;
        
        cout << "Точность на обучающей выборке: " << train_accuracy << endl;
    }
    
    void evaluateModel() {
        cout << "\n4. ОЦЕНКА КАЧЕСТВА РАСПОЗНАВАНИЯ" << endl;
        cout << string(50, '=') << endl;
        
        if(!knnModel) {
            cout << "Модель не обучена!" << endl;
            return;
        }
        
        // Предсказание на тестовой выборке
        arma::Row<size_t> predictions;
        knnModel->Predict(X_test, predictions);
        
        // Расчет точности
        size_t correct = 0;
        for(size_t i = 0; i < y_test.n_elem; i++) {
            if(y_test[i] == predictions[i]) correct++;
        }
        double accuracy = (double)correct / y_test.n_elem;
        
        cout << "Точность (accuracy): " << accuracy << endl;
        
        // Матрица ошибок (упрощенная)
        const size_t num_classes = 10;
        vector<vector<int>> confusion_matrix(num_classes, vector<int>(num_classes, 0));
        
        for(size_t i = 0; i < y_test.n_elem; i++) {
            confusion_matrix[y_test[i]][predictions[i]]++;
        }
        
        cout << "\nМатрица ошибок (первые 5x5):" << endl;
        for(int i = 0; i < 5; i++) {
            for(int j = 0; j < 5; j++) {
                cout << confusion_matrix[i][j] << "\t";
            }
            cout << endl;
        }
        
        // Визуализация примеров
        visualizePredictions(predictions);
    }
    
    void visualizePredictions(const arma::Row<size_t>& predictions) {
        cout << "\nПримеры классификации:" << endl;
        
        int correct_shown = 0;
        int incorrect_shown = 0;
        
        for(size_t i = 0; i < min((size_t)10, y_test.n_elem); i++) {
            if(y_test[i] == predictions[i] && correct_shown < 3) {
                cout << "Правильно: Истинный класс: " << y_test[i] 
                     << ", Предсказанный: " << predictions[i] << endl;
                correct_shown++;
            }
            else if(y_test[i] != predictions[i] && incorrect_shown < 3) {
                cout << "Ошибка: Истинный класс: " << y_test[i] 
                     << ", Предсказанный: " << predictions[i] << " !" << endl;
                incorrect_shown++;
            }
        }
    }
    
    void demonstrateDecisionProcess(size_t sample_idx = 0) {
        cout << "\n5. ПРОЦЕСС ПРИНЯТИЯ РЕШЕНИЯ (k-NN)" << endl;
        cout << string(50, '=') << endl;
        
        if(sample_idx >= X_test.n_cols) sample_idx = 0;
        
        arma::mat test_sample = X_test.col(sample_idx);
        size_t true_label = y_test[sample_idx];
        
        // Для k-NN в mlpack нужно использовать поиск соседей
        arma::Mat<size_t> neighbors;
        arma::mat distances;
        
        KNN knn_search(X_train);
        knn_search.Search(test_sample, 5, neighbors, distances);
        
        cout << "Тестовый пример (истинный класс: " << true_label << "):" << endl;
        cout << "Индексы 5 ближайших соседей: ";
        for(size_t i = 0; i < neighbors.n_rows; i++) {
            cout << neighbors(i, 0) << " ";
        }
        cout << endl;
        
        // Определение класса по соседям
        vector<int> neighbor_counts(10, 0);
        for(size_t i = 0; i < neighbors.n_rows; i++) {
            size_t neighbor_idx = neighbors(i, 0);
            neighbor_counts[y_train[neighbor_idx]]++;
        }
        
        size_t predicted_label = 0;
        int max_count = 0;
        for(size_t i = 0; i < neighbor_counts.size(); i++) {
            if(neighbor_counts[i] > max_count) {
                max_count = neighbor_counts[i];
                predicted_label = i;
            }
        }
        
        cout << "Результат голосования: ";
        for(size_t i = 0; i < 10; i++) {
            if(neighbor_counts[i] > 0) {
                cout << "Класс " << i << ": " << neighbor_counts[i] << " ";
            }
        }
        cout << endl;
        
        cout << "Предсказанный класс: " << predicted_label << endl;
    }
    
    void runFullDemo() {
        cout << "ДЕМОНСТРАЦИЯ ОСНОВ РАСПОЗНАВАНИЯ ОБРАЗОВ" << endl;
        cout << string(60, '=') << endl;
        
        extractFeaturesInfo();
        trainModel();
        evaluateModel();
        demonstrateDecisionProcess();
        
        cout << "\n" << string(60, '=') << endl;
        cout << "ДЕМОНСТРАЦИЯ ЗАВЕРШЕНА" << endl;
        cout << "\nОсновные понятия, которые были продемонстрированы:" << endl;
        cout << "1. Данные и предобработка" << endl;
        cout << "2. Признаки и их извлечение" << endl;
        cout << "3. Обучение с учителем" << endl;
        cout << "4. Классификация и оценка качества" << endl;
        cout << "5. Принятие решений в моделях" << endl;
    }
};

int main() {
    // Создание и запуск демо
    PatternRecognitionDemo demo;
    demo.runFullDemo();
    
    cout << "\n" << string(60, '=') << endl;
    cout << "ПРОСТОЙ ПРИМЕР КЛАССИФИКАЦИИ" << endl;
    
    // Простой тест
    cout << "\nДемонстрация завершена успешно!" << endl;
    cout << "Для реального использования с MNIST требуется:" << endl;
    cout << "1. Загрузка реальных данных MNIST" << endl;
    cout << "2. Настройка параметров модели" << endl;
    cout << "3. Более сложная визуализация (используя OpenCV)" << endl;
    
    return 0;
}