sloppycell-users Mailing List for SloppyCell

Hello!

I have very bad news for you.
09/08/2018 - on this day I hacked your OS and got full access to your account slo...@li...

So, you can change the password, yes... But my malware intercepts it every time.

How I made it:
In the software of the router, through which you went online, was a vulnerability.
I just hacked this router and placed my malicious code on it.
When you went online, my trojan was installed on the OS of your device.

After that, I made a full dump of your disk (I have all your address book, history of viewing sites, all files, phone numbers and addresses of all your contacts).

A month ago, I wanted to lock your device and ask for a not big amount of btc to unlock.
But I looked at the sites that you regularly visit, and I was shocked by what I saw!!!
I'm talk you about sites for adults.

I want to say - you are a BIG pervert. Your fantasy is shifted far away from the normal course!

And I got an idea....
I made a screenshot of the adult sites where you have fun (do you understand what it is about, huh?).
After that, I made a screenshot of your joys (using the camera of your device) and glued them together.
Turned out amazing! You are so spectacular!

I'm know that you would not like to show these screenshots to your friends, relatives or colleagues.
I think $731 is a very, very small amount for my silence.
Besides, I have been spying on you for so long, having spent a lot of time!

Pay ONLY in Bitcoins!
My BTC wallet: 182PJESsEWbuJ8PEgfM58p64jbok3i1gNU

You do not know how to use bitcoins?
Enter a query in any search engine: "how to replenish btc wallet".
It's extremely easy

For this payment I give you two days (48 hours).
As soon as this letter is opened, the timer will work.

After payment, my virus and dirty screenshots with your enjoys will be self-destruct automatically.
If I do not receive from you the specified amount, then your device will be locked, and all your contacts will receive a screenshots with your "enjoys".

I hope you understand your situation.
- Do not try to find and destroy my virus! (All your data, files and screenshots is already uploaded to a remote server)
- Do not try to contact me (this is not feasible, I sent you an email from your account)
- Various security services will not help you; formatting a disk or destroying a device will not help, since your data is already on a remote server.

P.S. You are not my single victim. so, I guarantee you that I will not disturb you again after payment!
 This is the word of honor hacker

I also ask you to regularly update your antiviruses in the future. This way you will no longer fall into a similar situation.

Do not hold evil! I just do my job.
Good luck.

Hi,

By trial and error I noticed that constraints do not work if they are added to a network that has already been integrated.

Here is a minimal example:

from SloppyCell.ReactionNetworks import *
from SloppyCell.Testing.AlgTestNets import algebraic_net
import scipy
tlist_algebraic_net = scipy.array([0] + [0.8*x for x in range(1, 51)])
algebraic_net_constraints = algebraic_net.copy('alg_net_constraints')
traj1 = Dynamics.integrate(algebraic_net_constraints, tlist_algebraic_net)
algebraic_net_constraints.addConstraint('X1toobig',trigger='leq(X1,0.5)',
                                        message='X1 is big!')
traj2 = Dynamics.integrate(algebraic_net_constraints, tlist_algebraic_net)

If the first integration (traj1) is removed, the constraint works as expected. This apparently occurs only for constraints that are triggered after t=0.

Is this intended behavior?

Best,
Fridolin

Attempting to install the sloppycell package using pip2.7 gives the
following error message:

Collecting sloppycell
  Using cached SloppyCell-1.1.0.dev1.tar.gz
    Complete output from command python setup.py egg_info:
    /usr/lib/python2.7/dist-packages/setuptools/dist.py:333: UserWarning:
Normalizing '1.1.0dev1' to '1.1.0.dev1'
      normalized_version,
    running egg_info
    running build_src
    build_src
    building extension "SloppyCell._daskr" sources
      target build/src.linux-x86_64-2.7/SloppyCell/_daskrmodule.c does not
exist:
       Assuming _daskrmodule.c was generated with "build_src --inplace"
command.
       Yes! Using 'SloppyCell/_daskrmodule.c' as up-to-date target.
    f2py options: []
      adding 'build/src.linux-x86_64-2.7/fortranobject.c' to sources.
      adding 'build/src.linux-x86_64-2.7' to include_dirs.
    error: f2py target_c file 'build/src.linux-x86_64-2.7/fortranobject.c'
not found

    ----------------------------------------
Command "python setup.py egg_info" failed with error code 1 in
/tmp/pip-build-st1Xij/sloppycell/

One possible reason is that I want sloppycell to be run with python2.7 but
on my system the python command is aliased to python3.6 by Anaconda.

As a work-around, I think I can get around this by simply running python
setup.py build on the source, so this isn't a pressing issue for me at the
moment.

-Varun

Greetings,

Welcome to our site for cars and trucks in USA:

www.caradsusa.com

Sell It Yourself and online shopping site
for cars, trucks, spare parts, accessories,
services and rentals.

Find your: cars for sale, new cars, used cars and 
collector cars. Search for spare parts, accessories,
services and rentals here.

Always free advertising for one week or longer 
for a small fee.

This site is also a very good resource for older cars,
collector cars, veteran cars, antique cars, vintage cars 
or classic cars, because we got world largest car maker 
list included in our shopping and advertising site.

If you are interested, do not forget to tell
your friends about our site.

Welcome to try this site and join us.

Best Regards,

Car Ads USA

Unsubscribing:

If you wish not to receive any more information
from us simply use this link to unsubscribe:

http://caradsusa.com/scripts/unsubscribe.php?ema...@li...

Hi,

Let me thank you first for sharing this amazing work so everyone can learn
what you guys have done.
I am trying to re-produce the plots that are presented in 2004 paper: "The
statistical mechanics of complex signaling networks: nerve growth
​ ​
factor signaling". I can successfully run the corresponding directories
(any of those 2004 folders) and even can run run.Models.py
<http://run.models.py/> but I am not able to run any of these python codes
that are provided at Gutenkunst2007.

Fig1B_spectra_plot.py
Fig1C_alignment_plot.py
Fig3_plot.py
S1_eigenvector_plots.py
S4_rescaled_Brown_plot.py
S5_plot.py

The error that I get is this:
line 14, in <module>
h = scipy.io.read_array(os.path.join(model, 'hessian.dat'))
AttributeError: 'module' object has no attribute 'read_array'

I am using PyCharm  to run the python codes. I really appreciate if you can
help me to figure out what my mistake is.

Best regards
Mohammad Jabalameli
Physics PhD candidate, Northeastern University

Hi SloppyCell peeps, I'm getting the following three errors when I run the
test suite that is included in the package.  All other tests pass. Any idea
what's up?

Thanks!

- Gaurav

ERROR: test_Nonoscillatory (test_Periodic.test_Periodic)

Test that a nonoscillatory network is detected

----------------------------------------------------------------------

Traceback (most recent call last):

  File
"/Users/gaurav/Desktop/sloppycell-git-90b2667456ad90be6698fbd7614e39d9176a9b86/Testing/test_Periodic.py",
line 340, in test_Nonoscillatory

    net.Calculate({'M_P':[0, 72]})

  File
"//anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.6-x86_64.egg/SloppyCell/ReactionNetworks/Network_mod.py",
line 904, in Calculate

    self._find_limit_cycle(params)

  File
"//anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.6-x86_64.egg/SloppyCell/ReactionNetworks/Network_mod.py",
line 804, in _find_limit_cycle

    s_star = scipy.exp(self._eliminate_slowest_mode(ls0, ls1, ls2))

  File
"//anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.6-x86_64.egg/SloppyCell/ReactionNetworks/Network_mod.py",
line 757, in _eliminate_slowest_mode

    s[1:] -= lambda_1*lambda_1*vector_1

