def process(tree_string): """ @param tree_string: a newick string @return: a multi-line string that summarizes the results """ np.set_printoptions(linewidth=200) out = StringIO() # build the newick tree from the string tree = NewickIO.parse(tree_string, FelTree.NewickTree) # get ordered names and ids ordered_ids, ordered_names = get_ordered_ids_and_names(tree) # get the distance matrix with ordered indices including all nodes in the tree nvertices = len(list(tree.preorder())) nleaves = len(list(tree.gen_tips())) id_to_index = dict((myid, i) for i, myid in enumerate(ordered_ids)) D = np.array(tree.get_partial_distance_matrix(ordered_ids)) # define mass vectors m_uniform_unscaled = [1]*nvertices m_degenerate_unscaled = [1]*nleaves + [0]*(nvertices-nleaves) m_uniform = np.array(m_uniform_unscaled, dtype=float) / sum(m_uniform_unscaled) m_degenerate = np.array(m_degenerate_unscaled, dtype=float) / sum(m_degenerate_unscaled) # show some of the distance matrices print >> out, 'ordered names:' print >> out, ordered_names print >> out print >> out, 'embedded points with mass uniformly distributed among all vertices:' print >> out, Euclid.edm_to_weighted_points(D, m_uniform) print >> out print >> out, 'embedded points with mass uniformly distributed among the leaves:' print >> out, Euclid.edm_to_weighted_points(D, m_degenerate) print >> out # return the response return out.getvalue().strip()
def process(tree_string): """ @param tree_string: a newick string @return: a multi-line string that summarizes the results """ np.set_printoptions(linewidth=200) out = StringIO() # build the newick tree from the string tree = NewickIO.parse(tree_string, FelTree.NewickTree) # get ordered names and ids ordered_ids, ordered_names = get_ordered_ids_and_names(tree) # get the distance matrix with ordered indices including all nodes in the tree nvertices = len(list(tree.preorder())) nleaves = len(list(tree.gen_tips())) id_to_index = dict((myid, i) for i, myid in enumerate(ordered_ids)) D = np.array(tree.get_partial_distance_matrix(ordered_ids)) # define mass vectors m_uniform_unscaled = [1] * nvertices m_degenerate_unscaled = [1] * nleaves + [0] * (nvertices - nleaves) m_uniform = np.array(m_uniform_unscaled, dtype=float) / sum(m_uniform_unscaled) m_degenerate = np.array(m_degenerate_unscaled, dtype=float) / sum(m_degenerate_unscaled) # show some of the distance matrices print >> out, 'ordered names:' print >> out, ordered_names print >> out print >> out, 'embedded points with mass uniformly distributed among all vertices:' print >> out, Euclid.edm_to_weighted_points(D, m_uniform) print >> out print >> out, 'embedded points with mass uniformly distributed among the leaves:' print >> out, Euclid.edm_to_weighted_points(D, m_degenerate) print >> out # return the response return out.getvalue().strip()
def get_response_content(fs): # build the newick tree from the string tree = NewickIO.parse(fs.tree_string, FelTree.NewickTree) nvertices = len(list(tree.preorder())) nleaves = len(list(tree.gen_tips())) ninternal = nvertices - nleaves # get ordered ids with the internal nodes first ordered_ids = get_ordered_ids(tree) leaf_ids = [id(node) for node in tree.gen_tips()] # get the distance matrix and the augmented distance matrix D_leaf = np.array(tree.get_partial_distance_matrix(leaf_ids)) D = np.array(tree.get_partial_distance_matrix(ordered_ids)) D_aug = get_augmented_distance(D, nleaves, fs.ndups) # analyze the leaf distance matrix X_leaf = Euclid.edm_to_points(D_leaf) # get the eigendecomposition of the centered augmented distance matrix X_aug = Euclid.edm_to_points(D_aug, nvertices - 1) # explicitly compute the points for the given number of dups using weights m = [1] * ninternal + [1 + fs.ndups] * nleaves m = np.array(m, dtype=float) / sum(m) X_weighted = Euclid.edm_to_weighted_points(D, m) # explicitly compute the points for 10x dups m = [1] * ninternal + [1 + fs.ndups * 10] * nleaves m = np.array(m, dtype=float) / sum(m) X_weighted_10x = Euclid.edm_to_weighted_points(D, m) # explicitly compute the limiting points as the number of dups increases X = Euclid.edm_to_points(D) X -= np.mean(X[-nleaves:], axis=0) XL = X[-nleaves:] U, s, Vt = np.linalg.svd(XL) Z = np.dot(X, Vt.T) # report the results np.set_printoptions(linewidth=300, threshold=10000) out = StringIO() print >> out, 'leaf distance matrix:' print >> out, D_leaf print >> out print >> out, 'points derived from the leaf distance matrix' print >> out, '(the first column is proportional to the Fiedler vector):' print >> out, X_leaf print >> out if fs.show_aug: print >> out, 'augmented distance matrix:' print >> out, D_aug print >> out print >> out, 'points derived from the augmented distance matrix' print >> out, '(the first column is proportional to the Fiedler vector):' print >> out, get_ugly_matrix(X_aug, ninternal, nleaves) print >> out print >> out, 'points computed using masses:' print >> out, X_weighted print >> out print >> out, 'points computed using masses with 10x dups:' print >> out, X_weighted_10x print >> out print >> out, 'limiting points:' print >> out, Z print >> out return out.getvalue()
def get_response_content(fs): # build the newick tree from the string tree = NewickIO.parse(fs.tree_string, FelTree.NewickTree) nvertices = len(list(tree.preorder())) nleaves = len(list(tree.gen_tips())) ninternal = nvertices - nleaves # get ordered ids with the internal nodes first ordered_ids = get_ordered_ids(tree) leaf_ids = [id(node) for node in tree.gen_tips()] # get the distance matrix and the augmented distance matrix D_leaf = np.array(tree.get_partial_distance_matrix(leaf_ids)) D = np.array(tree.get_partial_distance_matrix(ordered_ids)) D_aug = get_augmented_distance(D, nleaves, fs.ndups) # analyze the leaf distance matrix X_leaf = Euclid.edm_to_points(D_leaf) # get the eigendecomposition of the centered augmented distance matrix X_aug = Euclid.edm_to_points(D_aug, nvertices-1) # explicitly compute the points for the given number of dups using weights m = [1]*ninternal + [1+fs.ndups]*nleaves m = np.array(m, dtype=float) / sum(m) X_weighted = Euclid.edm_to_weighted_points(D, m) # explicitly compute the points for 10x dups m = [1]*ninternal + [1+fs.ndups*10]*nleaves m = np.array(m, dtype=float) / sum(m) X_weighted_10x = Euclid.edm_to_weighted_points(D, m) # explicitly compute the limiting points as the number of dups increases X = Euclid.edm_to_points(D) X -= np.mean(X[-nleaves:], axis=0) XL = X[-nleaves:] U, s, Vt = np.linalg.svd(XL) Z = np.dot(X, Vt.T) # report the results np.set_printoptions(linewidth=300, threshold=10000) out = StringIO() print >> out, 'leaf distance matrix:' print >> out, D_leaf print >> out print >> out, 'points derived from the leaf distance matrix' print >> out, '(the first column is proportional to the Fiedler vector):' print >> out, X_leaf print >> out if fs.show_aug: print >> out, 'augmented distance matrix:' print >> out, D_aug print >> out print >> out, 'points derived from the augmented distance matrix' print >> out, '(the first column is proportional to the Fiedler vector):' print >> out, get_ugly_matrix(X_aug, ninternal, nleaves) print >> out print >> out, 'points computed using masses:' print >> out, X_weighted print >> out print >> out, 'points computed using masses with 10x dups:' print >> out, X_weighted_10x print >> out print >> out, 'limiting points:' print >> out, Z print >> out return out.getvalue()
def process(): """ @return: a multi-line string that summarizes the results """ np.set_printoptions(linewidth=200) out = StringIO() # define a degenerate mass vector m_degenerate = np.array([0.25, 0.25, 0.25, 0.25, 0, 0]) # define some distance matrices D_leaves = Euclid.g_D_b D_all = Euclid.g_D_c nvertices = 6 nleaves = 4 # get the projection and the weighted multidimensional scaling X = Euclid.edm_to_points(D_all) Y = Euclid.edm_to_weighted_points(D_all, m_degenerate) D_X = np.array([[np.dot(pb - pa, pb - pa) for pa in X] for pb in X]) D_Y = np.array([[np.dot(pb - pa, pb - pa) for pa in Y] for pb in Y]) # get the embedding using only the leaves print >> out, 'embedding of leaves from the leaf distance matrix:' print >> out, Euclid.edm_to_points(D_leaves) print >> out, 'projection of all vertices onto the MDS space of the leaves:' print >> out, do_projection(D_all, nleaves) print >> out, 'embedding of all vertices using uniform weights:' print >> out, X print >> out, 'corresponding distance matrix:' print >> out, D_X print >> out, 'embedding of all vertices using degenerate weights:' print >> out, Y print >> out, 'corresponding distance matrix:' print >> out, D_Y return out.getvalue().strip()
def process(): """ @return: a multi-line string that summarizes the results """ np.set_printoptions(linewidth=200) out = StringIO() # define a degenerate mass vector m_degenerate = np.array([0.25, 0.25, 0.25, 0.25, 0, 0]) # define some distance matrices D_leaves = Euclid.g_D_b D_all = Euclid.g_D_c nvertices = 6 nleaves = 4 # get the projection and the weighted multidimensional scaling X = Euclid.edm_to_points(D_all) Y = Euclid.edm_to_weighted_points(D_all, m_degenerate) D_X = np.array([[np.dot(pb-pa, pb-pa) for pa in X] for pb in X]) D_Y = np.array([[np.dot(pb-pa, pb-pa) for pa in Y] for pb in Y]) # get the embedding using only the leaves print >> out, 'embedding of leaves from the leaf distance matrix:' print >> out, Euclid.edm_to_points(D_leaves) print >> out, 'projection of all vertices onto the MDS space of the leaves:' print >> out, do_projection(D_all, nleaves) print >> out, 'embedding of all vertices using uniform weights:' print >> out, X print >> out, 'corresponding distance matrix:' print >> out, D_X print >> out, 'embedding of all vertices using degenerate weights:' print >> out, Y print >> out, 'corresponding distance matrix:' print >> out, D_Y return out.getvalue().strip()
def get_canonical_2d_mds(D, m, reference_points): """ This function is about projecting the points. It is like MDS except the reflections across the axes are not arbitrary. Also it only uses the first two axes. @param D: the full distance matrix @param m: the mass vector @param reference_points: a 2D reference projection of vertices of the tree @return: the weighted MDS points as a numpy matrix """ X = Euclid.edm_to_weighted_points(D, m) return reflect_to_reference(X.T[:2].T, reference_points)
def get_canonical_2d_mds(D, m, reference_points): """ This function is about projecting the points. It is like MDS except the reflections across the axes are not arbitrary. Also it only uses the first two axes. @param D: the full distance matrix @param m: the mass vector @param reference_points: a 2D reference projection of vertices of the tree @return: the weighted MDS points as a numpy matrix """ X = Euclid.edm_to_weighted_points(D, m) return reflect_to_reference(X.T[:2].T, reference_points)
def get_canonical_3d_mds(D, m, reference_points): """ This function is about projecting the points. It is like MDS except the reflections across the axes are not arbitrary. Also it only uses the first three axes. @param D: the full distance matrix @param m: the mass vector @param reference_points: a 3D reference projection of vertices of the tree @return: the weighted MDS points as a numpy matrix """ X = Euclid.edm_to_weighted_points(D, m) X_3d = X.T[:3].T sign_vector = MatrixUtil.get_best_reflection(X_3d, reference_points) return X_3d * sign_vector
def get_canonical_3d_mds(D, m, reference_points): """ This function is about projecting the points. It is like MDS except the reflections across the axes are not arbitrary. Also it only uses the first three axes. @param D: the full distance matrix @param m: the mass vector @param reference_points: a 3D reference projection of vertices of the tree @return: the weighted MDS points as a numpy matrix """ X = Euclid.edm_to_weighted_points(D, m) X_3d = X.T[:3].T sign_vector = MatrixUtil.get_best_reflection(X_3d, reference_points) return X_3d * sign_vector
def process(): """ @return: a multi-line string that summarizes the results """ np.set_printoptions(linewidth=200) out = StringIO() # define some distance matrices D_leaves = Euclid.g_D_b D_all = Euclid.g_D_c nvertices = 6 nleaves = 4 # define mass vectors m_degenerate = np.array([0.25, 0.25, 0.25, 0.25, 0, 0]) m_interesting = np.array([.2, .2, .2, .2, .1, .1]) m_uniform = np.ones(nvertices) / float(nvertices) # augment a distance matrix by adding leaflets D_augmented = add_leaflets(D_all, nleaves) # create the projection of points X_projected = do_projection(D_all, nleaves) # show some of the distance matrices print >> out, 'pairwise distances among vertices in the original tree:' print >> out, D_all print >> out, 'pairwise distance matrix augmented with one leaflet per leaf:' print >> out, D_augmented # get the distance matrices corresponding to the cases in the docstring print >> out, 'case 1: embedding of all vertices:' print >> out, Euclid.edm_to_points(D_all) print >> out, 'case 2: embedding of leaves and leaflets from the leaflet-augmented distance matrix:' print >> out, Euclid.edm_to_points(D_augmented) print >> out, 'case 3: projection of all vertices onto the MDS space of the leaves:' print >> out, X_projected # another embedding print >> out, 'embedding of leaves from the leaf distance matrix:' print >> out, Euclid.edm_to_points(D_leaves) # show embeddings of a tree augmented with leaflets print >> out, 'first few coordinates of the original vertices of the embedded tree with lots of leaflets per leaf:' D_super_augmented = D_all.copy() for i in range(20): D_super_augmented = add_leaflets(D_super_augmented, nleaves) X_super = Euclid.edm_to_points(D_super_augmented) X_super_block_small = X_super[:6].T[:3].T print >> out, X_super_block_small print >> out, 'ratio of coordinates of projected points to coordinates of this block of the embedding of the augmented tree:' print >> out, X_projected / X_super_block_small # test Z = Euclid.edm_to_weighted_points(D_all, m_uniform) print >> out, 'generalized case 1:' print >> out, Z # test Z = Euclid.edm_to_weighted_points(D_all, m_interesting) print >> out, 'generalized case 2:' print >> out, Z # test Z = Euclid.edm_to_weighted_points(D_all, m_degenerate) print >> out, 'generalized case 3:' print >> out, Z # test Z = get_weighted_embedding_b(D_all, m_uniform) print >> out, 'eric formula case 1:' print >> out, Z # test Z = get_weighted_embedding_b(D_all, m_interesting) print >> out, 'eric formula case 2:' print >> out, Z # test Z = get_weighted_embedding_b(D_all, m_degenerate) print >> out, 'eric formula case 3:' print >> out, Z # test stuff print >> out, 'testing random stuff:' D = D_all m = m_degenerate nvertices = len(m) sqrtm = np.sqrt(m) M = np.diag(sqrtm) cross_product_matrix = Euclid.edm_to_weighted_cross_product(D, m) U_cross, S_cross, VT_cross = np.linalg.svd(cross_product_matrix, full_matrices=False) Q = np.dot(M, np.dot(cross_product_matrix, M.T)) U, B, VT = np.linalg.svd(Q, full_matrices=False) S = np.sqrt(np.diag(B)) US = np.dot(U, S) M_pinv = np.linalg.pinv(M) M_pinv_narrow = M_pinv.T[:-2].T US_short = US[:-2] print >> out, 'eigenvalues of the abdi cross product:', S_cross print >> out, 'eigenvalues of the eric cross product:', B print >> out, M_pinv print >> out, US print >> out, M_pinv_narrow print >> out, US_short Z = np.dot(M_pinv_narrow, US_short) print >> out, Z # return the response return out.getvalue().strip()