DeepBeliefNetwork.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014, Shogun Toolbox Foundation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:

 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its
 * contributors may be used to endorse or promote products derived from this
 * software without specific prior written permission.

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * Written (W) 2014 Khaled Nasr
 */

#ifndef __DEEPBELIEFNETWORK_H__
#define __DEEPBELIEFNETWORK_H__

#include <shogun/lib/config.h>

#include <shogun/lib/common.h>
#include <shogun/base/SGObject.h>
#include <shogun/neuralnets/RBM.h>
#include <lib/SGMatrixList.h>

namespace shogun
{
template <class T> class SGVector;
template <class T> class SGMatrix;
template <class T> class SGMatrixList;
template <class T> class CDenseFeatures;
template <class T> class CDynamicArray;
class CDynamicObjectArray;
class CNeuralNetwork;
class CNeuralLayer;

class CDeepBeliefNetwork : public CSGObject
{
public:
    CDeepBeliefNetwork();

    CDeepBeliefNetwork(int32_t num_visible_units,
        ERBMVisibleUnitType unit_type = RBMVUT_BINARY);

    virtual ~CDeepBeliefNetwork();

    virtual void add_hidden_layer(int32_t num_units);

    virtual void initialize_neural_network(float64_t sigma = 0.01);

    virtual void set_batch_size(int32_t batch_size);

    virtual void pre_train(CDenseFeatures<float64_t>* features);

    virtual void pre_train(int32_t index, CDenseFeatures<float64_t>* features);

    virtual void train(CDenseFeatures<float64_t>* features);

    virtual CDenseFeatures<float64_t>* transform(
        CDenseFeatures<float64_t>* features, int32_t i=-1);

    virtual CDenseFeatures<float64_t>* sample(
        int32_t num_gibbs_steps=1, int32_t batch_size=1);

    virtual void reset_chain();

    virtual CNeuralNetwork* convert_to_neural_network(
        CNeuralLayer* output_layer=NULL, float64_t sigma = 0.01);

    virtual SGMatrix<float64_t> get_weights(int32_t index,
        SGVector<float64_t> p = SGVector<float64_t>());

    virtual SGVector<float64_t> get_biases(int32_t index,
        SGVector<float64_t> p = SGVector<float64_t>());

    virtual const char* get_name() const { return "DeepBeliefNetwork"; }

protected:
    virtual void down_step(int32_t index, SGVector<float64_t> params,
        SGMatrix<float64_t> input, SGMatrix<float64_t> result,
        bool sample_states = true);

    virtual void up_step(int32_t index, SGVector<float64_t> params,
        SGMatrix<float64_t> input, SGMatrix<float64_t> result,
        bool sample_states = true);

    virtual void wake_sleep(SGMatrix<float64_t> data,
        CRBM* top_rbm,
        SGMatrixList<float64_t> sleep_states,
        SGMatrixList<float64_t> wake_states,
        SGMatrixList<float64_t> psleep_states,
        SGMatrixList<float64_t> pwake_states,
        SGVector<float64_t> gen_params,
        SGVector<float64_t> rec_params,
        SGVector<float64_t> gen_gradients,
        SGVector<float64_t> rec_gradients);

private:
    void init();

public:
    SGVector<int32_t> pt_cd_num_steps;

    SGVector<bool> pt_cd_persistent;

    SGVector<bool> pt_cd_sample_visible;

    SGVector<float64_t> pt_l2_coefficient;

    SGVector<float64_t> pt_l1_coefficient;

    SGVector<int32_t> pt_monitoring_interval;

    SGVector<int32_t> pt_monitoring_method;

    SGVector<int32_t> pt_max_num_epochs;

    SGVector<int32_t> pt_gd_mini_batch_size;

    SGVector<float64_t> pt_gd_learning_rate;

    SGVector<float64_t> pt_gd_learning_rate_decay;

    SGVector<float64_t> pt_gd_momentum;

    int32_t cd_num_steps;

    int32_t monitoring_interval;

    int32_t max_num_epochs;

    int32_t gd_mini_batch_size;

    float64_t gd_learning_rate;

    float64_t gd_learning_rate_decay;

    float64_t gd_momentum;

protected:
    ERBMVisibleUnitType m_visible_units_type;

    int32_t m_num_layers;

    CDynamicArray<int32_t>* m_layer_sizes;

    SGMatrixList<float64_t> m_states;

    int32_t m_batch_size;

    SGVector<float64_t> m_params;

    int32_t m_num_params;

    SGVector<int32_t> m_bias_index_offsets;

    SGVector<int32_t> m_weights_index_offsets;

    float64_t m_sigma;
};

}
#endif