def test_leaf_distn_a(self):
# Read the example tree.
example_tree = '(a:2, (b:1, c:1, d:1, e:1)x:1)y;'
R, B, N = FtreeIO.newick_to_RBN(example_tree)
T = Ftree.R_to_T(R)
r = Ftree.R_to_root(R)
# Get the leaf distribution associated with the root.
internal_to_leaf_distn = get_internal_vertex_to_leaf_distn(T, B)
r_to_leaf_distn = internal_to_leaf_distn[r]
leaves = Ftree.T_to_leaves(T)
observed_name_weight_pairs = [
(N[v], r_to_leaf_distn[v]) for v in leaves]
# Set up the expectation for the test.
n = 5.0
expected_name_weight_pairs = []
expected_first_value = n / (3*n - 2)
expected_non_first_value = 2 / (3*n - 2)
expected_name_weight_pairs.append(('a', expected_first_value))
for name in list('bcde'):
expected_name_weight_pairs.append((name, expected_non_first_value))
# Do the comparison for testing.
expected_d = dict(expected_name_weight_pairs)
observed_d = dict(observed_name_weight_pairs)
for v in leaves:
name = N[v]
expected_value = expected_d[name]
observed_value = observed_d[name]
self.assertTrue(np.allclose(expected_value, observed_value))
def get_response_content(fs):
# define the requested physical size of the images (in pixels)
physical_size = (640, 480)
# get the directed edges and the branch lengths and vertex names
R, B, N = FtreeIO.newick_to_RBN(fs.tree_string)
# get the requested undirected edge
edge = get_edge(R, N, fs.branch_name)
# get the undirected tree topology
T = Ftree.R_to_T(R)
# get the leaves and the vertices of articulation
leaves = Ftree.T_to_leaves(T)
internal = Ftree.T_to_internal_vertices(T)
vertices = leaves + internal
nleaves = len(leaves)
v_to_index = Ftree.invseq(vertices)
# get the requested indices
x_index = fs.x_axis - 1
y_index = fs.y_axis - 1
if x_index >= nleaves - 1 or y_index >= nleaves - 1:
raise ValueError(
'projection indices must be smaller than the number of leaves')
# adjust the branch length
initial_length = B[edge]
t = sigmoid(fs.frame_progress)
B[edge] = (1 - t) * initial_length + t * fs.final_length
# get the points
w, v = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
X_full = np.dot(v, np.diag(np.reciprocal(np.sqrt(w))))
X = np.vstack([X_full[:, x_index], X_full[:, y_index]]).T
# draw the image
ext = Form.g_imageformat_to_ext[fs.imageformat]
return get_animation_frame(ext, physical_size, fs.scale, v_to_index, T, X,
w)
def get_response_content(fs):
# define the requested physical size of the images (in pixels)
physical_size = (640, 480)
# get the directed edges and the branch lengths and vertex names
R, B, N = FtreeIO.newick_to_RBN(fs.tree_string)
# get the requested undirected edge
edge = get_edge(R, N, fs.branch_name)
# get the undirected tree topology
T = Ftree.R_to_T(R)
# get the leaves and the vertices of articulation
leaves = Ftree.T_to_leaves(T)
internal = Ftree.T_to_internal_vertices(T)
vertices = leaves + internal
nleaves = len(leaves)
v_to_index = Ftree.invseq(vertices)
# get the requested indices
x_index = fs.x_axis - 1
y_index = fs.y_axis - 1
if x_index >= nleaves-1 or y_index >= nleaves-1:
raise ValueError(
'projection indices must be smaller than the number of leaves')
# adjust the branch length
initial_length = B[edge]
t = sigmoid(fs.frame_progress)
B[edge] = (1-t)*initial_length + t*fs.final_length
# get the points
w, v = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
X_full = np.dot(v, np.diag(np.reciprocal(np.sqrt(w))))
X = np.vstack([X_full[:,x_index], X_full[:,y_index]]).T
# draw the image
ext = Form.g_imageformat_to_ext[fs.imageformat]
return get_animation_frame(ext, physical_size, fs.scale,
v_to_index, T, X, w)
def main(args):
# do some validation
if args.nframes < 2:
raise ValueError('nframes should be at least 2')
# define the requested physical size of the images (in pixels)
physical_size = (args.physical_width, args.physical_height)
# get the directed edges and the branch lengths and vertex names
R, B, N = FtreeIO.newick_to_RBN(args.tree)
# get the requested undirected edge
edge = get_edge(R, N, args.branch_name)
initial_length = B[edge]
# get the undirected tree topology
T = Ftree.R_to_T(R)
# get the leaves and the vertices of articulation
leaves = Ftree.T_to_leaves(T)
internal = Ftree.T_to_internal_vertices(T)
vertices = leaves + internal
nleaves = len(leaves)
v_to_index = Ftree.invseq(vertices)
# get the requested indices
x_index = args.x_axis - 1
y_index = args.y_axis - 1
if x_index >= nleaves-1 or y_index >= nleaves-1:
raise ValueError(
'projection indices must be smaller than the number of leaves')
X_prev = None
# create the animation frames and write them as image files
pbar = Progress.Bar(args.nframes)
for frame_index in range(args.nframes):
linear_progress = frame_index / float(args.nframes - 1)
if args.interpolation == 'sigmoid':
t = sigmoid(linear_progress)
else:
t = linear_progress
B[edge] = (1-t)*initial_length + t*args.final_length
w, v = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
X_full = np.dot(v, np.diag(np.reciprocal(np.sqrt(w))))
X = np.vstack([X_full[:,x_index], X_full[:,y_index]]).T
if X_prev is not None:
X = reflect_to_match(X, X_prev)
X_prev = X
image_string = get_animation_frame(
args.image_format, physical_size, args.scale,
v_to_index, T, X, w)
image_filename = 'frame-%04d.%s' % (frame_index, args.image_format)
image_pathname = os.path.join(args.output_directory, image_filename)
with open(image_pathname, 'wb') as fout:
fout.write(image_string)
pbar.update(frame_index+1)
pbar.finish()
def main(args):
# do some validation
if args.nframes < 2:
raise ValueError('nframes should be at least 2')
# define the requested physical size of the images (in pixels)
physical_size = (args.physical_width, args.physical_height)
# get the directed edges and the branch lengths and vertex names
R, B, N = FtreeIO.newick_to_RBN(args.tree)
# get the requested undirected edge
edge = get_edge(R, N, args.branch_name)
initial_length = B[edge]
# get the undirected tree topology
T = Ftree.R_to_T(R)
# get the leaves and the vertices of articulation
leaves = Ftree.T_to_leaves(T)
internal = Ftree.T_to_internal_vertices(T)
vertices = leaves + internal
nleaves = len(leaves)
v_to_index = Ftree.invseq(vertices)
# get the requested indices
x_index = args.x_axis - 1
y_index = args.y_axis - 1
if x_index >= nleaves - 1 or y_index >= nleaves - 1:
raise ValueError(
'projection indices must be smaller than the number of leaves')
X_prev = None
# create the animation frames and write them as image files
pbar = Progress.Bar(args.nframes)
for frame_index in range(args.nframes):
linear_progress = frame_index / float(args.nframes - 1)
if args.interpolation == 'sigmoid':
t = sigmoid(linear_progress)
else:
t = linear_progress
B[edge] = (1 - t) * initial_length + t * args.final_length
w, v = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
X_full = np.dot(v, np.diag(np.reciprocal(np.sqrt(w))))
X = np.vstack([X_full[:, x_index], X_full[:, y_index]]).T
if X_prev is not None:
X = reflect_to_match(X, X_prev)
X_prev = X
image_string = get_animation_frame(args.image_format, physical_size,
args.scale, v_to_index, T, X, w)
image_filename = 'frame-%04d.%s' % (frame_index, args.image_format)
image_pathname = os.path.join(args.output_directory, image_filename)
with open(image_pathname, 'wb') as fout:
fout.write(image_string)
pbar.update(frame_index + 1)
pbar.finish()
def test_leaf_distn_schur(self):
# Read the example tree.
example_tree = LeafWeights.g_acl_tree
R, B, N = FtreeIO.newick_to_RBN(example_tree)
T = Ftree.R_to_T(R)
r = Ftree.R_to_root(R)
# Get the leaf distribution associated with the root.
leaf_distn = get_leaf_distn_schur(R, B)
leaves = Ftree.T_to_leaves(T)
observed_name_weight_pairs = [
(N[v], leaf_distn[v]) for v in leaves]
# Do the comparison for testing.
observed_name_to_weight = dict(observed_name_weight_pairs)
for name in LeafWeights.g_acl_ordered_names:
s_expected = LeafWeights.g_acl_expected_weights[name]
s_observed = '%.3f' % observed_name_to_weight[name]
self.assertEqual(s_expected, s_observed)
def get_response_content(fs):
# read the tree
R, B, N = FtreeIO.newick_to_RBN(fs.tree)
r = Ftree.R_to_root(R)
T = Ftree.R_to_T(R)
leaves = Ftree.T_to_leaves(T)
internal_not_r = [v for v in Ftree.T_to_internal_vertices(T) if v is not r]
# define the lists of leaves induced by the root
vertex_partition = sorted(Ftree.R_to_vertex_partition(R))
vertex_lists = [sorted(p) for p in vertex_partition]
leaf_set = set(leaves)
leaf_lists = [sorted(s & leaf_set) for s in vertex_partition]
# order the list of leaves in a nice block form
leaves = [v for lst in leaf_lists for v in lst]
# remove internal vertices by Schur complementation
L_schur_rooted = Ftree.TB_to_L_schur(T, B, leaves + [r])
L_schur_full = Ftree.TB_to_L_schur(T, B, leaves)
# show the matrix
np.set_printoptions(linewidth=132)
out = StringIO()
# show the rooted schur complement
w, v = scipy.linalg.eigh(L_schur_rooted)
print >> out, 'rooted Schur complement:'
print >> out, L_schur_rooted
print >> out, 'Felsenstein weights at the root:'
print >> out, -L_schur_rooted[-1][:-1] / L_schur_rooted[-1, -1]
print >> out, 'rooted Schur complement eigendecomposition:'
print >> out, w
print >> out, v
print >> out
# show the full schur complement
w, v = scipy.linalg.eigh(L_schur_full)
print >> out, 'full Schur complement:'
print >> out, L_schur_full
print >> out, 'full Schur complement eigendecomposition:'
print >> out, w
print >> out, v
print >> out
# analyze perron components
print >> out, 'perron components:'
print >> out
start = 0
for lst in leaf_lists:
n = len(lst)
C = L_schur_rooted[start:start+n, start:start+n]
print >> out, 'C:'
print >> out, C
w_eff = np.sum(C)
b_eff = 1 / w_eff
print >> out, 'effective conductance:'
print >> out, w_eff
print >> out, 'effective branch length (or resistance or variance):'
print >> out, b_eff
S = np.linalg.pinv(C)
print >> out, 'C^-1 (rooted covariance-like):'
print >> out, S
w, v = scipy.linalg.eigh(S)
print >> out, 'rooted covariance-like eigendecomposition:'
print >> out, w
print >> out, v
print >> out, 'perron value:'
print >> out, w[-1]
print >> out, 'reciprocal of perron value:'
print >> out, 1 / w[-1]
print >> out
start += n
print >> out
# analyze subtrees
print >> out, 'subtree Laplacian analysis:'
print >> out
start = 0
for lst in vertex_lists:
n = len(lst)
C = Ftree.TB_to_L_schur(T, B, lst + [r])
w, v = scipy.linalg.eigh(C)
print >> out, 'subtree Laplacian:'
print >> out, C
print >> out, 'eigendecomposition:'
print >> out, w
print >> out, v
print >> out
start += n
# analyze subtrees
print >> out, 'full Schur complement subtree analysis:'
print >> out
start = 0
for lst in leaf_lists:
n = len(lst)
C = Ftree.TB_to_L_schur(T, B, lst + [r])
w, v = scipy.linalg.eigh(C)
print >> out, 'full Schur complement in subtree:'
print >> out, C
print >> out, 'eigendecomposition:'
print >> out, w
print >> out, v
print >> out
start += n
return out.getvalue()
def get_response_content(fs):
# read the tree
R, B, N = FtreeIO.newick_to_RBN(fs.tree)
r = Ftree.R_to_root(R)
T = Ftree.R_to_T(R)
leaves = Ftree.T_to_leaves(T)
internal_not_r = [v for v in Ftree.T_to_internal_vertices(T) if v is not r]
# define the lists of leaves induced by the root
vertex_partition = sorted(Ftree.R_to_vertex_partition(R))
vertex_lists = [sorted(p) for p in vertex_partition]
leaf_set = set(leaves)
leaf_lists = [sorted(s & leaf_set) for s in vertex_partition]
# order the list of leaves in a nice block form
leaves = [v for lst in leaf_lists for v in lst]
# remove internal vertices by Schur complementation
L_schur_rooted = Ftree.TB_to_L_schur(T, B, leaves + [r])
L_schur_full = Ftree.TB_to_L_schur(T, B, leaves)
# show the matrix
np.set_printoptions(linewidth=132)
out = StringIO()
# show the rooted schur complement
w, v = scipy.linalg.eigh(L_schur_rooted)
print >> out, 'rooted Schur complement:'
print >> out, L_schur_rooted
print >> out, 'Felsenstein weights at the root:'
print >> out, -L_schur_rooted[-1][:-1] / L_schur_rooted[-1, -1]
print >> out, 'rooted Schur complement eigendecomposition:'
print >> out, w
print >> out, v
print >> out
# show the full schur complement
w, v = scipy.linalg.eigh(L_schur_full)
print >> out, 'full Schur complement:'
print >> out, L_schur_full
print >> out, 'full Schur complement eigendecomposition:'
print >> out, w
print >> out, v
print >> out
# analyze perron components
print >> out, 'perron components:'
print >> out
start = 0
for lst in leaf_lists:
n = len(lst)
C = L_schur_rooted[start:start + n, start:start + n]
print >> out, 'C:'
print >> out, C
w_eff = np.sum(C)
b_eff = 1 / w_eff
print >> out, 'effective conductance:'
print >> out, w_eff
print >> out, 'effective branch length (or resistance or variance):'
print >> out, b_eff
S = np.linalg.pinv(C)
print >> out, 'C^-1 (rooted covariance-like):'
print >> out, S
w, v = scipy.linalg.eigh(S)
print >> out, 'rooted covariance-like eigendecomposition:'
print >> out, w
print >> out, v
print >> out, 'perron value:'
print >> out, w[-1]
print >> out, 'reciprocal of perron value:'
print >> out, 1 / w[-1]
print >> out
start += n
print >> out
# analyze subtrees
print >> out, 'subtree Laplacian analysis:'
print >> out
start = 0
for lst in vertex_lists:
n = len(lst)
C = Ftree.TB_to_L_schur(T, B, lst + [r])
w, v = scipy.linalg.eigh(C)
print >> out, 'subtree Laplacian:'
print >> out, C
print >> out, 'eigendecomposition:'
print >> out, w
print >> out, v
print >> out
start += n
# analyze subtrees
print >> out, 'full Schur complement subtree analysis:'
print >> out
start = 0
for lst in leaf_lists:
n = len(lst)
C = Ftree.TB_to_L_schur(T, B, lst + [r])
w, v = scipy.linalg.eigh(C)
print >> out, 'full Schur complement in subtree:'
print >> out, C
print >> out, 'eigendecomposition:'
print >> out, w
print >> out, v
print >> out
start += n
return out.getvalue()
