def create_tree_parsimony_impl(msa):
calculator = DistanceCalculator('identity')
constructor = DistanceTreeConstructor(distance_calculator=calculator, method='nj')
starting_tree = constructor.build_tree(msa)
scorer = ParsimonyScorer()
searcher = NNITreeSearcher(scorer)
constructor = ParsimonyTreeConstructor(searcher=searcher,starting_tree=starting_tree)
tree = constructor.build_tree(msa)
Phylo.write(tree, "../../data/created/tree" + str(random.randint(0,10000000)) + ".nex", "nexus")
Phylo.draw(tree,do_show=False)
plt.savefig("../../data/created/createdTree_parsimony.png")
return "../../data/created/createdTree_parsimony.png"
def consensus(msa):
alignment = MultipleSeqAlignment(msa)
calculator = DistanceCalculator('identity')
dm = calculator.get_distance(alignment)
constructor = DistanceTreeConstructor(calculator, 'nj')
tree = constructor.build_tree(alignment)
print tree
class DistanceTreeConstructorTest(unittest.TestCase):
"""Test DistanceTreeConstructor"""
def setUp(self):
self.aln = AlignIO.read(open('TreeConstruction/msa.phy'), 'phylip')
calculator = DistanceCalculator('blosum62')
self.dm = calculator.get_distance(self.aln)
self.constructor = DistanceTreeConstructor(calculator)
def test_upgma(self):
tree = self.constructor.upgma(self.dm)
self.assertTrue(isinstance(tree, BaseTree.Tree))
tree_file = StringIO.StringIO()
Phylo.write(tree, tree_file, 'newick')
ref_tree = open('./TreeConstruction/upgma.tre')
self.assertEqual(tree_file.getvalue(), ref_tree.readline())
ref_tree.close()
def test_nj(self):
tree = self.constructor.nj(self.dm)
self.assertTrue(isinstance(tree, BaseTree.Tree))
tree_file = StringIO.StringIO()
Phylo.write(tree, tree_file, 'newick')
ref_tree = open('./TreeConstruction/nj.tre')
self.assertEqual(tree_file.getvalue(), ref_tree.readline())
ref_tree.close()
def test_built_tree(self):
tree = self.constructor.build_tree(self.aln)
self.assertTrue(isinstance(tree, BaseTree.Tree))
tree_file = StringIO.StringIO()
Phylo.write(tree, tree_file, 'newick')
ref_tree = open('./TreeConstruction/nj.tre')
self.assertEqual(tree_file.getvalue(), ref_tree.readline())
ref_tree.close()
class DistanceTreeConstructorTest(unittest.TestCase):
"""Test DistanceTreeConstructor"""
def setUp(self):
self.aln = AlignIO.read('TreeConstruction/msa.phy', 'phylip')
calculator = DistanceCalculator('blosum62')
self.dm = calculator.get_distance(self.aln)
self.constructor = DistanceTreeConstructor(calculator)
def test_upgma(self):
tree = self.constructor.upgma(self.dm)
self.assertTrue(isinstance(tree, BaseTree.Tree))
# tree_file = StringIO()
# Phylo.write(tree, tree_file, 'newick')
ref_tree = Phylo.read('./TreeConstruction/upgma.tre', 'newick')
self.assertTrue(Consensus._equal_topology(tree, ref_tree))
# ref_tree.close()
def test_nj(self):
tree = self.constructor.nj(self.dm)
self.assertTrue(isinstance(tree, BaseTree.Tree))
# tree_file = StringIO()
# Phylo.write(tree, tree_file, 'newick')
ref_tree = Phylo.read('./TreeConstruction/nj.tre', 'newick')
self.assertTrue(Consensus._equal_topology(tree, ref_tree))
# ref_tree.close()
def test_built_tree(self):
tree = self.constructor.build_tree(self.aln)
self.assertTrue(isinstance(tree, BaseTree.Tree))
# tree_file = StringIO()
# Phylo.write(tree, tree_file, 'newick')
ref_tree = Phylo.read('./TreeConstruction/nj.tre', 'newick')
self.assertTrue(Consensus._equal_topology(tree, ref_tree))
class DistanceTreeConstructorTest(unittest.TestCase):
"""Test DistanceTreeConstructor"""
def setUp(self):
self.aln = AlignIO.read('TreeConstruction/msa.phy', 'phylip')
calculator = DistanceCalculator('blosum62')
self.dm = calculator.get_distance(self.aln)
self.constructor = DistanceTreeConstructor(calculator)
def test_upgma(self):
tree = self.constructor.upgma(self.dm)
self.assertTrue(isinstance(tree, BaseTree.Tree))
# tree_file = StringIO()
# Phylo.write(tree, tree_file, 'newick')
ref_tree = Phylo.read('./TreeConstruction/upgma.tre', 'newick')
self.assertTrue(Consensus._equal_topology(tree, ref_tree))
# ref_tree.close()
def test_nj(self):
tree = self.constructor.nj(self.dm)
self.assertTrue(isinstance(tree, BaseTree.Tree))
# tree_file = StringIO()
# Phylo.write(tree, tree_file, 'newick')
ref_tree = Phylo.read('./TreeConstruction/nj.tre', 'newick')
self.assertTrue(Consensus._equal_topology(tree, ref_tree))
# ref_tree.close()
def test_built_tree(self):
tree = self.constructor.build_tree(self.aln)
self.assertTrue(isinstance(tree, BaseTree.Tree))
# tree_file = StringIO()
# Phylo.write(tree, tree_file, 'newick')
ref_tree = Phylo.read('./TreeConstruction/nj.tre', 'newick')
self.assertTrue(Consensus._equal_topology(tree, ref_tree))
def consensus(msa):
alignment = MultipleSeqAlignment(msa)
calculator = DistanceCalculator('identity')
dm = calculator.get_distance(alignment)
constructor = DistanceTreeConstructor(calculator, 'nj')
tree = constructor.build_tree(alignment)
print tree
def fastaToNJTree(fastaFile, outputFile):
aln = AlignIO.read(fastaFile, 'fasta')
calculator = DistanceCalculator('identity')
dm = calculator.get_distance(aln)
constructor = DistanceTreeConstructor(calculator, 'nj')
tree = constructor.build_tree(aln)
Phylo.write(tree, outputFile, 'newick')
def main():
alignment = AlignIO.read(open("protein.fasta"), "fasta")
calculator = DistanceCalculator('identity')
dm = calculator.get_distance(alignment)
constructor = DistanceTreeConstructor(calculator, 'upgma')
tree = constructor.build_tree(alignment)
tree.ladderize()
Phylo.draw(tree)
def create_tree_distance_impl(msa, algorithm):
calculator = DistanceCalculator('identity')
constructor = DistanceTreeConstructor(distance_calculator=calculator,method=algorithm)
tree = constructor.build_tree(msa)
Phylo.write(tree, "../../data/created/tree" + str(random.randint(0,10000000)) + ".nex", "nexus")
Phylo.draw(tree,do_show=False)
plt.savefig("../../data/created/createdTree"+algorithm+".png")
return "../../data/created/createdTree"+algorithm+".png"
def tree(self):
"""Returns a phylogenetic tree constructed from the given alignment."""
calculator = DistanceCalculator(self._distance_model)
constructor = DistanceTreeConstructor(calculator, self._tree_algorithm)
tree = constructor.build_tree(self.alignment)
# Make the tree rooted.
tree.root_at_midpoint()
tree.root.name = 'Root'
return tree
def build_phylogenetic_tree(seqs):
calculator = DistanceCalculator(DISTANCE_TYPE)
# Print distance matrix for testing
# distance_matrix = calculator.get_distance(seqs)
constructor = DistanceTreeConstructor(calculator,
TREE_CONSTRUCTION_ALGORITHM)
tree = constructor.build_tree(seqs)
return tree
def NJ_tree(infile, file_type):
#Tree creation with neighbor-joining
filename = "static/data/sauvegardes/" + dirName + infile
aln = AlignIO.read(filename, file_type) #clustal si alignement clustal, fasta si alignement fasta
calculator = DistanceCalculator('identity')
constructor = DistanceTreeConstructor(calculator, 'nj') # nj ou UPGMA
tree = constructor.build_tree(aln)
tree.ladderize()
Phylo.draw(tree, do_show=False)
Phylo.write(tree, 'static/data/sauvegardes/' + dirName + 'tree.txt', "newick")
foo = current_path + "/static/data/sauvegardes/" + dirName + 'tree.png'
plt.savefig(foo)
def blosumnj(filename):
aln = AlignIO.read(open(filename), 'fasta')
print(aln)
calculator = DistanceCalculator('blosum62')
dm = calculator.get_distance(aln)
print(dm)
from Bio.Phylo.TreeConstruction import DistanceTreeConstructor
constructor = DistanceTreeConstructor(calculator, 'nj')
tree = constructor.build_tree(aln)
print(tree)
def tree(aln_item):
aln = [item.data(35) for item in aln_item]
for path in aln:
handle = open(path)
alignment = AlignIO.read(handle, "clustal")
calculator = DistanceCalculator(
'identity') # Se calculan las distancias
dm = calculator.get_distance(alignment) # Se obtienen las distancias
constructor = DistanceTreeConstructor(calculator)
upgma_tree = constructor.build_tree(
alignment) # Se construye el arbol filogenetico
Phylo.draw(upgma_tree) # Grafico del arbol filogenetico
def __init__(self, proteina=""):
self.proteina = proteina
#if proteina != "":
with open("./arbol.aln", "r") as aln:
alignment = AlignIO.read(aln, "clustal")
calculator = DistanceCalculator('identity')
dm = calculator.get_distance(alignment)
#print(dm)
constructor = DistanceTreeConstructor(calculator)
upgma_tree = constructor.build_tree(alignment)
Phylo.draw(upgma_tree)
def createFasta(inputList):
file = open("phylogenetics.fasta", 'w')
for s in range(100):
s = inputList[s]
file.write(">" + s.name + '\n')
file.write(s.dnaGenome + '\n')
file.close()
aln = AlignIO.read('phylogenetics.fasta', 'fasta')
#print(aln)
calculator = DistanceCalculator('identity')
dm = calculator.get_distance(aln)
#print(dm)
constructor = DistanceTreeConstructor(calculator, 'nj')
tree = constructor.build_tree(aln)
drawing = Phylo.draw_ascii(tree)
return drawing
class DistanceTreeConstructorTest(unittest.TestCase):
"""Test DistanceTreeConstructor."""
def setUp(self):
self.aln = AlignIO.read("TreeConstruction/msa.phy", "phylip")
calculator = DistanceCalculator("blosum62")
self.dm = calculator.get_distance(self.aln)
self.constructor = DistanceTreeConstructor(calculator)
def test_upgma(self):
tree = self.constructor.upgma(self.dm)
self.assertIsInstance(tree, BaseTree.Tree)
# tree_file = StringIO()
# Phylo.write(tree, tree_file, 'newick')
ref_tree = Phylo.read("./TreeConstruction/upgma.tre", "newick")
self.assertTrue(Consensus._equal_topology(tree, ref_tree))
# ref_tree.close()
def test_nj(self):
tree = self.constructor.nj(self.dm)
self.assertIsInstance(tree, BaseTree.Tree)
# tree_file = StringIO()
# Phylo.write(tree, tree_file, 'newick')
ref_tree = Phylo.read("./TreeConstruction/nj.tre", "newick")
self.assertTrue(Consensus._equal_topology(tree, ref_tree))
# ref_tree.close()
# create a matrix of length 2
calculator = DistanceCalculator("blosum62")
self.min_dm = calculator.get_distance(self.aln)
for i in range(len(self.min_dm) - 2):
del self.min_dm[len(self.min_dm) - 1]
min_tree = self.constructor.nj(self.min_dm)
self.assertIsInstance(min_tree, BaseTree.Tree)
ref_min_tree = Phylo.read("./TreeConstruction/nj_min.tre", "newick")
self.assertTrue(Consensus._equal_topology(min_tree, ref_min_tree))
def test_built_tree(self):
tree = self.constructor.build_tree(self.aln)
self.assertIsInstance(tree, BaseTree.Tree)
# tree_file = StringIO()
# Phylo.write(tree, tree_file, 'newick')
ref_tree = Phylo.read("./TreeConstruction/nj.tre", "newick")
self.assertTrue(Consensus._equal_topology(tree, ref_tree))
def makePhyloTree(alignedfile, outfile, matrixfile):
with open(alignedfile,'r') as a:
align = AlignIO.read(a,'clustal')
print(type(align))
calculator = DistanceCalculator('identity')
dist_matrix = calculator.get_distance(align)
c = DistanceTreeConstructor(calculator)
print(dist_matrix)
f = open(matrixfile, "w")
f.write(str(dist_matrix))
f.close()
phylotree = c.build_tree(align)
phylotree.rooted = True
#print(phylotree)
Phylo.write(phylotree, outfile, "phyloxml")
a.close()
return phylotree
def dendroNJ(inFile, model='identity', bootstrap=True, replicate=100):
"""
Given an alingment in fasta format, the function returns a Neighbor Joining tree in newick format.
Module required:
- AlignIO (from Bio)
- DistanceCalculator (from Bio.Phylo.TreeConstruction)
- DistanceTreeConstructor (from Bio.Phylo.TreeConstruction)
- bootstrap_consensus (from Bio.Phylo.Consensus)
Usage: <inFile> <model (default = 'identity')> <bootstrap (default = True)>
<replicate (default = 100)>
"""
aln = AlignIO.read(inFile, 'fasta') # read the alignment
constructor = DistanceTreeConstructor(DistanceCalculator(model), 'nj')
if bootstrap:
tree = bootstrap_consensus(aln, int(replicate), constructor, majority_consensus)
else:
tree = constructor.build_tree(aln)
return tree.format('newick')
def generate(self):
FileOutput = open("./output.txt",'w')
for i in range(self.listaB.lista.count()):
itemList = self.listaB.lista.item(i).text().split('/')
FileOutput.write("./FASTAS/{}/{}".format(itemList[0],itemList[1]))
FileOutput.close()
# Generar todo el fasta a alinear.
with open('./output.txt') as f:
for line in f:
path = line.strip('\n').replace(" ","\\ ")
os.system('cat '+path+' >> all.fasta')
#
#MuscleCommandline
os.system('muscle -in all.fasta -clwout tree.aln ')
with open("./tree.aln", "r") as aln:
algn = AlignIO.read(aln,"clustal")
calculator = DistanceCalculator('identity')
dm = calculator.get_distance(algn)
constructor = DistanceTreeConstructor(calculator)
upgma_tree = constructor.build_tree(algn)
Phylo.draw(upgma_tree)
from Bio import AlignIO
pocketAlignment = AlignIO.read(open(pocketAlignmentFile), "fasta")
print("Calculating Distance Matrix")
for substMat in substMatrices:
try:
alnFile = pocketAlignmentFile.split("/")[-1]
fname = "autotree/" + substMat + "_" + alnFile + ".pxml"
print(fname)
if (os.path.exists(fname)):
tree = Phylo.read(fname, "phyloxml")
else:
calculator = DistanceCalculator(substMat)
dm = calculator.get_distance(pocketAlignment)
print("Building tree")
constructor = DistanceTreeConstructor(calculator, 'nj')
tree = constructor.build_tree(pocketAlignment)
Phylo.write(tree, fname, "phyloxml")
evaluateTree(tree, substMat)
except Exception as err:
print("Error for ", substMat)
print(err)
pass
else:
print("Reading tree")
tree = Phylo.read(treeFile, "newick")
evaluateTree(tree)
#peters-macbook-pro:alignments peter$ python 04_printEnrichment.py trees/2xb7_manning_blossum90_manning.fasta 35 70 data/hms_lincs/activities/hms_20052.csv "% Control" trees/2xb7_manning_blossum90_manning.nwk
#print(type(alignment))
# Open the distance calculator and create a distance matrix
from Bio.Phylo.TreeConstruction import DistanceCalculator
calculator = DistanceCalculator('identity')
distance_matrix = calculator.get_distance(alignment)
#print(distance_matrix)
# Open the tree constructor and build a tree
from Bio.Phylo.TreeConstruction import DistanceTreeConstructor
constructor = DistanceTreeConstructor(calculator)
shark_tree = constructor.build_tree(alignment)
shark_tree.rooted = True
#print(shark_tree)
Phylo.write(shark_tree, "shark_tree.xml", "phyloxml")
# Create the tree figure
Phylo.draw_ascii(shark_tree)
fig = plt.figure(figsize=(13, 5), dpi=100) # create figure & set the size
matplotlib.rc('font', size=12) # fontsize of the leaf and node labels
matplotlib.rc('xtick', labelsize=10) # fontsize of the tick labels
matplotlib.rc('ytick', labelsize=10) # fontsize of the tick labels
#turtle_tree.ladderize() # optional: re-order the tree
axes = fig.add_subplot(1, 1, 1)
Phylo.draw(shark_tree, axes=axes)
input_handle.close()
output_handle.close()
# convert the clustalW format to phylip for the program
from Bio import AlignIO
AlignIO.convert("BRCA2_family_fixed.fasta", "fasta", "BRCA2_family.phy", "phylip")
# Read the sequences and align
aln = AlignIO.read('BRCA2_family.phy', 'phylip')
# create a starting tree with NJ
calculator = DistanceCalculator('identity')
dm = calculator.get_distance(aln)
constructor = DistanceTreeConstructor(calculator, 'nj')
starting_tree = constructor.build_tree(aln)
# A substitution cost matrix, used from in-lecture excise (penalty of 2 for transversion and gap, penalty of 1 for
# # transition)
cost_matrix = [[0],
[2,0],
[1,2,0],
[2,1,2,0],
[2,2,2,2,0]]
# weighted cost matrix corresponds to
weight = DistanceMatrix(names=['A', 'C', 'G', 'T','-'], matrix=cost_matrix)
# ParsimonyScorer will use the Sankoff Algorithm when provided with a matrix argument
scorer = ParsimonyScorer(matrix=weight)
infile = ''.join(name.split(".")[:-1]) + 'infile.txt'
fn = ''.join(name.split(".")[:-1]) + 'phylo.txt'
write_leaves_to_charmat(target_nodes_original_network_uniq, fn)
os.system("python2 /home/mattjones/projects/scLineages/SingleCellLineageTracing/scripts/binarize_multistate_charmat.py " + fn + " " + infile)
aln = AlignIO.read(infile, "phylip")
aln = unique_alignments(aln)
calculator = DistanceCalculator('identity', skip_letters='?')
constructor = DistanceTreeConstructor(calculator, 'nj')
t0 = time.time()
tree = constructor.build_tree(aln)
t1 = time.time()
out = stem + "_nj.txt"
print(out)
Phylo.write(tree, out, 'newick')
nj_net = newick_to_network(out)
#newick = convert_network_to_newick_format(nj_net)
#with open(out, "w") as f:
# f.write(newick)
# old code for using Phylo to parse newick files to networkx objects
#nj_net = Phylo.to_networkx(tree)
def main():
"""
Takes in a character matrix, an algorithm, and an output file and
returns a tree in newick format.
"""
parser = argparse.ArgumentParser()
parser.add_argument("netfp", type=str, help="character_matrix")
parser.add_argument("-nj",
"--neighbor-joining",
action="store_true",
default=False)
parser.add_argument("--neighbor_joining_weighted",
action="store_true",
default=False)
parser.add_argument("--ilp", action="store_true", default=False)
parser.add_argument("--hybrid", action="store_true", default=False)
parser.add_argument("--cutoff",
type=int,
default=80,
help="Cutoff for ILP during Hybrid algorithm")
parser.add_argument(
"--hybrid_lca_mode",
action="store_true",
help=
"Use LCA distances to transition in hybrid mode, instead of number of cells",
)
parser.add_argument("--time_limit",
type=int,
default=-1,
help="Time limit for ILP convergence")
parser.add_argument(
"--iter_limit",
type=int,
default=-1,
help="Max number of iterations for ILP solver",
)
parser.add_argument("--greedy", "-g", action="store_true", default=False)
parser.add_argument("--camin-sokal",
"-cs",
action="store_true",
default=False)
parser.add_argument("--verbose",
action="store_true",
default=False,
help="output verbosity")
parser.add_argument("--mutation_map", type=str, default="")
parser.add_argument("--num_threads", type=int, default=1)
parser.add_argument("--no_triplets", action="store_true", default=False)
parser.add_argument("--max_neighborhood_size", type=str, default=3000)
parser.add_argument("--out_fp",
type=str,
default=None,
help="optional output file")
parser.add_argument("--seed",
type=int,
default=None,
help="Random seed for ILP solver")
args = parser.parse_args()
netfp = args.netfp
outfp = args.out_fp
verbose = args.verbose
lca_mode = args.hybrid_lca_mode
if lca_mode:
lca_cutoff = args.cutoff
cell_cutoff = None
else:
cell_cutoff = args.cutoff
lca_cutoff = None
time_limit = args.time_limit
iter_limit = args.iter_limit
num_threads = args.num_threads
max_neighborhood_size = args.max_neighborhood_size
seed = args.seed
if seed is not None:
random.seed(seed)
np.random.seed(seed)
score_triplets = not args.no_triplets
prior_probs = None
if args.mutation_map != "":
prior_probs = pic.load(open(args.mutation_map, "rb"))
name = netfp.split("/")[-1]
stem = ".".join(name.split(".")[:-1])
true_network = nx.read_gpickle(netfp)
if isinstance(true_network, Cassiopeia_Tree):
true_network = true_network.get_network()
target_nodes = get_leaves_of_tree(true_network)
target_nodes_uniq = []
seen_charstrings = []
for t in target_nodes:
if t.char_string not in seen_charstrings:
seen_charstrings.append(t.char_string)
target_nodes_uniq.append(t)
if args.greedy:
if verbose:
print("Running Greedy Algorithm on " +
str(len(target_nodes_uniq)) + " Cells")
reconstructed_network_greedy = solve_lineage_instance(
target_nodes_uniq,
method="greedy",
prior_probabilities=prior_probs)
net = reconstructed_network_greedy[0]
if outfp is None:
outfp = name.replace("true", "greedy")
pic.dump(net, open(outfp, "wb"))
elif args.hybrid:
if verbose:
print("Running Hybrid Algorithm on " +
str(len(target_nodes_uniq)) + " Cells")
print("Parameters: ILP on sets of " + str(cutoff) + " cells " +
str(time_limit) + "s to complete optimization")
reconstructed_network_hybrid = solve_lineage_instance(
target_nodes_uniq,
method="hybrid",
hybrid_cell_cutoff=cell_cutoff,
hybrid_lca_cutoff=lca_cutoff,
prior_probabilities=prior_probs,
time_limit=time_limit,
threads=num_threads,
max_neighborhood_size=max_neighborhood_size,
seed=seed,
num_iter=iter_limit,
)
net = reconstructed_network_hybrid[0]
if outfp is None:
outfp = name.replace("true", "hybrid")
pic.dump(net, open(outfp, "wb"))
elif args.ilp:
if verbose:
print("Running Hybrid Algorithm on " +
str(len(target_nodes_uniq)) + " Cells")
print("Parameters: ILP on sets of " + str(cutoff) + " cells " +
str(time_limit) + "s to complete optimization")
reconstructed_network_ilp = solve_lineage_instance(
target_nodes_uniq,
method="ilp",
hybrid_subset_cutoff=cutoff,
prior_probabilities=prior_probs,
time_limit=time_limit,
max_neighborhood_size=max_neighborhood_size,
seed=seed,
num_iter=iter_limit,
)
net = reconstructed_network_ilp[0]
# reconstructed_network_ilp = nx.relabel_nodes(reconstructed_network_ilp, string_to_sample)
if outfp is None:
outfp = name.replace("true", "ilp")
pic.dump(net, open(outfp, "wb"))
elif args.neighbor_joining:
if verbose:
print("Running Neighbor-Joining on " +
str(len(target_nodes_uniq)) + " Unique Cells")
infile = "".join(name.split(".")[:-1]) + "infile.txt"
fn = "".join(name.split(".")[:-1]) + "phylo.txt"
write_leaves_to_charmat(target_nodes_uniq, fn)
script = SCLT_PATH / "TreeSolver" / "binarize_multistate_charmat.py"
cmd = "python3.6 " + str(
script) + " " + fn + " " + infile + " --relaxed"
p = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(p.pid, 0)
aln = AlignIO.read(infile, "phylip-relaxed")
aln = unique_alignments(aln)
t0 = time.time()
calculator = DistanceCalculator("identity", skip_letters="?")
constructor = DistanceTreeConstructor(calculator, "nj")
tree = constructor.build_tree(aln)
tree.root_at_midpoint()
nj_net = Phylo.to_networkx(tree)
# convert labels to characters for writing to file
i = 0
rndict = {}
for n in nj_net:
if n.name is None:
rndict[n] = Node("state-node", [])
# n.name = "internal" + str(i)
# i += 1
else:
rndict[n] = Node(n.name, [])
nj_net = nx.relabel_nodes(nj_net, rndict)
# convert labels to strings, not Bio.Phylo.Clade objects
# c2str = map(lambda x: x.name, list(nj_net.nodes()))
# c2strdict = dict(zip(list(nj_net.nodes()), c2str))
# nj_net = nx.relabel_nodes(nj_net, c2strdict)
cm = pd.read_csv(fn, sep="\t", index_col=0)
cm_lookup = dict(
zip(
list(
cm.apply(lambda x: "|".join([str(k) for k in x.values]),
axis=1)),
cm.index.values,
))
nj_net = fill_in_tree(nj_net, cm)
nj_net = tree_collapse(nj_net)
for n in nj_net:
if n.char_string in cm_lookup.keys():
n.is_target = True
nj_net = Cassiopeia_Tree("neighbor-joining", network=nj_net)
if outfp is None:
outfp = name.replace("true", "nj")
pic.dump(nj_net, open(outfp, "wb"))
# Phylo.write(tree, out, 'newick')
os.system("rm " + infile)
os.system("rm " + fn)
elif args.neighbor_joining_weighted:
if verbose:
print("Running Neighbor-Joining with Weighted Scoring on " +
str(len(target_nodes_uniq)) + " Unique Cells")
target_node_charstrings = np.array(
[t.get_character_vec() for t in target_nodes_uniq])
dm = compute_distance_mat(target_node_charstrings,
len(target_node_charstrings),
priors=prior_probs)
ids = [t.name for t in target_nodes_uniq]
cm_uniq = pd.DataFrame(target_node_charstrings)
cm_uniq.index = ids
dm = sp.spatial.distance.squareform(dm)
dm = DistanceMatrix(dm, ids)
newick_str = nj(dm, result_constructor=str)
tree = newick_to_network(newick_str, cm_uniq)
nj_net = fill_in_tree(tree, cm_uniq)
nj_net = tree_collapse(nj_net)
cm_lookup = dict(
zip(
list(
cm_uniq.apply(
lambda x: "|".join([str(k) for k in x.values]),
axis=1)),
cm_uniq.index.values,
))
rdict = {}
for n in nj_net:
if n.char_string in cm_lookup:
n.is_target = True
else:
n.is_target = False
nj_net = Cassiopeia_Tree("neighbor-joining", network=nj_net)
if outfp is None:
outfp = name.replace("true", "nj_weighted")
pic.dump(nj_net, open(outfp, "wb"))
elif args.camin_sokal:
if verbose:
print("Running Camin-Sokal Max Parsimony Algorithm on " +
str(len(target_nodes_uniq)) + " Unique Cells")
samples_to_cells = {}
indices = []
for i, n in zip(range(len(target_nodes_uniq)), target_nodes_uniq):
samples_to_cells["s" + str(i)] = n.name
indices.append(n.name)
n.name = str(i)
infile = "".join(name.split(".")[:-1]) + "_cs_infile.txt"
fn = "".join(name.split(".")[:-1]) + "_cs_phylo.txt"
weights_fn = "".join(name.split(".")[:-1]) + "_cs_weights.txt"
write_leaves_to_charmat(target_nodes_uniq, fn)
script = SCLT_PATH / "TreeSolver" / "binarize_multistate_charmat.py"
cmd = "python3.6 " + str(script) + " " + fn + " " + infile
pi = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(pi.pid, 0)
weights = construct_weights(infile, weights_fn)
os.system("touch outfile")
os.system("touch outtree")
outfile = stem + "outfile.txt"
outtree = stem + "outtree.txt"
# run phylip mix with camin-sokal
responses = "." + stem + ".temp.txt"
FH = open(responses, "w")
current_dir = os.getcwd()
FH.write(infile + "\n")
FH.write("F\n" + outfile + "\n")
FH.write("P\n")
FH.write("W\n")
FH.write("Y\n")
FH.write(weights_fn + "\n")
FH.write("F\n" + outtree + "\n")
FH.close()
t0 = time.time()
cmd = "~/software/phylip-3.697/exe/mix"
cmd += " < " + responses + " > screenout1"
p = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(p.pid, 0)
consense_outtree = stem + "consenseouttree.txt"
consense_outfile = stem + "consenseoutfile.txt"
FH = open(responses, "w")
FH.write(outtree + "\n")
FH.write("F\n" + consense_outfile + "\n")
FH.write("Y\n")
FH.write("F\n" + consense_outtree + "\n")
FH.close()
if verbose:
print("Computing Consensus Tree, elasped time: " +
str(time.time() - t0))
cmd = "~/software/phylip-3.697/exe/consense"
cmd += " < " + responses + " > screenout"
p2 = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(p2.pid, 0)
newick_str = ""
with open(consense_outtree, "r") as f:
for l in f:
l = l.strip()
newick_str += l
cm = pd.read_csv(fn, sep="\t", index_col=0, dtype=str)
cm.index = indices
cs_net = newick_to_network(newick_str, cm)
for n in cs_net:
if n.name in samples_to_cells:
n.name = samples_to_cells[n.name]
cs_net = fill_in_tree(cs_net, cm)
cs_net = tree_collapse2(cs_net)
cm_lookup = dict(
zip(
list(
cm.apply(lambda x: "|".join([str(k) for k in x.values]),
axis=1)),
cm.index.values,
))
for n in cs_net:
if n.char_string in cm_lookup.keys():
n.is_target = True
cs_net = Cassiopeia_Tree("camin-sokal", network=cs_net)
if outfp is None:
outfp = name.replace("true", "cs")
pic.dump(cs_net, open(outfp, "wb"))
os.system("rm " + outfile)
os.system("rm " + responses)
os.system("rm " + outtree)
os.system("rm " + consense_outfile)
os.system("rm " + infile)
os.system("rm " + fn)
else:
raise Exception(
"Please choose an algorithm from the list: greedy, hybrid, ilp, nj, or camin-sokal"
)
# CAGTTCGCCACAA Gamma
# Several thigns can be done witht he alignment: get a distance matrix from it:
dstcalc = DistanceCalculator('identity')
dm = dstcalc.get_distance(aln)
# DistanceMatrix(names=['Alpha', 'Beta', 'Gamma', 'Delta', 'Epsilon'], matrix=[[0], [0.23076923076923073, 0], [0.3846153846153846, 0.23076923076923073, 0], [0.5384615384615384, 0.5384615384615384, 0.5384615384615384, 0], [0.6153846153846154, 0.3846153846153846, 0.46153846153846156, 0.15384615384615385, 0]])
print "What's the get_distance(aln) from DistanceCalculator('identity') object?"
print type(dm)
print dm
# Alpha 0
# Beta 0.230769230769 0
# Gamma 0.384615384615 0.230769230769 0
# Delta 0.538461538462 0.538461538462 0.538461538462 0
# Epsilon 0.615384615385 0.384615384615 0.461538461538 0.153846153846 0
# build a tree from it.
from Bio.Phylo.TreeConstruction import DistanceTreeConstructor
construc0 = DistanceTreeConstructor(dstcalc, 'nj')
tre0 = construc0.build_tree(aln)
print type(tre0)
# as you can see from abovedstcalc is needed for te constructor and then
# to build the tree the alignment is needed. That's two things which need to originae fromt he same thing.
# A bit of a tall order
# You can build the tree from a distance matrix only, by leaving out the aln argument
# by not using the build_tree method on the constructor, but rather the .nj method
construc2 = DistanceTreeConstructor()
tre2 = construc2.nj(dm)
print type(tre2)
args = parser.parse_args()
records = [x for x in SeqIO.parse(args.fasta, 'fasta')]
aligned = align_clustalW_records(records)
seqCount = 0
for idx, cluster in enumerate(aligned):
seqCount += 1
#print(aligned[idx].id + "\t" + aligned[idx].seq)
calculator = DistanceCalculator('identity')
constructor = DistanceTreeConstructor(calculator, 'upgma')
tree = constructor.build_tree(aligned)
dm = calculator.get_distance(aligned)
#tree.ladderize() # Flip branches so deeper clades are displayed at top
#Phylo.draw_ascii(tree)
newmat = dm.matrix
nnmat = []
for elem in newmat:
nnmat.append(elem[:-1])
newe = None
olde = None
nclusts = 0
def run_nj_naive(cm_uniq, stem, verbose=True):
if verbose:
print("Running Neighbor-Joining on " + str(cm_uniq.shape[0]) +
" Unique Cells")
cm_lookup = list(cm_uniq.apply(lambda x: "|".join(x.values), axis=1))
fn = stem + "phylo.txt"
infile = stem + "infile.txt"
cm_uniq.to_csv(fn, sep='\t')
script = (SCLT_PATH / 'TreeSolver' / 'binarize_multistate_charmat.py')
cmd = "python3.6 " + str(script) + " " + fn + " " + infile + " --relaxed"
p = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(p.pid, 0)
aln = AlignIO.read(infile, "phylip-relaxed")
calculator = DistanceCalculator('identity')
constructor = DistanceTreeConstructor(calculator, 'nj')
tree = constructor.build_tree(aln)
tree.root_at_midpoint()
nj_net = Phylo.to_networkx(tree)
# convert labels to characters for writing to file
rndict = {}
for n in nj_net:
if n.name is None:
rndict[n] = Node('state-node', [])
elif n.name in cm_uniq:
rndict[n] = Node(n.name, cm_uniq.loc[n.name].values)
# convert labels to strings, not Bio.Phylo.Clade objects
#c2str = map(lambda x: x.name, list(nj_net.nodes()))
#c2strdict = dict(zip(list(nj_net.nodes()), c2str))
nj_net = nx.relabel_nodes(nj_net, rndict)
# nj_net = fill_in_tree(nj_net, cm_uniq)
# nj_net = tree_collapse2(nj_net)
rdict = {}
for n in nj_net:
if nj_net.out_degree(n) == 0 and n.char_string in cm_lookup:
n.is_target = True
else:
n.is_target = False
state_tree = nj_net
ret_tree = Cassiopeia_Tree(method='neighbor-joining',
network=state_tree,
name='Cassiopeia_state_tree')
os.system("rm " + infile)
os.system("rm " + fn)
return ret_tree
def main():
"""
Takes in a character matrix, an algorithm, and an output file and
returns a tree in newick format.
"""
parser = argparse.ArgumentParser()
parser.add_argument("char_fp", type=str, help="character_matrix")
parser.add_argument("out_fp", type=str, help="output file name")
parser.add_argument("-nj",
"--neighbor-joining",
action="store_true",
default=False)
parser.add_argument("--ilp", action="store_true", default=False)
parser.add_argument("--hybrid", action="store_true", default=False)
parser.add_argument("--cutoff",
type=int,
default=80,
help="Cutoff for ILP during Hybrid algorithm")
parser.add_argument("--time_limit",
type=int,
default=1500,
help="Time limit for ILP convergence")
parser.add_argument("--greedy", "-g", action="store_true", default=False)
parser.add_argument("--camin-sokal",
"-cs",
action="store_true",
default=False)
parser.add_argument("--verbose",
action="store_true",
default=False,
help="output verbosity")
parser.add_argument("--mutation_map", type=str, default="")
parser.add_argument("--num_threads", type=int, default=1)
parser.add_argument("--max_neighborhood_size", type=int, default=10000)
args = parser.parse_args()
char_fp = args.char_fp
out_fp = args.out_fp
verbose = args.verbose
cutoff = args.cutoff
time_limit = args.time_limit
num_threads = args.num_threads
max_neighborhood_size = args.max_neighborhood_size
stem = ''.join(char_fp.split(".")[:-1])
cm = pd.read_csv(char_fp, sep='\t', index_col=0)
cm_uniq = cm.drop_duplicates(inplace=False)
newick = ""
prior_probs = None
if args.mutation_map != "":
prior_probs = read_mutation_map(args.mutation_map)
if args.greedy:
target_nodes = cm_uniq.astype(str).apply(lambda x: '|'.join(x), axis=1)
if verbose:
print('Running Greedy Algorithm on ' + str(len(target_nodes)) +
" Cells")
string_to_sample = dict(zip(target_nodes, cm.index))
target_nodes = map(lambda x, n: x + "_" + n, target_nodes,
cm_uniq.index)
reconstructed_network_greedy = solve_lineage_instance(
target_nodes, method="greedy", prior_probabilities=prior_probs)
# score parsimony
score = 0
for e in reconstructed_network_greedy.edges():
score += get_edge_length(e[0], e[1])
print("Parsimony: " + str(score))
#reconstructed_network_greedy = nx.relabel_nodes(reconstructed_network_greedy, string_to_sample)
newick = convert_network_to_newick_format(reconstructed_network_greedy)
with open(out_fp, "w") as f:
f.write(newick)
out_stem = "".join(out_fp.split(".")[:-1])
pic.dump(reconstructed_network_greedy, open(out_stem + ".pkl", "wb"))
elif args.hybrid:
target_nodes = cm_uniq.astype(str).apply(lambda x: '|'.join(x), axis=1)
if verbose:
print('Running Hybrid Algorithm on ' + str(len(target_nodes)) +
" Cells")
print('Parameters: ILP on sets of ' + str(cutoff) + ' cells ' +
str(time_limit) + 's to complete optimization')
string_to_sample = dict(zip(target_nodes, cm.index))
target_nodes = map(lambda x, n: x + "_" + n, target_nodes,
cm_uniq.index)
print("running algorithm...")
reconstructed_network_hybrid = solve_lineage_instance(
target_nodes,
method="hybrid",
hybrid_subset_cutoff=cutoff,
prior_probabilities=prior_probs,
time_limit=time_limit,
threads=num_threads,
max_neighborhood_size=max_neighborhood_size)
if verbose:
print("Scoring Parsimony...")
# score parsimony
score = 0
for e in reconstructed_network_hybrid.edges():
score += get_edge_length(e[0], e[1])
if verbose:
print("Parsimony: " + str(score))
if verbose:
print("Writing the tree to output...")
#reconstructed_network_hybrid = nx.relabel_nodes(reconstructed_network_hybrid, string_to_sample)
out_stem = "".join(out_fp.split(".")[:-1])
pic.dump(reconstructed_network_hybrid, open(out_stem + ".pkl", "wb"))
newick = convert_network_to_newick_format(reconstructed_network_hybrid)
with open(out_fp, "w") as f:
f.write(newick)
elif args.ilp:
target_nodes = cm_uniq.astype(str).apply(lambda x: '|'.join(x), axis=1)
if verbose:
print("Running ILP Algorithm on " + str(len(target_nodes)) +
" Unique Cells")
print("Paramters: ILP allowed " + str(time_limit) +
"s to complete optimization")
string_to_sample = dict(zip(target_nodes, cm.index))
target_nodes = map(lambda x, n: x + "_" + n, target_nodes,
cm_uniq.index)
reconstructed_network_ilp = solve_lineage_instance(
target_nodes,
method="ilp",
prior_probabilities=prior_probs,
time_limit=time_limit,
max_neighborhood_size=max_neighborhood_size)
# score parsimony
score = 0
for e in reconstructed_network_ilp.edges():
score += get_edge_length(e[0], e[1])
print("Parsimony: " + str(score))
#reconstructed_network_ilp = nx.relabel_nodes(reconstructed_network_ilp, string_to_sample)
newick = convert_network_to_newick_format(reconstructed_network_ilp)
with open(out_fp, "w") as f:
f.write(newick)
out_stem = "".join(out_fp.split(".")[:-1])
pic.dump(reconstructed_network_ilp, open(out_stem + ".pkl", "wb"))
elif args.neighbor_joining:
cm.drop_duplicates(inplace=True)
if verbose:
print("Running Neighbor-Joining on " + str(cm.shape[0]) +
" Unique Cells")
fn = stem + "phylo.txt"
infile = stem + "infile.txt"
cm.to_csv(fn, sep='\t')
os.system(
"python2 ~/projects/scLineages/SingleCellLineageTracing/scripts/binarize_multistate_charmat.py "
+ fn + " " + infile + " --relaxed")
aln = AlignIO.read(infile, "phylip-relaxed")
calculator = DistanceCalculator('identity')
constructor = DistanceTreeConstructor(calculator, 'nj')
tree = constructor.build_tree(aln)
tree.root_at_midpoint()
nj_net = Phylo.to_networkx(tree)
# convert labels to characters for writing to file
i = 0
for n in nj_net:
if n.name is None:
n.name = "internal" + str(i)
i += 1
# convert labels to strings, not Bio.Phylo.Clade objects
c2str = map(lambda x: x.name, nj_net.nodes())
c2strdict = dict(zip(nj_net.nodes(), c2str))
nj_net = nx.relabel_nodes(nj_net, c2strdict)
nj_net = tree_collapse(nj_net)
out_stem = "".join(out_fp.split(".")[:-1])
pic.dump(nj_net, open(out_stem + ".pkl", "wb"))
newick = convert_network_to_newick_format(nj_net)
with open(out_fp, "w") as f:
f.write(newick)
os.system("rm " + infile)
os.system("rm " + fn)
elif args.camin_sokal:
cells = cm.index
samples = [("s" + str(i)) for i in range(len(cells))]
samples_to_cells = dict(zip(samples, cells))
cm.index = list(range(len(cells)))
if verbose:
print("Running Camin-Sokal on " + str(cm.shape[0]) +
" Unique Cells")
infile = stem + 'infile.txt'
fn = stem + "phylo.txt"
weights_fn = stem + "weights.txt"
cm.to_csv(fn, sep='\t')
os.system(
"python2 /home/mattjones/projects/scLineages/SingleCellLineageTracing/scripts/binarize_multistate_charmat.py "
+ fn + " " + infile)
weights = construct_weights(infile, weights_fn)
outfile = stem + 'outfile.txt'
outtree = stem + 'outtree.txt'
# run phylip mix with camin-sokal
responses = "." + stem + ".temp.txt"
FH = open(responses, 'w')
current_dir = os.getcwd()
FH.write(infile + "\n")
FH.write("F\n" + outfile + "\n")
FH.write("P\n")
FH.write("Y\n")
FH.write("F\n" + outtree + "\n")
FH.close()
t0 = time.time()
cmd = "~/software/phylip-3.697/exe/mix"
cmd += " < " + responses + " > screenout"
p = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(p.pid, 0)
consense_outtree = stem + "consenseouttree.txt"
consense_outfile = stem + "conenseoutfile.txt"
FH = open(responses, "w")
FH.write(outtree + "\n")
FH.write("F\n" + consense_outfile + "\n")
FH.write("Y\n")
FH.write("F\n" + consense_outtree + "\n")
FH.close()
if verbose:
print("Computing Consensus Tree, elasped time: " +
str(time.time() - t0))
cmd = "~/software/phylip-3.697/exe/consense"
cmd += " < " + responses + " > screenout2"
p2 = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(p2.pid, 0)
newick_str = ""
with open(consense_outtree, "r") as f:
for l in f:
l = l.strip()
newick_str += l
#tree = Phylo.parse(consense_outtree, "newick").next()
tree = newick_to_network(newick_str)
#tree.rooted = True
cs_net = tree_collapse(tree)
#cs_net = Phylo.to_networkx(tree)
cs_net = nx.relabel_nodes(cs_net, samples_to_cells)
out_stem = "".join(out_fp.split(".")[:-1])
pic.dump(cs_net, open(out_stem + ".pkl", "wb"))
newick = convert_network_to_newick_format(cs_net)
with open(out_fp, "w") as f:
f.write(newick)
os.system("rm " + outfile)
os.system("rm " + responses)
os.system("rm " + outtree)
os.system("rm " + consense_outfile)
os.system("rm " + infile)
os.system("rm " + fn)
elif alg == "--max-likelihood" or alg == '-ml':
#cells = cm.index
#samples = [("s" + str(i)) for i in range(len(cells))]
#samples_to_cells = dict(zip(samples, cells))
#cm.index = list(range(len(cells)))
if verbose:
print("Running Camin-Sokal on " + str(cm.shape[0]) +
" Unique Cells")
infile = stem + 'infile.txt'
fn = stem + "phylo.txt"
cm.to_csv(fn, sep='\t')
os.system(
"python2 /home/mattjones/projects/scLineages/SingleCellLineageTracing/scripts/binarize_multistate_charmat.py "
+ fn + " " + infile + " --relaxed")
os.system("/home/mattjones/software/FastTreeMP < " + infile + " > " +
out_fp)
tree = Phylo.parse(out_fp, "newick").next()
ml_net = Phylo.to_networkx(tree)
i = 0
for n in ml_net:
if n.name is None:
n.name = "internal" + str(i)
i += 1
c2str = map(lambda x: str(x), ml_net.nodes())
c2strdict = dict(zip(ml_net.nodes(), c2str))
ml_net = nx.relabel_nodes(ml_net, c2strdict)
out_stem = "".join(out_fp.split(".")[:-1])
pic.dump(ml_net, open(out_stem + ".pkl", "wb"))
os.system("rm " + infile)
os.system("rm " + fn)
else:
raise Exception(
"Please choose an algorithm from the list: greedy, hybrid, ilp, nj, max-likelihood, or camin-sokal"
)
print distanceMatrix
aln = AlignIO.read('/home/harsheel/CPME Assignments/genealign.fasta', 'fasta')
print aln
calculator = DistanceCalculator('identity')
dm = calculator.get_distance(aln)
print dm
constructor1 = DistanceTreeConstructor(calculator,'upgma') #rooted=True
constructor2 = DistanceTreeConstructor(calculator,'nj') #rooted=False
#FH=open('/home/harsheel/CPME Assignments/distanceMatrixTest.txt','r')
tree1=constructor1.build_tree(aln)
tree2=constructor2.build_tree(aln)
Bio.Phylo.draw_ascii(tree1)
#Bio.Phylo.draw(tree1)
Bio.Phylo.draw_ascii(tree2)
#Bio.Phylo.draw(tree2)
#tree = tree.as_phyloxml()
#tree1.print_newick()
print tree1
print tree2
Bio.Phylo.write(tree1, 'tree1.tre', 'newick')
def main():
"""
Takes in a character matrix, an algorithm, and an output file and
returns a tree in newick format.
"""
parser = argparse.ArgumentParser()
parser.add_argument("netfp", type=str, help="character_matrix")
parser.add_argument("typ", type=str, help="category of stress test")
parser.add_argument("-nj",
"--neighbor-joining",
action="store_true",
default=False)
parser.add_argument("--ilp", action="store_true", default=False)
parser.add_argument("--hybrid", action="store_true", default=False)
parser.add_argument("--cutoff",
type=int,
default=80,
help="Cutoff for ILP during Hybrid algorithm")
parser.add_argument("--time_limit",
type=int,
default=1500,
help="Time limit for ILP convergence")
parser.add_argument("--greedy", "-g", action="store_true", default=False)
parser.add_argument("--camin-sokal",
"-cs",
action="store_true",
default=False)
parser.add_argument("--verbose",
action="store_true",
default=False,
help="output verbosity")
parser.add_argument("--mutation_map", type=str, default="")
parser.add_argument("--num_threads", type=int, default=1)
parser.add_argument("--no_triplets", action="store_true", default=False)
parser.add_argument("--max_neighborhood_size", type=str, default=3000)
args = parser.parse_args()
netfp = args.netfp
t = args.typ
verbose = args.verbose
cutoff = args.cutoff
time_limit = args.time_limit
num_threads = args.num_threads
max_neighborhood_size = args.max_neighborhood_size
score_triplets = (not args.no_triplets)
name = netfp.split("/")[-1]
spl = name.split("_")
param = spl[-3]
run = spl[-1].split(".")[0]
prior_probs = None
if args.mutation_map != "":
prior_probs = pic.load(open(args.mutation_map, "rb"))
stem = '.'.join(name.split(".")[:-1])
true_network = nx.read_gpickle(netfp)
target_nodes = get_leaves_of_tree(true_network, clip_identifier=True)
target_nodes_original_network = get_leaves_of_tree(true_network,
clip_identifier=False)
k = map(lambda x: "s" + x.split("_")[-1], target_nodes_original_network)
s_to_char = dict(zip(k, target_nodes))
char_to_s = dict(zip(target_nodes, k))
unique_ii = np.unique(target_nodes, return_index=True)
target_nodes_uniq = np.array(target_nodes)[unique_ii[1]]
target_nodes_original_network_uniq = np.array(
target_nodes_original_network)[unique_ii[1]]
string_to_sample = dict(zip(target_nodes, target_nodes_original_network))
if args.greedy:
if verbose:
print('Running Greedy Algorithm on ' +
str(len(target_nodes_uniq)) + " Cells")
reconstructed_network_greedy = solve_lineage_instance(
target_nodes_uniq,
method="greedy",
prior_probabilities=prior_probs)
#reconstructed_network_greedy = nx.relabel_nodes(reconstructed_network_greedy, string_to_sample)
newick = convert_network_to_newick_format(reconstructed_network_greedy)
out = stem + "_greedy.txt"
#with open(out, "w") as f:
# f.write(newick)
pic.dump(reconstructed_network_greedy,
open(name.replace("true", "greedy"), "wb"))
elif args.hybrid:
if verbose:
print('Running Hybrid Algorithm on ' +
str(len(target_nodes_uniq)) + " Cells")
print('Parameters: ILP on sets of ' + str(cutoff) + ' cells ' +
str(time_limit) + 's to complete optimization')
reconstructed_network_hybrid = solve_lineage_instance(
target_nodes_original_network_uniq,
method="hybrid",
hybrid_subset_cutoff=cutoff,
prior_probabilities=prior_probs,
time_limit=time_limit,
threads=num_threads,
max_neighborhood_size=max_neighborhood_size)
reconstructed_network_hybrid = nx.relabel_nodes(
reconstructed_network_hybrid, string_to_sample)
#out = stem + "_hybrid.pkl"
#pic.dump(reconstructed_network_hybrid, open(out, "wb"))
#newick = convert_network_to_newick_format(reconstructed_network_hybrid)
#out = stem + "_hybrid.txt"
#with open(out, "w") as f:
# f.write(newick)
pic.dump(reconstructed_network_hybrid,
open(name.replace("true", "hybrid"), "wb"))
elif args.ilp:
if verbose:
print('Running Hybrid Algorithm on ' +
str(len(target_nodes_uniq)) + " Cells")
print('Parameters: ILP on sets of ' + str(cutoff) + ' cells ' +
str(time_limit) + 's to complete optimization')
reconstructed_network_ilp = solve_lineage_instance(
target_nodes_uniq,
method="ilp",
hybrid_subset_cutoff=cutoff,
prior_probabilities=prior_probs,
time_limit=time_limit,
threads=num_threads)
reconstructed_network_ilp = nx.relabel_nodes(reconstructed_network_ilp,
string_to_sample)
pic.dump(reconstructed_network_ilp,
open(name.replace("true", "ilp"), "wb"))
elif args.neighbor_joining:
if verbose:
print("Running Neighbor-Joining on " +
str(len(target_nodes_uniq)) + " Unique Cells")
infile = ''.join(name.split(".")[:-1]) + 'infile.txt'
fn = ''.join(name.split(".")[:-1]) + 'phylo.txt'
write_leaves_to_charmat(target_nodes_original_network_uniq, fn)
script = (SCLT_PATH / 'TreeSolver' / 'binarize_multistate_charmat.py')
cmd = "python3.6 " + str(
script) + " " + fn + " " + infile + " --relaxed"
p = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(p.pid, 0)
aln = AlignIO.read(infile, "phylip")
aln = unique_alignments(aln)
t0 = time.time()
calculator = DistanceCalculator('identity', skip_letters='?')
constructor = DistanceTreeConstructor(calculator, 'nj')
tree = constructor.build_tree(aln)
out = stem + "_nj.txt"
Phylo.write(tree, out, 'newick')
print(
str(param) + "\t" + str(run) + "\t" + "neighbor-joining" + "\t" +
str(t) + "\t" + str(time.time() - t0))
os.system("rm " + infile)
os.system("rm " + fn)
elif args.camin_sokal:
if verbose:
print('Running Camin-Sokal Max Parsimony Algorithm on ' +
str(len(target_nodes_uniq)) + " Unique Cells")
infile = ''.join(name.split(".")[:-1]) + '_cs_infile.txt'
fn = ''.join(name.split(".")[:-1]) + '_cs_phylo.txt'
weights_fn = ''.join(name.split(".")[:-1]) + "_cs_weights.txt"
write_leaves_to_charmat(target_nodes_original_network_uniq, fn)
script = (SCLT_PATH / 'TreeSolver' / 'binarize_multistate_charmat.py')
cmd = "python3.6 " + str(
script) + " " + fn + " " + infile + " --relaxed"
pi = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(pi.pid, 0)
weights = construct_weights(infile, weights_fn)
outfile = stem + 'outfile.txt'
outtree = stem + 'outtree.txt'
# run phylip mix with camin-sokal
responses = "." + stem + ".temp.txt"
FH = open(responses, 'w')
current_dir = os.getcwd()
FH.write(infile + "\n")
FH.write("F\n" + outfile + "\n")
FH.write("P\n")
FH.write("W\n")
FH.write("Y\n")
FH.write(weights_fn + "\n")
FH.write("F\n" + outtree + "\n")
FH.close()
t0 = time.time()
cmd = "~/software/phylip-3.697/exe/mix"
cmd += " < " + responses + " > screenout1"
p = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(p.pid, 0)
consense_outtree = stem + "consenseouttree.txt"
consense_outfile = stem + "consenseoutfile.txt"
FH = open(responses, "w")
FH.write(outtree + "\n")
FH.write("F\n" + consense_outfile + "\n")
FH.write("Y\n")
FH.write("F\n" + consense_outtree + "\n")
FH.close()
if verbose:
print("Computing Consensus Tree, elasped time: " +
str(time.time() - t0))
cmd = "~/software/phylip-3.697/exe/consense"
cmd += " < " + responses + " > screenout"
p2 = subprocess.Popen(cmd, shell=True)
pid, ecode = os.waitpid(p2.pid, 0)
os.system("rm " + outfile)
os.system("rm " + responses)
os.system("rm " + outtree)
os.system("rm " + consense_outfile)
os.system("rm " + infile)
os.system("rm " + fn)
else:
raise Exception(
"Please choose an algorithm from the list: greedy, hybrid, ilp, nj, or camin-sokal"
)