TypeError: Cannot cast ufunc subtract output from dtype('complex128') to
dtype('float64') with casting rule 'same_kind'


======================================================================

ERROR: test_Assignment (test_Stochastic.test_Events)

Test that assignments work in the stochastic integrator

----------------------------------------------------------------------

Traceback (most recent call last):

  File
"/Users/gaurav/Desktop/sloppycell-git-90b2667456ad90be6698fbd7614e39d9176a9b86/Testing/test_Stochastic.py",
line 62, in test_Assignment

    params)

  File
"//anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.6-x86_64.egg/SloppyCell/ReactionNetworks/Network_mod.py",
line 874, in calculate

    self.Calculate(vars, params)

  File
"//anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.6-x86_64.egg/SloppyCell/ReactionNetworks/Network_mod.py",
line 908, in Calculate

    self.trajectory = self.integrateStochastic(t, params=params)

  File
"//anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.6-x86_64.egg/SloppyCell/ReactionNetworks/Network_mod.py",
line 1177, in integrateStochastic

    t, dv, cv, self.stochastic['rmsd'], times[tInd])

  File "<string>", line 3, in integrate_stochastic_tidbit

  File "mtrand.pyx", line 967, in mtrand.RandomState.seed
(numpy/random/mtrand/mtrand.c:12182)

ValueError: Seed must be between 0 and 4294967295


======================================================================

ERROR: test_basic (test_Stochastic.test_Events)

Test that the stochastic integrator's basic functions work

----------------------------------------------------------------------

Traceback (most recent call last):

  File
"/Users/gaurav/Desktop/sloppycell-git-90b2667456ad90be6698fbd7614e39d9176a9b86/Testing/test_Stochastic.py",
line 32, in test_basic

    net.Calculate({'x':times}, params)

  File
"//anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.6-x86_64.egg/SloppyCell/ReactionNetworks/Network_mod.py",
line 908, in Calculate

    self.trajectory = self.integrateStochastic(t, params=params)

  File
"//anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.6-x86_64.egg/SloppyCell/ReactionNetworks/Network_mod.py",
line 1177, in integrateStochastic

    t, dv, cv, self.stochastic['rmsd'], times[tInd])

  File "<string>", line 3, in integrate_stochastic_tidbit

  File "mtrand.pyx", line 967, in mtrand.RandomState.seed
(numpy/random/mtrand/mtrand.c:12182)

ValueError: Seed must be between 0 and 4294967295

Hi Uriel,

I assume you mean at the parameter optimization level... None of the optimizers built into SloppyCell has that feature. One somewhat hacky way to do it is to define a residual that implements that constraint, by penalizing deviations away from it. It would be something like Residual.Prior, but with a more complex GetValue and derivatives.

Best,
Ryan

On Apr 21, 2016, at 5:33 AM, Uriel Urquiza <s12...@sm...> wrote:

> Ryan 
> 
> Is it possible to impose a constrain rule  e.g. ((p1+p2) - μ)**2/σ**2
> 
> Uriel
> 
>> On May 4, 2015, at 11:26 AM, Uriel Urquiza <s12...@sm...> wrote:
>> 
>> Hi Ryan,
>> 
>> Im trying to enforce a period and amplitude constrain in sloppy cell and sensitivity integration (si) dose not work for them. I am doing thinking in making 
>> additional lm functions that use finite differences instead of si. Is is reasonable to use as template the original lm functions? or a more deep medications
>> are necessary to avoid using si
>> 
>> Cheers
>> 
>> 
>> Uriel
> 
> 
> -- 
> The University of Edinburgh is a charitable body, registered in
> Scotland, with registration number SC005336.
> 

--
Ryan Gutenkunst
Assistant Professor of Molecular and Cellular Biology, University of Arizona
phone: (520) 626-0569, office: LSS 325, web: http://gutengroup.mcb.arizona.edu

Latest papers: "Triallelic population genomics for inferring correlated fitness effects of same site nonsynonymous mutations"
Genetics; http://dx.doi.org/10.1534/genetics.115.184812
"Whole genome sequence analyses of Western Central African Pygmy hunter-gatherers reveal a complex demographic history and identify candidate genes under positive natural selection"
Genome Research; http://dx.doi.org/10.1101/gr.192971.115

Ryan 

Is it possible to impose a constrain rule  e.g. ((p1+p2) - μ)**2/σ**2

Uriel
-- 
The University of Edinburgh is a charitable body, registered in
Scotland, with registration number SC005336.

Ryan 

Is it possible to impose a constrain rule  e.g. ((p1+p2) - μ)**2/σ**2

Uriel

> On May 4, 2015, at 11:26 AM, Uriel Urquiza <s12...@sm...> wrote:
> 
> Hi Ryan,
> 
> Im trying to enforce a period and amplitude constrain in sloppy cell and sensitivity integration (si) dose not work for them. I am doing thinking in making 
> additional lm functions that use finite differences instead of si. Is is reasonable to use as template the original lm functions? or a more deep medications
> are necessary to avoid using si
> 
> Cheers
> 
> 
> Uriel


-- 
The University of Edinburgh is a charitable body, registered in
Scotland, with registration number SC005336.

run run_JAK_mod.py

Initial cost: 298.94896354
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
/home/amritava/programming/JAK-STAT/run_JAK_mod.py in <module>()
     17 
     18 print 'Initial cost:', m.cost(params)
---> 19 params = Optimization.fmin_lm_log_params(m, params, maxiter=20, disp=False)
     20 print 'Optimized cost:', m.cost(params)
     21 print 'Optimized parameters:', params

/usr/local/lib/python2.7/dist-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/Optimization.pyc in fmin_lm_log_params(m, params, *args, **kwargs)
    135     jac = lambda lp: scipy.asarray(m.jacobian_log_params_sens(lp))
    136     sln = lmopt.fmin_lm(f=func, x0=scipy.log(params), fprime=jac,
--> 137                         *args, **kwargs)
    138     if isinstance(params, KeyedList):
    139         pout = params.copy()

/usr/local/lib/python2.7/dist-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/lmopt.pyc in fmin_lm(f, x0, fprime, args, avegtol, epsilon, maxiter, full_output, disp, retall, lambdainit, jinit, trustradius)
    173     func_calls = 0
    174     grad_calls = 0
--> 175     res,currentcost = safe_res(f,x0,args)
    176     func_calls+=1
    177     m = res.shape[0]

/usr/local/lib/python2.7/dist-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/lmopt.pyc in safe_res(f, x, args)
     92     """
     93     try:
---> 94         res = asarray(apply(f,(x,)+args))
     95         cost = sum(res**2)
     96     except (SloppyCell.Utility.SloppyCellException,OverflowError):

/usr/local/lib/python2.7/dist-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/Optimization.pyc in func(log_params)
    128     def func(log_params):
    129         try:
--> 130             return m.res_log_params(log_params)
    131         except Utility.SloppyCellException:
    132             logger.warn('Exception in cost evaluation. Cost set to inf.')

/usr/local/lib/python2.7/dist-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/Model_mod.pyc in res_log_params(self, log_params)
    158         Return the residual values given the logarithm of the parameters
    159         """
--> 160         return self.res(scipy.exp(log_params))
    161 
    162     def res_dict(self, params):

/usr/local/lib/python2.7/dist-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/Model_mod.pyc in res(self, params)
    152         """
    153 
--> 154         return self._evaluate(params)[0]
    155 
    156     def res_log_params(self, log_params):

/usr/local/lib/python2.7/dist-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/Model_mod.pyc in _evaluate(self, params, T)
    114          arrangment makes notification of observers much simpler.)
    115         """
