/*
 * MLP.cpp
 *
 *  Created on: 09.06.2011
 *      Author: sven
 */
#include <boost/foreach.hpp>
#include <boost/cstdlib.hpp>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <limits>
#include <sstream>
#include "MLP.h"

MLP::MLP(const MLPConfig& mlpConf)
:mStartHidden(1+mlpConf.getNumInputNeurons()),mStartOutput(mStartHidden+mlpConf.getNumHiddenNeurons())
,mNoNeuron(mStartOutput + mlpConf.getNumOutputNeurons())
,mActivity(mNoNeuron), mDelta(mNoNeuron)
,mMomentum(mlpConf.getMomentum())
,mLernrate(mlpConf.getLernrate()),mConfig(mlpConf),mTrainSuccess(false),mDoStop(false)
{
	mWeights = mlpConf.getWeights();
	for (uint32_t i = 0; i < mNoNeuron ; i++) {
		mDeltaWeights.push_back(vector<double>(mNoNeuron));
		mOldUpdate.push_back(vector<double>(mNoNeuron));
	}
    // Bias neuron is always on
    mActivity.at(0) = 1.0;
}

MLP::~MLP()
{

}

void MLP::dump()
{
	int width = 12;
	int prec = 8;
	cout << "============ MLP config==========" << endl;
	cout << "start hidden: " << mStartHidden << endl;
	cout << "start output: " << mStartOutput << endl;
	cout << "no neuron: " << mNoNeuron << endl;

	cout << "Weights:" << endl;
	BOOST_FOREACH(vector<double> i, mWeights)
	{
		BOOST_FOREACH(double w, i)
		{
			cout << setw(width) << fixed << setprecision(prec)  << w;
		}
		cout << endl;
	}
	cout << "Deltaweights:" << endl;
	BOOST_FOREACH(vector<double> i, mDeltaWeights)
	{
		BOOST_FOREACH(double w, i)
		{
			cout << setw(width) << setprecision(prec)  << w;
		}
		cout << endl;
	}
	cout << "OldUpdate:" << endl;
	BOOST_FOREACH(vector<double> i, mOldUpdate)
	{
		BOOST_FOREACH(double w, i)
		{
			cout << setw(width) << setprecision(prec)  << w;
		}
		cout << endl;
	}
	cout << "Activity:" << endl;
	BOOST_FOREACH(double w, mActivity)
	{
		cout << setw(width) << setprecision(prec)  << w;
	}
    cout << endl;
	cout << "=================================" << endl;
}

double MLP::sigmoid(const double& a)
{
    double res = 0.0;
    res = 1.0 / (1.0 + exp(-a) );
    return res;
}

void MLP::propagate(const Pattern& pattern)
{
    uint32_t i,j;
    double activation = 0.0;
    if (pattern.size() != (mStartHidden - 1) ) {
        cerr << "Pattern does not match input neurons: " << pattern.size() << " != " << (mStartHidden - 1) << endl;
        exit(1);
    }
    for (i=1 ; i < mStartHidden ; i++) {
        mActivity.at(i) = pattern.at(i - 1);
    }
    for (i=mStartHidden ; i<mStartOutput ; i++) {
        activation = mActivity.at(0) * mWeights.at(0).at(i);
        for (j=1 ; j<mStartHidden ; j++) {
            activation += mActivity.at(j) * mWeights.at(j).at(i);
        }
        mActivity.at(i) = sigmoid(activation);
    }
    for (i=mStartOutput ; i < mNoNeuron ; i++) {
        activation = mActivity.at(0) * mWeights.at(0).at(i);
        for (j=mStartHidden ; j<mStartOutput ; j++) {
            activation += mActivity.at(j) * mWeights.at(j).at(i);
        }
        mActivity.at(i) = sigmoid(activation);
    }
}
void MLP::back_propagate(const Target& target)
{
    uint32_t i,j;
    // injected error
    for (i=mStartOutput ; i<mNoNeuron ; i++ ) {
        mDelta.at(i) = (-1.0) * (target.at( i-mStartOutput ) - mActivity.at(i) );
        mDelta.at(i) *= mActivity.at(i) * ( 1.0 -  mActivity.at(i));
    }

    // implicit error
    for (i=mStartHidden ; i<mStartOutput ; i++) {
        for ( j=mStartOutput , mDelta.at(i)=0 ; j<mNoNeuron ; j++) {
            mDelta.at(i) += mWeights.at(i).at(j) * mDelta.at(j);
        }
        mDelta.at(i) *= mActivity.at(i) * ( 1.0 - mActivity.at(i) );
    }

    // bias weight deltas
    for (j=mStartHidden ; j<mNoNeuron ; j++) {
        mDeltaWeights.at(0).at(j) += (mActivity.at(0) * mDelta.at(j));
    }

    // input to hidden weight deltas
    for (i=1 ; i<mStartHidden ; i++) {
        for(j=mStartHidden;j < mStartOutput;j++) {
            mDeltaWeights.at(i).at(j) += (mActivity.at(i) * mDelta.at(j));
        }
    }

    // hidden to output weight deltas
    for(i=mStartHidden;i < mStartOutput;i++) {
        for(j=mStartOutput;j < mNoNeuron;j++) {
            mDeltaWeights.at(i).at(j) += (mActivity.at(i) * mDelta.at(j));
        }
    }
}

