def test_GroupedAggroByColor_WithWimpyBraveAndKNN(self): brave = BraveHypothesis() wimpy = WimpyHypothesis() knn = KNearestNeighbors(3) self.setUpDecisioner(brave, wimpy, knn) def create_monster(): color = randint(1, 100) # Every monster below 50 is aggressive if color < 50: return Monster(1, [color], 'aggressive') # Otherwise if they are above 50 they are # passive else: return Monster(0, [color], 'passive') # Next we load up the training data for i in range(100): # Create the monster and generate all the data, by default # we expect everything in the training period to be true # meaning attack for data monster = create_monster() self.assertTrue(self.decisioner.get_guess(monster.color)) self.decisioner.update(monster.color, 1, monster.action(True)) # Finally we need to know that normal KNN was matched as the best # fitness for the data set self.assertGreater(knn.fitness(), brave.fitness()) self.assertGreater(knn.fitness(), wimpy.fitness()) # Then we are going to run over all of the data sets # We want to also track the actual value and the maximum # value for comparison maximum_value = 5000.0 actual_value = 0.0 for i in range(5000): # Create the monster, guess on it and grab the outcome # which is all required information for the loop monster = create_monster() guess = self.decisioner.get_guess(monster.color) outcome = monster.action(guess) # update values for comparison after loop maximum_value -= monster._aggressive actual_value += outcome # self.decisioner.update(monster.color, guess, outcome) # We need to know that KNN is still our best fit for this # data set self.assertGreater(knn.fitness(), brave.fitness()) self.assertGreater(knn.fitness(), wimpy.fitness()) # Finally we expect that the standard KNN process will obtain # within 10 percent margin of the best possible solution self.assertGreater(actual_value / maximum_value, 0.9)
def test_AllPassiveMonsters_WithWimpyAndBrave(self): brave = BraveHypothesis() wimpy = WimpyHypothesis() self.setUpDecisioner(brave, wimpy) # First we will start with the basic training case # which is the first 100 in the range for i in range(101): monster = Monster(0, [randint(1, 100)], 'passive') # Get the guess from the decisioner for the first 100, # we expect every guess to be 1 self.assertTrue(self.decisioner.get_guess(monster.color)) # Then we will update from this guess self.decisioner.update(monster.color, 1, monster.action(True)) for i in range(5000): monster = Monster(0, [randint(1, 100)], 'aggressive') # Get the guess from the decisioner for the next 5000, # We expect all of them to be wimpy and thus not attack self.assertTrue(self.decisioner.get_guess(monster.color)) # Then we will update from this guess self.decisioner.update(monster.color, 1, 1) # Finally we know that the wimpy hypothesis should always have # a greater fitness than the brave for each iteration self.assertGreater(brave.fitness(), wimpy.fitness())
def test_simpleResponse_WithDrPerceptron(self): brave = BraveHypothesis() wimpy = WimpyHypothesis() drP = DrPerceptron() self.setUpDecisioner(brave, wimpy, drP) # First we will start with the basic training case # which is the first 100 in the range for i in range(101): nonAggro = 0 # this means not aggro color = [randint(1, 100)] monster = Monster(nonAggro, color, 'passive') # Get the guess from the decisioner for the first 100, # we expect every guess to be 1 self.assertTrue(self.decisioner.get_guess(monster.color)) # Then we will update from this guess self.decisioner.update(monster.color, 1, monster.action(True)) # DrPerceptron should converge pretty quickly and be better than wimpy but not as good as brave for i in range(100): aggro = 1 # this means aggro color = [randint(1, 100)] monster = Monster(aggro, color, 'aggressive') # Then we will update from this guess self.decisioner.update(monster.color, 1, 1) self.assertGreater(drP.fitness(), wimpy.fitness()) self.assertGreater(brave.fitness(), drP.fitness())
def test_frequencyResponse_forHarmonic_WithOptimusPerceptron(self): brave = BraveHypothesis() wimpy = WimpyHypothesis() oPP = OptimusPerceptron() self.setUpDecisioner(brave, wimpy, oPP) # First we will start with the basic training case # which is the first 100 in the range for i in range(101): nonAggro = 0 # this means not aggro color = [randint(1, 100)] monster = Monster(nonAggro, color, 'passive') # Get the guess from the decisioner for the first 100, # we expect every guess to be 1 self.assertTrue(self.decisioner.get_guess(monster.color)) # Then we will update from this guess self.decisioner.update(monster.color, 1, monster.action(True)) # Dr. Perceptron should do better than brave and wimpy # when encountering monsters that repeat with a frequency # that is trainable given Dr.Perceptron's window size. # In otherwords, Dr. Perceptron trains on a frequency of # Monsters but training on a pattern is limited to the # input size of Dr. Perceptron (which as of this check-in # is 5) # # We test a staggered input with a repeating pattern for i in range(1000): aggroPattern = [0, 1, 1, 0, 1] aggroIdx = i%len(aggroPattern) color = [randint(1, 100)] monster = Monster(aggroPattern[aggroIdx], color, 'aggressiveish') # Then we will update from this guess self.decisioner.update(monster.color, aggroPattern[aggroIdx], aggroPattern[aggroIdx]) # drP should always be better than wimpy self.assertGreater(oPP.fitness(), wimpy.fitness()) # after a lot of training for a pattern that is harmonic within the input size Dr.P should beat out brave self.assertGreater(oPP.fitness(), brave.fitness()) # Since the pattern is highly regular within the input size, the fitness should be really really close to 1. # With great harmony results great trainability and therefore great fitness self.assertGreater(oPP.fitness(), 0.99)
def test_frequencyResponse_WithDrPerceptron(self): brave = BraveHypothesis() wimpy = WimpyHypothesis() drP = DrPerceptron() self.setUpDecisioner(brave, wimpy, drP) # First we will start with the basic training case # which is the first 100 in the range for i in range(101): nonAggro = 0 # this means not aggro color = [randint(1, 100)] monster = Monster(nonAggro, color, 'passive') # Get the guess from the decisioner for the first 100, # we expect every guess to be 1 self.assertTrue(self.decisioner.get_guess(monster.color)) # Then we will update from this guess self.decisioner.update(monster.color, 1, monster.action(True)) # Dr. Perceptron should do better than brave and wimpy # when encountering monsters that repeat with a frequency # that is trainable given Dr.Perceptron's window size. # In otherwords, Dr. Perceptron trains on a frequency of # Monsters but training on a pattern is limited to the # input size of Dr. Perceptron (which as of this check-in # is 5) # # We test a staggered input for i in range(10): aggro = 1 # this means aggro passive = 0 # this means aggro evenMonstersPassive = i%2 color = [randint(1, 100)] monster = Monster(evenMonstersPassive, color, 'aggressiveish') # Then we will update from this guess self.decisioner.update(monster.color, evenMonstersPassive, evenMonstersPassive) # drP should always be better than wimpy self.assertGreater(drP.fitness(), wimpy.fitness()) # after 2 sets of 5 inputs drP should be better than brave self.assertGreater(drP.fitness(), brave.fitness())
class BraveHypothesisTest(unittest.TestCase): FAKE_VECTOR = [0, 0] WAS_ATTACKED = 1 SUCCESSFUL_OUTCOME = 1 def setUp(self): self._brave = BraveHypothesis() def tearDown(self): self._brave = None def test_update_fitness(self): """Test that the fitness is being updated as expected for brave""" self.assertEqual(0.0, self._brave.fitness()) self._brave.update(self.FAKE_VECTOR, self.WAS_ATTACKED, self.SUCCESSFUL_OUTCOME) self.assertEqual(1.0, self._brave.fitness()) self._brave.update(self.FAKE_VECTOR, self.WAS_ATTACKED, self.SUCCESSFUL_OUTCOME) self.assertEqual(1.0, self._brave.fitness()) self._brave.update(self.FAKE_VECTOR, self.WAS_ATTACKED, self.SUCCESSFUL_OUTCOME) self.assertEqual(1.0, self._brave.fitness()) # Add misses to the system self._brave.update(self.FAKE_VECTOR, 0, 0) self.assertEqual(0.7500, round(self._brave.fitness(), 4)) self._brave.update(self.FAKE_VECTOR, 0, 0) self.assertEqual(0.6000, round(self._brave.fitness(), 4)) self._brave.update(self.FAKE_VECTOR, 0, 0) self.assertEqual(0.5000, round(self._brave.fitness(), 4)) self._brave.update(self.FAKE_VECTOR, 0, 0) self.assertEqual(0.4286, round(self._brave.fitness(), 4)) self._brave.update(self.FAKE_VECTOR, 0, 0) self.assertEqual(0.3750, round(self._brave.fitness(), 4)) # Add failures to the system self._brave.update(self.FAKE_VECTOR, 1, -1) self.assertEqual(0.3333, round(self._brave.fitness(), 4)) self._brave.update(self.FAKE_VECTOR, 1, -1) self.assertEqual(0.3000, round(self._brave.fitness(), 4)) self._brave.update(self.FAKE_VECTOR, 1, -1) self.assertEqual(0.2727, round(self._brave.fitness(), 4)) # Add some more hits self._brave.update(self.FAKE_VECTOR, self.WAS_ATTACKED, self.SUCCESSFUL_OUTCOME) self.assertEqual(0.3333, round(self._brave.fitness(), 4)) self._brave.update(self.FAKE_VECTOR, self.WAS_ATTACKED, self.SUCCESSFUL_OUTCOME) self.assertEqual(0.3846, round(self._brave.fitness(), 4)) def test_get_guess(self): """Test that the guesses for brave are always true, meaning attack""" for x in range(10): self.assertTrue(self._brave.get_guess(self.FAKE_VECTOR))