mimgrating from another repo

lib/ann/fann/tests/CMakeLists.txt

@@ -0,0 +1,25 @@
+project (fann_tests)
+include(CheckCXXCompilerFlag)
+
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src/include)
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/lib/googletest/include)
+
+CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14)
+CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
+CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
+if(COMPILER_SUPPORTS_CXX14)
+    message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has C++14 support.")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
+elseif(COMPILER_SUPPORTS_CXX11)
+    message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has C++11 support.")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+elseif(COMPILER_SUPPORTS_CXX0X)
+    message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has C++0x support.")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+else()
+    message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++0x, C++11 or C++14 support. FANN will still work with no problem, but the tests will not be able to compile.")
+    return()
+endif()
+
+ADD_EXECUTABLE(fann_tests main.cpp fann_test.cpp fann_test_data.cpp fann_test_train.cpp)
+target_link_libraries(fann_tests gtest doublefann)

lib/ann/fann/tests/fann_test.cpp

@@ -0,0 +1,168 @@
+#include <vector>
+#include "fann_test.h"
+
+using namespace std;
+
+void FannTest::SetUp() {
+    //ensure random generator is seeded at a known value to ensure reproducible results
+    srand(0);
+    fann_disable_seed_rand();
+}
+
+void FannTest::TearDown() {
+    net.destroy();
+    data.destroy_train();
+}
+
+void FannTest::AssertCreate(neural_net &net, unsigned int numLayers, const unsigned int *layers,
+                            unsigned int neurons, unsigned int connections) {
+    EXPECT_EQ(numLayers, net.get_num_layers());
+    EXPECT_EQ(layers[0], net.get_num_input());
+    EXPECT_EQ(layers[numLayers - 1], net.get_num_output());
+    unsigned int *layers_res = new unsigned int[numLayers];
+    net.get_layer_array(layers_res);
+    for (unsigned int i = 0; i < numLayers; i++) {
+        EXPECT_EQ(layers[i], layers_res[i]);
+    }
+    delete layers_res;
+
+    EXPECT_EQ(neurons, net.get_total_neurons());
+    EXPECT_EQ(connections, net.get_total_connections());
+
+    AssertWeights(net, -0.09, 0.09, 0.0);
+}
+
+void FannTest::AssertCreateAndCopy(neural_net &net, unsigned int numLayers, const unsigned int *layers, unsigned int neurons,
+                                   unsigned int connections) {
+    AssertCreate(net, numLayers, layers, neurons, connections);
+    neural_net net_copy(net);
+    AssertCreate(net_copy, numLayers, layers, neurons, connections);
+}
+
+void FannTest::AssertWeights(neural_net &net, fann_type min, fann_type max, fann_type avg) {
+    connection *connections = new connection[net.get_total_connections()];
+    net.get_connection_array(connections);
+
+    fann_type minWeight = connections[0].weight;
+    fann_type maxWeight = connections[0].weight;
+    fann_type totalWeight = 0.0;
+    for (int i = 1; i < net.get_total_connections(); ++i) {
+        if (connections[i].weight < minWeight)
+            minWeight = connections[i].weight;
+        if (connections[i].weight > maxWeight)
+            maxWeight = connections[i].weight;
+        totalWeight += connections[i].weight;
+    }
+
+    EXPECT_NEAR(min, minWeight, 0.05);
+    EXPECT_NEAR(max, maxWeight, 0.05);
+    EXPECT_NEAR(avg, totalWeight / (fann_type) net.get_total_connections(), 0.5);
+}
+
+TEST_F(FannTest, CreateStandardThreeLayers) {
+    neural_net net(LAYER, 3, 2, 3, 4);
+    AssertCreateAndCopy(net, 3, (const unsigned int[]) {2, 3, 4}, 11, 25);
+}
+
+TEST_F(FannTest, CreateStandardThreeLayersUsingCreateMethod) {
+    ASSERT_TRUE(net.create_standard(3, 2, 3, 4));
+    unsigned int layers[] = {2, 3, 4};
+    AssertCreateAndCopy(net, 3, layers, 11, 25);
+}
+
+TEST_F(FannTest, CreateStandardFourLayersArray) {
+    unsigned int layers[] = {2, 3, 4, 5};
+    neural_net net(LAYER, 4, layers);
+    AssertCreateAndCopy(net, 4, layers, 17, 50);
+}
+
+TEST_F(FannTest, CreateStandardFourLayersArrayUsingCreateMethod) {
+    unsigned int layers[] = {2, 3, 4, 5};
+    ASSERT_TRUE(net.create_standard_array(4, layers));
+    AssertCreateAndCopy(net, 4, layers, 17, 50);
+}
+
+TEST_F(FannTest, CreateStandardFourLayersVector) {
+    vector<unsigned int> layers{2, 3, 4, 5};
+    neural_net net(LAYER, layers.begin(), layers.end());
+    AssertCreateAndCopy(net, 4, layers.data(), 17, 50);
+}
+
+TEST_F(FannTest, CreateSparseFourLayers) {
+    neural_net net(0.5, 4, 2, 3, 4, 5);
+    AssertCreateAndCopy(net, 4, (const unsigned int[]){2, 3, 4, 5}, 17, 31);
+}
+
+TEST_F(FannTest, CreateSparseFourLayersUsingCreateMethod) {
+    ASSERT_TRUE(net.create_sparse(0.5f, 4, 2, 3, 4, 5));
+    AssertCreateAndCopy(net, 4, (const unsigned int[]){2, 3, 4, 5}, 17, 31);
+}
+
+TEST_F(FannTest, CreateSparseArrayFourLayers) {
+    unsigned int layers[] = {2, 3, 4, 5};
+    neural_net net(0.5f, 4, layers);
+    AssertCreateAndCopy(net, 4, layers, 17, 31);
+}
+
+TEST_F(FannTest, CreateSparseArrayFourLayersUsingCreateMethod) {
+    unsigned int layers[] = {2, 3, 4, 5};
+    ASSERT_TRUE(net.create_sparse_array(0.5f, 4, layers));
+    AssertCreateAndCopy(net, 4, layers, 17, 31);
+}
+
+TEST_F(FannTest, CreateSparseArrayWithMinimalConnectivity) {
+    unsigned int layers[] = {2, 2, 2};
+    neural_net net(0.01f, 3, layers);
+    AssertCreateAndCopy(net, 3, layers, 8, 8);
+}
+
+TEST_F(FannTest, CreateShortcutFourLayers) {
+    neural_net net(SHORTCUT, 4, 2, 3, 4, 5);
+    AssertCreateAndCopy(net, 4, (const unsigned int[]){2, 3, 4, 5}, 15, 83);
+    EXPECT_EQ(SHORTCUT, net.get_network_type());
+}
+
+TEST_F(FannTest, CreateShortcutFourLayersUsingCreateMethod) {
+    ASSERT_TRUE(net.create_shortcut(4, 2, 3, 4, 5));
+    AssertCreateAndCopy(net, 4, (const unsigned int[]){2, 3, 4, 5}, 15, 83);
+    EXPECT_EQ(SHORTCUT, net.get_network_type());
+}
+
+TEST_F(FannTest, CreateShortcutArrayFourLayers) {
+    unsigned int layers[] = {2, 3, 4, 5};
+    neural_net net(SHORTCUT, 4, layers);
+    AssertCreateAndCopy(net, 4, layers, 15, 83);
+    EXPECT_EQ(SHORTCUT, net.get_network_type());
+}
+
+TEST_F(FannTest, CreateShortcutArrayFourLayersUsingCreateMethod) {
+    unsigned int layers[] = {2, 3, 4, 5};
+    ASSERT_TRUE(net.create_shortcut_array(4, layers));
+    AssertCreateAndCopy(net, 4, layers, 15, 83);
+    EXPECT_EQ(SHORTCUT, net.get_network_type());
+}
+
+TEST_F(FannTest, CreateFromFile) {
+    ASSERT_TRUE(net.create_standard(3, 2, 3, 4));
+    neural_net netToBeSaved(LAYER, 3, 2, 3, 4);
+    ASSERT_TRUE(netToBeSaved.save("tmpfile"));
+
+    neural_net netToBeLoaded("tmpfile");
+    AssertCreateAndCopy(netToBeLoaded, 3, (const unsigned int[]){2, 3, 4}, 11, 25);
+}
+
+TEST_F(FannTest, CreateFromFileUsingCreateMethod) {
+    ASSERT_TRUE(net.create_standard(3, 2, 3, 4));
+    neural_net inputNet(LAYER, 3, 2, 3, 4);
+    ASSERT_TRUE(inputNet.save("tmpfile"));
+
+    ASSERT_TRUE(net.create_from_file("tmpfile"));
+
+    AssertCreateAndCopy(net, 3, (const unsigned int[]){2, 3, 4}, 11, 25);
+}
+
+TEST_F(FannTest, RandomizeWeights) {
+    neural_net net(LAYER, 2, 20, 10);
+    net.randomize_weights(-1.0, 1.0);
+    AssertWeights(net, -1.0, 1.0, 0);
+}

