shin/NeuralNetworkLib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

changed to gtest

Browse Source
This commit is contained in:
Shin
2016-03-30 22:36:44 +02:00
parent 59abad41a9
commit 5c1d1efcc0
6 changed files with 137 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
tests/CMakeLists.txt
View File

@@ -1,11 +1,18 @@
cmake_minimum_required(VERSION 3.2)
project(NeuralNetworkTests CXX)
set(CMAKE_CXX_FLAGS " --std=c++14")
add_executable(activation activation.cpp)
target_link_libraries(activation NeuralNetwork)
target_link_libraries(activation gtest gtest_main)
add_executable(basis basis.cpp)
target_link_libraries(basis NeuralNetwork)
target_link_libraries(basis gtest gtest_main)
#[[
add_executable(backpropagation backpropagation.cpp)
target_link_libraries(backpropagation NeuralNetwork)
@@ -44,4 +51,4 @@ add_executable(quickpropagation_perf quickpropagation_perf.cpp)
target_link_libraries(quickpropagation_perf NeuralNetwork)
add_executable(propagation_cmp propagation_cmp.cpp)
target_link_libraries(propagation_cmp NeuralNetwork)
target_link_libraries(propagation_cmp NeuralNetwork)]]

111
tests/activation.cpp
View File

@@ -3,70 +3,69 @@
#include <NeuralNetwork/ActivationFunction/HyperbolicTangent.h>
#include <NeuralNetwork/ActivationFunction/Linear.h>
#include <iostream>
#include <cassert>
#include <chrono>
#include "gtest/gtest.h"
union {
__m128 v; // SSE 4 x float vector
float a[4]; // scalar array of 4 floats
} U;
union SSE {
__m128 sse; // SSE 4 x float vector
float floats[4]; // scalar array of 4 floats
};
int main() {
{
NeuralNetwork::ActivationFunction::Heaviside h(1.0);
assert(h(0.2) == 0);
assert(h(1.2) == 1);
}
TEST(Heaviside, ParamOne) {
NeuralNetwork::ActivationFunction::Heaviside h(1.0);
ASSERT_EQ(h(0.2), 0);
ASSERT_EQ(h(1.2), 1);
}
{
NeuralNetwork::ActivationFunction::Heaviside h(0.7);
assert(h(0.2) == 0);
assert(h(0.8) == 1);
}
TEST(Heaviside, ParamZeroPointSeven) {
NeuralNetwork::ActivationFunction::Heaviside h(0.7);
ASSERT_EQ(h(0.2), 0);
ASSERT_EQ(h(0.8), 1);
}
{
NeuralNetwork::ActivationFunction::Sigmoid s(0.7);
assert(s(0.1) > 0.482407);
assert(s(0.1) < 0.482607);
TEST(Sigmoid, ParamZeroPointSeven) {
NeuralNetwork::ActivationFunction::Sigmoid s(0.7);
ASSERT_GT(s(0.1), 0.482407);
ASSERT_LT(s(0.1), 0.482607);
assert(s(10) > 0.000901051);
assert(s(10) < 0.000921051);
}
{
NeuralNetwork::ActivationFunction::Sigmoid s(-5);
assert(s(0.1) > 0.622359);
assert(s(0.1) < 0.622559);
assert(s(0.7) > 0.970588);
assert(s(0.7) < 0.970788);
}
{
NeuralNetwork::ActivationFunction::Sigmoid s(-0.7);
U.a[0]=0.1;
U.a[1]=10;
U.v=s(U.v);
ASSERT_GT(s(10), 0.000901051);
ASSERT_LT(s(10), 0.000921051);
}
assert(U.a[0] > 0.517483);
assert(U.a[0] < 0.51750);
TEST(Sigmoid, ParamMinusFive) {
NeuralNetwork::ActivationFunction::Sigmoid s(-5);
ASSERT_GT(s(0.1), 0.622359);
ASSERT_LT(s(0.1), 0.622559);
assert(U.a[1] > 0.998989);
assert(U.a[1] < 0.999189);
}
{
NeuralNetwork::ActivationFunction::Linear s(1.0);
assert(s(0.5) > 0.4999);
assert(s(0.5) < 0.5001);
ASSERT_GT(s(0.7), 0.970588);
ASSERT_LT(s(0.7), 0.970788);
}
assert(s(0.0) == 0.0);
}
{
NeuralNetwork::ActivationFunction::Linear s(0.7);
assert(s(0.0) == 0.0);
TEST(SigmoidSSE, ParamMinusZeroPointSeven) {
NeuralNetwork::ActivationFunction::Sigmoid s(-0.7);
SSE comp;
comp.floats[0]=0.1;
comp.floats[1]=10;
comp.sse=s(comp.sse);
assert(s(1.0) > 0.6999);
assert(s(1.0) < 0.7001);
}
ASSERT_GT(comp.floats[0], 0.517483);
ASSERT_LT(comp.floats[0], 0.51750);
return 0;
ASSERT_GT(comp.floats[1], 0.998989);
ASSERT_LT(comp.floats[1], 0.999189);
}
TEST(Linear, ParamOne) {
NeuralNetwork::ActivationFunction::Linear s(1.0);
ASSERT_GT(s(0.5), 0.4999);
ASSERT_LT(s(0.5), 0.5001);
ASSERT_EQ(s(0.0), 0.0);
}
TEST(Linear, ParamZeroPointSeven) {
NeuralNetwork::ActivationFunction::Linear s(0.7);
ASSERT_GT(s(1.0), 0.6999);
ASSERT_LT(s(1.0), 0.7001);
ASSERT_EQ(s(0.0), 0.0);
}

68
tests/basis.cpp
View File

@@ -1,41 +1,41 @@
#include <NeuralNetwork/BasisFunction/Linear.h>
#include <NeuralNetwork/BasisFunction/Product.h>
#include <iostream>
#include <cassert>
#include <chrono>
#include "gtest/gtest.h"
int main() {
{
NeuralNetwork::BasisFunction::Linear l;
assert(39.0==l({1,2,3,5},{1,2,3,5}));
}
{
NeuralNetwork::BasisFunction::Linear l;
assert(88.0==l({1,2,3,5,7},{1,2,3,5,7}));
}
{
NeuralNetwork::BasisFunction::Linear l;
std::vector<float> w;
for(int in=0;in<100;in++) {
w.push_back(2);
}
assert(400.0==l(w,w));
}
{
NeuralNetwork::BasisFunction::Linear l;
std::vector<float> w;
for(int in=0;in<55;in++) {
w.push_back(2);
}
assert(220.0==l(w,w));
}
{
NeuralNetwork::BasisFunction::Product l;
std::vector<float> w({0,0.501,1});
std::vector<float> i({0,0.2,0.3});
TEST(Linear,FourElements) {
NeuralNetwork::BasisFunction::Linear l;
ASSERT_EQ(39.0, l({1,2,3,5},{1,2,3,5}));
}
assert(l(w,i) > 0.05999);
assert(l(w,i) < 0.06001);
TEST(Linear,FiveElements) {
NeuralNetwork::BasisFunction::Linear l;
ASSERT_EQ(88.0, l({1,2,3,5,7},{1,2,3,5,7}));
}
TEST(Linear,HundredElements) {
NeuralNetwork::BasisFunction::Linear l;
std::vector<float> w;
for(int in=0;in<100;in++) {
w.push_back(2);
}
ASSERT_EQ(400.0, l(w,w));
}
TEST(Linear,FivetyFiveElements) {
NeuralNetwork::BasisFunction::Linear l;
std::vector<float> w;
for(int in=0;in<55;in++) {
w.push_back(2);
}
ASSERT_EQ(220.0, l(w,w));
}
TEST(Product,Product) {
NeuralNetwork::BasisFunction::Product p;
std::vector<float> w({0,0.501,1});
std::vector<float> i({0,0.2,0.3});
ASSERT_GT(p(w,i), 0.05999);
ASSERT_LT(p(w,i), 0.06001);
}