void MLP::update_weight()
{
    uint32_t i,j;
    double update;
    mOldWeights = mWeights;
    for(i=0;i < mNoNeuron;i++) { 
        for(j=0;j < mNoNeuron;j++) { 
            update = (-1.) * mLernrate * mDeltaWeights.at(i).at(j);
            update += mMomentum * mOldUpdate.at(i).at(j);
            mWeights.at(i).at(j) += update; 
            mOldUpdate.at(i).at(j) = update; 
            mDeltaWeights.at(i).at(j) = 0.0; 
        }
    }
}

void MLP::reset_delta()
{
    for (uint32_t i=0 ; i < mNoNeuron ; i++) {
        mDelta.at(i) = 0.0;
    }
}

void MLP::train(const Traindata & traindata, const Traindata& valdata, const uint32_t numCycles, const std::string& outputfilename)
{
    Traindata::const_iterator it;
    double error = numeric_limits<double>::infinity();
    for (uint32_t i = 0; i < numCycles ; i++) {
        it = traindata.begin();
        for( ; it != traindata.end() ; it++) {
            propagate((*it).mPattern);
            back_propagate((*it).mTarget);
            if (mConfig.getUpdateMode() == MLPConfig::UPDATE_MODE_SINGLE) {
                update_weight();
                reset_delta();
            }
            if (isStop()) {
                ostringstream oss;
                oss << "mlp_lastconfig_" << mOldError << ".txt";
                writeWeightsToFile(oss.str(),mOldWeights);
                return;
            }
        }
        if (mConfig.getUpdateMode() == MLPConfig::UPDATE_MODE_BATCH) {
            update_weight();
            reset_delta();
        }
        error = validate(valdata);
        if (i>0) {
			cout << "Error: " << error << " cycles: " << (i+1) << endl;
			if (error < mConfig.getErrorThreshold()) {
				cout << "Error: " << error << " cycles: " << (i+1) << endl;
				writeWeightsToFile(outputfilename,mWeights);
				mTrainSuccess = true;
				return;
			}
			// error increases on a low level
			if ( (error < mConfig.getConfigAcceptanceErrorThreshold() ) && (mOldError < error) ) {
				cout << "Olderror: " << mOldError << " Error: " << error << " cycles: " << (i+1) << endl;
				writeWeightsToFile(outputfilename,mOldWeights);
				mTrainSuccess = true;
				return;
			}
        	mOldError = error;
        }
    }
	if (!mTrainSuccess) {
        ostringstream oss;
        oss << "mlp_lastconfig_" << error << ".txt";
		writeWeightsToFile(oss.str(),mWeights);
	}
}

double MLP::validate(const Traindata & valdata) {
    double error = 0.0;
    if (valdata.empty()) {
    	return numeric_limits<double>::infinity();
    }
    uint32_t j;
    Traindata::const_iterator it = valdata.begin();
    for( ; it != valdata.end() ; it++) {
        propagate((*it).mPattern);
        for(j=mStartOutput;j < mNoNeuron;j++)
        {
            error += pow(((*it).mTarget.at(j - mStartOutput) - mActivity.at(j)),2);
        }
    }
    return error;
}

void MLP::writeWeightsToFile(const string& filename, const Weights& weights)
{
    ofstream outFile;
    outFile.open(filename.c_str(),ios::out);
    uint32_t i,j;

    outFile << "Bias: 0" << endl;
    outFile << "Input:";
    for (i=1; i<mStartHidden ; i++) {
    	outFile << " " << i;
    }
    outFile << endl;

    outFile << "Hidden:";
    for (i=mStartHidden; i<mStartOutput ; i++) {
    	outFile << " " << i;
    }
    outFile << endl;

    outFile << "Output:";
    for (i=mStartOutput; i<mNoNeuron ; i++) {
    	outFile << " " << i;
    }
    outFile << endl;

    outFile << "Threshold" << endl;
    for ( i=mStartHidden ; i < mNoNeuron ; i++ ) {
        outFile << "0 " << i << " " << scientific << weights.at(0).at(i) << endl;
    }
    outFile << "Input -> Hidden" << endl;
    for (i=1; i<mStartHidden; i++) {
        for (j=mStartHidden; j<mStartOutput; j++) {
            outFile << i << " " << j << " " << scientific << weights.at(i).at(j) << endl;
        }
    }
    outFile << "Hidden -> Output" << endl;
    for (i=mStartHidden; i<mStartOutput; i++) {
        for (j=mStartOutput; j<mNoNeuron; j++) {
            outFile << i << " " << j << " " << scientific << weights.at(i).at(j) << endl;
        }
    }
    outFile.close();
}

void MLP::propagate(const Pattern &pattern, Output &result)
{
    propagate(pattern);
    for (uint32_t i=mStartOutput; i<mNoNeuron ; i++) {
        result.push_back(mActivity.at(i));
    }
}

void MLP::stop()
{
    //cout << __FUNCTION__ << " locking mutex" << endl;
    mMutex.lock();
    mDoStop = true;
    mMutex.unlock();
    //cout << __FUNCTION__ << " unlocking mutex" << endl;
}

bool MLP::isStop()
{
    bool res;
    //cout << __FUNCTION__ << " locking mutex" << endl;
    mMutex.lock();
    res = mDoStop;
    mMutex.unlock();
    //cout << __FUNCTION__ << " unlocking mutex" << endl;
    return res;
}