Beispiel #1
0
TEST_F(PlayCounterTest, InitializingCounstructor) {
    PlayCounter playCounter(5);

    EXPECT_FALSE(playCounter.isPlayed());
    EXPECT_EQ(5, playCounter.getTimesPlayed());

    testCycle(&playCounter);
}
Beispiel #2
0
TEST_F(PlayCounterTest, DefaultCounstructor) {
    PlayCounter playCounter;

    EXPECT_FALSE(playCounter.isPlayed());
    EXPECT_EQ(0, playCounter.getTimesPlayed());

    testCycle(&playCounter);
}
Beispiel #3
0
inline void NeuralNet::training_SCG (Iterator itTrainingsPatternBegin, Iterator itTrainingsPatternEnd, 
                              Iterator itTestPatternBegin, Iterator itTestPatternEnd, 
                              size_t batchSize, 
                              size_t convergenceSteps)
{
    std::cout << "START TRAINING : SCG" << std::endl;
    size_t convergenceCount = 0;
    NNTYPE minError = 1e10;

    size_t cycleCount = 0;
    size_t testCycleCount = 0;
    NNTYPE testError = 1e20;

    // until convergence
    while (convergenceCount < convergenceSteps)
    {
	std::cout << "train cycle " << cycleCount << std::endl;
        ++cycleCount;
	NNTYPE trainError = trainCycles_SCG (itTrainingsPatternBegin, itTrainingsPatternEnd, batchSize);
//	std::cout << "test cycle" << std::endl;

        if (testCycleCount % m_pSettings->testRepetitions == 0)
            testError = testCycle (itTestPatternBegin, itTestPatternEnd);

        ++testCycleCount;


	static double x = -1.0;
	x += 1.0;
	m_pSettings->resetPlot ("errors");
	m_pSettings->addPoint ("trainErrors", m_pSettings->count_E, trainError);
	m_pSettings->addPoint ("testErrors", m_pSettings->count_E, testError);
	m_pSettings->plot ("errors", "training", "trainErrors", "points", "");
	m_pSettings->plot ("errors", "training_", "trainErrors", "lines", "cspline");
	m_pSettings->plot ("errors", "test", "testErrors", "points", "");
	m_pSettings->plot ("errors", "test_", "testErrors", "lines", "cspline");



	(*this).print (std::cout);
	std::cout << "check convergence; minError " << minError << "  current " << testError << "  current convergence count " << convergenceCount << std::endl;
	if (testError < minError)
	{
	    convergenceCount = 0;
	    minError = testError;
	}
	else
	    ++convergenceCount;

	std::cout << "testError : " << testError << "   trainError : " << trainError << std::endl;
    }
    std::cout << "END TRAINING" << std::endl;
}