# Finding a subnetwork with a given topology in E. Coli

A few weeks ago I posted about how easy it was, using Python’s Networkx module and the RegulonDB database, to get and navigate through the genetic network of E. Coli. I didn’t mention at the time that you can also find all the subnetworks of E. Coli sharing a given topology with just a few lines of code:

import networkx.algorithms.isomorphism as iso
def find_pattern(graph,pattern,sign_sensitive = True):

if sign_sensitive:
edge_match = lambda e1,e2 : (e1['sign']==e2['sign'])
else:
edge_match = None
matcher = iso.DiGraphMatcher(graph,pattern,edge_match=edge_match)
return list(matcher.subgraph_isomorphisms())

## Feedforward loops in E. coli

As an example, let us have a look at the feedforward loops in E. coli. A feedforward loop can be described as a gene having an action on another gene, both directly and through the intermediary of another gene, like in the following sketch, where the arrows can represent activations or repressions

A feedforward !

If you want to print all the feedforward loops in E. coli’s network (as represented by RegulonDB), try this :

import networkx as nx
feedforward = nx.DiGraph()
ffwd_in_ecoli = find_pattern(ECN,feedforward,sign_sensitive=False)
for subgraph in ffwd_in_ecoli:
print subgraph

This prints each feedforward loop with the respective roles of the different genes (A,I, or C). As you can see there are 63 feedforward loops in regulonDB’s network, which is many. Let us now get sign-specific :

import itertools as itt
labels = []
frequencies = []
for signs in itt.product(('+','-'),repeat = 3):

ffwd = nx.DiGraph()
('I','B',{'sign':signs[1]}),
('A','B',{'sign':signs[2]})])
frequency = len(list(find_pattern(ECN,ffwd,True)))
frequencies.append(frequency)
labels.append(" ".join(signs))

frequencies = array([float(f) for f in frequencies])/sum(frequencies)
fig,ax = subplots(1, figsize=(5,5))
title('feedforward loops in E. coli, \n by signs of A->I,I->B,A->B')
show()

Relative frequencies of the different feedforward loops in E. coli

I’m not the first one to do such reasearch, but that won’t prevent me from commenting 🙂 The most frequent pattern can be seen as a double repression : gene A represses gene B, and, as an additional punishment, also represses the activator I of B. Such feedforwards are called coherent, as the two actions of the gene A have the same effect on the gene B. The second most frequent feedforward is incoherent: gene A activates gene B while activating a repressor of B, which seems a little foolish, but can be a way of creating bumps of activity (B is awaken just a few minutes before its repressor puts it down again).

## A word of caution

Note that the algorithm didn’t find any feedforward loop with activations only (+++), while some have been reported in the literature. The same way, I couldn’t find any mutual interaction between two genes (A has an action on B and B has an action on A). So if you are going to use regulonDB’s network of interactions for reasearch purposes, always have in mind :

• The database is INCOMPLETE, meaning that you can use it (carefully) to deduce the existence of stuff, but not to prove the absence of something. In particular, many gene interactions that occur through the intermediary of metabolites are omited ! For instance, the gene cyaA produces the cyclic AMP that is necessary to activate the genes regulated by crp. However only crp appears as a regulator of these genes.
• In the context of synthetic biology, the few genes added to the bacteria are often supposed to work independently of the rest of the bacteria (some biologists say that they are orthogonal to the rest of the system). Thus, if you design a feedforward loop, it will be a feedforward loop and nothing else. But keep in mind that when the pattern-matching algorithm finds a feedforward loop in E. coli’s networks, each gene of the triangle could also be under the influence of many other, and maybe the behavior of the circuit is not what could be inferred by looking only at these three genes.
• The algorithm consider isomorphism between subnetworks, which implies that it won’t mind if the subnetwork is under the influence of external genes, but it will mind if the subnetwork has auto-regulations that do not appear on the provided pattern. For instance, fis regulates crp and vice-versa, but this won’t be reported if you simply look for the pattern $A\leftrightarrow B$ because, in addition, fis and crp regulate themselves !

# Overstressed ? Here, take some bacteria !

The European jamboree of the 2012 iGEM competition (a synthetic biology contest for undergraduates) is over. And our team didn’t make it through to the world finals at Boston’s MIT 😦 .
Given that the event took place in Amsterdam, maybe this small project of mine would have given us more chances:

Hallucicoli, symbiosis meets happiness

Not sure, however, that it would be appreciated in Boston, as the FBI is one of iGEM’s main sponsors !

So what do you think… Feasible ? Marketable ?

It is a little akward to put such things on the internet, expecially if you, reader, are my future employer, so here is a disclaimer: this is just for fun (note, however, that right now real people are leading a real project to make bacteria produce THC). I do not support the use of drugs under any form and I never, ever had weed in my life (which may not be the case of many of the European iGEMers, who spent three very happy days in Amsterdam !)