--> 116         self.params.update(params)
    117         self.check_parameter_bounds(params)
    118         self.CalculateForAllDataPoints(params)

/usr/local/lib/python2.7/dist-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/KeyedList_mod.pyc in update(self, other)
    113         else:
    114             if(len(self) != len(other)):
--> 115                 raise ValueError, 'Other list not of same length!'
    116             for ii in range(len(self)):
    117                 self[ii] = other[ii]

ValueError: Other list not of same length!

Hello Ally,

(I've CC'd my response to SloppyCell-users, just so this gets archived. Without your code, I don't think there's anything proprietary to worry about.)

This is the case where the fix is simple, but the reasoning is subtle (and points out the dangers of global variables). All you need to do is move the call to Network.full_speed() to be before you import RunInParallel.

Why is this the fix?
As you probably know, in MPI each worker runs the same code file as the master. They only branch when there's specific code that identifies whether the node is worker or master. In SloppyCell's case, this happens when RunInParallel is imported. So everything before that call will be run on all the nodes, everything after it only run on the master. Network.full_speed() sets a global variable in ReactionNetworks.Network_mod that makes integrations default to only calculating requested points, rather than filling in the whole trajectory (which makes for nicer plots). Because this is changing the behavior of the integrator, it results in small changes to numerical accuracy, which are amplified in an optimization run, because of the many evaluations that an optimization does, changing the chosen parameter set based on small changes in the previous cost. So when running in Parallel, the workers were calculating without full_speed(), so some networks were being integrated that way. When calculating serially, all networks were integrated with full_speed().

So the issue was with numerical precision, but not in passing values between nodes.

Best,
Ryan

On May 29, 2015, at 8:52 AM, Ally Hume <a....@ed...> wrote:

> Hi Ryan,
> 
> I attach the code and models. The models are scientific work in progress so please don't pass onto others and please only use for this debugging exercise and then delete. Thanks.
> 
> In the code the main python script is: runTest.py  this is the parallel version. 
> 
> If you run with different numbers of nodes you will see different results, e.g. 
> 
> mpirun -n 3 python runTest.py
> 
> produces:
> 
> Iteration number 0
> Current cost 275715250.891
> Move 1 gives cost of 259236857.311
> Move 2 gives cost of  259237326.162
> Iteration number 1
> Current cost 259237326.162
> Move 1 gives cost of 245677098.168
> Move 2 gives cost of  245676895.78
> Current function value: 245676895.780133
> Iterations: 2
> Function evaluations: 7
> Gradient evaluations: 3
> Maximum number of iterations exceeded with no convergence 
> Best cost: 122838447.89
> 
> but -n 1 or -n 2 will produce different data. (Note that -n 10 seems to crash but that is another problem I've yet to investigate in any detail!)
> 
> The code may use pandas to do some data processing of the models. If you get errors related to that then please install pandas.
> 
> The actual output includes lots of warnings and errors but at the end you see the output shown above.
> 
> As I said previously I suspect it is in the Calculate function because if I make that execute all processing on the master then we get consistent results.
> 
> Thanks you very much for your help with this.  Hopefully you can run this quite easily. If it is too complex for you to run then we can probably trim it down to a simpler example that still exhibits the problem, but if you can run this then it saves us that work.
> 
> As you say it may be rounding errors but I would expect pythons pickle functionality to mean that there is no now of precision as data is passed back and forward between the master and the nodes so I don't see why rounding errors should be the cause of this.  But I could be missing something.
> 
> Anyway good luck, please let me know if I can help.  Also there is not rush for this - please do not let it spoil your weekend. I just want to send this email before the weekend.  We are not expecting you to work on it over the weekend! :)
> 
> Regards,
> 
> Ally
> 
> 
> 
> -- 
> The University of Edinburgh is a charitable body, registered in
> Scotland, with registration number SC005336.
> 
> <SloppyCellDebugging.tar.gz>
> 
> Ally Hume
> Software Architect
> EPCC, The University of Edinburgh
> Tel: 0131 651 3397   Skype: ally.hume
> 
> 
> 
> 
> 
> 
> 
> 
> On 28 May 2015, at 17:54, "Gutenkunst, Ryan N - (rgutenk)" <rg...@em...> wrote:
> 
>> Hi Ally,
>> 
>> I agree, this is worrying. My big concern is if individual parameter evaluations are giving noticeably different results. The optimization routines can be sensitive to very small differences (numerical precision) in intermediate results, which is something we can't really control.
>> 
>> Can you send me a working example, and I can help debug?
>> 
>> Best,
>> Ryan
>> 
>> On May 27, 2015, at 8:23 AM, Ally Hume <a....@ed...> wrote:
>>> Hi,
>>> 
>>> I've been running the Optimization.fmin_lm_log_params function in parallel and sequentially and I get a different results depending on the number of nodes I use. 
>>> 
>>> I did a bit of debugging and have managed to track it down to the Calculate function in Collections.py.  If I change this part of the code so that it always runs sequentially (i.e. does all the processing locally rather than sending some off to the worker nodes) then I get consistent results no matter how many nodes I'm using.
>>> 
>>> This seems very worrying. I can probably prove data privately if you are unable to reproduce this yourselves.
>>> 
>>> Ally
>>> 
>>> Ally Hume
>>> Software Architect
>>> EPCC, The University of Edinburgh
>>> Tel: 0131 651 3397   Skype: ally.hume
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> -- 
>>> The University of Edinburgh is a charitable body, registered in
>>> Scotland, with registration number SC005336.
>>> 
>>> 
>>> ------------------------------------------------------------------------------
>>> _______________________________________________
>>> SloppyCell-users mailing list
>>> Slo...@li...
>>> https://lists.sourceforge.net/lists/listinfo/sloppycell-users
>> 
>> --
>> Ryan Gutenkunst
>> Assistant Professor
>> Molecular and Cellular Biology
>> University of Arizona
>> phone: (520) 626-0569, office LSS 325
>> http://gutengroup.mcb.arizona.edu
>> 
>> 
> 

--
Ryan Gutenkunst
Assistant Professor
Molecular and Cellular Biology
University of Arizona
phone: (520) 626-0569, office LSS 325
http://gutengroup.mcb.arizona.edu

Hi Ally,

I agree, this is worrying. My big concern is if individual parameter evaluations are giving noticeably different results. The optimization routines can be sensitive to very small differences (numerical precision) in intermediate results, which is something we can't really control.

Can you send me a working example, and I can help debug?

Best,
Ryan

On May 27, 2015, at 8:23 AM, Ally Hume <a....@ed...> wrote:
> Hi,
> 
> I've been running the Optimization.fmin_lm_log_params function in parallel and sequentially and I get a different results depending on the number of nodes I use. 
> 
> I did a bit of debugging and have managed to track it down to the Calculate function in Collections.py.  If I change this part of the code so that it always runs sequentially (i.e. does all the processing locally rather than sending some off to the worker nodes) then I get consistent results no matter how many nodes I'm using.
> 
> This seems very worrying. I can probably prove data privately if you are unable to reproduce this yourselves.
> 
> Ally
> 
> Ally Hume
> Software Architect
> EPCC, The University of Edinburgh
> Tel: 0131 651 3397   Skype: ally.hume
> 
> 
> 
> 
> 
> 
> 
> 
> 
> -- 
> The University of Edinburgh is a charitable body, registered in
> Scotland, with registration number SC005336.
> 
> 
> ------------------------------------------------------------------------------
> _______________________________________________
> SloppyCell-users mailing list
> Slo...@li...
> https://lists.sourceforge.net/lists/listinfo/sloppycell-users

