예제 #1
0
    def train(self,
              X_train,
              y_train,
              epochs=10,
              retrain=0,
              batch_size=1,
              loss_update=10):
        cum_loss = 0
        history = {}
        losses = []

        def get_progress(num, den, length):
            """
            simple progress bar
            """
            if num == den - 1:
                return '=' * length
            arrow = int(float(num) / den * length)
            return '=' * (arrow - 1) + '>' + '.' * (20 - arrow)

        # preprocess inputs and outputs
        print 'preprocessing inputs and outputs...'
        for i in tqdm(range(len(X_train))):
            X_train[i] = self.str_to_deptree(X_train[i])
            root = Tree(formula=y_train[i])
            y_train[i] = [
                self.tar_vocab.sent_to_idx(formula)
                for formula in root.inorder()
            ]

        for epoch in range(retrain, epochs):
            epoch_loss = 0

            print 'Epoch %d/%d' % (epoch, epochs)

            for i in range(len(X_train)):
                if i + batch_size > len(X_train):
                    continue

                # NOTE: batch size forced to 1
                loss = self.run_epoch(X_train[i], y_train[i], batch_size=1)
                cum_loss += loss
                epoch_loss += loss

                progress = get_progress(i, len(X_train), length=20)
                out = '%d/%d [%s] loss: %f' % (i, len(X_train), progress,
                                               epoch_loss / (i + 1))
                sys.stdout.write('{0}\r'.format(out))
                sys.stdout.flush()
            print

            losses.append(epoch_loss)
            if epoch % loss_update == 0:
                self.save('%s_epoch_%d.json' % (self.sess, epoch))
        history['losses'] = losses
        return history