# Extract data from graph pictures with Python

If you want to transform a picture of a graph into exploitable data (which is very useful in science if you want to exploit a figure from an article without bothering the authors), here is a minimalistic interface written in python with the following features:

• Data extraction from picture files or from a picture in the clipboard.
• Data extraction from rotated graphs or graphs shown with (moderate) perspective.
• Advanced interface (left-click to select a point, right-click to deselect).
• Stores the points’ coordinates in a python variable and in the clipboard (for use in another application).

You can launch the interface with

points = pic2data()

This will either start a session using the picture from the clipboard, or , if there is none, wait for the clipboard to contain a picture. Alternatively you can use a picture from a file with

points = pic2data('graph.jpeg')

You will then be asked you to place the origin of the graph, as well as the coordinates of this origin (in case it it not (0,0)), and one reference point for each axis X and Y (i.e. points of these axis whose coordinates you know). Then you can select/deselect as many points of the curve as you want, and exit with the middle button.The list of selected points [(x1,y1),(x2,y2),…] is returned.

By default the program will consider that the graph is rectangular and parralel to the edges of the pictures (wich I will call straight in what follows). This will typically be the case for a graph from a scientific article. As a consequence the algorithm will automatically replace the reference point you chose for the X axis in order to put it at the same height as the origin, and it will replace the reference point for Y exactly above the origin. However if the graph on the picture is not straight, like in a photo, use the argument straight=False.

As an example, let us take a photo with a graph, like this one.

Fig. 1: Young Frederic Chopin disguised as Mozart.

As the graph is not straight we will use

points = pic2data('mozart.jpeg', straight = False)

Which gets you to that:

After placing the points and getting their coordinates one can redraw the plot with

from pylab import *
figure()
x,y = zip(*points)
plot(x,y,'o')
show()

And voilà !

Here is the code. Happy curving !

from urlparse import urlparse

import pygtk
import gtk
import tkSimpleDialog

import matplotlib.image as mpimg
import matplotlib.pyplot as plt

import numpy as np

def tellme(s):
print s
plt.title(s,fontsize=16)
plt.draw()

def pic2data(source='clipboard',straight=True):
""" GUI to get data from a XY graph image. Either provide the graph
as a path to an image in 'source' or copy it to the clipboard.
"""

##### GET THE IMAGE

clipboard = gtk.clipboard_get()

if source=='clipboard':

# This chunk tries the text content of the clipboard
# and empties it if it is not a file path

print "Waiting for an image in the clipboard..."
while not ( clipboard.wait_is_uris_available()
or clipboard.wait_is_image_available()):
pass

if clipboard.wait_is_uris_available(): # it's a path to a file !

source = clipboard.wait_for_uris()[0]
source = urlparse(source).path
return pic2data(source)

image = clipboard.wait_for_image().get_pixels_array()
origin = 'upper'

else: # source is a path to a file !

origin = 'lower'

###### DISPLAY THE IMAGE

plt.ion() # interactive mode !
fig, ax = plt.subplots(1)
imgplot = ax.imshow(image, origin=origin)
fig.canvas.draw()
plt.draw()

##### PROMPT THE AXES

def promptPoint(text=None):

if text is not None: tellme(text)
return  np.array(plt.ginput(1,timeout=-1)[0])

initialvalue=initialvalue)

origin = promptPoint('Place the origin')

Xref =  promptPoint('Place the X reference')

Yref =  promptPoint('Place the Y reference')

if straight :

Xref[1] = origin[1]
Yref[0] = origin[0]

##### PROMPT THE POINTS

selected_points = []

print "Right-click or press 's' to select"
print "Left-click or press 'del' to deselect"
print "Middle-click or press 'Enter' to confirm"
print "Note that the keyboard may not work."

selected_points = plt.ginput(-1,timeout=-1)

##### RETURN THE POINTS COORDINATES

#~ selected_points.sort() # sorts the points in increasing x order

# compute the coordinates of the points in the user-defined system

OXref = Xref - origin
OYref = Yref - origin
xScale =  (Xref_value - origin_value[0]) / np.linalg.norm(OXref)
yScale =  (Yref_value - origin_value[1]) / np.linalg.norm(OYref)

ux = OXref / np.linalg.norm(OXref)
uy = OYref / np.linalg.norm(OYref)

result = [(ux.dot(pt - origin) * xScale + origin_value[0],
uy.dot(pt - origin) * yScale + origin_value[1])
for pt in selected_points ]

# copy the result to the clipboard

clipboard.set_text('[' + '\n'.join([str(p) for p in result]) + ']')

