learnmodel.cpp

Go to the documentation of this file.

#include <assert.h>
#include <cmath>
#include <sstream>
#include <stdio.h>
#include "learnmodel.h"

namespace lemga {

static DataSet*
load_data (DataSet* pd, std::istream& is, UINT n, UINT in, UINT out) {
    for (UINT i = 0; i < n; ++i) {
        Input x(in);
        Output y(out);
        for (UINT j = 0; j < in; ++j)
            if (!(is >> x[j])) return pd;
        for (UINT j = 0; j < out; ++j)
            if (!(is >> y[j])) return pd;

        pd->append(x, y);
    }
    return pd;
}

DataSet* load_data (std::istream& is, UINT n, UINT in, UINT out) {
    DataSet* pd = new DataSet();
    return load_data(pd, is, n, in, out);
}

DataSet* load_data (std::istream& is, UINT n) {
    assert(n > 0);
    /* read the first line and infer the input dimension */
    Input x;
    do {
        char line[1024*10];
        is.getline(line, 1024*10);
        std::istringstream iss(line);
        REAL xi;
        while (iss >> xi)
            x.push_back(xi);
    } while (x.empty() && !is.eof());
    if (x.empty()) return 0;

    Output y(1, x.back());
    x.pop_back();

    DataSet* pd = new DataSet();
    pd->append(x, y);
    return load_data(pd, is, n-1, x.size(), 1);
}

LearnModel::LearnModel (UINT n_in, UINT n_out)
    : Object(), _n_in(n_in), _n_out(n_out), n_samples(0), logf(NULL)
{ /* empty */ }

bool LearnModel::serialize (std::ostream& os,
                            ver_list& vl) const {
    SERIALIZE_PARENT(Object, os, vl, 1);
    return (os << _n_in << ' ' << _n_out << '\n');
}

bool LearnModel::unserialize (std::istream& is, ver_list& vl,
                              const id_t& _id) {
    assert(_id == empty_id);
    UNSERIALIZE_PARENT(Object, is, vl, 1, v);
    if (v == 0) return true;
    return (is >> _n_in >> _n_out);
}

LearnModel::LearnModel (const LearnModel &lm)
    : Object(lm), _n_in(lm._n_in), _n_out(lm._n_out),
      ptd(lm.ptd), ptw(lm.ptw), n_samples(lm.n_samples), logf(lm.logf) /* is this reasonable? */
{ /* empty */ }

REAL LearnModel::r_error (const Output& out, const Output& y) const {
    assert(out.size() == n_output());
    assert(y.size() == n_output());

    REAL err = 0;
    for (UINT i = 0; i < _n_out; ++i) {
        REAL dif = out[i] - y[i];
        err += dif * dif;
    }
    return err / 2;
}

REAL LearnModel::c_error (const Output& out, const Output& y) const {
    assert(n_output() == 1);
    assert(std::fabs(std::fabs(y[0]) - 1) < INFINITESIMAL);
    return (out[0]*y[0] <= 0);
}

REAL LearnModel::train_r_error () const {
    assert(ptw != 0);
    REAL err = 0;
    for (UINT i = 0; i < n_samples; ++i)
        err += (*ptw)[i] * r_error(get_output(i), ptd->y(i));
    return err;
}

REAL LearnModel::train_c_error () const {
    assert(ptw != 0);
    REAL err = 0;
    for (UINT i = 0; i < n_samples; ++i)
        err += (*ptw)[i] * c_error(get_output(i), ptd->y(i));
    return err;
}

REAL LearnModel::test_r_error (const pDataSet& pd) const {
    UINT n = pd->size();
    REAL err = 0;
    for (UINT i = 0; i < n; ++i)
        err += r_error((*this)(pd->x(i)), pd->y(i));
    return err / n;
}

REAL LearnModel::test_c_error (const pDataSet& pd) const {
    UINT n = pd->size();
    REAL err = 0;
    for (UINT i = 0; i < n; ++i)
        err += c_error((*this)(pd->x(i)), pd->y(i));
    return err / n;
}

void LearnModel::set_train_data (const pDataSet& pd, const pDataWgt& pw) {
    n_samples = pd->size();
    assert(n_samples > 0);
    if (support_weighted_data()) {
        ptd = pd;
        ptw = (pw != 0)? pw : new DataWgt(n_samples, 1.0 / n_samples);
    }
    else {
        ptd = (!pw)? pd : pd->random_sample(*pw, n_samples);
        ptw = 0;
    }
    assert(!ptw || n_samples == ptw->size());
    assert(support_weighted_data() == (ptw != NULL));
#ifndef NDEBUG
    // assert: ptw is a probability vector
    if (ptw != 0) {
        REAL wsum = 0;
        for (UINT i = 0; i < n_samples; i++) {
            assert((*ptw)[i] >= 0);
            wsum += (*ptw)[i];
        }
        assert(wsum-1 > -EPSILON && wsum-1 < EPSILON);
    }
#endif
    UINT din = pd->x(0).size(), dout = pd->y(0).size();
    if (_n_in == 0)
        _n_in = din;
    else if (_n_in != din) {
        std::cerr << id() << "::set_train_data: Error: "
            "Wrong input dimension.\n";
        std::exit(-1);
    }
    if (_n_out == 0)
        _n_out = dout;
    else if (_n_out != dout) {
        std::cerr << id() << "::set_train_data: Error: "
            "Wrong output dimension.\n";
        std::exit(-1);
    }
}

REAL LearnModel::margin_of (const Input&, const Output&) const {
    OBJ_FUNC_UNDEFINED("margin_of");
}

REAL LearnModel::min_margin () const {
    REAL min_m = INFINITY;
    for (UINT i = 0; i < n_samples; ++i) {
        // assume all examples count (in computing the minimum)
        assert((*ptw)[i] > INFINITESIMAL);
        REAL m = margin(i);
        if (min_m > m) min_m = m;
    }
    return min_m;
}

} // namespace lemga

---