lib/ann/fann/tests/fann_test.h

@@ -0,0 +1,29 @@
+#ifndef FANN_FANN_TEST_H
+#define FANN_FANN_TEST_H
+
+#include "gtest/gtest.h"
+
+#include "doublefann.h"
+#include "fann_cpp.h"
+
+using namespace FANN;
+
+class FannTest : public testing::Test {
+protected:
+    neural_net net;
+    training_data data;
+
+    void AssertCreateAndCopy(neural_net &net, unsigned int numLayers, const unsigned int *layers, unsigned int neurons,
+                             unsigned int connections);
+
+    void AssertCreate(neural_net &net, unsigned int numLayers, const unsigned int *layers,
+                      unsigned int neurons, unsigned int connections);
+
+    void AssertWeights(neural_net &net, fann_type min, fann_type max, fann_type avg);
+
+    virtual void SetUp();
+
+    virtual void TearDown();
+};
+
+#endif

lib/ann/fann/tests/fann_test_data.cpp

@@ -0,0 +1,166 @@
+#include "fann_test_data.h"
+
+void FannTestData::SetUp() {
+    FannTest::SetUp();
+
+    numData = 2;
+    numInput = 3;
+    numOutput = 1;
+    inputValue = 1.1;
+    outputValue = 2.2;
+
+    inputData = new fann_type *[numData];
+    outputData = new fann_type *[numData];
+
+    InitializeTrainDataStructure(numData, numInput, numOutput, inputValue, outputValue, inputData, outputData);
+}
+
+void FannTestData::TearDown() {
+    FannTest::TearDown();
+    delete(inputData);
+    delete(outputData);
+}
+
+void FannTestData::InitializeTrainDataStructure(unsigned int numData,
+                                                unsigned int numInput,
+                                                unsigned int numOutput,
+                                                fann_type inputValue, fann_type outputValue,
+                                                fann_type **inputData,
+                                                fann_type **outputData) {
+    for (unsigned int i = 0; i < numData; i++) {
+        inputData[i] = new fann_type[numInput];
+        outputData[i] = new fann_type[numOutput];
+        for (unsigned int j = 0; j < numInput; j++)
+            inputData[i][j] = inputValue;
+        for (unsigned int j = 0; j < numOutput; j++)
+            outputData[i][j] = outputValue;
+    }
+}
+
+void FannTestData::AssertTrainData(training_data &trainingData, unsigned int numData, unsigned int numInput,
+                                   unsigned int numOutput, fann_type inputValue, fann_type outputValue) {
+    EXPECT_EQ(numData, trainingData.length_train_data());
+    EXPECT_EQ(numInput, trainingData.num_input_train_data());
+    EXPECT_EQ(numOutput, trainingData.num_output_train_data());
+
+    for (int i = 0; i < numData; i++) {
+        for (int j = 0; j < numInput; j++)
+                EXPECT_DOUBLE_EQ(inputValue, trainingData.get_input()[i][j]);
+        for (int j = 0; j < numOutput; j++)
+                EXPECT_DOUBLE_EQ(outputValue, trainingData.get_output()[i][j]);
+    }
+}
+
+
+TEST_F(FannTestData, CreateTrainDataFromPointerArrays) {
+    data.set_train_data(numData, numInput, inputData, numOutput, outputData);
+
+    AssertTrainData(data, numData, numInput, numOutput, inputValue, outputValue);
+}
+
+TEST_F(FannTestData, CreateTrainDataFromArrays) {
+    fann_type input[] = {inputValue, inputValue, inputValue, inputValue, inputValue, inputValue};
+    fann_type output[] = {outputValue, outputValue};
+    data.set_train_data(numData, numInput, input, numOutput, output);
+
+    AssertTrainData(data, numData, numInput, numOutput, inputValue, outputValue);
+}
+
+TEST_F(FannTestData, CreateTrainDataFromCopy) {
+    data.set_train_data(numData, numInput, inputData, numOutput, outputData);
+    training_data dataCopy(data);
+
+    AssertTrainData(dataCopy, numData, numInput, numOutput, inputValue, outputValue);
+}
+
+TEST_F(FannTestData, CreateTrainDataFromFile) {
+    data.set_train_data(numData, numInput, inputData, numOutput, outputData);
+    data.save_train("tmpFile");
+    training_data dataCopy;
+    dataCopy.read_train_from_file("tmpFile");
+
+    AssertTrainData(dataCopy, numData, numInput, numOutput, inputValue, outputValue);
+}
+
+void callBack(unsigned int pos, unsigned int numInput, unsigned int numOutput, fann_type *input, fann_type *output) {
+    for(unsigned int i = 0; i < numInput; i++)
+        input[i] = (fann_type) 1.2;
+    for(unsigned int i = 0; i < numOutput; i++)
+        output[i] = (fann_type) 2.3;
+}
+
+TEST_F(FannTestData, CreateTrainDataFromCallback) {
+    data.create_train_from_callback(numData, numInput, numOutput, callBack);
+    AssertTrainData(data, numData, numInput, numOutput, 1.2, 2.3);
+}
+
+TEST_F(FannTestData, ShuffleTrainData) {
+    //only really ensures that the data doesn't get corrupted, a more complete test would need to check
+    //that this was indeed a permutation of the original data
+    data.set_train_data(numData, numInput, inputData, numOutput, outputData);
+    data.shuffle_train_data();
+    AssertTrainData(data, numData, numInput, numOutput, inputValue, outputValue);
+}
+
+TEST_F(FannTestData, MergeTrainData) {
+    data.set_train_data(numData, numInput, inputData, numOutput, outputData);
+    training_data dataCopy(data);
+    data.merge_train_data(dataCopy);
+    AssertTrainData(data, numData*2, numInput, numOutput, inputValue, outputValue);
+}
+
+TEST_F(FannTestData, SubsetTrainData) {
+    data.set_train_data(numData, numInput, inputData, numOutput, outputData);
+    //call merge 2 times to get 8 data samples
+    data.merge_train_data(data);
+    data.merge_train_data(data);
+
+    data.subset_train_data(2, 5);
+
+    AssertTrainData(data, 5, numInput, numOutput, inputValue, outputValue);
+}
+
+TEST_F(FannTestData, ScaleOutputData) {
+    fann_type input[] = {0.0, 1.0, 0.5, 0.0, 1.0, 0.5};
+    fann_type output[] = {0.0, 1.0};
+    data.set_train_data(2, 3, input, 1, output);
+
+    data.scale_output_train_data(-1.0, 2.0);
+
+    EXPECT_DOUBLE_EQ(0.0, data.get_min_input());
+    EXPECT_DOUBLE_EQ(1.0, data.get_max_input());
+    EXPECT_DOUBLE_EQ(-1.0, data.get_min_output());
+    EXPECT_DOUBLE_EQ(2.0, data.get_max_output());
+}
+
+TEST_F(FannTestData, ScaleInputData) {
+    fann_type input[] = {0.0, 1.0, 0.5, 0.0, 1.0, 0.5};
+    fann_type output[] = {0.0, 1.0};
+    data.set_train_data(2, 3, input, 1, output);
+
+    data.scale_input_train_data(-1.0, 2.0);
+    EXPECT_DOUBLE_EQ(-1.0, data.get_min_input());
+    EXPECT_DOUBLE_EQ(2.0, data.get_max_input());
+    EXPECT_DOUBLE_EQ(0.0, data.get_min_output());
+    EXPECT_DOUBLE_EQ(1.0, data.get_max_output());
+}
+
+TEST_F(FannTestData, ScaleData) {
+    fann_type input[] = {0.0, 1.0, 0.5, 0.0, 1.0, 0.5};
+    fann_type output[] = {0.0, 1.0};
+    data.set_train_data(2, 3, input, 1, output);
+
+    data.scale_train_data(-1.0, 2.0);
+
+    for(unsigned int i = 0; i < 2; i++) {
+        fann_type *train_input = data.get_train_input(i);
+        EXPECT_DOUBLE_EQ(-1.0, train_input[0]);
+        EXPECT_DOUBLE_EQ(2.0, train_input[1]);
+        EXPECT_DOUBLE_EQ(0.5, train_input[2]);
+    }
+
+    EXPECT_DOUBLE_EQ(-1.0, data.get_train_output(0)[0]);
+    EXPECT_DOUBLE_EQ(2.0, data.get_train_output(0)[1]);
+
+}
+

