NeuralNetworkFileReader.cpp

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
 */

#include <shogun/lib/config.h>
#ifdef HAVE_JSON

#include <shogun/io/NeuralNetworkFileReader.h>
#include <shogun/neuralnets/NeuralNetwork.h>
#include <shogun/neuralnets/NeuralLayer.h>
#include <shogun/neuralnets/NeuralInputLayer.h>
#include <shogun/neuralnets/NeuralLinearLayer.h>
#include <shogun/neuralnets/NeuralLogisticLayer.h>
#include <shogun/neuralnets/NeuralSoftmaxLayer.h>
#include <shogun/neuralnets/NeuralRectifiedLinearLayer.h>
#include <shogun/lib/DynamicObjectArray.h>
#include <shogun/lib/SGVector.h>

using namespace shogun;

CNeuralNetwork* CNeuralNetworkFileReader::read_file(const char* file_path)
{
    json_object* json_network = json_object_from_file(file_path);

    if (is_error(json_network))
    {
        SG_ERROR("Error while opening file: %s!\n", file_path);
        return NULL;
    }

    CNeuralNetwork* network = parse_network(json_network);

    json_object_put(json_network);

    return network;
}

CNeuralNetwork* CNeuralNetworkFileReader::read_string(const char* str)
{
    json_object* json_network = json_tokener_parse(str);

    if (is_error(json_network))
    {
        SG_ERROR("Error while parsing the given string\n");
        return NULL;
    }

    CNeuralNetwork* network = parse_network(json_network);

    json_object_put(json_network);

    return network;
}

CNeuralNetwork* CNeuralNetworkFileReader::parse_network(json_object* json_network)
{
    CNeuralNetwork* network = new CNeuralNetwork;

    // find the layers
    json_object_iter iter;
    json_object* json_layers = NULL;
    json_object_object_foreachC(json_network, iter)
    {
        if (string_equal(iter.key, "layers"))
            json_layers = iter.val;
    }

    if (json_layers)
        network->set_layers(parse_layers(iter.val));
    else
        SG_ERROR("No layers found in file\n");

    // set the connections
    json_object_iter layers_iter;
    json_object_object_foreachC(json_layers, layers_iter)
    {
        json_object_iter layer_iter;
        json_object_object_foreachC(layers_iter.val, layer_iter)
        {
            if (string_equal(layer_iter.key, "inputs"))
            {
                int32_t len = json_object_array_length(layer_iter.val);

                for (int32_t i=0; i<len; i++)
                {
                    const char* input_key = json_object_get_string(
                        json_object_array_get_idx(layer_iter.val, i));

                    int32_t from = find_layer_index(json_layers, input_key);
                    int32_t to = find_layer_index(json_layers, layers_iter.key);

                    if (from == -1)
                        SG_ERROR("Invalid layer identifier (%s) in layer (%s)\n",
                            input_key, layers_iter.key);

                    network->connect(from, to);
                }
            }
        }
    }

    // set the training parameters
    float sigma = 0.01;
    json_object_object_foreachC(json_network, iter)
    {
        if (string_equal(iter.key, "sigma"))
            sigma = json_object_get_double(iter.val);
        else if (string_equal(iter.key, "optimization_method"))
        {
            const char* method = json_object_get_string(iter.val);
            if (string_equal(method, "NNOM_LBFGS"))
                network->set_optimization_method(NNOM_LBFGS);
            else if (string_equal(method, "NNOM_GRADIENT_DESCENT"))
                network->set_optimization_method(NNOM_GRADIENT_DESCENT);
            else
                SG_ERROR("Invalid optimization method (%s)\n", method);
        }
        else if (string_equal(iter.key, "l2_coefficient"))
            network->set_l2_coefficient(json_object_get_double(iter.val));
        else if (string_equal(iter.key, "l1_coefficient"))
            network->set_l1_coefficient(json_object_get_double(iter.val));
        else if (string_equal(iter.key, "dropout_hidden"))
            network->set_dropout_hidden(json_object_get_double(iter.val));
        else if (string_equal(iter.key, "dropout_input"))
            network->set_dropout_input(json_object_get_double(iter.val));
        else if (string_equal(iter.key, "max_norm"))
            network->set_max_norm(json_object_get_double(iter.val));
        else if (string_equal(iter.key, "epsilon"))
            network->set_epsilon(json_object_get_double(iter.val));
        else if (string_equal(iter.key, "max_num_epochs"))
            network->set_max_num_epochs(json_object_get_int(iter.val));
        else if (string_equal(iter.key, "gd_mini_batch_size"))
            network->set_gd_mini_batch_size(json_object_get_int(iter.val));
        else if (string_equal(iter.key, "gd_learning_rate"))
            network->set_gd_learning_rate(json_object_get_double(iter.val));
        else if (string_equal(iter.key, "gd_learning_rate_decay"))
            network->set_gd_learning_rate_decay(json_object_get_double(iter.val));
        else if (string_equal(iter.key, "gd_momentum"))
            network->set_gd_momentum(json_object_get_double(iter.val));
        else if (string_equal(iter.key, "gd_error_damping_coeff"))
            network->set_gd_error_damping_coeff(json_object_get_double(iter.val));

        else if (!string_equal(iter.key, "layers"))
            SG_ERROR("Invalid parameter (%s)\n", iter.key);
    }

    network->initialize_neural_network(sigma);

    return network;
}