clipboard.store() # makes the data available to other applications

plt.ioff()

return result

# Animate your 3D plots with Python’s Matplotlib

When you have a complicated 3D plot to show in a video or slideshow, it can be nice to animate it:

I obtained this surface with

import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import axes3d

fig = plt.figure()
X, Y, Z = axes3d.get_test_data(0.05)
s = ax.plot_surface(X, Y, Z, cmap=cm.jet)
plt.axis('off') # remove axes for visual appeal

To animate it I created the function rotanimate that you can use like that:

import numpy as np
angles = np.linspace(0,360,21)[:-1] # A list of 20 angles between 0 and 360

# create an animated gif (20ms between frames)
rotanimate(ax, angles,'movie.gif',delay=20)

# create a movie with 10 frames per seconds and 'quality' 2000
rotanimate(ax, angles,'movie.mp4',fps=10,bitrate=2000)

# create an ogv movie
rotanimate(ax, angles, 'movie.ogv',fps=10)

Here is the source-code:

import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import axes3d
import os, sys
import numpy as np

##### TO CREATE A SERIES OF PICTURES

def make_views(ax,angles,elevation=None, width=4, height = 3,
prefix='tmprot_',**kwargs):
"""
Makes jpeg pictures of the given 3d ax, with different angles.
Args:
ax (3D axis): te ax
angles (list): the list of angles (in degree) under which to
take the picture.
width,height (float): size, in inches, of the output images.
prefix (str): prefix for the files created.

Returns: the list of files created (for later removal)
"""

files = []
ax.figure.set_size_inches(width,height)

for i,angle in enumerate(angles):

ax.view_init(elev = elevation, azim=angle)
fname = '%s%03d.jpeg'%(prefix,i)
ax.figure.savefig(fname)
files.append(fname)

return files

##### TO TRANSFORM THE SERIES OF PICTURE INTO AN ANIMATION

def make_movie(files,output, fps=10,bitrate=1800,**kwargs):
"""
Uses mencoder, produces a .mp4/.ogv/... movie from a list of
picture files.
"""

output_name, output_ext = os.path.splitext(output)
command = { '.mp4' : 'mencoder "mf://%s" -mf fps=%d -o %s.mp4 -ovc lavc\
-lavcopts vcodec=msmpeg4v2:vbitrate=%d'
%(",".join(files),fps,output_name,bitrate)}

command['.ogv'] = command['.mp4'] + '; ffmpeg -i %s.mp4 -r %d %s'%(output_name,fps,output)

print command[output_ext]
output_ext = os.path.splitext(output)[1]
os.system(command[output_ext])

def make_gif(files,output,delay=100, repeat=True,**kwargs):
"""
Uses imageMagick to produce an animated .gif from a list of
picture files.
"""

loop = -1 if repeat else 0
os.system('convert -delay %d -loop %d %s %s'
%(delay,loop," ".join(files),output))

def make_strip(files,output,**kwargs):
"""
Uses imageMagick to produce a .jpeg strip from a list of
picture files.
"""

os.system('montage -tile 1x -geometry +0+0 %s %s'%(" ".join(files),output))

##### MAIN FUNCTION

def rotanimate(ax, angles, output, **kwargs):
"""
Produces an animation (.mp4,.ogv,.gif,.jpeg,.png) from a 3D plot on
a 3D ax

Args:
ax (3D axis): the ax containing the plot of interest
angles (list): the list of angles (in degree) under which to
show the plot.
output : name of the output file. The extension determines the
kind of animation used.
**kwargs:
- width : in inches
- heigth: in inches
- framerate : frames per second
- delay : delay between frames in milliseconds
- repeat : True or False (.gif only)
"""

output_ext = os.path.splitext(output)[1]

files = make_views(ax,angles, **kwargs)

D = { '.mp4' : make_movie,
'.ogv' : make_movie,
'.gif': make_gif ,
'.jpeg': make_strip,
'.png':make_strip}

D[output_ext](files,output,**kwargs)

for f in files:
os.remove(f)

##### EXAMPLE

if __name__ == '__main__':

fig = plt.figure()
X, Y, Z = axes3d.get_test_data(0.05)
s = ax.plot_surface(X, Y, Z, cmap=cm.jet)
plt.axis('off') # remove axes for visual appeal

angles = np.linspace(0,360,21)[:-1] # Take 20 angles between 0 and 360

# create an animated gif (20ms between frames)
rotanimate(ax, angles,'movie.gif',delay=20)

# create a movie with 10 frames per seconds and 'quality' 2000
rotanimate(ax, angles,'movie.mp4',fps=10,bitrate=2000)

# create an ogv movie
rotanimate(ax, angles, 'movie.ogv',fps=10)