--
Ryan Gutenkunst
Assistant Professor
Molecular and Cellular Biology
University of Arizona
phone: (520) 626-0569, office LSS 325
http://gutengroup.mcb.arizona.edu

Hi,

I've been running the Optimization.fmin_lm_log_params function in parallel and sequentially and I get a different results depending on the number of nodes I use. 

I did a bit of debugging and have managed to track it down to the Calculate function in Collections.py.  If I change this part of the code so that it always runs sequentially (i.e. does all the processing locally rather than sending some off to the worker nodes) then I get consistent results no matter how many nodes I'm using.

This seems very worrying. I can probably prove data privately if you are unable to reproduce this yourselves.

Ally

Ally Hume
Software Architect
EPCC, The University of Edinburgh
Tel: 0131 651 3397   Skype: ally.hume









-- 
The University of Edinburgh is a charitable body, registered in
Scotland, with registration number SC005336.

Hello Uriel,

If you're using SloppyCell.Optimization.fmin_lm_log_params, you should just need to change the call to m.jacobian_log_params_sens to a call to m.jacobian_fd, with a multiplication to account for converting from log params to normal params. The easiest way to do this is probably to create a jacobian_log_params_fd method in the Model.py Model class that is modeled on the jacobian_log_params_sens function.

Let me know if this isn't clear.

Best,
Ryan

On May 4, 2015, at 3:26 AM, Uriel Urquiza <s12...@sm...> wrote:

> Hi Ryan,
> 
> Im trying to enforce a period and amplitude constrain in sloppy cell and sensitivity integration (si) dose not work for them. I am doing thinking in making 
> additional lm functions that use finite differences instead of si. Is is reasonable to use as template the original lm functions? or a more deep medications
> are necessary to avoid using si
> 
> Cheers
> 
> 
> Uriel 
> -- 
> The University of Edinburgh is a charitable body, registered in
> Scotland, with registration number SC005336.
> 

--
Ryan Gutenkunst
Assistant Professor
Molecular and Cellular Biology
University of Arizona
phone: (520) 626-0569, office LSS 325
http://gutengroup.mcb.arizona.edu

Hi Ryan,

Im trying to enforce a period and amplitude constrain in sloppy cell and sensitivity integration (si) dose not work for them. I am doing thinking in making 
additional lm functions that use finite differences instead of si. Is is reasonable to use as template the original lm functions? or a more deep medications
are necessary to avoid using si

Cheers


Uriel 
-- 
The University of Edinburgh is a charitable body, registered in
Scotland, with registration number SC005336.

Hi Ally,

If the model/data comparison involves multiple Networks, then the integrations for those multiple networks are run in parallel. If you're problem uses only a single network, then you won't see any parallelism at that level.

Best,
Ryan

On Apr 24, 2015, at 12:40 PM, Ally Hume <a....@ed...> wrote:

> Fair point! I never noticed parallelism speed up the hessian calculation so I assumed there was no parallelism is that function. I'll investigate next week why I saw no speed up.
> 
> Regards,
> 
> Ally
> 
> Quoting "Gutenkunst, Ryan N - (rgutenk)" <rg...@em...> on Fri, 24 Apr 2015 16:42:47 +0000:
> 
>> Hi Ally,
>> 
>> Yes, the hessian calculations should be easily parallelizable. The tricky part will be ensuring that if that level is parallelized, then parallelization for the lower level cost calculations might need to be disabled, because I'm not sure how it will behave with mpi calls within mpi calls.
>> 
>> Best,
>> Ryan
>> 
>> On Apr 24, 2015, at 9:03 AM, Ally Hume <a....@ed...> wrote:
>> 
>>> Ryan,
>>> 
>>> Fix seems to have worked well.
>>> 
>>> I'm now starting to think about possible other parallelisations and was considering looking at the hessian() and hessian_log_params() as these can take while and there is a nice loop in there that looks easily parallelisable at first glance. It's just a suggestion and I cannot guarantee getting round to doing it but I was just wondering if you had any comments about the idea?
>>> 
>>> I would, of course, contribute back any code I do develop.
>>> 
>>> Regards,
>>> 
>>> Ally
>>> 
>>> 
>>> Ally Hume
>>> Software Architect
>>> EPCC, The University of Edinburgh
>>> Tel: 0131 651 3397   Skype: ally.hume
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> On 18 Apr 2015, at 00:42, "Gutenkunst, Ryan N - (rgutenk)" <rg...@em...> wrote:
>>> 
>>>> Hi Ally,
>>>> 
>>>> First, thank you for the very thorough bug report! It was actually two bugs. The first was a simple typo bug in using the N_dyn_vars name. The second more subtle bug had to do with how events are handled in the integration when running in parallel. Both should now be fixed in the git repository.
>>>> 
>>>> The parallel code hasn't been thoroughly tested in a while. To help ensure there aren't other lingering bugs, please advise the researcher to compare results of a parallel and non-paralllel jacobian evaluation to ensure they're equal, before running extensive calculations.
>>>> 
>>>> Best,
>>>> Ryan
>>>> 
>>>> On Apr 17, 2015, at 9:39 AM, Ally Hume <a....@ed...> wrote:
>>>> 
>>>>> I have trying to use the MPI parallelism functionality of sloppy cell and the code is hanging and simply never terminates.
>>>>> 
>>>>> I have debugged it a bit and now know a more about the cause but I would need to understand the code much better to go any further.
>>>>> 
>>>>> The Dyamics.integrate_sensitivity function sends out the tasks to the workers, processes some data at the master and then waits for each worker to return.  When worker 1 returns the result it is parsed by _parse_sens_result.  This function is throwing a NameError exception which is not caught here so the code does not try to get a result from workers 2,3,4... and hence these workers never terminate and the whole job hangs.
>>>>> 
>>>>> So why does _parse_sens_result throw an exception?  Because N_dyn_vars is not defined.  If I record the stack trace I get:
>>>>> 
>>>>> Traceback (most recent call last):
>>>>> File "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 958, in integrate_sensitivity
>>>>> _parse_sens_result(result, net, vars_assigned[worker], yout, youtdt, events_occurred)
>>>>> File "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 869, in _parse_sens_result
>>>>> e.ysens_fired = scipy.concatenate((e.ysens_fired, result[-1][eii].ysens_fired[N_dyn_vars:]))
>>>>> NameError: global name 'N_dyn_vars' is not defined
>>>>> 
>>>>> The line numbers do not match the code in git as I have added lots of debug lines to get this far. But you will see the line that is causing the problem is the first line in _parse_sens_result that uses the variable N_dyn_vars.
>>>>> 
>>>>> Could we be doing something wrong or is this a bug?  This all comes from a call to: Optimization.fmin_lm_log_params
>>>>> 
>>>>> If need be I can ask the researcher for more details of the model. My role here is to support him by getting this running on a cluster.
>>>>> 
>>>>> Any advise?
>>>>> 
>>>>> Regards,
>>>>> 
>>>>> Ally
>>>>> 
>>>>> Ally Hume
>>>>> Software Architect
>>>>> EPCC, The University of Edinburgh
>>>>> Tel: 0131 651 3397   Skype: ally.hume
>>>>> 
>>>>> 
>>>>> 
>>>>> 
>>>>> 
>>>>> 
>>>>> 
>>>>> 
>>>>> 
>>>>> --
>>>>> The University of Edinburgh is a charitable body, registered in
>>>>> Scotland, with registration number SC005336.
>>>>> 
>>>>> 
>>>>> ------------------------------------------------------------------------------
>>>>> BPM Camp - Free Virtual Workshop May 6th at 10am PDT/1PM EDT
>>>>> Develop your own process in accordance with the BPMN 2 standard
>>>>> Learn Process modeling best practices with Bonita BPM through live exercises
>>>>> http://www.bonitasoft.com/be-part-of-it/events/bpm-camp-virtual- event?utm_
>>>>> source=Sourceforge_BPM_Camp_5_6_15&utm_medium=email&utm_campaign=VA_SF
>>>>> _______________________________________________
>>>>> SloppyCell-users mailing list
>>>>> Slo...@li...
>>>>> https://lists.sourceforge.net/lists/listinfo/sloppycell-users
>>>> 
>>>> --
>>>> Ryan Gutenkunst
>>>> Assistant Professor
>>>> Molecular and Cellular Biology
>>>> University of Arizona
>>>> phone: (520) 626-0569, office LSS 325
>>>> http://gutengroup.mcb.arizona.edu
>>>> 
>>>> 
>>> 
>>> 
>>> --
>>> The University of Edinburgh is a charitable body, registered in
>>> Scotland, with registration number SC005336.
>>> 
>> 
>> --
>> Ryan Gutenkunst
>> Assistant Professor
>> Molecular and Cellular Biology
>> University of Arizona
>> phone: (520) 626-0569, office LSS 325
>> http://gutengroup.mcb.arizona.edu
>> 
>> 
>> 
> 
> 
> 
> ----------------------------------------------------------
> Ally Hume
> Software Architect
> EPCC, The University of Edinburgh
> Tel: +44 131 651 3397
> 
> 
> -- 
> The University of Edinburgh is a charitable body, registered in
> Scotland, with registration number SC005336.
> 
> 

