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_with_all_hypothesis(self): brave = BraveHypothesis() wimpy = WimpyHypothesis() knn3 = KNearestNeighbors(3) knn5 = KNearestNeighbors(5) knn7 = KNearestNeighbors(7) knn11 = KNearestNeighbors(11) rando = RandoHypothesis() prob = SimpleProbabilityHypothesis() # drP3 = OptimusPerceptron(11) # drP5 = DrPerceptron(5) # drP7 = DrPerceptron(7) # drP11 = DrPerceptron(11) # self.setUpDecisioner(brave, wimpy, knn3, knn5, knn7, knn11, rando, prob, # drP3, # drP5, # drP7, # drP11, ) def create_monster(): color = randint(1, 100) if color < 70: if random() >= 0.3: return Monster(0, [color], 'passive') return Monster(1, [color], 'aggressive') else: if random() >= 0.7: return Monster(0, [color], 'passive') return Monster(1, [color], 'aggressive') for i in range(100): monster = create_monster() self.decisioner.update(monster.color, 1, monster.action(True)) maximum_value = 1000.0 actual_value = 0.0 for i in range(1000): monster = create_monster() guess = self.decisioner.get_guess(monster.color) outcome = monster.action(guess) self.decisioner.update(monster.color, guess, outcome) maximum_value -= monster._aggressive actual_value += outcome
def test_update_ratio_matches_expected(self): """Test the KNN algorithm with our built in rolling window""" knn = KNearestNeighbors(1) # First we define the method for generating our two # categories in a single dimension def generate_monster(): color = randint(1, 100) # All colors less than 50 are passive if color < 50: return Monster(0, [color], 'passive') # Otherwise the monster is aggresive return Monster(1, [color], 'aggressive') # Run the inital training phase for i in range(100): monster = generate_monster() knn.update(monster.color, 1, monster.action(True)) # Then we need to run over a set of values, we should see # a relatively high ratio of actual value vs maximum value actual_value = 0.0 maximum_value = 5000.0 for i in range(5000): monster = generate_monster() guess = knn.get_guess(monster.color) outcome = monster.action(guess) maximum_value -= monster._aggressive actual_value += outcome knn.update(monster.color, guess, outcome) self.assertGreaterEqual(actual_value / maximum_value, 0.9)
def test_update_ratio_matches_expected(self): """Test the KNN algorithm with our built in rolling window""" knn = KNearestNeighbors(1) # First we define the method for generating our two # categories in a single dimension def generate_monster(): color = randint(1, 100) # All colors less than 50 are passive if color < 50: return Monster(0, [color], 'passive') # Otherwise the monster is aggresive return Monster(1, [color], 'aggressive') # Run the inital training phase for i in range(100): monster = generate_monster() knn.update(monster.color, 1, monster.action(True)) # Then we need to run over a set of values, we should see # a relatively high ratio of actual value vs maximum value actual_value = 0.0 maximum_value = 5000.0 for i in range(5000): monster = generate_monster() guess = knn.get_guess(monster.color) outcome = monster.action(guess) maximum_value -= monster._aggressive actual_value += outcome knn.update(monster.color, guess, outcome) self.assertGreaterEqual(actual_value/ maximum_value, 0.9)
def create_monster(): color = randint(1, 100) if color < 70: if random() < 0.3: return Monster(1, [color], 'aggressive') return Monster(0, [color], 'passive') else: if random() < 0.7: return Monster(1, [color], 'aggressive') return Monster(0, [color], 'passive') hyps = [ BraveHypothesis(), WimpyHypothesis(), KNearestNeighbors(3), KNearestNeighbors(5), KNearestNeighbors(7), KNearestNeighbors(11), KNearestNeighbors(17), KNearestNeighbors(23), KNearestNeighbors(29), KNearestNeighbors(31), KNearestNeighbors(37), KNearestNeighbors(41), KNearestNeighbors(43), KNearestNeighbors(47), SimpleProbabilityHypothesis(), RandoHypothesis(), OptimusPerceptron(47), # mod 47 universe OptimusPerceptron(43), # mod 43 universe
def setUp(self): # We set the window to 99 to allow the first set to key # on 100 values updated self._hypothesis = KNearestNeighbors(3, window=99)
class KNearestNeighborsTest(unittest.TestCase): def setUp(self): # We set the window to 99 to allow the first set to key # on 100 values updated self._hypothesis = KNearestNeighbors(3, window=99) def tearDown(self): self._hypothesis = None def test_update_1dimension(self): """Test the KNN algorithm in one dimension at multiple points""" # Set up cluster of two distant groups in one dimension for i in range(50): self._hypothesis.update([1], 1, -1) for i in range(50): self._hypothesis.update([50], 1, 1) self.assertFalse(self._hypothesis.get_guess([-1])) self.assertFalse(self._hypothesis.get_guess([1])) self.assertFalse(self._hypothesis.get_guess([-15])) self.assertFalse(self._hypothesis.get_guess([15])) self.assertFalse(self._hypothesis.get_guess([-24])) self.assertFalse(self._hypothesis.get_guess([24])) self.assertTrue(self._hypothesis.get_guess([50])) self.assertTrue(self._hypothesis.get_guess([49])) self.assertTrue(self._hypothesis.get_guess([51])) self.assertTrue(self._hypothesis.get_guess([26])) self.assertTrue(self._hypothesis.get_guess([74])) def test_update_2dimension(self): """Test the KNN algorithm in two dimensions at multiple points""" # Set up cluster of two distance groups in two dimensions for i in range(50): self._hypothesis.update([1, 1], 1, -1) for i in range(50): self._hypothesis.update([50, 50], 1, 1) self.assertFalse(self._hypothesis.get_guess([1, 1])) self.assertFalse(self._hypothesis.get_guess([-1, -1])) self.assertFalse(self._hypothesis.get_guess([15, 15])) self.assertFalse(self._hypothesis.get_guess([-15, -15])) self.assertFalse(self._hypothesis.get_guess([24, 24])) self.assertFalse(self._hypothesis.get_guess([-24, -24])) self.assertTrue(self._hypothesis.get_guess([50, 50])) self.assertTrue(self._hypothesis.get_guess([49, 49])) self.assertTrue(self._hypothesis.get_guess([51, 51])) self.assertTrue(self._hypothesis.get_guess([26, 26])) self.assertTrue(self._hypothesis.get_guess([74, 74])) def test_update_over_Ndimensions(self): """Test the KNN algorithm in between 2 and 10 dimensions""" for dimension in range(2, 10): # first set the aggressive monsters at [10, ..., 10] for i in range(50): self._hypothesis.update([10] * dimension, 1, -1) # Next set the non-aggresive monsters at [90, ..., 90] for i in range(50): self._hypothesis.update([90] * dimension, 1, 1) self.assertFalse(self._hypothesis.get_guess([0] * dimension)) self.assertFalse(self._hypothesis.get_guess([40] * dimension)) self.assertTrue(self._hypothesis.get_guess([100] * dimension)) self.assertTrue(self._hypothesis.get_guess([55] * dimension)) def test_update_ratio_matches_expected(self): """Test the KNN algorithm with our built in rolling window""" knn = KNearestNeighbors(1) # First we define the method for generating our two # categories in a single dimension def generate_monster(): color = randint(1, 100) # All colors less than 50 are passive if color < 50: return Monster(0, [color], 'passive') # Otherwise the monster is aggresive return Monster(1, [color], 'aggressive') # Run the inital training phase for i in range(100): monster = generate_monster() knn.update(monster.color, 1, monster.action(True)) # Then we need to run over a set of values, we should see # a relatively high ratio of actual value vs maximum value actual_value = 0.0 maximum_value = 5000.0 for i in range(5000): monster = generate_monster() guess = knn.get_guess(monster.color) outcome = monster.action(guess) maximum_value -= monster._aggressive actual_value += outcome knn.update(monster.color, guess, outcome) self.assertGreaterEqual(actual_value/ maximum_value, 0.9)
class KNearestNeighborsTest(unittest.TestCase): def setUp(self): # We set the window to 99 to allow the first set to key # on 100 values updated self._hypothesis = KNearestNeighbors(3, window=99) def tearDown(self): self._hypothesis = None def test_update_1dimension(self): """Test the KNN algorithm in one dimension at multiple points""" # Set up cluster of two distant groups in one dimension for i in range(50): self._hypothesis.update([1], 1, -1) for i in range(50): self._hypothesis.update([50], 1, 1) self.assertFalse(self._hypothesis.get_guess([-1])) self.assertFalse(self._hypothesis.get_guess([1])) self.assertFalse(self._hypothesis.get_guess([-15])) self.assertFalse(self._hypothesis.get_guess([15])) self.assertFalse(self._hypothesis.get_guess([-24])) self.assertFalse(self._hypothesis.get_guess([24])) self.assertTrue(self._hypothesis.get_guess([50])) self.assertTrue(self._hypothesis.get_guess([49])) self.assertTrue(self._hypothesis.get_guess([51])) self.assertTrue(self._hypothesis.get_guess([26])) self.assertTrue(self._hypothesis.get_guess([74])) def test_update_2dimension(self): """Test the KNN algorithm in two dimensions at multiple points""" # Set up cluster of two distance groups in two dimensions for i in range(50): self._hypothesis.update([1, 1], 1, -1) for i in range(50): self._hypothesis.update([50, 50], 1, 1) self.assertFalse(self._hypothesis.get_guess([1, 1])) self.assertFalse(self._hypothesis.get_guess([-1, -1])) self.assertFalse(self._hypothesis.get_guess([15, 15])) self.assertFalse(self._hypothesis.get_guess([-15, -15])) self.assertFalse(self._hypothesis.get_guess([24, 24])) self.assertFalse(self._hypothesis.get_guess([-24, -24])) self.assertTrue(self._hypothesis.get_guess([50, 50])) self.assertTrue(self._hypothesis.get_guess([49, 49])) self.assertTrue(self._hypothesis.get_guess([51, 51])) self.assertTrue(self._hypothesis.get_guess([26, 26])) self.assertTrue(self._hypothesis.get_guess([74, 74])) def test_update_over_Ndimensions(self): """Test the KNN algorithm in between 2 and 10 dimensions""" for dimension in range(2, 10): # first set the aggressive monsters at [10, ..., 10] for i in range(50): self._hypothesis.update([10] * dimension, 1, -1) # Next set the non-aggresive monsters at [90, ..., 90] for i in range(50): self._hypothesis.update([90] * dimension, 1, 1) self.assertFalse(self._hypothesis.get_guess([0] * dimension)) self.assertFalse(self._hypothesis.get_guess([40] * dimension)) self.assertTrue(self._hypothesis.get_guess([100] * dimension)) self.assertTrue(self._hypothesis.get_guess([55] * dimension)) def test_update_ratio_matches_expected(self): """Test the KNN algorithm with our built in rolling window""" knn = KNearestNeighbors(1) # First we define the method for generating our two # categories in a single dimension def generate_monster(): color = randint(1, 100) # All colors less than 50 are passive if color < 50: return Monster(0, [color], 'passive') # Otherwise the monster is aggresive return Monster(1, [color], 'aggressive') # Run the inital training phase for i in range(100): monster = generate_monster() knn.update(monster.color, 1, monster.action(True)) # Then we need to run over a set of values, we should see # a relatively high ratio of actual value vs maximum value actual_value = 0.0 maximum_value = 5000.0 for i in range(5000): monster = generate_monster() guess = knn.get_guess(monster.color) outcome = monster.action(guess) maximum_value -= monster._aggressive actual_value += outcome knn.update(monster.color, guess, outcome) self.assertGreaterEqual(actual_value / maximum_value, 0.9)