NeuralNetwork.cpp

// ============================================================
// Project 1: Neural Network from Scratch
// OOP: Layer, Neuron, Activator classes
// DSA: 2D vectors, matrix operations
// Domain: AI/ML
// ============================================================

#include <iostream>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iomanip>
using namespace std;

// ---------- Activation Functions ----------
class Activator {
public:
    static double sigmoid(double x) {
        return 1.0 / (1.0 + exp(-x));
    }
    static double sigmoidDerivative(double x) {
        double s = sigmoid(x);
        return s * (1.0 - s);
    }
};

// ---------- Neuron ----------
class Neuron {
public:
    double output;
    double delta;
    vector<double> weights;

    Neuron(int numInputs) : output(0.0), delta(0.0) {
        for (int i = 0; i <= numInputs; i++) // +1 for bias
            weights.push_back(((double)rand() / RAND_MAX) * 2.0 - 1.0);
    }

    double activate(const vector<double>& inputs) {
        double sum = weights.back(); // bias weight
        for (int i = 0; i < (int)inputs.size(); i++)
            sum += inputs[i] * weights[i];
        output = Activator::sigmoid(sum);
        return output;
    }
};

// ---------- Layer ----------
class Layer {
public:
    vector<Neuron> neurons;
    int numInputs;

    Layer(int numNeurons, int numInputs) : numInputs(numInputs) {
        for (int i = 0; i < numNeurons; i++)
            neurons.emplace_back(numInputs);
    }

    vector<double> forward(const vector<double>& inputs) {
        vector<double> outputs;
        for (auto& neuron : neurons)
            outputs.push_back(neuron.activate(inputs));
        return outputs;
    }
};

// ---------- Neural Network ----------
class NeuralNetwork {
private:
    vector<Layer> layers;
    double learningRate;

public:
    NeuralNetwork(vector<int> topology, double lr = 0.5) : learningRate(lr) {
        for (int i = 1; i < (int)topology.size(); i++)
            layers.emplace_back(topology[i], topology[i - 1]);
    }

    vector<double> forward(const vector<double>& input) {
        vector<double> current = input;
        for (auto& layer : layers)
            current = layer.forward(current);
        return current;
    }

    void backpropagate(const vector<double>& input, const vector<double>& target) {
        // Forward pass first
        vector<vector<double>> layerInputs;
        layerInputs.push_back(input);
        vector<double> current = input;
        for (auto& layer : layers) {
            current = layer.forward(current);
            layerInputs.push_back(current);
        }

        // Output layer deltas
        Layer& outputLayer = layers.back();
        for (int j = 0; j < (int)outputLayer.neurons.size(); j++) {
            double out = outputLayer.neurons[j].output;
            double err = target[j] - out;
            outputLayer.neurons[j].delta = err * Activator::sigmoidDerivative(out);
        }

        // Hidden layer deltas
        for (int i = (int)layers.size() - 2; i >= 0; i--) {
            for (int j = 0; j < (int)layers[i].neurons.size(); j++) {
                double error = 0.0;
                for (auto& nextNeuron : layers[i + 1].neurons)
                    error += nextNeuron.delta * nextNeuron.weights[j];
                double out = layers[i].neurons[j].output;
                layers[i].neurons[j].delta = error * Activator::sigmoidDerivative(out);
            }
        }

        // Update weights
        for (int i = 0; i < (int)layers.size(); i++) {
            const vector<double>& inp = layerInputs[i];
            for (auto& neuron : layers[i].neurons) {
                for (int k = 0; k < (int)inp.size(); k++)
                    neuron.weights[k] += learningRate * neuron.delta * inp[k];
                neuron.weights.back() += learningRate * neuron.delta; // bias
            }
        }
    }

    void train(const vector<vector<double>>& X,
               const vector<vector<double>>& Y,
               int epochs) {
        for (int e = 0; e < epochs; e++) {
            double totalLoss = 0.0;
            for (int i = 0; i < (int)X.size(); i++) {
                vector<double> pred = forward(X[i]);
                backpropagate(X[i], Y[i]);
                totalLoss += pow(Y[i][0] - pred[0], 2);
            }
            if ((e + 1) % 1000 == 0)
                cout << "Epoch " << setw(5) << (e + 1)
                     << " | Loss: " << fixed << setprecision(6) << totalLoss / X.size() << "\n";
        }
    }

    void predict(const vector<double>& input) {
        vector<double> out = forward(input);
        cout << "Input: [";
        for (int i = 0; i < (int)input.size(); i++) {
            cout << input[i];
            if (i < (int)input.size() - 1) cout << ", ";
        }
        cout << "] => Predicted: " << fixed << setprecision(4) << out[0]
             << " => Class: " << (out[0] >= 0.5 ? 1 : 0) << "\n";
    }
};

// ---------- Main ----------
int main() {
    srand(42);
    cout << "========================================\n";
    cout << "   Neural Network from Scratch (XOR)\n";
    cout << "========================================\n\n";

    // XOR dataset
    vector<vector<double>> X = {{0,0},{0,1},{1,0},{1,1}};
    vector<vector<double>> Y = {{0},  {1},  {1},  {0}};

    // Topology: 2 inputs -> 4 hidden -> 1 output
    NeuralNetwork nn({2, 4, 1}, 0.5);

    cout << "Training on XOR problem...\n\n";
    nn.train(X, Y, 5000);

    cout << "\n--- Predictions ---\n";
    for (auto& x : X) nn.predict(x);

    cout << "\n========================================\n";
    cout << "   Training on AND gate\n";
    cout << "========================================\n\n";

    vector<vector<double>> X2 = {{0,0},{0,1},{1,0},{1,1}};
    vector<vector<double>> Y2 = {{0},  {0},  {0},  {1}};

    NeuralNetwork nn2({2, 3, 1}, 0.5);
    nn2.train(X2, Y2, 3000);

    cout << "\n--- Predictions ---\n";
    for (auto& x : X2) nn2.predict(x);

    return 0;
}