--
Ryan Gutenkunst
Assistant Professor
Molecular and Cellular Biology
University of Arizona
phone: (520) 626-0569, office LSS 325
http://gutengroup.mcb.arizona.edu

Fair point! I never noticed parallelism speed up the hessian  
calculation so I assumed there was no parallelism is that function.  
I'll investigate next week why I saw no speed up.

Regards,

Ally

Quoting "Gutenkunst, Ryan N - (rgutenk)" <rg...@em...>  
on Fri, 24 Apr 2015 16:42:47 +0000:

> Hi Ally,
>
> Yes, the hessian calculations should be easily parallelizable. The  
> tricky part will be ensuring that if that level is parallelized,  
> then parallelization for the lower level cost calculations might  
> need to be disabled, because I'm not sure how it will behave with  
> mpi calls within mpi calls.
>
> Best,
> Ryan
>
> On Apr 24, 2015, at 9:03 AM, Ally Hume <a....@ed...> wrote:
>
>> Ryan,
>>
>> Fix seems to have worked well.
>>
>> I'm now starting to think about possible other parallelisations and  
>> was considering looking at the hessian() and hessian_log_params()  
>> as these can take while and there is a nice loop in there that  
>> looks easily parallelisable at first glance. It's just a suggestion  
>> and I cannot guarantee getting round to doing it but I was just  
>> wondering if you had any comments about the idea?
>>
>> I would, of course, contribute back any code I do develop.
>>
>> Regards,
>>
>> Ally
>>
>>
>> Ally Hume
>> Software Architect
>> EPCC, The University of Edinburgh
>> Tel: 0131 651 3397   Skype: ally.hume
>>
>>
>>
>>
>>
>>
>>
>>
>> On 18 Apr 2015, at 00:42, "Gutenkunst, Ryan N - (rgutenk)"  
>> <rg...@em...> wrote:
>>
>>> Hi Ally,
>>>
>>> First, thank you for the very thorough bug report! It was actually  
>>> two bugs. The first was a simple typo bug in using the N_dyn_vars  
>>> name. The second more subtle bug had to do with how events are  
>>> handled in the integration when running in parallel. Both should  
>>> now be fixed in the git repository.
>>>
>>> The parallel code hasn't been thoroughly tested in a while. To  
>>> help ensure there aren't other lingering bugs, please advise the  
>>> researcher to compare results of a parallel and non-paralllel  
>>> jacobian evaluation to ensure they're equal, before running  
>>> extensive calculations.
>>>
>>> Best,
>>> Ryan
>>>
>>> On Apr 17, 2015, at 9:39 AM, Ally Hume <a....@ed...> wrote:
>>>
>>>> I have trying to use the MPI parallelism functionality of sloppy  
>>>> cell and the code is hanging and simply never terminates.
>>>>
>>>> I have debugged it a bit and now know a more about the cause but  
>>>> I would need to understand the code much better to go any further.
>>>>
>>>> The Dyamics.integrate_sensitivity function sends out the tasks to  
>>>> the workers, processes some data at the master and then waits for  
>>>> each worker to return.  When worker 1 returns the result it is  
>>>> parsed by _parse_sens_result.  This function is throwing a  
>>>> NameError exception which is not caught here so the code does not  
>>>> try to get a result from workers 2,3,4... and hence these workers  
>>>> never terminate and the whole job hangs.
>>>>
>>>> So why does _parse_sens_result throw an exception?  Because  
>>>> N_dyn_vars is not defined.  If I record the stack trace I get:
>>>>
>>>> Traceback (most recent call last):
>>>> File  
>>>> "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 958, in  
>>>> integrate_sensitivity
>>>> _parse_sens_result(result, net, vars_assigned[worker], yout,  
>>>> youtdt, events_occurred)
>>>> File  
>>>> "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 869, in  
>>>> _parse_sens_result
>>>> e.ysens_fired = scipy.concatenate((e.ysens_fired,  
>>>> result[-1][eii].ysens_fired[N_dyn_vars:]))
>>>> NameError: global name 'N_dyn_vars' is not defined
>>>>
>>>> The line numbers do not match the code in git as I have added  
>>>> lots of debug lines to get this far. But you will see the line  
>>>> that is causing the problem is the first line in  
>>>> _parse_sens_result that uses the variable N_dyn_vars.
>>>>
>>>> Could we be doing something wrong or is this a bug?  This all  
>>>> comes from a call to: Optimization.fmin_lm_log_params
>>>>
>>>> If need be I can ask the researcher for more details of the  
>>>> model. My role here is to support him by getting this running on  
>>>> a cluster.
>>>>
>>>> Any advise?
>>>>
>>>> Regards,
>>>>
>>>> Ally
>>>>
>>>> Ally Hume
>>>> Software Architect
>>>> EPCC, The University of Edinburgh
>>>> Tel: 0131 651 3397   Skype: ally.hume
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>> --
>>>> The University of Edinburgh is a charitable body, registered in
>>>> Scotland, with registration number SC005336.
>>>>
>>>>
>>>> ------------------------------------------------------------------------------
>>>> BPM Camp - Free Virtual Workshop May 6th at 10am PDT/1PM EDT
>>>> Develop your own process in accordance with the BPMN 2 standard
>>>> Learn Process modeling best practices with Bonita BPM through  
>>>> live exercises
>>>> http://www.bonitasoft.com/be-part-of-it/events/bpm-camp-virtual-  
>>>> event?utm_
>>>> source=Sourceforge_BPM_Camp_5_6_15&utm_medium=email&utm_campaign=VA_SF
>>>> _______________________________________________
>>>> SloppyCell-users mailing list
>>>> Slo...@li...
>>>> https://lists.sourceforge.net/lists/listinfo/sloppycell-users
>>>
>>> --
>>> Ryan Gutenkunst
>>> Assistant Professor
>>> Molecular and Cellular Biology
>>> University of Arizona
>>> phone: (520) 626-0569, office LSS 325
>>> http://gutengroup.mcb.arizona.edu
>>>
>>>
>>
>>
>> --
>> The University of Edinburgh is a charitable body, registered in
>> Scotland, with registration number SC005336.
>>
>
> --
> Ryan Gutenkunst
> Assistant Professor
> Molecular and Cellular Biology
> University of Arizona
> phone: (520) 626-0569, office LSS 325
> http://gutengroup.mcb.arizona.edu
>
>
>



