DomainAdaptationMulticlassLibLinear.cpp

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2012 Sergey Lisitsyn
 * Copyright (C) 2012 Sergey Lisitsyn
 */

#include <shogun/lib/config.h>
#ifdef HAVE_LAPACK
#include <shogun/transfer/domain_adaptation/DomainAdaptationMulticlassLibLinear.h>
#include <shogun/labels/MulticlassLabels.h>

using namespace shogun;

CDomainAdaptationMulticlassLibLinear::CDomainAdaptationMulticlassLibLinear() :
    CMulticlassLibLinear()
{
    init_defaults();
}

CDomainAdaptationMulticlassLibLinear::CDomainAdaptationMulticlassLibLinear(
        float64_t target_C, CDotFeatures* target_features, CLabels* target_labels,
        CLinearMulticlassMachine* source_machine) :
    CMulticlassLibLinear(target_C,target_features,target_labels)
{
    init_defaults();

    set_source_machine(source_machine);
}

void CDomainAdaptationMulticlassLibLinear::init_defaults()
{
    m_train_factor = 1.0;
    m_source_bias = 0.5;
    m_source_machine = NULL;

    register_parameters();
}

float64_t CDomainAdaptationMulticlassLibLinear::get_source_bias() const
{
    return m_source_bias;
}

void CDomainAdaptationMulticlassLibLinear::set_source_bias(float64_t source_bias)
{
    m_source_bias = source_bias;
}

float64_t CDomainAdaptationMulticlassLibLinear::get_train_factor() const
{
    return m_train_factor;
}

void CDomainAdaptationMulticlassLibLinear::set_train_factor(float64_t train_factor)
{
    m_train_factor = train_factor;
}

CLinearMulticlassMachine* CDomainAdaptationMulticlassLibLinear::get_source_machine() const
{
    SG_REF(m_source_machine);
    return m_source_machine;
}

void CDomainAdaptationMulticlassLibLinear::set_source_machine(
        CLinearMulticlassMachine* source_machine)
{
    SG_UNREF(m_source_machine);
    SG_REF(source_machine);
    m_source_machine = source_machine;
}

void CDomainAdaptationMulticlassLibLinear::register_parameters()
{
    SG_ADD((CSGObject**)&m_source_machine, "source_machine", "source domain machine",
            MS_NOT_AVAILABLE);
    SG_ADD(&m_train_factor, "train_factor", "factor of target domain regularization",
            MS_AVAILABLE);
    SG_ADD(&m_source_bias, "source_bias", "bias to source domain",
            MS_AVAILABLE);
}

CDomainAdaptationMulticlassLibLinear::~CDomainAdaptationMulticlassLibLinear()
{
}

SGMatrix<float64_t> CDomainAdaptationMulticlassLibLinear::obtain_regularizer_matrix() const
{
    ASSERT(get_use_bias()==false);
    int32_t n_classes = ((CMulticlassLabels*)m_source_machine->get_labels())->get_num_classes();
    int32_t n_features = ((CDotFeatures*)m_source_machine->get_features())->get_dim_feature_space();
    SGMatrix<float64_t> w0(n_classes,n_features);

    for (int32_t i=0; i<n_classes; i++)
    {
        SGVector<float64_t> w = ((CLinearMachine*)m_source_machine->get_machine(i))->get_w();
        for (int32_t j=0; j<n_features; j++)
            w0(j,i) = m_train_factor*w[j];
    }

    return w0;
}

CBinaryLabels* CDomainAdaptationMulticlassLibLinear::get_submachine_outputs(int32_t i)
{
    CBinaryLabels* target_outputs = CMulticlassMachine::get_submachine_outputs(i);
    CBinaryLabels* source_outputs = m_source_machine->get_submachine_outputs(i);
    int32_t n_target_outputs = target_outputs->get_num_labels();
    ASSERT(n_target_outputs==source_outputs->get_num_labels());
    SGVector<float64_t> result(n_target_outputs);
    for (int32_t j=0; j<result.vlen; j++)
        result[j] = (1-m_source_bias)*target_outputs->get_value(j) + m_source_bias*source_outputs->get_value(j);

    SG_UNREF(target_outputs);
    SG_UNREF(source_outputs);

    return new CBinaryLabels(result);
}
#endif /* HAVE_LAPACK */