Modelling cellular processes with Python and Scipy B.G. Olivier (bgoli@sun.ac.za), J.M. Rohwer (jr@sun.ac.za) and J.-H.S. Hofmeyr (jhsh@sun.ac.za) Dept. of Biochemistry, University of Stellenbosch, Private Bag X1, Matieland 7602, South Africa Abstract. This paper shows how Python and Scipy can be used to simulate the time-dependent and steady-state behaviour of reaction networks, and introduces Pysces, a Python modelling toolkit. Keywords: Computer Simulation, Metabolism, Python Computer Language Abbreviations: Pysces Python Simulator for Cellular Systems 1. Introduction With the rapid increase in the number of pieces in the puzzle that is the living cell, the need for tools that paste them back together again has become paramount. Computer software for modelling these complex cellular systems forms an indispensable part of this toolkit. In this paper we show how it is possible to model a metabolic reaction network directly using a modern computer language. We use Python, an interpreted scripting language with an intuitive, high-level interface well suited to numerical programming. One of the most remarkable features of Python is its ability to interface with code written in other languages. This ability is particularly useful since many tried and tested numerical routines are written in Fortran or C. In the next section we shall, using only Python and Scipy (a library of routines for scientific computing), construct a simple metabolic model, perform a time-course simulation, solve for the steady-state concentrations and generate a parameter portrait. We also introduce a new modelling tool called Pysces, short for Python Simulator of Cellular Systems, which is being developed by our group. 2. Modelling with Python and Scipy The model [3] consists of a system with a branch and a two-member moiety conserved cycle with the reaction network (Fig. 1). c 2002 Kluwer Academic Publishers. Printed in the Netherlands. btk2002_olivier.tex; 21/06/2002; 14:20; p.1
2 Olivier, Rohwer and Hofmeyr 3 X4 X0 1 S1 S2 S3 X7 2 X6 Figure 1. A example reaction network. 4 X 5 The first step is to import the Scipy module and define the rate vector as a function of the concentrations and parameters (in the code samples that follow, tab spaces have been reduced; the fully formatted source code is given in the Appendix). import scipy v = scipy.zeros((4), d ) # create rate vector def rate_eqs(s): # function with rate equations v[0]=v1*x0*s[1]/k1_x0*k1_s2/ \ (1+X0/K1_X0+S[1]/K1_S2+X0*S[1]/K1_X0*K1_S2) v[1]=v2*s[2]*x6/k2_s3*k2_x6/ \ (1+S[2]/K2_S3+X6/K2_X6+S[2]*X6/K2_S3*K2_X6) v[2]=v3*s[0]/(s[0]+k3_s1) v[3]=v4*s[0]/(s[0]+k4_s1) return v Next the differential equations are defined and the dependent metabolites are calculated, returning a vector ds dt. Note that the full ODE system is overdetermined because S2 and S3 form a moiety-conserved cycle; S3 has been chosen as the dependent metabolite and its concentration is updated by the conservation equation. The only reason that the ODE for S3 appears is to obtain its concentration as part of the output vector: def diff_eqs(s,t): Sdot = scipy.zeros((3), d ) # create ODE vector S[2] = S_tot - S[1] # calculate dependent S3 conc v = rate_eqs(s) # calculate rates # Differential equations Sdot[0] = v[0] - v[2] - v[3] # ds1/dt Sdot[1] = v[1] - v[0] # ds2/dt Sdot[2] = v[0] - v[1] # ds3/dt (only for output) return Sdot The concentration time course is generated with the Scipy LSODA ODE-solver. Although here we accept the default parameter values of btk2002_olivier.tex; 21/06/2002; 14:20; p.2
Modelling cellular processes with Python and Scipy 3 this solver, the interface allows the user to set any of these parameters through optional arguments to the odeint function: # create range of time points t_start = 0.0; t_end = 10.0; t_inc = 0.1 t_range = scipy.arange(t_start, t_end+t_inc, t_inc) t_course = scipy.integrate.odeint(diff_eqs,\ [S1,S2,S3],t_range) Similarly, the steady-state concentrations are calculated with the Scipy HYBRD non-linear solver using the final value of the time course as starting value. As with odeint, any parameter of this solver can be set by the user: fin_t_course = scipy.copy.copy(t_course[-1,:]) ss = scipy.optimize.fsolve(diff_eqs,fin_t_course,args=none) The steady-state flux is calculated from the steady-state concentrations J = rate_eqs(ss) A parameter scan (here of V 4 ) repeatedly calls the steady-state solver over a parameter range. The output of each step is used to initialise the following step. # set up scan range S_start = 0.0; S_end = 20.0; S_inc = 0.1 S_range = scipy.arange(s_start,s_end+s_inc,s_inc) ss_init = scipy.copy.copy(fin_t_course) scan_table = scipy.zeros((len(s_range),5), d ) # scan V4 for i in range(len(s_range)): V4 = S_range[i] ss = scipy.optimize.fsolve(diff_eqs,ss_init,args=none) J = rate_eqs(ss) # calculate flux scan_table[i,0] = S_range[i] scan_table[i,1:] = J ss_init = ss Results are visualised with the Scipy interface to the Gnuplot graphics program (Fig. 2). For example, the time course plot is generated by: from scipy import gplt btk2002_olivier.tex; 21/06/2002; 14:20; p.3
4 Olivier, Rohwer and Hofmeyr gplt.plot(t_range,t_course[:,0],t_range,t_course[:,1],\ t_range,t_course[:,2]) gplt.xtitle( Time ); gplt.ytitle( Concentration ) a. Time simulation b. V 4 scan of steady-state fluxes Figure 2. Examples of the graphical output of the Python/Scipy model described in the text. 3. Discussion From the above it is clear that Python/Scipy on its own already provides a simulation platform powerful enough to create models of arbitrary complexity. Python [2, 12] is a simple and clear, but extremely powerful, scripting language, allowing for both procedural and object-oriented programming. Moreover, it is open-source and therefore freely available. It is also easily extensible with wrapper generators such as Swig [11] and f2py [6], it has a very powerful numeric extension, and an existing scientific computing add-on Scipy [10] that already contains industrial strength ODE and nonlinear solvers, in addition to a number of graphing packages. However, the procedure presented is inefficient and cumbersome for large models. The user has to derive and code the ODEs and conservation equations by hand, and concentration variables have to be referred to by indexed vector variables instead of ordinary chemical names. This may cause problems for the naive user. We are therefore simplifying and automating the process of modelling by providing high-level tools in a program suite called Pysces, which include packages that: parse a model definition in terms of reaction and rate equations from which the stoichiometric matrix that describes the network topology is constructed; btk2002_olivier.tex; 21/06/2002; 14:20; p.4
Modelling cellular processes with Python and Scipy 5 analyse the stoichiometric matrix for relationships between steadystate fluxes and between the differential equations (from which conservation constraints are deduced); determine the elementary flux-modes of the system; serve as front-ends to the ODE and nonlinear solvers; calculate elasticities by differentiation of the rate equations; calculate control coefficients; do a bifurcation analysis using existing continuation algorithms; serve as front-ends to optimisation algorithms; interface to various graphing packages. It could be argued that the creation of yet another simulation platform is unnecessary, since there are already a number available: for example, Gepasi [5] (or its soon-to-be-realised reincarnation as Copasi), Scamp [9] and its successor Jarnac [8] (part of the Systems Biology Workbench project [4]), Scrumpy [7], and DBSolve [1], to name the ones that we are most familiar with. It is because we have been heavy users of these programs that we realise both their worth and their limitations. Although these are all excellent programs, none of them fulfil all of our requirements, both in terms of functionality and philosophy: we require a simulation platform that not only has a simple design, runs under all the major operating systems, and is open source, but most importantly, is completely under the control of the user, both at a low and a high level. It is the need for complete low-level control that we as primary users require most and what is lacking in other packages. Having access to a simulation platform is, however, not enough. Modelling cellular processes can be very difficult; for the beginner there is very little available in the form of teaching materials. Another envisaged feature that makes this project unique is the provision of an extensive set of freely-accessible web-based tutorials that teach the art of modelling using Pysces as platform, both in terms of the underlying theory and the construction of models and modelling tools. References 1. Goryanin, I., T. C. Hodgman, and E. Selkov: 1999, Mathematical simulation and analysis of cellular metabolism and regulation. Bioinformatics 15, 749 758. btk2002_olivier.tex; 21/06/2002; 14:20; p.5
6 Olivier, Rohwer and Hofmeyr 2. Harms, D. and K. McDonald: 1999, The Quick Python Book. Manning Publications, Greenwich. 3. Hofmeyr, J.-H. S.: 2001, Metabolic control analysis in a nutshell. In: T.-M. Yi, M. Hucka, M. Morohashi, and H. Kitano (eds.): Proceedings of the 2 nd International Conference on Systems Biology. pp. 291 300. 4. Hucka, M., A. Finney, H. Sauro, and H. Bolouri: 2001, The ERATO Systems Biology Workbench: Architectural Evolution. In: T.-M. Yi, M. Hucka, M. Morohashi, and H. Kitano (eds.): Proceedings of the 2 nd International Conference on Systems Biology. pp. 352 361. 5. Mendes, P.: 1997, Biochemistry by numbers: simulation of biochemical pathways with Gepasi 3. Trends Biochem. Sci. 9, 361 363. 6. Peterson, P., Fortran to Python Interface Generator (f2py). Information available via the World Wide Web at http://cens.ioc.ee/projects/f2py2e/ 7. Poolman, M. G., Scrumpy. Information available via the World Wide Web at http://bms-mudshark.brookes.ac.uk/scrumpy/scrumpy.html 8. Sauro, H. M.: 2000, JARNAC: A system for interactive metabolic analysis. In: J.-H. S. Hofmeyr, J. M. Rohwer, and J. L. Snoep (eds.): Animating the Cellular Map: Proceedings of the 9th International Meeting on BioThermoKinetics. pp. 221 228. 9. Sauro, H. M. and D. A. Fell: 1991, Scamp: a metabolic simulator and control analysis program. Math. Comput. Modelling 15, 15 28. 10. Scipy, Scientific tools for Python. Information available via the World Wide Web at http://www.scipy.org 11. Swig, Simplified Wrapper and Interface Generator. Information available via the World Wide Web at http://www.swig.org 12. Van Rossum, G., Python Programming Language. Information available via the World Wide Web at http://www.python.org btk2002_olivier.tex; 21/06/2002; 14:20; p.6