----------------------------------------------------------
Ally Hume
Software Architect
EPCC, The University of Edinburgh
Tel: +44 131 651 3397


-- 
The University of Edinburgh is a charitable body, registered in
Scotland, with registration number SC005336.

Hi Ally,

Yes, the hessian calculations should be easily parallelizable. The tricky part will be ensuring that if that level is parallelized, then parallelization for the lower level cost calculations might need to be disabled, because I'm not sure how it will behave with mpi calls within mpi calls.

Best,
Ryan

On Apr 24, 2015, at 9:03 AM, Ally Hume <a....@ed...> wrote:

> Ryan,
> 
> Fix seems to have worked well.
> 
> I'm now starting to think about possible other parallelisations and was considering looking at the hessian() and hessian_log_params() as these can take while and there is a nice loop in there that looks easily parallelisable at first glance. It's just a suggestion and I cannot guarantee getting round to doing it but I was just wondering if you had any comments about the idea?
> 
> I would, of course, contribute back any code I do develop.
> 
> Regards,
> 
> Ally
> 
> 
> Ally Hume
> Software Architect
> EPCC, The University of Edinburgh
> Tel: 0131 651 3397   Skype: ally.hume
> 
> 
> 
> 
> 
> 
> 
> 
> On 18 Apr 2015, at 00:42, "Gutenkunst, Ryan N - (rgutenk)" <rg...@em...> wrote:
> 
>> Hi Ally,
>> 
>> First, thank you for the very thorough bug report! It was actually two bugs. The first was a simple typo bug in using the N_dyn_vars name. The second more subtle bug had to do with how events are handled in the integration when running in parallel. Both should now be fixed in the git repository.
>> 
>> The parallel code hasn't been thoroughly tested in a while. To help ensure there aren't other lingering bugs, please advise the researcher to compare results of a parallel and non-paralllel jacobian evaluation to ensure they're equal, before running extensive calculations.
>> 
>> Best,
>> Ryan
>> 
>> On Apr 17, 2015, at 9:39 AM, Ally Hume <a....@ed...> wrote:
>> 
>>> I have trying to use the MPI parallelism functionality of sloppy cell and the code is hanging and simply never terminates.
>>> 
>>> I have debugged it a bit and now know a more about the cause but I would need to understand the code much better to go any further.
>>> 
>>> The Dyamics.integrate_sensitivity function sends out the tasks to the workers, processes some data at the master and then waits for each worker to return.  When worker 1 returns the result it is parsed by _parse_sens_result.  This function is throwing a NameError exception which is not caught here so the code does not try to get a result from workers 2,3,4... and hence these workers never terminate and the whole job hangs.
>>> 
>>> So why does _parse_sens_result throw an exception?  Because N_dyn_vars is not defined.  If I record the stack trace I get:
>>> 
>>> Traceback (most recent call last):
>>> File "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 958, in integrate_sensitivity
>>> _parse_sens_result(result, net, vars_assigned[worker], yout, youtdt, events_occurred)
>>> File "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 869, in _parse_sens_result
>>> e.ysens_fired = scipy.concatenate((e.ysens_fired, result[-1][eii].ysens_fired[N_dyn_vars:]))
>>> NameError: global name 'N_dyn_vars' is not defined
>>> 
>>> The line numbers do not match the code in git as I have added lots of debug lines to get this far. But you will see the line that is causing the problem is the first line in _parse_sens_result that uses the variable N_dyn_vars.
>>> 
>>> Could we be doing something wrong or is this a bug?  This all comes from a call to: Optimization.fmin_lm_log_params
>>> 
>>> If need be I can ask the researcher for more details of the model. My role here is to support him by getting this running on a cluster. 
>>> 
>>> Any advise?
>>> 
>>> Regards,
>>> 
>>> Ally
>>> 
>>> Ally Hume
>>> Software Architect
>>> EPCC, The University of Edinburgh
>>> Tel: 0131 651 3397   Skype: ally.hume
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> 
>>> -- 
>>> The University of Edinburgh is a charitable body, registered in
>>> Scotland, with registration number SC005336.
>>> 
>>> 
>>> ------------------------------------------------------------------------------
>>> BPM Camp - Free Virtual Workshop May 6th at 10am PDT/1PM EDT
>>> Develop your own process in accordance with the BPMN 2 standard
>>> Learn Process modeling best practices with Bonita BPM through live exercises
>>> http://www.bonitasoft.com/be-part-of-it/events/bpm-camp-virtual- event?utm_
>>> source=Sourceforge_BPM_Camp_5_6_15&utm_medium=email&utm_campaign=VA_SF
>>> _______________________________________________
>>> SloppyCell-users mailing list
>>> Slo...@li...
>>> https://lists.sourceforge.net/lists/listinfo/sloppycell-users
>> 
>> --
>> Ryan Gutenkunst
>> Assistant Professor
>> Molecular and Cellular Biology
>> University of Arizona
>> phone: (520) 626-0569, office LSS 325
>> http://gutengroup.mcb.arizona.edu
>> 
>> 
> 
> 
> -- 
> The University of Edinburgh is a charitable body, registered in
> Scotland, with registration number SC005336.
> 

--
Ryan Gutenkunst
Assistant Professor
Molecular and Cellular Biology
University of Arizona
phone: (520) 626-0569, office LSS 325
http://gutengroup.mcb.arizona.edu

Ryan,

Fix seems to have worked well.

I'm now starting to think about possible other parallelisations and was considering looking at the hessian() and hessian_log_params() as these can take while and there is a nice loop in there that looks easily parallelisable at first glance. It's just a suggestion and I cannot guarantee getting round to doing it but I was just wondering if you had any comments about the idea?

I would, of course, contribute back any code I do develop.

Regards,

Ally


Ally Hume
Software Architect
EPCC, The University of Edinburgh
Tel: 0131 651 3397   Skype: ally.hume








On 18 Apr 2015, at 00:42, "Gutenkunst, Ryan N - (rgutenk)" <rg...@em...> wrote:

> Hi Ally,
> 
> First, thank you for the very thorough bug report! It was actually two bugs. The first was a simple typo bug in using the N_dyn_vars name. The second more subtle bug had to do with how events are handled in the integration when running in parallel. Both should now be fixed in the git repository.
> 
> The parallel code hasn't been thoroughly tested in a while. To help ensure there aren't other lingering bugs, please advise the researcher to compare results of a parallel and non-paralllel jacobian evaluation to ensure they're equal, before running extensive calculations.
> 
> Best,
> Ryan
> 
> On Apr 17, 2015, at 9:39 AM, Ally Hume <a....@ed...> wrote:
> 
>> I have trying to use the MPI parallelism functionality of sloppy cell and the code is hanging and simply never terminates.
>> 
>> I have debugged it a bit and now know a more about the cause but I would need to understand the code much better to go any further.
>> 
>> The Dyamics.integrate_sensitivity function sends out the tasks to the workers, processes some data at the master and then waits for each worker to return.  When worker 1 returns the result it is parsed by _parse_sens_result.  This function is throwing a NameError exception which is not caught here so the code does not try to get a result from workers 2,3,4... and hence these workers never terminate and the whole job hangs.
>> 
>> So why does _parse_sens_result throw an exception?  Because N_dyn_vars is not defined.  If I record the stack trace I get:
>> 
>> Traceback (most recent call last):
>> File "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 958, in integrate_sensitivity
>> _parse_sens_result(result, net, vars_assigned[worker], yout, youtdt, events_occurred)
>> File "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 869, in _parse_sens_result
>> e.ysens_fired = scipy.concatenate((e.ysens_fired, result[-1][eii].ysens_fired[N_dyn_vars:]))
>> NameError: global name 'N_dyn_vars' is not defined
>> 
>> The line numbers do not match the code in git as I have added lots of debug lines to get this far. But you will see the line that is causing the problem is the first line in _parse_sens_result that uses the variable N_dyn_vars.
>> 
>> Could we be doing something wrong or is this a bug?  This all comes from a call to: Optimization.fmin_lm_log_params
>> 
>> If need be I can ask the researcher for more details of the model. My role here is to support him by getting this running on a cluster. 
>> 
>> Any advise?
>> 
>> Regards,
>> 
>> Ally
>> 
>> Ally Hume
>> Software Architect
>> EPCC, The University of Edinburgh
>> Tel: 0131 651 3397   Skype: ally.hume
>> 
>> 
>> 
>> 
>> 
>> 
>> 
>> 
>> 
>> -- 
>> The University of Edinburgh is a charitable body, registered in
>> Scotland, with registration number SC005336.
>> 
>> 
>> ------------------------------------------------------------------------------
>> BPM Camp - Free Virtual Workshop May 6th at 10am PDT/1PM EDT
>> Develop your own process in accordance with the BPMN 2 standard
>> Learn Process modeling best practices with Bonita BPM through live exercises
>> http://www.bonitasoft.com/be-part-of-it/events/bpm-camp-virtual- event?utm_
>> source=Sourceforge_BPM_Camp_5_6_15&utm_medium=email&utm_campaign=VA_SF
>> _______________________________________________
>> SloppyCell-users mailing list
>> Slo...@li...
>> https://lists.sourceforge.net/lists/listinfo/sloppycell-users
> 
> --
> Ryan Gutenkunst
> Assistant Professor
> Molecular and Cellular Biology
> University of Arizona
> phone: (520) 626-0569, office LSS 325
> http://gutengroup.mcb.arizona.edu
> 
> 


-- 
The University of Edinburgh is a charitable body, registered in
Scotland, with registration number SC005336.

Hi Ally,

First, thank you for the very thorough bug report! It was actually two bugs. The first was a simple typo bug in using the N_dyn_vars name. The second more subtle bug had to do with how events are handled in the integration when running in parallel. Both should now be fixed in the git repository.

The parallel code hasn't been thoroughly tested in a while. To help ensure there aren't other lingering bugs, please advise the researcher to compare results of a parallel and non-paralllel jacobian evaluation to ensure they're equal, before running extensive calculations.

Best,
Ryan

On Apr 17, 2015, at 9:39 AM, Ally Hume <a....@ed...> wrote:

> I have trying to use the MPI parallelism functionality of sloppy cell and the code is hanging and simply never terminates.
> 
> I have debugged it a bit and now know a more about the cause but I would need to understand the code much better to go any further.
> 
> The Dyamics.integrate_sensitivity function sends out the tasks to the workers, processes some data at the master and then waits for each worker to return.  When worker 1 returns the result it is parsed by _parse_sens_result.  This function is throwing a NameError exception which is not caught here so the code does not try to get a result from workers 2,3,4... and hence these workers never terminate and the whole job hangs.
> 
> So why does _parse_sens_result throw an exception?  Because N_dyn_vars is not defined.  If I record the stack trace I get:
> 
> Traceback (most recent call last):
> File "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 958, in integrate_sensitivity
> _parse_sens_result(result, net, vars_assigned[worker], yout, youtdt, events_occurred)
> File "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 869, in _parse_sens_result
> e.ysens_fired = scipy.concatenate((e.ysens_fired, result[-1][eii].ysens_fired[N_dyn_vars:]))
> NameError: global name 'N_dyn_vars' is not defined
> 
> The line numbers do not match the code in git as I have added lots of debug lines to get this far. But you will see the line that is causing the problem is the first line in _parse_sens_result that uses the variable N_dyn_vars.
> 
> Could we be doing something wrong or is this a bug?  This all comes from a call to: Optimization.fmin_lm_log_params
> 
> If need be I can ask the researcher for more details of the model. My role here is to support him by getting this running on a cluster. 
> 
> Any advise?
> 
> Regards,
> 
> Ally
> 
> Ally Hume
> Software Architect
> EPCC, The University of Edinburgh
> Tel: 0131 651 3397   Skype: ally.hume
> 
> 
> 
> 
> 
> 
> 
> 
> 
> -- 
> The University of Edinburgh is a charitable body, registered in
> Scotland, with registration number SC005336.
> 
> 
> ------------------------------------------------------------------------------
> BPM Camp - Free Virtual Workshop May 6th at 10am PDT/1PM EDT
> Develop your own process in accordance with the BPMN 2 standard
> Learn Process modeling best practices with Bonita BPM through live exercises
> http://www.bonitasoft.com/be-part-of-it/events/bpm-camp-virtual- event?utm_
> source=Sourceforge_BPM_Camp_5_6_15&utm_medium=email&utm_campaign=VA_SF
> _______________________________________________
> SloppyCell-users mailing list
> Slo...@li...
> https://lists.sourceforge.net/lists/listinfo/sloppycell-users

--
Ryan Gutenkunst
Assistant Professor
Molecular and Cellular Biology
University of Arizona
phone: (520) 626-0569, office LSS 325
http://gutengroup.mcb.arizona.edu

I have trying to use the MPI parallelism functionality of sloppy cell and the code is hanging and simply never terminates.

I have debugged it a bit and now know a more about the cause but I would need to understand the code much better to go any further.

The Dyamics.integrate_sensitivity function sends out the tasks to the workers, processes some data at the master and then waits for each worker to return.  When worker 1 returns the result it is parsed by _parse_sens_result.  This function is throwing a NameError exception which is not caught here so the code does not try to get a result from workers 2,3,4... and hence these workers never terminate and the whole job hangs.

So why does _parse_sens_result throw an exception?  Because N_dyn_vars is not defined.  If I record the stack trace I get:

Traceback (most recent call last):
File "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 958, in integrate_sensitivity
_parse_sens_result(result, net, vars_assigned[worker], yout, youtdt, events_occurred)
File "/exports/work/physics_epcc/ahume/sloppycell_anaconda/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-linux-x86_64.egg/SloppyCell/ReactionNetworks/Dynamics.py", line 869, in _parse_sens_result
e.ysens_fired = scipy.concatenate((e.ysens_fired, result[-1][eii].ysens_fired[N_dyn_vars:]))
NameError: global name 'N_dyn_vars' is not defined

The line numbers do not match the code in git as I have added lots of debug lines to get this far. But you will see the line that is causing the problem is the first line in _parse_sens_result that uses the variable N_dyn_vars.

Could we be doing something wrong or is this a bug?  This all comes from a call to: Optimization.fmin_lm_log_params

If need be I can ask the researcher for more details of the model. My role here is to support him by getting this running on a cluster. 

Any advise?

Regards,

Ally

Ally Hume
Software Architect
EPCC, The University of Edinburgh
Tel: 0131 651 3397   Skype: ally.hume









-- 
The University of Edinburgh is a charitable body, registered in
Scotland, with registration number SC005336.

Hi Uriel,

You're getting this error because SloppyCell doesn't know how to analytically take a derivative of this residual, and that's what the optimizer is looking for. The easiest solution is to try one of the other optimizers fmin_powell_log_params, fmin_powell, fmin_log_params, or fmin. (The last two are based on the Nelder-Mead simplex optimization algorithm.)

