[C++] 다층 퍼셉트론 예제 코드

---

/*
* Author : NeuroWhAI (https://neurowhai.github.com)
* Help : http://titaniumspider.tistory.com/12, http://se2n.com/study/io/인공지능/47
* License : Beerware
*/
#include <iostream>
#include <iomanip>
#include <cassert>
#include <vector>
#include <initializer_list>
#include <random>
#include <cmath>
#include <algorithm>
#include <stdexcept>
using namespace std;
class TrainingSet {
    public:
    TrainingSet() {
    }
    TrainingSet(const std::initializer_list<std::pair<std::vector<double>, double>>& trainingSet) {
        try {
            initialize(trainingSet);
        }
        catch (std::invalid_argument exp) {
            m_inputs.clear();
            m_outputs.clear();
        }
    }
    private:
    std::vector<std::vector<double>> m_inputs;
    std::vector<double> m_outputs;
    public:
    void initialize(const std::initializer_list<std::pair<std::vector<double>, double>>& trainingSet) {
        auto inputSize = trainingSet.begin()->first.size();
        for (auto& item : trainingSet) {
            if (item.first.size() != inputSize)
            throw std::invalid_argument("The size of the input set must be the same.");
        }
        m_inputs.clear();
        m_outputs.clear();
        for (auto& item : trainingSet) {
            m_inputs.emplace_back(item.first);
            m_outputs.emplace_back(item.second);
        }
    }
    public:
    std::size_t getSetCount() const {
        return m_outputs.size();
    }
    std::size_t getInputSize() const {
        if (m_inputs.size() > 0)
        return m_inputs[0].size();
        return 0;
    }
    void copyInput(int indexOfSet, std::vector<double>& outInput) const {
        outInput.clear();
        outInput.assign(m_inputs[indexOfSet].begin(), m_inputs[indexOfSet].end());
    }
    double getOutput(int indexOfSet) const {
        return m_outputs[indexOfSet];
    }
}
;
class Neuron {
    public:
    Neuron()
    : m_bias(0)
    , m_latestOutput(0)
    , m_latestDelta(0) {
    }
    private:
    std::vector<double> m_weights;
    double m_bias;
    double m_latestOutput;
    double m_latestDelta;
    public:
    void initialize(std::size_t inputSize) {
        m_latestOutput = 0;
        m_latestDelta = 0;
        m_weights.clear();
        m_weights.resize(inputSize);
        // 가중치는 랜덤하게 초기화 한다.
        std::random_device rd;
        std::mt19937 engine {
            rd()
        }
        ;
        std::uniform_real_distribution<> dist {
            -1.0, 1.0
        }
        ;
        m_bias = dist(engine);
        for (auto& weight : m_weights) {
            weight = dist(engine);
        }
    }
    public:
    double calculate(const std::vector<double>& input) {
        assert(input.size() == m_weights.size());
        const auto inputSize = input.size();
        double sum = m_bias;
        for (std::size_t i = 0; i < inputSize; ++i) {
            sum += m_weights[i] * input[i];
        }
        // 활성화 함수는 시그모이드를 사용한다.
        m_latestOutput = 1.0 / (1.0 + std::exp(-sum));
        return m_latestOutput;
    }
    double getLatestOutput() const {
        return m_latestOutput;
    }
    std::size_t getInputSize() const {
        return m_weights.size();
    }
    double getWeight(int index) const {
        return m_weights[index];
    }
    void addWeight(int index, double delta) {
        m_weights[index] += delta;
    }
    double getBias() const {
        return m_bias;
    }
    void addBias(double delta) {
        m_bias = delta;
    }
    double getLatestDelta() const {
        return m_latestDelta;
    }
    void setLatestDelta(double delta) {
        m_latestDelta = delta;
    }
}
;
class Network {
    public:
    Network() {
    }
    private:
    std::vector<std::vector<double>> m_inputs;
    std::vector<double> m_targetOutputs;
    private:
    std::vector<std::vector<Neuron>> m_layers;
    public:
    void initialize(const TrainingSet& trainingSet, const std::initializer_list<std::size_t>& hiddenLayerSizeList = {
    }
    ) {
        auto setCount = trainingSet.getSetCount();
        auto inputSize = trainingSet.getInputSize();
        // Copy Training Set
        m_inputs.clear();
        m_targetOutputs.clear();
        m_inputs.resize(setCount);
        for (std::size_t i = 0; i < setCount; ++i) {
            trainingSet.copyInput(i, m_inputs[i]);
            m_targetOutputs.emplace_back(trainingSet.getOutput(i));
        }
        // Build Network
        m_layers.clear();
        // Input Layer
        m_layers.emplace_back();
        m_layers[0].resize(inputSize);
        std::for_each(m_layers[0].begin(), m_layers[0].end(), [inputSize](Neuron& neuron) {
            neuron.initialize(inputSize);
        }
        );
        // Hidden Layer
        std::size_t prevLayerSize = m_layers[0].size();
        for (auto& layerSize : hiddenLayerSizeList) {
            m_layers.emplace_back();
            auto& layer = *(m_layers.end() - 1);
            layer.resize(layerSize);
            std::for_each(layer.begin(), layer.end(), [prevLayerSize](Neuron& neuron) {
                neuron.initialize(prevLayerSize);
            }
            );
            prevLayerSize = layer.size();
        }
        // Output Layer
        m_layers.emplace_back();
        auto& outputLayer = *(m_layers.end() - 1);
        outputLayer.resize(1);
        outputLayer[0].initialize(prevLayerSize);
    }
    public:
    double feed(const std::vector<double>& input) {
        std::vector<double> prevOutput = input;
        std::vector<double> outputs;
        for (auto& layer : m_layers) {
            for (auto& neuron : layer) {
                double result = neuron.calculate(prevOutput);
                outputs.emplace_back(result);
            }
            prevOutput = std::move(outputs);
            outputs.clear();
        }
        if (prevOutput.size() > 0)
        return prevOutput[0];
        return 0;
    }
    void train(std::size_t loopCount, double learningRate) {
        for (std::size_t step = 0; step < loopCount; ++step) {
            auto setCount = m_inputs.size();
            // 각 학습셋에 대해서 학습한다.
            for (std::size_t i = 0; i < setCount; ++i) {
                train(m_inputs[i], m_targetOutputs[i], learningRate);
            }
        }
    }
    void train(const std::vector<double>& input, double targetOutput, double learningRate) {
        double finalOutput = feed(input);
        double finalDelta = finalOutput * (1.0 - finalOutput) * (targetOutput - finalOutput);
        auto it = m_layers.rbegin();
        auto rEnd = m_layers.rend();
        /// 이전에 처리한 층. 델타 값이 계산된 층.
        auto* prevLayer = &*it;
        (*prevLayer)[0].setLatestDelta(finalDelta);
        // 가장 마지막 층 이전 층부터 입력층 순서로 델타 계산 및 가중치 조절.
        for (it += 1; it != rEnd; ++it) {
            auto& layer = *it;
            auto neuronCount = layer.size();
            for (std::size_t n = 0; n < neuronCount; ++n) {
                auto& neuron = layer[n];
                double output = neuron.getLatestOutput();
                double deltaSum = 0;
                // 현재 뉴런에 대해 델타를 계산하면서 동시에
                // 출력단에 연결된 뉴런의 가중치 조절.
                for (auto& prevNeuron : *prevLayer) {
                    double prevDelta = prevNeuron.getLatestDelta();
                    deltaSum += prevNeuron.getWeight(n) * prevDelta;
                    // 출력단 뉴런의 가중치 조절.
                    prevNeuron.addWeight(n, learningRate * output * prevDelta);
                }
                double delta = deltaSum * output * (1.0 - output);
                neuron.setLatestDelta(delta);
                // 바이어스 조절.
                neuron.addBias(learningRate * neuron.getBias() * delta);
            }
            prevLayer = &layer;
        }
    }
}
;
int main() {
    const double learningRate = 0.4;
    /// 학습 데이터
    TrainingSet trainingSet = {
        // {{Inputs...}, Output}
        { { 0, 0 }, 0 },
        { { 0, 1 }, 1 },
        { { 1, 0 }, 1 },
        { { 1, 1 }, 0 },
    }
    ;
    /// 신경망
    Network net;
    // 학습 데이터로 입력층, 출력층은 자동으로 만들어지며
    // 은닉층은 따로 크기를 받아 만든다.
    // 아래 코드의 경우 입력2 -> 은닉3 -> 출력1개가 된다.
    net.initialize(trainingSet, { 3 });
    // 아래 복사 작업은 결과값 확인을 위한 코드이므로 불필요하면 제거한다.
    /// 학습 데이터 개수
    auto setCount = trainingSet.getSetCount();
    /// 동시 입력 개수
    auto inputSize = trainingSet.getInputSize();
    std::vector<std::vector<double>> inputs;
    std::vector<double> targetOutputs;
    inputs.resize(setCount);
    for (std::size_t i = 0; i < setCount; ++i) {
        trainingSet.copyInput(i, inputs[i]);
        targetOutputs.emplace_back(trainingSet.getOutput(i));
    }
    std::size_t maxEpoch = 10000000;
    for (std::size_t epoch = 0; epoch < maxEpoch; ++epoch) {
        // 학습.
        net.train(5000, learningRate);
        /// 에러율
        double errorRate = 0;
        for (std::size_t i = 0; i < setCount; ++i) {
            for (auto& data : inputs[i]) {
                std::cout << data << " \t";
            }
            double output = net.feed(inputs[i]);
            std::cout << " -> \t" << output << " => \t" << targetOutputs[i] << std::endl;
            errorRate += std::abs(targetOutputs[i] - output);
        }
        std::cout << std::endl;
        errorRate /= 2.0;
        std::cout << std::setprecision(6) << "Error : " << errorRate * 100.0 << "%" << std::endl;
        // 에러가 일정 수준 미만으로 떨어지면 종료.
        if (errorRate < 0.01) {
            std::cout << "Finished!" << std::endl;
            std::cout << "Final Error : " << errorRate * 100.0 << "%" << std::endl;
            break;
        }
    }
    getchar();
    return 0;
}

---

코드 정렬을 어떤 사이트에서 했더니 뭔가 너무 정렬됬는데;;