phylovi/bito

Python-interface C++ library for Bayesian phylogenetics via optimization

bito's Issues

Make an Indexer, aka. a ParamParser

Sample trees from SBNs

🐵

Rename tree indices to ids (or something).

Currently we have the name "index" appear in the SBN parameter indexer, and also in the Node class. I think this is confusing.

So, I propose changing the "index" in Node to "id".

Objections? Alternate proposals?

Driver should be disposable rather than part of SBNInstance

Calculate BEAGLE likelihoods

Tests with IndexerRepresentationOf fail

Tests with IndexerRepresentationOf in libsbn.hpp fail on my mac. Indices returned by IndexerRepresentationOf do not match the correct indices.

https://github.com/matsengrp/libsbn/blob/f6d65ecff8aa5e4757bfbf25813730569f3db3ab/src/libsbn.hpp#L351-L352

set up proper communication with numpy

• branch length vectors become numpy vectors
• we can share sbn parameter vectors with python

Reorganize code

• naming of libsbn.cpp and libsbn.hpp is confusing: change libsbn.cpp to pylibsbn.cpp
• build.cpp is vaguely named
• functions vs methods
• Newick functions a mess

Compress site patterns of alignment for BEAGLE likelihood computation

More sophisticated comparison between vbpi and libsbn support estimation.

Bitset is limited to `size_t`, but intpacking is in terms of int32

Add an index to topologies and use it to index branch lengths

SymbolVectorOf segfaults when run from Python

Uncommenting inst.prepare_beagle_instance() in test_instance.py, and adding some print statements

      std::cout << "before\n";
        SymbolVector symbols =
            SymbolVectorOf(alignment.at(iter->second), symbol_table);
        std::cout << "after\n";

shows that this is a problem with SymbolVectorOf, which seems pretty innocuous.

Everything runs find when run from C++ in the libsbn.hpp test 🤷‍♂ ...

Improve documentation around higher-order tree traversal functions

Speed test tree traversal

Does tail recursion make a difference?

Docker build

Implement a bitarray class

So, it turns out that std::bitset requires length to be known at compile time. 😬

There is std::vector but it doesn't have all the nice ~ etc syntax.

So I'll wrap it and add these features.

set up continuous build/test

Downgrade to C++14

It seems like too much work to get Clang > 4 on OSX.

NEXUS tree parser

What to do with error handling?

So far I've been using printing and abort().

I think I'll start just throwing naked exceptions. I don't see a clear reason to wrap exceptions as RB does.

add a stupid FASTA parser

https://stackoverflow.com/questions/35251635/fasta-reader-written-in-c

BEAGLE gradient computation; tests

Add contributors list

Hello everyone-- it's time to acknowledge all of your contributors.

Shall we move development to a separate organization? If so, what shall we name it?

My suggestion would be viphylo or variationalphylo. Or perhaps VariationalPhylo? Ideas? Votes?

implement a tree class

Here are some initial ideas about how to implement a tree class.

Because we are sampling rooted trees and not changing them, the trees can be rooted and immutable. Because we'll want to efficiently store a lot of them, it makes sense to have the implementation separate out extra information such as branch length. If we combine this with a preference for composition over inheritance and RAII we have a simple design in which the core tree data structure is an array of shared_ptrs to descendants, along with a unique integer identifier. These can then get combined with other information via the integer index, such as an unordered_map to map from branches to branch lengths if they are needed.

After thinking this out I realized that this is quite similar to what we did in pplacer with stree and gtree.

I'm sure several things here will blow up in my face as I start playing around with implementations. If you can think of some of those things, please comment!

Expose branch lengths to Numpy

One initial manner external modelling/inference tools could interact with libsbn is by using it to calculate the phylogenetic likelihood. Doing this in Numpy-based tools (e.g. PyMC3) requires:

• Exposing branch lengths as a mutable array
• Exposing topology structure in an array-based data structure (e.g. an array of parent indices)

Conflict between `python_convention` and `CPPConvention`

Parallelize likelihood computation

At first I thought that we could do this simply with C++'s built in parallel loops, etc, but we'll need to think a little about how that will work.

If we want k threads I'd think that we'd want to initialize k BEAGLE instances and then send trees to the various instances on various threads. I think this is worth the programming effort?

How are we going to implement various tree types and their gradients?

Return likelihood along with gradient

Try making internal pointers inside Nodes unique_ptrs.

Test out sharing vectors between C++ and Python

Our current design involves doing computation in C++ (e.g. branch length gradients) and then using Python to modify things like the conditional subsplit distributions.

Let's try to test this sort of thing out by

• allocating a vector in C++
• modifying it using Python

Make trees immutable

Get build working on OSX + clang

Docker builds failing

It seems like they need the full path /opt/conda/bin/conda now ?

Make everything const that's not getting mutated

https://google.github.io/styleguide/cppguide.html#Reference_Arguments

Make trees suitable for unordered_map

Add hash and equality functions.

Index grabber for subsplit pairs from trees.

Reinstate topology counting and subsplit support estimation

The transition from Nodes to Trees broke the logic of collapsing trees on topology. So I'm ripping it out for now in favor of a simple tree vector.

• reinstate tests in build.hpp

Here are some bits that may be useful:

TreeCollection::TreeCollectionPtr Driver::ParseFile(const std::string &fname) {
  Tree::TreePtr tree;
  yy::parser parser_instance(*this);

  parser_instance.set_debug_level(trace_parsing_);

  std::ifstream in(fname.c_str());
  if (!in) {
    std::cerr << "Cannot open the File : " << fname << std::endl;
    abort();
  }
  std::string line;
  unsigned int line_number = 1;
  auto trees = std::make_shared<TreeCollection::TreePtrCounter>();
  while (std::getline(in, line)) {
    // Set the Bison location line number properly so we get useful error
    // messages.
    location_.initialize(nullptr, line_number);
    line_number++;
    if (line.size() > 0) {
      tree = ParseString(&parser_instance, line);
      auto search = trees->find(tree);
      if (search == trees->end()) {
        assert(trees->insert(std::make_pair(tree, 1)).second);
      } else {
        search->second++;
      }
    }
  }
  in.close();
  return std::make_shared<TreeCollection>(trees, this->TagTaxonMap());
}

BEAGLE scaling

implement scaling in BEAGLE.

syntactic sugar for maps

Right now we write

assert(tag_to_branch_number.insert(std::make_pair(k, v)).second);

for insertion. That's a little cumbersome. Getting elements is a little verbose too, though there at least this comes with the benefit of writing a good error message.

We could have a https://en.cppreference.com/w/cpp/language/function_template that would do the former. Or we could have a templated wrapper class?

Add a license

Test BEAGLE likelihood computation

generate and share a bitset dictionary from a tree

This will be modeled after ParamParser, so will map from a bitset to (int, int) pairs.

Get rootsplit and subsplit support

Actually store branch lengths in a tree object

Make bitsets immutable (if it seems helpful)

Separate hpp and cpp files

compilation is too slow 😢

Erick, clean out your TODOs.

Unfucking the tree containers

TreeCollection now uses a counter, which doesn't match with our desired use case of trees with branch lengths. We want to count topologies.