# E. coli versus the sun

I am really happy to see that the Zurich 2012 iGEM team has been designing a bacteria for sun protection. I had a similar idea a few months ago and I made a few fun slides out of it:

Bioshield – Natural Sun Protection

It seems that the team focused on sun detection and sunscreen agent production, while my concern with a bacteria-based sunscreen had been things like how to make a bacterial biofilm skin-adhesive and water-resistant. Has anyone any idea ?

# Make original and dynamic presentations with Sozi

I made a video to promote Sozi, an open-source software with which you can do presentations with nice effects (zooms, rotations, etc…). One of my commenters called my video a “meta-presentation”, which is to say a presentation on… presentations !

Interested ? Go visit their website !

# Sound up your Python !

Long simulations and optimisations are a plea to the modern modelist. Worst of all are the programs of average length (say, 5 to 15 minutes) that do not let you the time to start anything else during the runs, and have you lose your day before you know it. I wrote a few Python functions to ease the pain. The first is called ring() and produces… a ring (like an egg timer ! but if you have office-mates you may use a more neutral sound like somenone coughing, or scratching, etc…). You can use it like this:

def myLongFunction():
for i in range(100000):
print "I'm the world's most useless function !"

myLongFunction();ring()

In case you want your function to always ring at the end, you can also use my decorator @ringatend when you define the function :

@ringatend
def myLongFunction():
for i in range(100000):
print "I'm the world's most useless function !"

myLongFunction() # will ring at the end, no need to call 'ring()'

Now, if you really want to make your colleagues jealous (or crazy) you can ask Python to play some music in the background while the function runs, with my decorator @inmusic

@inmusic
def myLongFunction():
.................

myLongFunction() # will play music during the function's run !

Believe me, simulations look way shorter with on some Beny Hill (but they are actually slower 🙂 )

You can also combine the decorators to get a function that will play some music, and ring at the end:

@ringatend
@inmusic
def myLongFunction():

Here is the code for all that. You will need to install Pygame to play the sounds. I have also included some functions to splash popups: popup and @popupatend:

rom Tkinter import *
import tkMessageBox
import time
import pygame

# RING

def ring(sound='./cough.wav'):

pygame.mixer.init()
sound = pygame.mixer.Sound(sound=)
sound.play()
time.sleep(sound.get_length())
pygame.mixer.quit()

def ringatend(target):
""" a decorator to make your functions rings when they are done """

def f(*args,**kwargs):

result = target(*args,**kwargs)
ring()
return result

return f

# IN MUSIC !

def inmusic(target):
""" a decorator to play your functions in music """

def f(*args,**kwargs):

pygame.mixer.init()
sound = pygame.mixer.Sound('./music.wav')
sound.play()
result = target(*args,**kwargs)
sound.stop()
pygame.mixer.quit()
return result

return f

# POPUPS

def popup(txt='Finished'):
root = Tk()
tkMessageBox.showinfo('Finished!',txt)
root.destroy()
root.mainloop()

def popupatend(target):

def f(*args,**kwargs):

# Run the function
result = target(*args,**kwargs)

# Make a pretty text
fname = target.func_name
pretty_args = ','.join([str(a) for a in args])
pretty_kwargs = ','.join(['%s=%s'%(str(k),str(v))
for k,v in kwargs.iteritems()])
descr ='%s(%s,%s)'%(fname,pretty_args, pretty_kwargs)
descr = descr[:100] # in case it really is too long

# popup description
popup(txt='%s done !'%(descr))

return result

return f

### EXAMPLES

@ringatend
@inmusic
def myLongFunction():
for i in range(100000):
print "I'm the world's most useless function !"

myLongFunction()

@popupatend
def myLongFunction():
for i in range(100000):
print "I'm the most useless function !"

myLongFunction()

If you want to go further with the decorators, here are versions of the decorators with options that let you choose the sound or music you want to be played.

def ringatend2(soundFile):
""" a decorator generator using a specified soundfile """

def decorator(target):
""" a decorator using the specified soundfile """

def f(*args,**kwargs):

result = target(*args,**kwargs)
ring(soundFile)
return result

return f

return decorator

def inmusic2(soundFile):
""" a decorator generator using a specified soundfile """

def decorator(target):
""" a decorator to play your functions in music """

def f(*args,**kwargs):

pygame.mixer.init()
sound = pygame.mixer.Sound(soundFile)
sound.play()
result = target(*args,**kwargs)
sound.stop()
pygame.mixer.quit()
return result

return f

return decorator

### EXAMPLES

@ringatend2('./tarzan.wav')
@inmusic2('./diesIrae.wav')
def myLongFunction():
for i in range(10000):
print "The world's most useless function !"