def setup_root_finder(self, cassiopeia_tree: CassiopeiaTree) -> None:
"""Gives the implicit rooting strategy for the SNJ Solver.
By default, the SpectralNeighborJoining algorithm returns an
unrooted tree. To root this tree, an implicit root of all zeros is
added to the character matrix. Then, the dissimilarity map is
recalculated using the updated character matrix. If the tree already
has a computed dissimilarity map, only the new similarities are
calculated. See 'setup_root_finder' in NeighborJoiningSolver.
Args:
cassiopeia_tree: Input CassiopeiaTree to `solve`
"""
character_matrix = cassiopeia_tree.character_matrix.copy()
rooted_character_matrix = character_matrix.copy()
root = [0] * rooted_character_matrix.shape[1]
rooted_character_matrix.loc["root"] = root
cassiopeia_tree.root_sample_name = "root"
cassiopeia_tree.character_matrix = rooted_character_matrix
if self.dissimilarity_function is None:
raise DistanceSolver.DistanceSolverError(
"Please specify a dissimilarity function to add an implicit "
"root, or specify an explicit root"
)
dissimilarity_map = cassiopeia_tree.get_dissimilarity_map()
if dissimilarity_map is None:
cassiopeia_tree.compute_dissimilarity_map(
self.dissimilarity_function, self.prior_transformation
)
else:
dissimilarity = {"root": 0}
for leaf in character_matrix.index:
weights = None
if cassiopeia_tree.priors:
weights = solver_utilities.transform_priors(
cassiopeia_tree.priors, self.prior_transformation
)
dissimilarity[leaf] = self.dissimilarity_function(
rooted_character_matrix.loc["root"].values,
rooted_character_matrix.loc[leaf].values,
cassiopeia_tree.missing_state_indicator,
weights,
)
cassiopeia_tree.set_dissimilarity("root", dissimilarity)
cassiopeia_tree.character_matrix = character_matrix
def solve(
self,
cassiopeia_tree: CassiopeiaTree,
layer: Optional[str] = None,
collapse_mutationless_edges: bool = False,
logfile: str = "stdout.log",
) -> None:
"""Solves a tree for a general bottom-up distance-based solver routine.
The general solver routine proceeds by iteratively finding pairs of
samples to join together into a "cherry" and then reform the
dissimilarity matrix with respect to this new cherry. The implementation
of how to find cherries and update the dissimilarity map is left to
subclasses of DistanceSolver. The function will update the `tree`
attribute of the input CassiopeiaTree.
Args:
cassiopeia_tree: CassiopeiaTree object to be populated
layer: Layer storing the character matrix for solving. If None, the
default character matrix is used in the CassiopeiaTree.
collapse_mutationless_edges: Indicates if the final reconstructed
tree should collapse mutationless edges based on internal states
inferred by Camin-Sokal parsimony. In scoring accuracy, this
removes artifacts caused by arbitrarily resolving polytomies.
logfile: File location to log output. Not currently used.
"""
node_name_generator = solver_utilities.node_name_generator()
dissimilarity_map = self.get_dissimilarity_map(cassiopeia_tree, layer)
N = dissimilarity_map.shape[0]
# instantiate a dissimilarity map that can be updated as we join
# together nodes.
_dissimilarity_map = dissimilarity_map.copy()
# instantiate a tree where all samples appear as leaves.
tree = nx.Graph()
tree.add_nodes_from(_dissimilarity_map.index)
while N > 2:
i, j = self.find_cherry(_dissimilarity_map.to_numpy())
# get indices in the dissimilarity matrix to join
node_i, node_j = (
_dissimilarity_map.index[i],
_dissimilarity_map.index[j],
)
new_node_name = next(node_name_generator)
tree.add_node(new_node_name)
tree.add_edges_from([(new_node_name, node_i),
(new_node_name, node_j)])
_dissimilarity_map = self.update_dissimilarity_map(
_dissimilarity_map, (node_i, node_j), new_node_name)
N = _dissimilarity_map.shape[0]
tree = self.root_tree(
tree,
cassiopeia_tree.root_sample_name,
_dissimilarity_map.index.values,
)
# remove root from character matrix before populating tree
if (cassiopeia_tree.root_sample_name
in cassiopeia_tree.character_matrix.index):
cassiopeia_tree.character_matrix = (
cassiopeia_tree.character_matrix.drop(
index=cassiopeia_tree.root_sample_name))
cassiopeia_tree.populate_tree(tree, layer=layer)
cassiopeia_tree.collapse_unifurcations()
# collapse mutationless edges
if collapse_mutationless_edges:
cassiopeia_tree.collapse_mutationless_edges(
infer_ancestral_characters=True)