CDynamicObjectArray* CNeuralNetworkFileReader::parse_layers(
        json_object* json_layers)
{
    CDynamicObjectArray* layers = new CDynamicObjectArray();

    json_object_iter iter;
    json_object_object_foreachC(json_layers, iter)
    {
        layers->append_element(parse_layer(iter.val));
    }

    return layers;
}

CNeuralLayer* CNeuralNetworkFileReader::parse_layer(json_object* json_layer)
{
    json_object_iter iter;

    CNeuralLayer* layer = NULL;
    const char* type = NULL;

    // find the layer type and create a appropriate instance
    json_object_object_foreachC(json_layer, iter)
    {
        if (string_equal(iter.key, "type"))
        {
            type = json_object_get_string(iter.val);

            if (string_equal(type, "NeuralInputLayer"))
                layer = new CNeuralInputLayer();
            else if (string_equal(type, "NeuralLinearLayer"))
                layer = new CNeuralLinearLayer();
            else if (string_equal(type, "NeuralLogisticLayer"))
                layer = new CNeuralLogisticLayer();
            else if (string_equal(type, "NeuralSoftmaxLayer"))
                layer = new CNeuralSoftmaxLayer();
            else if (string_equal(type, "NeuralRectifiedLinearLayer"))
                layer = new CNeuralRectifiedLinearLayer();
            else
                SG_ERROR("Unknown layer type: %s", type);
        }
    }

    // fill in the fields
    json_object_object_foreachC(json_layer, iter)
    {
        if(string_equal(iter.key, "num_neurons"))
        {
            layer->set_num_neurons(json_object_get_int(iter.val));
        }
        else if(string_equal(type,"NeuralInputLayer") &&
            string_equal(iter.key, "start_index"))
        {
            ((CNeuralInputLayer*)layer)->set_start_index(
                json_object_get_int(iter.val));
        }
    }

    return layer;
}

int32_t CNeuralNetworkFileReader::find_layer_index(json_object* json_layers,
        const char* layer_key)
{
    int32_t index = 0;

    json_object_iter iter;
    json_object_object_foreachC(json_layers, iter)
    {
        if (string_equal(iter.key, layer_key))
            return index;
        else
            index++;
    }

    return -1;
}

bool CNeuralNetworkFileReader::string_equal(const char* str1, const char* str2)
{
    return (strcmp(str1, str2) == 0);
}

#endif