lib/ann/fann/tests/fann_test_data.h

@@ -0,0 +1,34 @@
+#ifndef FANN_FANN_TEST_DATA_H
+#define FANN_FANN_TEST_DATA_H
+
+#include "gtest/gtest.h"
+
+#include "doublefann.h"
+#include "fann_cpp.h"
+#include "fann_test.h"
+
+class FannTestData : public FannTest {
+protected:
+    unsigned int numData;
+    unsigned int numInput;
+    unsigned int numOutput;
+    fann_type inputValue;
+    fann_type outputValue;
+
+    fann_type **inputData;
+    fann_type **outputData;
+
+    virtual void SetUp();
+
+    virtual void TearDown();
+
+    void AssertTrainData(FANN::training_data &trainingData, unsigned int numData, unsigned int numInput,
+                         unsigned int numOutput, fann_type inputValue, fann_type outputValue);
+
+
+    void InitializeTrainDataStructure(unsigned int numData, unsigned int numInput, unsigned int numOutput,
+                                      fann_type inputValue, fann_type outputValue, fann_type **inputData,
+                                      fann_type **outputData);
+};
+
+#endif

lib/ann/fann/tests/fann_test_train.cpp

@@ -0,0 +1,35 @@
+#include "fann_test_train.h"
+
+using namespace std;
+
+void FannTestTrain::SetUp() {
+    FannTest::SetUp();
+}
+
+void FannTestTrain::TearDown() {
+    FannTest::TearDown();
+
+}
+
+TEST_F(FannTestTrain, TrainOnDateSimpleXor) {
+    neural_net net(LAYER, 3, 2, 3, 1);
+
+    data.set_train_data(4, 2, xorInput, 1, xorOutput);
+    net.train_on_data(data, 100, 100, 0.001);
+
+    EXPECT_LT(net.get_MSE(), 0.001);
+    EXPECT_LT(net.test_data(data), 0.001);
+}
+
+TEST_F(FannTestTrain, TrainSimpleIncrementalXor) {
+    neural_net net(LAYER, 3, 2, 3, 1);
+
+    for(int i = 0; i < 100000; i++) {
+        net.train((fann_type*) (const fann_type[]) {0.0, 0.0}, (fann_type*) (const fann_type[]) {0.0});
+        net.train((fann_type*) (const fann_type[]) {1.0, 0.0}, (fann_type*) (const fann_type[]) {1.0});
+        net.train((fann_type*) (const fann_type[]) {0.0, 1.0}, (fann_type*) (const fann_type[]) {1.0});
+        net.train((fann_type*) (const fann_type[]) {1.0, 1.0}, (fann_type*) (const fann_type[]) {0.0});
+    }
+
+    EXPECT_LT(net.get_MSE(), 0.01);
+}

lib/ann/fann/tests/fann_test_train.h

@@ -0,0 +1,24 @@
+#ifndef FANN_FANN_TEST_TRAIN_H
+#define FANN_FANN_TEST_TRAIN_H
+
+#include "fann_test.h"
+
+class FannTestTrain : public FannTest {
+protected:
+    fann_type xorInput[8] = {
+            0.0, 0.0,
+            0.0, 1.0,
+            1.0, 0.0,
+            1.0, 1.0};
+    fann_type xorOutput[4] = {
+            0.0,
+            1.0,
+            1.0,
+            0.0};
+
+    virtual void SetUp();
+
+    virtual void TearDown();
+};
+
+#endif

lib/ann/fann/tests/main.cpp

@@ -0,0 +1,6 @@
+#include "gtest/gtest.h"
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}