Merge pull request #439 from gyorilab/simplify_report

Implement feature to check effect of model simplification

Author: bgyori

mira/metamodel/ops.py

@@ -1,7 +1,7 @@
 """Operations for template models."""
 import logging
 from copy import deepcopy
-from collections import defaultdict, Counter
+from collections import defaultdict
 import itertools as itt
 from typing import Callable, Collection, Iterable, List, Mapping, Optional, \
     Tuple, Type, Union
@@ -10,13 +10,13 @@
 
 from .template_model import TemplateModel, Initial, Parameter, Observable
 from .templates import *
-from .comparison import get_dkg_refinement_closure
 from .units import Unit
 from .utils import SympyExprStr
 
 __all__ = [
     "stratify",
     "simplify_rate_laws",
+    "check_simplify_rate_laws",
     "aggregate_parameters",
     "get_term_roles",
     "counts_to_dimensionless",
@@ -571,6 +571,67 @@ def simplify_rate_laws(template_model: TemplateModel):
     return template_model
 
 
+def check_simplify_rate_laws(template_model: TemplateModel) -> \
+        Mapping[str, Union[str, int, TemplateModel]]:
+    """Return a summary of what changes upon rate law simplification
+
+    Parameters
+    ----------
+    template_model :
+        A template model
+
+    Returns
+    -------
+    :
+        A dictionary with the result of the check under the `result` key.
+        The result can be one of the following:
+        - {'result': 'NO_GROUP_CONTROLLERS'}: If there are no templates with
+           grouped controllers
+        - {'result': 'NO_CHANGE'}: If the model does contain templates with
+           grouped controllers but simplification does not change the model.
+        - {'result': 'NO_CHANGE_IN_MAX_CONTROLLERS',
+           'max_controller_count': n}: If the model is simplified but the
+           maximum number of controllers remains the same so it might not be
+           worth doing the simplification. In this case the max controller
+           count in the model is returned. The simplified model
+           itself is also returned.
+        - {'result': 'MEANINGFUL_CHANGE',
+           'max_controller_decrease': n}: If the model is simplified and the
+           maximum number of controllers also meaningfully changes. In this
+           case the decrease in the maximum controller count is returned.
+           The simplified model itself is also returned.
+    """
+    if not any(isinstance(template, (GroupedControlledConversion,
+                                     GroupedControlledProduction,
+                                     GroupedControlledDegradation))
+               for template in template_model.templates):
+        return {'result': 'NO_GROUP_CONTROLLERS'}
+    simplified_model = simplify_rate_laws(template_model)
+    old_template_count = len(template_model.templates)
+    new_template_count = len(simplified_model.templates)
+    if old_template_count == new_template_count:
+        return {'result': 'NO_CHANGE'}
+
+    def max_controller_count(template_model):
+        max_count = 0
+        for template in template_model.templates:
+            if hasattr(template, 'controllers'):
+                max_count = max(len(template.get_controllers()), max_count)
+            elif hasattr(template, 'controller'):
+                max_count = max(1, max_count)
+        return max_count
+
+    old_max_count = max_controller_count(template_model)
+    new_max_count = max_controller_count(simplified_model)
+    if old_max_count == new_max_count:
+        return {'result': 'NO_CHANGE_IN_MAX_CONTROLLERS',
+                'max_controller_count': old_max_count,
+                'simplified_model': simplified_model}
+    return {'result': 'MEANINGFUL_CHANGE',
+            'max_controller_decrease': old_max_count - new_max_count,
+            'simplified_model': simplified_model}
+
+
 def aggregate_parameters(template_model: TemplateModel) -> TemplateModel:
     """Return a template model after aggregating parameters for mass-action
     rate laws.
@@ -630,6 +691,7 @@ def aggregate_parameters(template_model: TemplateModel) -> TemplateModel:
     return template_model
 
 
+
 def simplify_rate_law(template: Template,
                       parameters: Mapping[str, Parameter]) \
         -> Union[List[Template], None]:

tests/test_ops.py

@@ -10,7 +10,7 @@
 from mira.metamodel import *
 from mira.metamodel.ops import stratify, simplify_rate_law, \
     counts_to_dimensionless, add_observable_pattern, \
-    get_observable_for_concepts
+    get_observable_for_concepts, check_simplify_rate_laws
 from mira.examples.sir import cities, sir, sir_2_city, sir_parameterized
 from mira.examples.concepts import infected, susceptible
 from mira.examples.chime import sviivr
@@ -696,3 +696,50 @@ def test_stratify_initials_parameters():
     assert set(tm3.parameters) == {'alpha', 'S0_old', 'S0_young'}
     assert tm3.parameters['S0_old'].value == 500
     assert tm3.parameters['S0_young'].value == 500
+
+
+def test_check_simplify():
+    a, b, c, A, B, C, D = sympy.symbols('a b c A B C D')
+
+    # No group controllers at all so nothing to simplify
+    assert check_simplify_rate_laws(
+        TemplateModel(
+            templates=[NaturalProduction(outcome=Concept(name='A'),
+                                         rate_law=SympyExprStr(a * A))],
+        )
+    ) == {'result': 'NO_GROUP_CONTROLLERS'}
+
+    # No simplification possible due to form of rate law
+    template = GroupedControlledDegradation(
+        subject=Concept(name='A'),
+        controllers=[Concept(name='B'), Concept(name='C')],
+        rate_law=SympyExprStr(b * B/C * A + a),
+    )
+    parameters = {'a': Parameter(name='a', value=1),
+                  'b': Parameter(name='b', value=1),
+                  'c': Parameter(name='c', value=1)}
+    tm = TemplateModel(templates=[template],
+                       parameters=parameters)
+    res = check_simplify_rate_laws(tm)
+    assert res['result'] == 'NO_CHANGE'
+
+    # Meaningful simplification with decrease in max controller count
+    template.rate_law = SympyExprStr((b * B + c * C) * A)
+    res = check_simplify_rate_laws(tm)
+    assert res['result'] == 'MEANINGFUL_CHANGE'
+    assert res['max_controller_decrease'] == 1
+
+    # Some simplification happens but the max controller
+    # count cannot be decreased due to a second template
+    # with 3 controllers that cannot be simplified
+    template2 = GroupedControlledDegradation(
+        subject=Concept(name='A'),
+        controllers=[Concept(name='B'), Concept(name='C'),
+                     Concept(name='D')],
+        rate_law=SympyExprStr(b * B/C*D * A + a),
+    )
+    tm = TemplateModel(templates=[template, template2],
+                       parameters=parameters)
+    res = check_simplify_rate_laws(tm)
+    assert res['result'] == 'NO_CHANGE_IN_MAX_CONTROLLERS'
+    assert res['max_controller_count'] == 3