Esempio n. 1
0
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)
Esempio n. 2
0
 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)
Esempio n. 4
0
    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()
Esempio n. 5
0
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")
Esempio n. 6
0
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