Code to analyse the consistent networks.
Aggregate the possible input parameters.
Aggregate the possible regulatory relationships in the networks.
Aggregate the possible theta parameters.
Analyse the dependencies between pairs of network features.
Count how often each possible input parameters occurs.
Count the possible regulatory relationships in the networks.
Count the possible theta parameters.
Chow-Liu trees were originally defined in Chow, C. K.; Liu, C. N. (1968), “Approximating discrete probability distributions with dependence trees”, IEEE Transactions on Information Theory IT-14 (3): 462-467.
In this module, each data point is presented as a sequence of discrete-valued features. For example suppose we have data, X = {X}, where each x has n=4 features.
>>> X = [
... 'AACC',
... 'AAGC',
... 'AAGC',
... 'GCTC',
... 'ACTC',
... ]
>>> n = len(X[0])
We can calculate the marginal distribution of each feature
>>> import pybool.chow_liu_trees as CLT
>>> for u in xrange(n):
... print CLT.marginal_distribution(X, u)
defaultdict(<type 'float'>, {'A': 0.80000000000000004, 'G': 0.20000000000000001})
defaultdict(<type 'float'>, {'A': 0.60000000000000009, 'C': 0.40000000000000002})
defaultdict(<type 'float'>, {'C': 0.20000000000000001, 'T': 0.40000000000000002, 'G': 0.40000000000000002})
defaultdict(<type 'float'>, {'C': 1.0})
and also the marginal distribution of a pair of features
>>> print CLT.marginal_pair_distribution(X, 0, 1)
defaultdict(<type 'float'>, {('A', 'A'): 0.60000000000000009, ('G', 'C'): 0.20000000000000001, ('A', 'C'): 0.20000000000000001})
>>> print CLT.marginal_pair_distribution(X, 1, 2)
defaultdict(<type 'float'>, {('A', 'G'): 0.40000000000000002, ('C', 'T'): 0.40000000000000002, ('A', 'C'): 0.20000000000000001})
We can calculate the mutual infomation between all pairs of features
>>> for v in xrange(n):
... for u in xrange(v):
... print u, v, CLT.calculate_mutual_information(X, u, v)
0 1 0.223143551314
0 2 0.223143551314
1 2 0.673011667009
0 3 0.0
1 3 0.0
2 3 0.0
Finally we can build a Chow-Liu tree
>>> T = CLT.build_chow_liu_tree(X, n)
>>> print T.edges(data=True)
[(0, 1, {'weight': -0.22314355131420974}), (0, 3, {'weight': -0}), (1, 2, {'weight': -0.6730116670092563})]
Build a Chow-Liu tree from the data, X. n is the number of features. The weight on each edge is the negative of the mutual information between those features. The tree is returned as a networkx object.
X are the data points. u and v are the indices of the features to calculate the mutual information for.
Return the marginal distribution for the u’th features of the data points, X.
Return the marginal distribution for the u’th and v’th features of the data points, X.
Code to help implement constraints in Boolean networks.
Check each pair on genes in the list have different on/off patterns.
Check that no consecutive genes in the list have the same on/off pattern.
Check that two genes do not have the same on/off pattern.
Check the first gene expresses before the second.
Check there is no expression for the given gene.
Check that the gene starts off, switches on and remains on.
Check that the gene starts on, switches off and remains off.
Check the genes in the list are expressed in the same order they are given.
Bases: object
Given a set of change points, offers various functions to check that genes are going on and off in the correct temporal order.
Realisation.
Check that no genes in the list have the same on/off pattern.
Check that no consecutive genes in the list have the same on/off pattern.
Check that gene1 and gene2 do not have the same on/off pattern.
Check gene1 is expressed before gene2.
Check there is no expression for the given gene.
Check that the gene starts off, switches on and remains on.
Check that the gene starts on, switches off and remains off.
Check the genes in the list are expressed in order.
Change points for a realisation.
Bases: tuple
Condition(name, inputs, constraints, merged_inputs)
Alias for field number 2
Alias for field number 1
Alias for field number 3
Alias for field number 0
Bases: tuple
Gene(name, color, position)
Alias for field number 1
Alias for field number 0
Alias for field number 2
Bases: object
Base meta-data functionality for regulatory networks.
Add a condition to the network.
Add an external input gene to the network.
Add a non-external input gene to the network.
combinations(‘ABCD’, 2) –> AB AC AD BC BD CD combinations(range(4), 3) –> 012 013 023 123
Take 2 constraints and combine them. If union is False, then take the intersection.
@return: Yield consecutive items from the iterable as a tuple.
External input function to turn a gene off.
External input function to turn a gene on.
I/O for boolean regulatory networks.
Bases: object
Builds graphs representing the information in the meta data.
Bases: object
Builds graphs representing the information in the meta data using Python package networkx.
Takes a matrix and creates a new one with headers for rows and columns.
Pad and centre a string to the given width.
Set up matplotlib parameters for plotting using TeX.
Make sure a directory exists, making it and its parents if necessary.
Create a BGL graph of the network.
Create a BGL graph of the possible networks.
Return a path to the named output file.
Plot the realisation of the network.
Plot the network realisations over all the conditions.
Convert a regulatory value to a string.
@return: A string representing the rgb colour.
Log some information about the network constraint meta data.
Log some information about the possible networks.
Write the graph as a DOT file and a SVG file.
Code to describe and generate boolean networks.
Bases: object
A boolean regulatory network.
The regulatory connections.
Generate an entire realisation of the network.
Parameters for external inputs.
Meta-data for this type of network.
The constitutive (default) gene states.
Bases: object
Generates boolean networks with all possible parameters.
Inspect the expression of a gene to find when it turns off and on.
Yield each possible combination of the values given.
@arg possible_values: Should be a sequence of sequences of possible values. @arg X: Object to store combinations in. If not given, a numpy array is used.
For example:
>>> possible_values = (
... (-5, 0, 1),
... (0, 1),
... )
>>> for X in combinations(possible_values):
... print X
[-5 0]
[0 0]
[1 0]
[-5 1]
[0 1]
[1 1]
Evaluate the network under all the conditions until one does not match.
@return: The first condition that does not match (or None) and the number of mismatches as a tuple.
Evaluate the network under one condition.
Filter those networks from the iterable that have the same J.
Maps the features of a network (theta, J, input parameters) into a sequence.
@return: The number of possible combinations of the values.
Use the current values of gene expression, X, to calculate the values at the next time point.
Identifies which feature in the network u refers to.
pybool: A python package that infers Boolean networks given a set of constraints.
Consider the common scenario of a biologist who is studying a particular regulatory network. They study a set of genes that are known to play a role in the network. They have some background knowledge of particular regulatory connections from his own studies or from the literature. In addition to this they have perturbation data that reveals the temporal order of expression of the genes under some conditions. For example, these could be derived from loss-of-function or over-expression experiments. The biologist would like to elucidate the entire network and to this end can perform various experiments to test particular regulatory connections. These experiments are costly and time-consuming. Which connections should they focus on? This is where the pybool package can help. By modelling candidate regulatory networks using Boolean logic, pybool evaluates which networks are consistent with the perturbation data and the known regulatory connections.
Return the release and svn revision as a string.