Comprehensive comparison for AI technology in applications

#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <stdexcept>
#include <cmath>
#include <algorithm>

// Neural Network Inference Engine for Image Classification
// Demonstrates AI pattern: Forward propagation through a simple neural network

class Matrix {
public:
    std::vector<std::vector<double>> data;
    size_t rows, cols;

    Matrix(size_t r, size_t c) : rows(r), cols(c) {
        data.resize(rows, std::vector<double>(cols, 0.0));
    }

    Matrix multiply(const Matrix& other) const {
        if (cols != other.rows) {
            throw std::invalid_argument("Matrix dimensions incompatible for multiplication");
        }
        Matrix result(rows, other.cols);
        for (size_t i = 0; i < rows; ++i) {
            for (size_t j = 0; j < other.cols; ++j) {
                for (size_t k = 0; k < cols; ++k) {
                    result.data[i][j] += data[i][k] * other.data[k][j];
                }
            }
        }
        return result;
    }

    void applyReLU() {
        for (auto& row : data) {
            for (auto& val : row) {
                val = std::max(0.0, val);
            }
        }
    }

    void applySoftmax() {
        for (auto& row : data) {
            double maxVal = *std::max_element(row.begin(), row.end());
            double sum = 0.0;
            for (auto& val : row) {
                val = std::exp(val - maxVal);
                sum += val;
            }
            for (auto& val : row) {
                val /= sum;
            }
        }
    }
};

class NeuralNetworkInference {
private:
    std::vector<Matrix> weights;
    std::vector<Matrix> biases;
    std::vector<std::string> classLabels;

public:
    NeuralNetworkInference(const std::vector<std::string>& labels) : classLabels(labels) {
        // Initialize network: 784 input -> 128 hidden -> 10 output (MNIST-like)
        weights.emplace_back(784, 128);
        weights.emplace_back(128, 10);
        biases.emplace_back(1, 128);
        biases.emplace_back(1, 10);
        
        // Initialize with random weights (simplified for demo)
        for (auto& w : weights) {
            for (auto& row : w.data) {
                for (auto& val : row) {
                    val = (rand() % 1000) / 1000.0 - 0.5;
                }
            }
        }
    }

    std::pair<std::string, double> predict(const std::vector<double>& input) {
        if (input.size() != 784) {
            throw std::invalid_argument("Input must be 784 features");
        }

        // Convert input to matrix
        Matrix x(1, 784);
        x.data[0] = input;

        try {
            // Layer 1: Dense + ReLU
            Matrix hidden = x.multiply(weights[0]);
            for (size_t i = 0; i < hidden.cols; ++i) {
                hidden.data[0][i] += biases[0].data[0][i];
            }
            hidden.applyReLU();

            // Layer 2: Dense + Softmax
            Matrix output = hidden.multiply(weights[1]);
            for (size_t i = 0; i < output.cols; ++i) {
                output.data[0][i] += biases[1].data[0][i];
            }
            output.applySoftmax();

            // Find predicted class
            size_t maxIdx = 0;
            double maxProb = output.data[0][0];
            for (size_t i = 1; i < output.cols; ++i) {
                if (output.data[0][i] > maxProb) {
                    maxProb = output.data[0][i];
                    maxIdx = i;
                }
            }

            return {classLabels[maxIdx], maxProb};
        } catch (const std::exception& e) {
            throw std::runtime_error("Inference failed: " + std::string(e.what()));
        }
    }
};

int main() {
    try {
        std::vector<std::string> labels = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};
        NeuralNetworkInference model(labels);

        // Simulate 28x28 grayscale image input (784 pixels)
        std::vector<double> imageData(784, 0.0);
        for (size_t i = 0; i < 784; ++i) {
            imageData[i] = (rand() % 256) / 255.0;
        }

        auto [predictedClass, confidence] = model.predict(imageData);
        std::cout << "Predicted Class: " << predictedClass << std::endl;
        std::cout << "Confidence: " << (confidence * 100) << "%" << std::endl;

    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}