void PerformanceFunctionalTest::test_calculate_terms_Jacobian(void) { message += "test_calculate_terms_Jacobian\n"; DataSet ds; NeuralNetwork nn; PerformanceFunctional pf(&nn, &ds); pf.set_objective_type(PerformanceFunctional::SUM_SQUARED_ERROR_OBJECTIVE); Matrix<double> terms_Jacobian; // Test ds.set(1, 1, 3); ds.initialize_data(0.0); nn.set(1, 1); nn.initialize_parameters(0.0); terms_Jacobian = pf.calculate_terms_Jacobian(); assert_true(terms_Jacobian.get_rows_number() == 3, LOG); assert_true(terms_Jacobian.get_columns_number() == 2, LOG); assert_true(terms_Jacobian == 0.0, LOG); }
TEST(TestNeuralNetwork, getWeights) { NeuralNetwork nn {400, 25, 10}; EXPECT_EQ(401*25 + 26 * 10, nn.getWeights().size()); for (auto w : nn.getWeights()) { EXPECT_FLOAT_EQ(0.0f, w); } }
void test_video() { VideoCapture cap(CV_CAP_ANY); ImageProcessor processor; ImageLoader loader; NeuralNetwork net; net.load(NET_FILE_NAME); //net.visualize_hidden_units(1, 50); if (!cap.isOpened()) { cout << "Failed to initialize camera\n"; return; } namedWindow("CameraCapture"); namedWindow("ProcessedCapture"); cv::Mat frame; while (true) { cap >> frame; cv::Mat processedFrame = processor.process_image(frame); if(processedFrame.rows * processedFrame.cols == INPUT_LAYER_SIZE) { mat input = loader.to_arma_mat(processedFrame); int label = net.predict(input); if(label == 0) putText(frame, "A", Point(500, 300), FONT_HERSHEY_SCRIPT_SIMPLEX, 2, Scalar::all(0), 3, 8); else if(label == 1) putText(frame, "E", Point(500, 300), FONT_HERSHEY_SCRIPT_SIMPLEX, 2, Scalar::all(0), 3, 8); else if(label == 2) putText(frame, "I", Point(500, 300), FONT_HERSHEY_SCRIPT_SIMPLEX, 2, Scalar::all(0), 3, 8); else if(label == 3) putText(frame, "O", Point(500, 300), FONT_HERSHEY_SCRIPT_SIMPLEX, 2, Scalar::all(0), 3, 8); else if(label == 4) putText(frame, "U", Point(500, 300), FONT_HERSHEY_SCRIPT_SIMPLEX, 2, Scalar::all(0), 3, 8); } imshow("CameraCapture", frame); imshow("ProcessedCapture", processedFrame); int key = waitKey(5); if(key == 13) { imwrite("captura.jpg", frame); } if (key == 27) break; } destroyAllWindows(); }
void NeuralNetworkManager::resetNeuralNetworks() { TRACE("NeuralNetworkManager::resetNeuralNetworks"); QMutexLocker locker(&mNetworkExecutionMutex); for(QListIterator<NeuralNetwork*> i(mNeuralNetworks); i.hasNext();) { NeuralNetwork *net = i.next(); net->reset(); } }
void NeuralNetworkTest::test_get_multilayer_perceptron_pointer(void) { message += "test_get_multilayer_perceptron_pointer\n"; NeuralNetwork nn; // Test nn.set(1, 1); assert_true(nn.get_multilayer_perceptron_pointer() != NULL, LOG); }
TEST(TestNeuralNetwork, backpropagationConvergence) { NeuralNetwork nn {2, 2, 2}; vector<float> weights {0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f}; nn.setWeights(weights); nn.setActivationFunction(ActivationFunction::tangent()); testConvergence(nn, &NeuralNetwork::calcBackpropagationGradient, createXorEqSample); }
void NeuralNetworkTest::test_get_conditions_layer_pointer(void) { message += "test_get_conditions_layer_pointer\n"; NeuralNetwork nn; nn.construct_conditions_layer(); // Test assert_true(nn.get_conditions_layer_pointer() != NULL, LOG); }
TEST(TestNeuralNetwork, setWeights) { NeuralNetwork nn {400, 25, 10}; float curWeight = 0.0f; nn.setWeights([&curWeight] {return curWeight++;}); for (int i = 0; i < nn.getWeights().size(); ++i) { EXPECT_FLOAT_EQ((float)i, nn.getWeights()[i]); } }
void NeuralNetworkTest::test_get_independent_parameters_pointer(void) { message += "test_get_independent_parameters_pointer\n"; NeuralNetwork nn; nn.construct_independent_parameters(); // Test assert_true(nn.get_independent_parameters_pointer() != NULL, LOG); }
void evaluate_net(vector<pair<mat, mat> > &test_data) { NeuralNetwork net; net.load(NET_FILE_NAME); //net.print(); double corrects = net.evaluate(test_data); double percentage = (corrects / CANT_TEST_ELEM) * 100; cout << "corrects: " << corrects << ", percentage: " << percentage << "%" << endl; cout<<"total cost: "<<net.calcule_total_cost(test_data, 0); }
void LevenbergMarquardtAlgorithmTest::test_calculate_gradient(void) { message += "test_calculate_gradient\n"; DataSet ds; NeuralNetwork nn; PerformanceFunctional pf(&nn, &ds); Vector<double> terms; Matrix<double> terms_Jacobian; Vector<double> gradient; LevenbergMarquardtAlgorithm lma(&pf); // Test // ds.set(1, 1, 2); // ds.randomize_data_normal(); // nn.set(1, 1); // nn.randomize_parameters_normal(); // terms = pf.calculate_terms(); // terms_Jacobian = pf.calculate_terms_Jacobian(); // gradient = lma.calculate_gradient(terms, terms_Jacobian); // assert_true((gradient-pf.calculate_gradient()).calculate_absolute_value() < 1.0e-3, LOG); // Test nn.set(1, 1); nn.randomize_parameters_normal(); MockErrorTerm* mptp = new MockErrorTerm(&nn); pf.set_user_error_pointer(mptp); terms= pf.calculate_terms(); terms_Jacobian = pf.calculate_terms_Jacobian(); gradient = lma.calculate_gradient(terms, terms_Jacobian); assert_true(gradient == pf.calculate_gradient(), LOG); }
void EvolutionaryAlgorithmTest::test_from_XML(void) { message += "test_from_XML\n"; DataSet ds; NeuralNetwork nn; PerformanceFunctional pf(&nn, &ds); EvolutionaryAlgorithm ea(&pf); EvolutionaryAlgorithm ea1; EvolutionaryAlgorithm ea2; tinyxml2::XMLDocument* document; Matrix<double> population; // Test document = ea1.to_XML(); ea2.from_XML(*document); delete document; assert_true(ea1 == ea2, LOG); // Test ds.set(1, 1, 1); ds.randomize_data_normal(); nn.set(1, 1); ea.set_population_size(4); ea.set_elitism_size(0); ea.randomize_population_normal(); population = ea.get_population(); document = ea.to_XML(); ea.initialize_population(0.0); ea.from_XML(*document); delete document; assert_true((ea.get_population() - population).calculate_absolute_value() < 1.0e-3, LOG); }
void NeuralNetworkTest::test_randomize_parameters_normal(void) { message += "test_randomize_parameters_normal\n"; NeuralNetwork nn; Vector<double> network_parameters; // Test nn.set(1, 1, 1); nn.randomize_parameters_normal(1.0, 0.0); network_parameters = nn.arrange_parameters(); assert_true(network_parameters == 1.0, LOG); }
void NeuralNetworkManager::valueChanged(Value *value) { if(value == 0) { return; } if(value == mBypassNetworkValue) { QMutexLocker locker(&mNetworkExecutionMutex); for(QListIterator<NeuralNetwork*> i(mNeuralNetworks); i.hasNext();) { NeuralNetwork *net = i.next(); net->bypassNetwork(mBypassNetworkValue->get()); } } }
void test_function( NeuralNetwork &net, double *table, int rows, int cols, double err_thresh = 0.0 ) { vector< example > examples; load_examples( table, rows, cols, examples); print_examples( examples); cout << "Initial weights: \n"; net.print_net(); cout << endl; net.train( examples, err_thresh ); print_results( examples, net ); cout << endl; }
void NeuralNetworkTest::test_randomize_parameters_uniform(void) { message += "test_randomize_parameters_uniform\n"; NeuralNetwork nn; Vector<double> parameters; // Test nn.set(1, 1, 1); nn.randomize_parameters_uniform(); parameters = nn.arrange_parameters(); assert_true(parameters >= -1.0, LOG); assert_true(parameters <= 1.0, LOG); }
void NeuralNetworkTest::test_calculate_parameters_norm(void) { message += "test_calculate_parameters_norm\n"; NeuralNetwork nn; double parameters_norm; // Test nn.set(); parameters_norm = nn.calculate_parameters_norm(); assert_true(parameters_norm == 0.0, LOG); }
void NeuralNetworkManager::executeNeuralNetworks() { TRACE("NeuralNetworkManager::executeNeuralNetworks"); if(!mDisableNetworkUpdate->get()) { //mNetworkEvaluationStarted is triggered as upstream event of NextStep. QMutexLocker locker(&mNetworkExecutionMutex); for(QListIterator<NeuralNetwork*> i(mNeuralNetworks); i.hasNext();) { NeuralNetwork *net = i.next(); net->executeStep(mNumberOfNetworkUpdatesPerStep->get()); } } //trigger evaluation competed even if the update was not triggered //because it may still be changed by a third-party plug-in, e.g. a playback device. mNetworkEvaluationCompleted->trigger(); }
static void visualizeNeuron(const NeuralNetwork& network, Image& image, unsigned int outputNeuron) { Matrix matrix; std::string solverClass = util::KnobDatabase::getKnobValue( "NeuronVisualizer::SolverClass", "Differentiable"); if(solverClass == "Differentiable") { matrix = optimizeWithDerivative(&network, image, outputNeuron); } else if(solverClass == "NonDifferentiable") { matrix = optimizeWithoutDerivative(&network, image, outputNeuron); } else if(solverClass == "Analytical") { matrix = optimizeAnalytically(&network, image, outputNeuron); } else { throw std::runtime_error("Invalid neuron visializer solver class " + solverClass); } size_t x = 0; size_t y = 0; util::getNearestToSquareFactors(x, y, network.getInputBlockingFactor()); updateImage(image, matrix, x, y); }
static NeuralNetwork extractTileFromNetwork(const NeuralNetwork& network, unsigned int outputNeuron) { // Get the connected subgraph auto newNetwork = network.getSubgraphConnectedToThisOutput(outputNeuron); util::log("NeuronVisualizer") << "sliced out tile with shape: " << newNetwork.shapeString() << ".\n"; // Remove all other connections from the final layer #if 1 size_t block = (outputNeuron % newNetwork.getOutputNeurons()) / newNetwork.getOutputBlockingFactor(); size_t offset = (outputNeuron % newNetwork.getOutputNeurons()) % newNetwork.getOutputBlockingFactor(); auto& outputLayer = newNetwork.back(); assert(block < outputLayer.blocks()); Matrix weights = outputLayer[block].slice(0, offset, outputLayer.getInputBlockingFactor(), 1); Matrix bias = outputLayer.at_bias(block).slice(0, offset, 1, 1); outputLayer.resize(1, outputLayer.getInputBlockingFactor(), 1); outputLayer[0] = weights; outputLayer.at_bias(0) = bias; util::log("NeuronVisualizer") << " trimmed to: " << newNetwork.shapeString() << ".\n"; #endif return newNetwork; }
Vector<double> Car::calculate_final_solutions(const NeuralNetwork& neural_network) const { Car car_copy(*this); car_copy.set_final_independent_variable(neural_network.get_independent_parameters_pointer()->get_parameter(0)); switch(solution_method) { case RungeKutta: { return(car_copy.calculate_Runge_Kutta_final_solution(neural_network)); } break; case RungeKuttaFehlberg: { return(car_copy.calculate_Runge_Kutta_Fehlberg_final_solution(neural_network)); } break; default: { std::ostringstream buffer; buffer << "OpenNN Exception: Car class\n" << "Vector<double> calculate_final_solutions(const NeuralNetwork&) const method.\n" << "Unknown solution method.\n"; throw std::logic_error(buffer.str()); } break; } }
TYPE error_single(NeuralNetwork& nn, const values_t& input, const values_t& expected_output) { values_t output; nn.process(input, output); TYPE res = abs(output - expected_output); return res*res/2; }
TEST(TestNeuralNetwork, costFunction) { int called = 0; CostFunction c([&called](float, float expected) { called++; return expected * 64.0f; }); NeuralNetwork nn {2, 2}; vector<float> expected {1.0f, 0.5f}; nn.setCostFunction(c); EXPECT_FLOAT_EQ((64.0f + 32.0f), nn.calcCost(expected)); EXPECT_EQ(2, called); }
TEST(StateTest, AllMethodsWithInit) { typedef NeuralNetwork<double, StepActivationFunction<double >> network; NeuralNetwork<double, StepActivationFunction<double >> nn; ASSERT_NO_THROW(nn.init()); ASSERT_THROW(nn.setEntries(2), network::WrongState); ASSERT_THROW(nn.setExits(2), network::WrongState); ASSERT_THROW(nn.setLayersCount(1), network::WrongState); ASSERT_THROW(nn.setEntries(2), network::WrongState); ASSERT_THROW(nn.setNeurons(1, 2), network::WrongState); ASSERT_THROW(nn.setNeurons(2, 2), network::WrongState); std::vector<double> ans; ans.assign(2, 1); ASSERT_NO_THROW(nn.learn(ans.begin(), ans.end())); ASSERT_NO_THROW(nn.calcOutput()); ASSERT_NO_THROW(nn.stop()); }
void SumSquaredErrorTest::test_calculate_squared_errors(void) { message += "test_calculate_squared_errors\n"; NeuralNetwork nn; DataSet ds; SumSquaredError sse(&nn, &ds); Vector<double> squared_errors; double objective; // Test nn.set(1,1,1); nn.initialize_parameters(0.0); ds.set(1,1,1); ds.initialize_data(0.0); squared_errors = sse.calculate_squared_errors(); assert_true(squared_errors.size() == 1, LOG); assert_true(squared_errors == 0.0, LOG); // Test nn.set(2,2,2); nn.randomize_parameters_normal(); ds.set(2,2,2); ds.randomize_data_normal(); squared_errors = sse.calculate_squared_errors(); objective = sse.calculate_error(); assert_true(fabs(squared_errors.calculate_sum() - objective) < 1.0e-12, LOG); }
void saveNetwork(const NeuralNetwork<TDevice> &nn, const std::string &filename) { rapidjson::Document jsonDoc; jsonDoc.SetObject(); nn.exportLayers (&jsonDoc); nn.exportWeights(&jsonDoc); FILE *file = fopen(filename.c_str(), "w"); if (!file) throw std::runtime_error("Cannot open file"); rapidjson::FileStream os(file); rapidjson::PrettyWriter<rapidjson::FileStream> writer(os); jsonDoc.Accept(writer); fclose(file); }
void NeuralNetworkTest::test_from_XML(void) { message += "test_from_XML\n"; NeuralNetwork nn; tinyxml2::XMLDocument* document; // Test nn.initialize_random(); document = nn.to_XML(); nn.from_XML(*document); delete document; }
void TrainingStrategyTest::test_perform_training(void) { message += "test_perform_training\n"; NeuralNetwork nn; DataSet ds; PerformanceFunctional pf(&nn, &ds); TrainingStrategy ts(&pf); // Test nn.set(1, 1); ds.set(1,1,2); // ts.perform_training(); }
void Physics::testPhysics(){ int box3 = createBox(895,95,395); int box4 = createBox(195,195,195); createJoint(box3, box4,0, 50, 50, 2, 50, 50,50, 30,30,30); /* int box = createBox(85,385,185); createJoint(box3, box, 0,50, 50, 3, 50, 50, 3, 0,0,0); int box5 = createBox(95,95,395); createJoint(box, box5, 0,50, 50,5, 50, 50, 0, 0,0,0); */ // createSensor(box2, pressure); //NN test std::vector<NeuralNode*> inputs; for(int i=0;i< (int) sensors.size();i++){ inputs.push_back(new NeuralNode(&sensors.at(i))); } inputs.push_back(new NeuralNode(1)); //index 3 inputs.push_back(new NeuralNode(-2)); //index 4 float* testPoint = new float; *testPoint = 5; inputs.push_back(new NeuralNode(testPoint)); //index 5 theNet = new NeuralNetwork(inputs); theNet->insertNode(SUM,5,3,3,1); theNet->insertNode(SIN,1,1); theNet->changeLayer(); theNet->insertNode(PRODUCT,0,1,2,2); theNet->stopBuilding(); NeuralNetwork* aNet = new NeuralNetwork(theNet->getLastLayer()); aNet->insertNode(PRODUCT,0,0,10000,10000); aNet->stopBuilding(); subnets.push_back(aNet); effectorNNindex.push_back(0); effectorNNindex.push_back(1); effectorNNindex.push_back(2); solveGroundConflicts(); }
TEST(TestNeuralNetwork, testIfBackpropGradientIsEqToNumerical) { NeuralNetwork nn {2, 2}; vector<float> weights {0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f}; vector<float> input; vector<float> expected; vector<float> backpropGradient; vector<float> numericalGradient; int iter = 0; bool lastBatch; input.resize(2); expected.resize(2); nn.setWeights(weights); nn.setActivationFunction(ActivationFunction::sigmoid()); do { lastBatch = createAndOrSample(iter++, input, expected); nn.setInput(input); nn.calc(); nn.calcNumericalGradient(expected, numericalGradient); nn.calcBackpropagationGradient(expected, backpropGradient); ASSERT_EQ(numericalGradient.size(), backpropGradient.size()); for (int i = 0; i < numericalGradient.size(); ++i) { EXPECT_NEAR(numericalGradient[i], backpropGradient[i], 0.0001f); numericalGradient[i] = 0.0f; backpropGradient[i] = 0.0f; } } while(!lastBatch); }