Best,
Ryan

On Mar 10, 2015, at 11:55 AM, Uriel Urquiza <s12...@sm...<mailto:s12...@sm...>> wrote:


Hi Ryan,

I have been trying to use PeriodCheckResiduals but I can’t make it work. Basically I create the model

m = Model([experiments],[network])

and then I do

m.AddResiduals(Residuals.PeriodCheckResidual(<……..>))

When i run any optimisation function it returns an error (find it at the bottom). So i wonder if you have tried using the function.

Furthermore, I also realised that the experiment class has a AddPeriodCheck() so I don’t understand where my period constraints should go.

Thanks for helping

Uriel


---------------------------------------------------------------------------
NotImplementedError                       Traceback (most recent call last)
<ipython-input-68-52f64a5de63c> in <module>()
----> 1 params=Optimization.fmin_lm_log_params(m,params,maxiter=10,disp=True)
      2

/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.10-x86_64.egg/SloppyCell/Optimization.pyc in fmin_lm_log_params(m, params, *args, **kwargs)
    135     jac = lambda lp: scipy.asarray(m.jacobian_log_params_sens(lp))
    136     sln = lmopt.fmin_lm(f=func, x0=scipy.log(params), fprime=jac,
--> 137                         *args, **kwargs)
    138     if isinstance(params, KeyedList):
    139         pout = params.copy()

/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.10-x86_64.egg/SloppyCell/lmopt.pyc in fmin_lm(f, x0, fprime, args, avegtol, epsilon, maxiter, full_output, disp, retall, lambdainit, jinit, trustradius)
    158             func_calls = func_calls + 2*len(x)
    159         else :
--> 160             j = asarray(apply(fprime,(x,)+args))
    161             grad_calls+=1
    162

/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.10-x86_64.egg/SloppyCell/Optimization.pyc in <lambda>(lp)
    133             return [scipy.inf] * Nres
    134
--> 135     jac = lambda lp: scipy.asarray(m.jacobian_log_params_sens(lp))
    136     sln = lmopt.fmin_lm(f=func, x0=scipy.log(params), fprime=jac,
    137                         *args, **kwargs)

/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.10-x86_64.egg/SloppyCell/Model_mod.pyc in jacobian_log_params_sens(self, log_params)
    585         """
    586         params = scipy.exp(log_params)
--> 587         j = self.jacobian_sens(params)
    588         j_log = j.copy()
    589         j_log.update(scipy.asarray(j) * scipy.asarray(params))

/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.10-x86_64.egg/SloppyCell/Model_mod.pyc in jacobian_sens(self, params)
    613                                 self.internalVars, self.internalVarsDerivs,
    614                                 self.params))
--> 615                  for (resId, res) in self.residuals.items()]
    616
    617         return KeyedList(deriv)

/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.10-x86_64.egg/SloppyCell/Residuals.pyc in Dp(self, predictions, senspredictions, internalVars, internalVarsDerivs, params)
     73
     74             # This first term is dres/dy * dy/dp
---> 75             dres_dy = self.dy(predictions, internalVars, params)
     76             for calcKey in dres_dy.keys():
     77                 for yKey in dres_dy[calcKey].keys():

/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/SloppyCell-CVS-py2.7-macosx-10.10-x86_64.egg/SloppyCell/Residuals.pyc in dy(self, predictions, internalVars, params)
     44             {calculation name: {variable name: {x value: deriv}}}
     45         """
---> 46         raise NotImplementedError
     47
     48     def dintVars(self, predictions, internalVars, params):

NotImplementedError:



On Jan 30, 2015, at 9:34 PM, Gutenkunst, Ryan N - (rgutenk) <rg...@em...<mailto:rg...@em...>> wrote:

Hello Uriel,

This functionality was developed by Bob Kuczenski ( https://www.linkedin.com/in/bobkuczenski ) when he was a graduate student, and it hasn't been used all that much. So it may be rough around the edges.

Nevertheless: PeriodCheckResidual(key=<name for residual>, calcKey=<name of Network to get prediction from>, depVarKey=<name of variable you have period of>, indVarValue=<time at which you want to assess period>,  depVarMeasurement=<measured period>, depVarSigma=<uncertainty of period>)

If your system takes a while to settle into a periodic orbit, you can get indVarValue to be some time far into the future, when you think the transients will have damped out. Unfortunately, this isn't necessarily straightforward when optimizing, because the speed at which transients damp no doubt depends on the parameter values. So you'll need to set it far out, which is computationally costly. So you'll have to compromise, then check your results to ensure that the optimization did find a solution where the transients are indeed gone.

Best,
Ryan

On Jan 30, 2015, at 3:45 AM, José María Uriel Urquiza García <uri...@gm...<mailto:uri...@gm...>> wrote:

Dear Ryan,

I found that in sloppycell it is possible to add a period constrain in the residuals using Experiment.AddPeriodChecks. Nonetheless it is not clear for me what are the arguments clacKey and chemical. Furthermore, I have data that but i would rather set the startTime when the system is in the unforced dynamics but for which i don’t time series data. I wonder if this is possible?

Cheers and thanks for all the amazing!!! guidance so far

Uriel

--
Ryan Gutenkunst
Assistant Professor
Molecular and Cellular Biology
University of Arizona
phone: (520) 626-0569
http://gutengroup.mcb.arizona.edu<http://gutengroup.mcb.arizona.edu/>


The University of Edinburgh is a charitable body, registered in
Scotland, with registration number SC005336.

The University of Edinburgh is a charitable body, registered in
Scotland, with registration number SC005336.

Hello Uriel,

This functionality was developed by Bob Kuczenski ( https://www.linkedin.com/in/bobkuczenski ) when he was a graduate student, and it hasn't been used all that much. So it may be rough around the edges.

Nevertheless: PeriodCheckResidual(key=<name for residual>, calcKey=<name of Network to get prediction from>, depVarKey=<name of variable you have period of>, indVarValue=<time at which you want to assess period>,  depVarMeasurement=<measured period>, depVarSigma=<uncertainty of period>)

If your system takes a while to settle into a periodic orbit, you can get indVarValue to be some time far into the future, when you think the transients will have damped out. Unfortunately, this isn't necessarily straightforward when optimizing, because the speed at which transients damp no doubt depends on the parameter values. So you'll need to set it far out, which is computationally costly. So you'll have to compromise, then check your results to ensure that the optimization did find a solution where the transients are indeed gone.

Best,
Ryan

On Jan 30, 2015, at 3:45 AM, José María Uriel Urquiza García <uri...@gm...> wrote:

> Dear Ryan,
> 
> I found that in sloppycell it is possible to add a period constrain in the residuals using Experiment.AddPeriodChecks. Nonetheless it is not clear for me what are the arguments clacKey and chemical. Furthermore, I have data that but i would rather set the startTime when the system is in the unforced dynamics but for which i don’t time series data. I wonder if this is possible?
> 
> Cheers and thanks for all the amazing!!! guidance so far
> 
> Uriel

--
Ryan Gutenkunst
Assistant Professor
Molecular and Cellular Biology
University of Arizona
phone: (520) 626-0569
http://gutengroup.mcb.arizona.edu

Dear Ryan,

I found that in sloppycell it is possible to add a period constrain in the residuals using Experiment.AddPeriodChecks. Nonetheless it is not clear for me what are the arguments clacKey and chemical. Furthermore, I have data that but i would rather set the startTime when the system is in the unforced dynamics but for which i don’t time series data. I wonder if this is possible?

Cheers and thanks for all the amazing!!! guidance so far

Uriel