def knnClassifier(train, test, k, kdtree=False, weight=naiveWeight):
predictions = test
probs = []
kdTreeKnn = None
kNeighbors = None
kWeights = None
if kdtree:
kdTreeKnn = KdTree(train)
for i in range(len(test)):
for j in range(len(test[0])):
predictions[i][j] = test[i][j]
if kdtree:
kdTreeKnn.knn(k, predictions[i])
kNeighbors = kdTreeKnn.knnResults
kWeights = kdTreeKnn.knnDistances
else:
kNeighbors, kWeights = knn_naive(k, train, predictions[i])
kWeights = weight(kWeights)
sumWeights = 0
sumPred = 0
for j in range(k):
sumWeights += kWeights[j]
sumPred += kWeights[j] * kNeighbors[j][-1]
predictions[i][-1] = round(sumPred / sumWeights)
probs.append(list(predictions[i]))
probs[i][-1] = sumPred / sumWeights
return (predictions, probs)
def buildNodalTree(self, sNodes):
log.info("---start buildNodalTree---")
raise Exception('DEPRECATED...buildNodalTree in mapLoads.py')
sys.stdout.flush()
#print "type(aCentroids)=%s type(sCentroids)=%s" %(type(aCentroids), type(sCentroids))
self.nodalTree = KdTree('node', sNodes, nClose=self.nCloseNodes)
log.info("---finish buildNodalTree---")
sys.stdout.flush()
def test_build(self):
"""Test if we are building correctly the Kd-Tree"""
kd_tree_generated_by_function = KdTree(self.points)
kd_tree_generated_by_hand = self.kd_tree
self.validate_node(kd_tree_generated_by_function.root_node,
kd_tree_generated_by_hand.root_node)
def buildCentroidTree(self, sCentroids):
"""
sCentroids - dict of structural centroids
id: element id
"""
log.info("---start buildCentroidTree---")
sys.stdout.flush()
#print "type(aCentroids)=%s type(sCentroids)=%s" %(type(aCentroids), type(sCentroids))
msg = 'Element '
for (id,sCentroid) in sorted(iteritems(sCentroids)):
msg += "%s " % id
log.info(msg + '\n')
self.centroidTree = KdTree('element', sCentroids, nClose=self.nCloseElements)
log.info("---finish buildCentroidTree---")
sys.stdout.flush()
def main():
number_of_points = 1000
points = generate_points(number_of_points)
kd_tree = KdTree(points)
# Query to search points
query_x = [400, 500]
query_y = [300, 400]
region_x = [None, None]
region_y = [None, None]
search_result = kd_tree.search(query_x, query_y, region_x, region_y)
print("The query:")
print("X = [%d, %d]" % (query_x[0], query_x[1]))
print("Y = [%d, %d]" % (query_y[0], query_y[1]))
print("Returns:")
print(search_result)
print("######################################################################################################\n")
def group_tweets_by_state(tweets):
"""Return a dictionary that aggregates tweets by their nearest state center.
The keys of the returned dictionary are state names, and the values are
lists of tweets that appear closer to that state center than any other.
tweets -- a sequence of tweet abstract data types
>>> sf = make_tweet("welcome to san francisco", None, 38, -122)
>>> ny = make_tweet("welcome to new york", None, 41, -74)
>>> two_tweets_by_state = group_tweets_by_state([sf, ny])
>>> len(two_tweets_by_state)
2
>>> california_tweets = two_tweets_by_state['CA']
>>> len(california_tweets)
1
>>> tweet_string(california_tweets[0])
'"welcome to san francisco" @ (38, -122)'
"""
center_state_dict = {}
centers = []
for state, polygons in us_states.items():
center = find_state_center(polygons)
centers.append(center)
center_state_dict[center] = state
state_centers = KdTree(centers)
tweets_by_state = {}
for tweet in tweets:
location = tweet_location(tweet)
nearest_state_center = state_centers.nearest_neigbour(
location).location
nearest_state = center_state_dict[nearest_state_center]
if nearest_state not in tweets_by_state:
tweets_by_state[nearest_state] = []
tweets_by_state[nearest_state].append(tweet)
return tweets_by_state
def setUp(self):
"""This is called immediately before calling every test method"""
# ODD CASE
self.points_odd = [[2, 4], [-1, 5], [3, -3], [6, 1], [1, 2]]
self.points_odd_sorted_x = [[-1, 5], [1, 2], [2, 4], [3, -3], [6, 1]]
self.points_odd_sorted_y = [[3, -3], [6, 1], [1, 2], [2, 4], [-1, 5]]
self.kd_tree_odd = KdTree(self.points_odd)
# EVEN CASE
self.points_even = [[2, 4], [-1, 5], [3, -3], [1, 2]]
self.points_even_sorted_x = [[-1, 5], [1, 2], [2, 4], [3, -3]]
self.points_even_sorted_y = [[3, -3], [1, 2], [2, 4], [-1, 5]]
self.kd_tree_even = KdTree(self.points_even)
# QUERY TO SEARCH IN THE KD-TREE
self.query_x = [1, 3]
self.query_y = [2, 4]
# BUILDING A KD-TREE
# LEVEL 4 KD_TREE
self.node_level_4_1 = Node()
self.node_level_4_1.type = NodeType.LEAF
self.node_level_4_1.level = 4
self.node_level_4_1.cut = None
self.node_level_4_1.point = [3, 1]
self.node_level_4_1.left_child = None
self.node_level_4_1.right_child = None
self.node_level_4_2 = Node()
self.node_level_4_2.type = NodeType.LEAF
self.node_level_4_2.level = 4
self.node_level_4_2.cut = None
self.node_level_4_2.point = [1, 2]
self.node_level_4_2.left_child = None
self.node_level_4_2.right_child = None
# LEVEL 3 KD_TREE
self.node_level_3_1 = Node()
self.node_level_3_1.type = NodeType.INTERNAL
self.node_level_3_1.level = 3
self.node_level_3_1.cut = 1
self.node_level_3_1.point = None
self.node_level_3_1.left_child = self.node_level_4_1
self.node_level_3_1.right_child = self.node_level_4_2
self.node_level_3_2 = Node()
self.node_level_3_2.type = NodeType.LEAF
self.node_level_3_2.level = 3
self.node_level_3_2.cut = None
self.node_level_3_2.point = [4, 5]
self.node_level_3_2.left_child = None
self.node_level_3_2.right_child = None
self.node_level_3_3 = Node()
self.node_level_3_3.type = NodeType.LEAF
self.node_level_3_3.level = 3
self.node_level_3_3.cut = None
self.node_level_3_3.point = [2, 6]
self.node_level_3_3.left_child = None
self.node_level_3_3.right_child = None
self.node_level_3_4 = Node()
self.node_level_3_4.type = NodeType.LEAF
self.node_level_3_4.level = 3
self.node_level_3_4.cut = None
self.node_level_3_4.point = [5, 7]
self.node_level_3_4.left_child = None
self.node_level_3_4.right_child = None
self.node_level_3_5 = Node()
self.node_level_3_5.type = NodeType.LEAF
self.node_level_3_5.level = 3
self.node_level_3_5.cut = None
self.node_level_3_5.point = [6, 3]
self.node_level_3_5.left_child = None
self.node_level_3_5.right_child = None
self.node_level_3_6 = Node()
self.node_level_3_6.type = NodeType.LEAF
self.node_level_3_6.level = 3
self.node_level_3_6.cut = None
self.node_level_3_6.point = [8, 4]
self.node_level_3_6.left_child = None
self.node_level_3_6.right_child = None
self.node_level_3_7 = Node()
self.node_level_3_7.type = NodeType.LEAF
self.node_level_3_7.level = 3
self.node_level_3_7.cut = None
self.node_level_3_7.point = [7, 8]
self.node_level_3_7.left_child = None
self.node_level_3_7.right_child = None
self.node_level_3_8 = Node()
self.node_level_3_8.type = NodeType.LEAF
self.node_level_3_8.level = 3
self.node_level_3_8.cut = None
self.node_level_3_8.point = [9, 9]
self.node_level_3_8.left_child = None
self.node_level_3_8.right_child = None
# LEVEL 2 KD_TREE
self.node_level_2_1 = Node()
self.node_level_2_1.type = NodeType.INTERNAL
self.node_level_2_1.level = 2
self.node_level_2_1.cut = 3
self.node_level_2_1.point = None
self.node_level_2_1.left_child = self.node_level_3_1
self.node_level_2_1.right_child = self.node_level_3_2
self.node_level_2_2 = Node()
self.node_level_2_2.type = NodeType.INTERNAL
self.node_level_2_2.level = 2
self.node_level_2_2.cut = 2
self.node_level_2_2.point = None
self.node_level_2_2.left_child = self.node_level_3_3
self.node_level_2_2.right_child = self.node_level_3_4
self.node_level_2_3 = Node()
self.node_level_2_3.type = NodeType.INTERNAL
self.node_level_2_3.level = 2
self.node_level_2_3.cut = 6
self.node_level_2_3.point = None
self.node_level_2_3.left_child = self.node_level_3_5
self.node_level_2_3.right_child = self.node_level_3_6
self.node_level_2_4 = Node()
self.node_level_2_4.type = NodeType.INTERNAL
self.node_level_2_4.level = 2
self.node_level_2_4.cut = 7
self.node_level_2_4.point = None
self.node_level_2_4.left_child = self.node_level_3_7
self.node_level_2_4.right_child = self.node_level_3_8
# LEVEL 1 KD_TREE
self.node_level_1_1 = Node()
self.node_level_1_1.type = NodeType.INTERNAL
self.node_level_1_1.level = 1
self.node_level_1_1.cut = 5
self.node_level_1_1.point = None
self.node_level_1_1.left_child = self.node_level_2_1
self.node_level_1_1.right_child = self.node_level_2_2
self.node_level_1_2 = Node()
self.node_level_1_2.type = NodeType.INTERNAL
self.node_level_1_2.level = 1
self.node_level_1_2.cut = 4
self.node_level_1_2.point = None
self.node_level_1_2.left_child = self.node_level_2_3
self.node_level_1_2.right_child = self.node_level_2_4
# LEVEL 0 KD_TREE
self.root_node = Node()
self.root_node.type = NodeType.INTERNAL
self.root_node.level = 0
self.root_node.cut = 5
self.root_node.point = None
self.root_node.left_child = self.node_level_1_1
self.root_node.right_child = self.node_level_1_2
self.points = [[1, 2], [2, 6], [3, 1], [4, 5], [5, 7], [6, 3], [7, 8],
[8, 4], [9, 9]]
self.kd_tree = KdTree(self.points)
self.kd_tree.root_node = self.root_node