예제 #2
0
class Solution:
    def diameterOfBinaryTree(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root == None:
            return 0

        self.deepest_path = 0

        def dfs(node):
            if node == None:
                return 0
            left_depth = dfs(node.left)
            right_depth = dfs(node.right)
            self.deepest_path = max(self.deepest_path,
                                    left_depth + right_depth + 1)
            return 1 + max(left_depth, right_depth)

        dfs(root)
        return self.deepest_path - 1


if __name__ == "__main__":
    solution = Solution()
    t1 = Tree([1, 2, 3, 4, 5, None, None]).root
    print(solution.diameterOfBinaryTree(t1))
    t2 = Tree([1]).root
    print(solution.diameterOfBinaryTree(t2))
예제 #3
0
 def setUp(self):
     self.solution = Solution()
     self.testCase1 = Tree([3, 9, 20, None, None, 15, 7])
예제 #4
0
            return 0
        return self.dfs(root, sum) + self.pathSum(root.left, sum) + self.pathSum(root.right, sum)

class Solution(object):
    # using hashmap
    def pathSum(self, root, target):
        """
        :type root: TreeNode
        :type target: int
        :rtype: int
        """
        self.count = 0
        preDict = {0: 1}
        def dfs(p, target, pathSum, preDict):
            if p:
                pathSum += p.val
                self.count += preDict.get(pathSum - target, 0)
                preDict[pathSum] = preDict.get(pathSum, 0) + 1
                dfs(p.left, target, pathSum, preDict)
                dfs(p.right, target, pathSum, preDict)
                preDict[pathSum] -= 1
        dfs(root, target, 0, preDict)
        return self.count
    
    
if __name__ == "__main__":
    solution = Solution()
    tree1 = [10,5,-3,3,2,None,11,3,-2,None,1]
    t1 = Tree(tree1).root
    sum = 8
    print(solution.pathSum(t1, sum))
예제 #5
0
from tree_utils import Tree
class Solution(object):
    
    def reload_the_set(self, root, unique_ele):
        unique_ele.add(root.val)
        if root.left:
            self.reload_the_set(root.left, unique_ele)
        if root.right:
            self.reload_the_set(root.right, unique_ele)
        if not root.left and not root.right:
            return

    def findSecondMinimumValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        unique_eles = set()
        self.reload_the_set(root, unique_eles)
        sorted_set = sorted(unique_eles)
        if len(sorted_set)<=1:
            return -1
        else:
            return sorted_set[1]
        
if __name__ == "__main__":
    solution = Solution()
    tree1 = Tree([2, 2, 5, None, None, 5, 7])
    print(solution.findSecondMinimumValue(tree1.root))
    tree2 = Tree([2,2,2])
    print(solution.findSecondMinimumValue(tree2.root))
예제 #6
0
        result = []
        cur_last_node = root
        next_last_node = root
        level_sum = 0
        level_nodes_num = 0
        queue = []
        queue.insert(0, root)
        while len(queue) != 0:
            cur_node = queue.pop()
            if cur_node.left:
                next_last_node = cur_node.left
                queue.insert(0, cur_node.left)
            if cur_node.right:
                next_last_node = cur_node.right
                queue.insert(0, cur_node.right)
            level_sum += cur_node.val
            level_nodes_num += 1
            if cur_node is cur_last_node:
                cur_last_node = next_last_node
                result.append(level_sum / level_nodes_num)
                level_nodes_num = 0
                level_sum = 0
        return result


if __name__ == '__main__':
    solution = Solution()
    tree = Tree([3, 9, 20, 15, 17])
    tree.viewTreeBFS()
    print(solution.averageOfLevels(tree.root))
예제 #7
0
    def train(self,
              X_train,
              y_train,
              epochs=10,
              retrain=0,
              batch_size=10,
              loss_update=10):
        cum_loss = 0
        history = {}
        losses = []

        def get_progress(num, den, length):
            """
            simple progress bar
            """
            if num == den - 1:
                return '=' * length
            arrow = int(float(num) / den * length)
            return '=' * (arrow - 1) + '>' + '.' * (20 - arrow)

        for epoch in range(retrain, epochs):
            epoch_loss = 0

            print 'Epoch %d/%d' % (epoch, epochs)

            for i in range(0, len(X_train), batch_size):
                X_batch = X_train[i:i + batch_size]

                if len(X_batch) < batch_size:
                    continue

                if epoch == 0:
                    # initialize training data to trees
                    for j in range(i, i + batch_size):
                        root = Tree(formula=y_train[j])
                        y_train[j] = [
                            self.tar_vocab.sent_to_idx(formula)
                            for formula in root.inorder()
                        ]

                X_batch = torch.tensor(X_batch,
                                       dtype=torch.long,
                                       device=self.device)
                y_batch = y_train[i:i + batch_size]

                loss = self.run_epoch(X_batch, y_batch, batch_size=batch_size)

                cum_loss += loss
                epoch_loss += loss

                progress = get_progress(i, len(X_train), length=20)
                out = '%d/%d [%s] loss: %f' % (i, len(X_train), progress,
                                               epoch_loss / (i + 1))
                sys.stdout.write('{0}\r'.format(out))
                sys.stdout.flush()
            print

            losses.append(epoch_loss)
            if epoch % loss_update == 0:
                self.save('%s_epoch_%d.json' % (self.sess, epoch))
        history['losses'] = losses
        return history
예제 #8
0
    def findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        queue = [root]
        cur_last_node = root
        next_last_node = root
        result = root.val
        while len(queue) != 0:
            cur_node = queue.pop(0)
            if cur_node.right:
                queue.append(cur_node.right)
                next_last_node = cur_node.right
            if cur_node.left:
                queue.append(cur_node.left)
                next_last_node = cur_node.left

            if cur_node is cur_last_node:
                cur_last_node = next_last_node
                result = cur_node.val
        return result


if __name__ == '__main__':
    solution = Solution()
    t1 = Tree([1, 2, 3, 4, None, 5, 6, 7])
    print(solution.findBottomLeftValue(t1.root))
    t2 = Tree([2, 1, 3])
    print(solution.findBottomLeftValue(t2.root))
예제 #9
0
class Solution(object):
    def kthSmallest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        self.unique_set = set()

        def dfs(cur_node):
            if cur_node:
                self.unique_set.add(cur_node.val)
                dfs(cur_node.left)
                dfs(cur_node.right)

        dfs(root)
        return sorted(self.unique_set)[k - 1]


class Solution2(object):
    def kthSmallest(self, root, k):
        pass


from tree_utils import Tree
if __name__ == "__main__":
    solution = Solution()
    tree = [1]
    t = Tree(tree).root
    print(solution.kthSmallest(t, 1))
예제 #10
0
            result.append(max(x.val for x in queue if x.val is not None))
            temp_queue = []
            for node in queue:
                if node.left != None:
                    temp_queue.append(node.left)
                if node.right != None:
                    temp_queue.append(node.right)
            queue = temp_queue
        return result


class Solution2:
    def largestValues(self, root):
        row = [root]
        result = []
        while any(row):
            result.append(max(x.val for x in row))
            # this is not valide, the intereter could not find the definition of node
            # row = [kid for kid in (node.left, node.right) if kid for node in row ]
            row = [
                kid for node in row for kid in (node.left, node.right) if kid
            ]

        return result


if __name__ == "__main__":
    solution = Solution()
    tree = Tree([1, 3, 2, 5, 3, None, 9])
    print(solution.largestValues(tree.root))
예제 #11
0
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        cur_ptr = root
        next_right = root
        cur_right = root
        result = []
        que = [root]
        while que:
            cur_ptr = que.pop(0)
            if cur_ptr.left:
                que.append(cur_ptr.left)
                next_right = cur_ptr.left
            if cur_ptr.right:
                que.append(cur_ptr.right)
                next_right = cur_ptr.right
            if cur_ptr == cur_right:
                result.append(cur_ptr.val)
                cur_right = next_right
        return result


if __name__ == "__main__":
    s = Solution()
    t = [1, 2, 3, None, 5, None, 4]
    root = Tree.genTree(t)
    s.rightSideView(root)