causing 2.4.6__tar.gz

causing-2.4.6/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+**Copyright (c) 2020 Dr. Holger Bartel, RealRate GmbH**
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

causing-2.4.6/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: causing
+Version: 2.4.6
+Summary: Causing: CAUSal INterpretation using Graphs
+Home-page: https://github.com/realrate/Causing
+Author: Dr. Holger Bartel
+Author-email: holger.bartel@realrate.ai
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy~=1.23
+Requires-Dist: pandas~=1.3
+Requires-Dist: scipy~=1.9
+Requires-Dist: sympy~=1.5
+Requires-Dist: networkx~=2.7
+Requires-Dist: pre-commit
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Causing: CAUSal INterpretation using Graphs
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/)
+
+_Causing is a multivariate graphical analysis tool helping you to interpret the causal
+effects of a given equation system._ 
+
+Get a nice colored graph and immediately understand the causal effects between the variables.
+
+**Input:** You simply have to put in a dataset and provide an equation system in form of a
+python function. The endogenous variables on the left-hand side are assumed to be caused by
+the variables on the right-hand side of the equation. Thus, you provide the causal structure
+in form of a directed acyclic graph (DAG).
+
+**Output:** As an output, you will get a colored graph of quantified effects acting between
+the model variables. You can immediately interpret mediation chains for every
+individual observation - even for highly complex nonlinear systems.
+
+Here is a table relating Causing to other approaches:
+
+Causing is | Causing is NOT
+--- | ---
+✅ causal model given | ❌ causal search
+✅ DAG directed acyclic graph | ❌ cyclic, undirected, or bidirected graph
+✅ latent variables | ❌ just observed / manifest variables
+✅ individual effects | ❌ just average effects
+✅ direct, total, and mediation effects | ❌ just total effects
+✅ structural model | ❌ reduced model
+✅ small and big data | ❌ big data requirement
+✅ graphical results | ❌ just numerical results
+✅ XAI explainable AI | ❌ black box neural network
+
+The Causing approach is quite flexible. It can be applied to highly latent models with many of the modeled endogenous variables being unobserved. Exogenous variables are assumed to be observed and deterministic. The most severe restriction certainly is that you need to specify the causal model / causal ordering. 
+
+## Causal Effects
+
+Causing combines total effects and mediation effects in one single graph that is easy to explain. 
+
+The total effects of a variable on the final variable are shown in the corresponding nodes of the graph. The total effects are split up over their outgoing edges, yielding the mediation effects shown on the edges. Just education has more than one outgoing edge to be interpreted in this way.
+
+The effects differ from individual to individual. To emphasize  this, we talk about individual effects. And the corresponding graph, combining total and mediation effects is called the Individual  Mediation Effects (IME) graph. 
+
+## Software
+
+Causing is free software written in _Python 3_. Graphs are generated using _Graphviz_. See dependencies in [setup.py](setup.py). Causing is available under MIT license. See [LICENSE](LICENSE.md "LICENSE").
+
+The software is developed by RealRate, an AI rating agency aiming to re-invent the rating market by using AI, interpretability, and avoiding any conflict of interest. See www.realrate.ai.
+
+When starting `python -m causing.examples example` after cloning / downloading the Causing repository you will find the results  in the _output_ folder. The results are saved in SVG files. The IME files show the individual mediation effects graphs for the respective individual.
+
+See `causing/examples` for the code generating some examples.
+
+## Start your Model
+
+To start your model, you have to provide the following information, as done in the example code below:
+
+- Define all your model variables as SymPy symbols.
+- Note that in Sympy some operators are special, e.g. Max() instead of max().
+- Provide the model equations in topological order, that is, in order of computation.
+- Then the model is specified with:
+    - _xvars_: exogenous variables
+    - _yvars_: endogenous variables in topological order
+    - _equations_: previously defined equations
+    - _final_var_: the final variable of interest used for mediation effects
+
+## 1. A Simple Example
+
+Assume a model defined by the equation system:
+
+Y<sub>1</sub> = X<sub>1</sub>
+
+Y<sub>2</sub> = X<sub>2</sub> + 2 * Y<sub>1</sub><sup>2</sup>
+
+Y<sub>3</sub> = Y<sub>1</sub> + Y<sub>2</sub>.
+
+This gives the following graphs. Some notes to understand them:
+
+- The data used consists of 200 observations. They are available for the x variables X<sub>1</sub> and X<sub>2</sub> with mean(X<sub>1</sub>) = 3 and mean(X<sub>2</sub>) = 2. Variables Y<sub>1</sub> and Y<sub>2</sub> are assumed to be latent / unobserved. Y<sub>3</sub> is assumed to be manifest / observed. Therefore, 200 observations are available for Y<sub>3</sub>.
+
+- To allow for benchmark comparisons, each individual effect is measured with respect to the mean of all observations. 
+
+- Nodes and edges are colored, showing positive (_green_) and negative (_red_) effects they have on the final variable Y<sub>3</sub>.
+
+- Individual effects are based on the given model. For each individual, however, its _own_ exogenous data is put into the given graph function to yield the corresponding endogenous values. The effects are computed at this individual point. Individual effects are shown below just for individual no. 1 out of the 200 observations. 
+
+- Total effects are shown below in the nodes and they are split up over the outgoing edges yielding the Mediation effects shown on the edges. Note, however, that just outgoing edges sum up to the node value, incoming edges do not. All effects are effects just on the final variable of interest, assumed here to be Y<sub>3</sub>.
+
+![Individual Mediation Effects (IME)](https://github.com/realrate/Causing/raw/develop/images_readme/IME_1.svg)
+
+As you can see in the right-most graph for the individual mediation effects (IME), there is one green path starting at X<sub>1</sub> passing through Y<sub>1</sub>, Y<sub>2</sub>, and finally ending in Y<sub>3</sub>. This means that X<sub>1</sub> is the main cause for Y<sub>3</sub> taking on a value above average with its effect on Y<sub>3</sub> being +29.81. However, this positive effect is slightly reduced by X<sub>2</sub>. In total, accounting for all exogenous and endogenous effects, Y<sub>3</sub> is +27.07 above average. You can understand at one glance why Y<sub>3</sub> is above average for individual no. 1.
+
+You can find the full source code for this example [here](https://github.com/realrate/Causing/blob/develop/causing/examples/models.py#L16-L45).
+
+## 2. Application to Education and Wages
+
+To dig a bit deeper, here we have a real-world example from social sciences. We analyze how the wage earned by young American workers is determined by their educational attainment, family characteristics, and test scores.
+
+This 5-minute introductory video gives a short overview of Causing and includes this real data example: See [Causing Introduction Video](https://youtu.be/GJLsjSZOk2w "Causing_Introduction_Video").
+
+See here for a detailed analysis of the Education and Wages example: [An Application of Causing: Education and Wages](docs/education.md).
+
+## 3. Application to Insurance Ratings
+
+The Causing approach and its formulas together with an application are given in:
+
+> Bartel, Holger (2020), "Causal Analysis - With an Application to Insurance Ratings"
+DOI: 10.13140/RG.2.2.31524.83848
+https://www.researchgate.net/publication/339091133
+
+Note that in this early paper the mediation effects on the final variable of interest are called final effects. Also, while the current Causing version just uses numerically computed effects, that paper uses closed formulas.
+
+The paper proposes simple linear algebra formulas for the causal analysis of equation systems. The effect of one variable on another is the total derivative. It is extended to endogenous system variables. These total effects are identical to the effects used in graph theory and its do-calculus. Further, mediation effects are defined, decomposing the total effect of one variable on a final variable of interest over all its directly caused variables. This allows for an easy but in-depth causal and mediation analysis. 
+
+The equation system provided by the user is represented as a structural neural network (SNN). The network's nodes are represented by the model variables and its edge weights are given by the effects. Unlike classical deep neural networks, we follow a sparse and 'small data' approach. This new methodology is applied to the financial strength ratings of insurance companies. 
+
+> **Keywords:** total derivative, graphical effect, graph theory, do-Calculus, structural neural network, linear Simultaneous Equations Model (SEM), Structural Causal Model (SCM), insurance rating
+
+## Award
+
+RealRate's AI software _Causing_ is a winner of the PyTorch AI Hackathon.
+
+<img src="https://github.com/realrate/Causing/raw/develop/images_readme/RealRate_AI_Software_Winner.png">
+
+We are excited to be a winner of the PyTorch AI Hackathon 2020 in the Responsible AI category. This is quite an honor given that more than 2,500 teams submitted their projects.
+
+[devpost.com/software/realrate-explainable-ai-for-company-ratings](https://devpost.com/software/realrate-explainable-ai-for-company-ratings "devpost.com/software/realrate-explainable-ai-for-company-ratings").
+
+## GitHub Star History
+
+[star-history.com](https://www.star-history.com/#realrate/Causing&Date)
+![star-history-2025327](https://github.com/user-attachments/assets/67271706-0534-4b97-b9da-7fe502f1d94a)
+
+## Contact
+
+Dr. Holger Bartel  
+RealRate  
+Cecilienstr. 14, D-12307 Berlin  
+[holger.bartel@realrate.ai](mailto:holger.bartel@realrate.ai?subject=[Causing])  
+Phone: +49 160 957 90 844  
+[realrate.ai](https://realrate.ai)  
+[drbartel.com](https://drbartel.com)  

causing-2.4.6/README.md

@@ -0,0 +1,142 @@
+# Causing: CAUSal INterpretation using Graphs
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/)
+
+_Causing is a multivariate graphical analysis tool helping you to interpret the causal
+effects of a given equation system._ 
+
+Get a nice colored graph and immediately understand the causal effects between the variables.
+
+**Input:** You simply have to put in a dataset and provide an equation system in form of a
+python function. The endogenous variables on the left-hand side are assumed to be caused by
+the variables on the right-hand side of the equation. Thus, you provide the causal structure
+in form of a directed acyclic graph (DAG).
+
+**Output:** As an output, you will get a colored graph of quantified effects acting between
+the model variables. You can immediately interpret mediation chains for every
+individual observation - even for highly complex nonlinear systems.
+
+Here is a table relating Causing to other approaches:
+
+Causing is | Causing is NOT
+--- | ---
+✅ causal model given | ❌ causal search
+✅ DAG directed acyclic graph | ❌ cyclic, undirected, or bidirected graph
+✅ latent variables | ❌ just observed / manifest variables
+✅ individual effects | ❌ just average effects
+✅ direct, total, and mediation effects | ❌ just total effects
+✅ structural model | ❌ reduced model
+✅ small and big data | ❌ big data requirement
+✅ graphical results | ❌ just numerical results
+✅ XAI explainable AI | ❌ black box neural network
+
+The Causing approach is quite flexible. It can be applied to highly latent models with many of the modeled endogenous variables being unobserved. Exogenous variables are assumed to be observed and deterministic. The most severe restriction certainly is that you need to specify the causal model / causal ordering. 
+
+## Causal Effects
+
+Causing combines total effects and mediation effects in one single graph that is easy to explain. 
+
+The total effects of a variable on the final variable are shown in the corresponding nodes of the graph. The total effects are split up over their outgoing edges, yielding the mediation effects shown on the edges. Just education has more than one outgoing edge to be interpreted in this way.
+
+The effects differ from individual to individual. To emphasize  this, we talk about individual effects. And the corresponding graph, combining total and mediation effects is called the Individual  Mediation Effects (IME) graph. 
+
+## Software
+
+Causing is free software written in _Python 3_. Graphs are generated using _Graphviz_. See dependencies in [setup.py](setup.py). Causing is available under MIT license. See [LICENSE](LICENSE.md "LICENSE").
+
+The software is developed by RealRate, an AI rating agency aiming to re-invent the rating market by using AI, interpretability, and avoiding any conflict of interest. See www.realrate.ai.
+
+When starting `python -m causing.examples example` after cloning / downloading the Causing repository you will find the results  in the _output_ folder. The results are saved in SVG files. The IME files show the individual mediation effects graphs for the respective individual.
+
+See `causing/examples` for the code generating some examples.
+
+## Start your Model
+
+To start your model, you have to provide the following information, as done in the example code below:
+
+- Define all your model variables as SymPy symbols.
+- Note that in Sympy some operators are special, e.g. Max() instead of max().
+- Provide the model equations in topological order, that is, in order of computation.
+- Then the model is specified with:
+    - _xvars_: exogenous variables
+    - _yvars_: endogenous variables in topological order
+    - _equations_: previously defined equations
+    - _final_var_: the final variable of interest used for mediation effects
+
+## 1. A Simple Example
+
+Assume a model defined by the equation system:
+
+Y<sub>1</sub> = X<sub>1</sub>
+
+Y<sub>2</sub> = X<sub>2</sub> + 2 * Y<sub>1</sub><sup>2</sup>
+
+Y<sub>3</sub> = Y<sub>1</sub> + Y<sub>2</sub>.
+
+This gives the following graphs. Some notes to understand them:
+
+- The data used consists of 200 observations. They are available for the x variables X<sub>1</sub> and X<sub>2</sub> with mean(X<sub>1</sub>) = 3 and mean(X<sub>2</sub>) = 2. Variables Y<sub>1</sub> and Y<sub>2</sub> are assumed to be latent / unobserved. Y<sub>3</sub> is assumed to be manifest / observed. Therefore, 200 observations are available for Y<sub>3</sub>.
+
+- To allow for benchmark comparisons, each individual effect is measured with respect to the mean of all observations. 
+
+- Nodes and edges are colored, showing positive (_green_) and negative (_red_) effects they have on the final variable Y<sub>3</sub>.
+
+- Individual effects are based on the given model. For each individual, however, its _own_ exogenous data is put into the given graph function to yield the corresponding endogenous values. The effects are computed at this individual point. Individual effects are shown below just for individual no. 1 out of the 200 observations. 
+
+- Total effects are shown below in the nodes and they are split up over the outgoing edges yielding the Mediation effects shown on the edges. Note, however, that just outgoing edges sum up to the node value, incoming edges do not. All effects are effects just on the final variable of interest, assumed here to be Y<sub>3</sub>.
+
+![Individual Mediation Effects (IME)](https://github.com/realrate/Causing/raw/develop/images_readme/IME_1.svg)
+
+As you can see in the right-most graph for the individual mediation effects (IME), there is one green path starting at X<sub>1</sub> passing through Y<sub>1</sub>, Y<sub>2</sub>, and finally ending in Y<sub>3</sub>. This means that X<sub>1</sub> is the main cause for Y<sub>3</sub> taking on a value above average with its effect on Y<sub>3</sub> being +29.81. However, this positive effect is slightly reduced by X<sub>2</sub>. In total, accounting for all exogenous and endogenous effects, Y<sub>3</sub> is +27.07 above average. You can understand at one glance why Y<sub>3</sub> is above average for individual no. 1.
+
+You can find the full source code for this example [here](https://github.com/realrate/Causing/blob/develop/causing/examples/models.py#L16-L45).
+
+## 2. Application to Education and Wages
+
+To dig a bit deeper, here we have a real-world example from social sciences. We analyze how the wage earned by young American workers is determined by their educational attainment, family characteristics, and test scores.
+
+This 5-minute introductory video gives a short overview of Causing and includes this real data example: See [Causing Introduction Video](https://youtu.be/GJLsjSZOk2w "Causing_Introduction_Video").
+
+See here for a detailed analysis of the Education and Wages example: [An Application of Causing: Education and Wages](docs/education.md).
+
+## 3. Application to Insurance Ratings
+
+The Causing approach and its formulas together with an application are given in:
+
+> Bartel, Holger (2020), "Causal Analysis - With an Application to Insurance Ratings"
+DOI: 10.13140/RG.2.2.31524.83848
+https://www.researchgate.net/publication/339091133
+
+Note that in this early paper the mediation effects on the final variable of interest are called final effects. Also, while the current Causing version just uses numerically computed effects, that paper uses closed formulas.
+
+The paper proposes simple linear algebra formulas for the causal analysis of equation systems. The effect of one variable on another is the total derivative. It is extended to endogenous system variables. These total effects are identical to the effects used in graph theory and its do-calculus. Further, mediation effects are defined, decomposing the total effect of one variable on a final variable of interest over all its directly caused variables. This allows for an easy but in-depth causal and mediation analysis. 
+
+The equation system provided by the user is represented as a structural neural network (SNN). The network's nodes are represented by the model variables and its edge weights are given by the effects. Unlike classical deep neural networks, we follow a sparse and 'small data' approach. This new methodology is applied to the financial strength ratings of insurance companies. 
+
+> **Keywords:** total derivative, graphical effect, graph theory, do-Calculus, structural neural network, linear Simultaneous Equations Model (SEM), Structural Causal Model (SCM), insurance rating
+
+## Award
+
+RealRate's AI software _Causing_ is a winner of the PyTorch AI Hackathon.
+
+<img src="https://github.com/realrate/Causing/raw/develop/images_readme/RealRate_AI_Software_Winner.png">
+
+We are excited to be a winner of the PyTorch AI Hackathon 2020 in the Responsible AI category. This is quite an honor given that more than 2,500 teams submitted their projects.
+
+[devpost.com/software/realrate-explainable-ai-for-company-ratings](https://devpost.com/software/realrate-explainable-ai-for-company-ratings "devpost.com/software/realrate-explainable-ai-for-company-ratings").
+
+## GitHub Star History
+
+[star-history.com](https://www.star-history.com/#realrate/Causing&Date)
+![star-history-2025327](https://github.com/user-attachments/assets/67271706-0534-4b97-b9da-7fe502f1d94a)
+
+## Contact
+
+Dr. Holger Bartel  
+RealRate  
+Cecilienstr. 14, D-12307 Berlin  
+[holger.bartel@realrate.ai](mailto:holger.bartel@realrate.ai?subject=[Causing])  
+Phone: +49 160 957 90 844  
+[realrate.ai](https://realrate.ai)  
+[drbartel.com](https://drbartel.com)  

causing-2.4.6/causing/__init__.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+"""causing - causal interpretation using graphs."""
+
+# flake8: noqa
+
+# public Causing API
+from causing.model import Model
+
+
+def create_indiv(m: Model, xdat, show_nr_indiv: int) -> dict:
+    """Calculate effects and limit result set to `show_nr_indiv`
+
+    This is mostly to for backwards compatability and to shrink the amount of
+    data for tests cases. Otherwise, use `Model.calc_effects` directly.
+    """
+    eff = m.calc_effects(xdat)
+    for key in ["xnodeeffects", "ynodeeffects", "xedgeeffects", "yedgeeffects"]:
+        if key in ["xnodeeffects", "ynodeeffects"]:
+            eff[key] = eff[key][:, :show_nr_indiv]
+        else:
+            eff[key] = eff[key][:show_nr_indiv]
+    return eff

causing-2.4.6/causing/graph.py

@@ -0,0 +1,272 @@
+# -*- coding: utf-8 -*-
+"""Create direct, total and mediation Graphviz graph from dot_str"""
+import re
+import subprocess
+from typing import Iterable
+from itertools import chain
+from pathlib import Path
+from functools import cache
+
+import numpy as np
+import networkx
+
+from causing.model import Model
+from causing import utils
+
+
+DOT_COMMAND = "dot"
+
+
+@cache
+def dot_version() -> list[int]:
+    full_output = subprocess.check_output(
+        [DOT_COMMAND, "-V"], encoding="utf-8", stderr=subprocess.STDOUT
+    )
+    match = re.search(r"(\d+[.])+\d+", full_output)
+    assert match
+    version = match.group(0)
+    return [int(x) for x in version.split(".")]
+
+
+def fix_svg_scale(svg_code):
+    """Work around graphviz SVG generation bug
+
+    Graphviz divides the numbers in the viewBox attribute by the scale instead
+    of multiplying it. We work around it my multiplying with the scale twice.
+    See https://github.com/realrate/RealRate-Private/issues/631
+    and https://gitlab.com/graphviz/graphviz/-/issues/1406
+    """
+    # find scaling factor
+    scale_match = re.search(r"scale\(([0-9.]+)", svg_code)
+    assert scale_match
+    factor = float(scale_match.group(1)) ** 2
+
+    # edit SVG tag
+    orig_svg_tag = next(re.finditer(r"<svg.*?>", svg_code, flags=re.DOTALL)).group(0)
+    attrs = {
+        match.group(1): match.group(2)
+        for match in re.finditer(r'(\w+)="(.*?)"', orig_svg_tag)
+    }
+    new_svg_tag = "<svg "
+    for attr, val in attrs.items():
+        if attr == "viewBox":
+            val = " ".join(str(float(x) * factor) for x in val.split(" "))
+        new_svg_tag += f'{attr}="{val}" '
+    new_svg_tag += ">"
+
+    # return with changed SVG tag
+    return svg_code.replace(orig_svg_tag, new_svg_tag)
+
+
+def save_graph(path: Path, graph_dot):
+    """Render graph as SVG"""
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    # with open(path.stem + ".txt", "w") as file:
+    #     file.write(graph_dot)
+
+    svg_code = subprocess.check_output(
+        [DOT_COMMAND, "-Tsvg"], input=graph_dot, encoding="utf-8"
+    )
+    # if dot_version()[0] < 3:
+    #     svg_code = fix_svg_scale(svg_code)
+    with open(path, "w") as f:
+        f.write(svg_code)
+
+
+def annotated_graphs(
+    m: Model,
+    graph_json,
+    ids: Iterable[str] = None,
+    node_labels: dict[str, str] = {},
+) -> Iterable[networkx.DiGraph]:
+    """Return DiGraphs with all information required to draw IME graphs"""
+    if ids is None:
+        ids = [str(i + 1) for i in range(len(graph_json["xedgeeffects"]))]
+    for graph_id, exj, eyj, eyx, eyy in zip(
+        ids,
+        np.array(graph_json["xnodeeffects"]).T,
+        np.array(graph_json["ynodeeffects"]).T,
+        graph_json["xedgeeffects"],
+        graph_json["yedgeeffects"],
+    ):
+        g = m.graph.copy()
+        g.graph["id"] = graph_id
+
+        # nodes
+        for var, effect in chain(zip(m.xvars, exj), zip(m.yvars, eyj)):
+            if np.isnan(effect):
+                g.remove_node(var)
+                continue
+            data = g.nodes[var]
+            data["effect"] = effect
+            data["label"] = node_labels.get(var, var)
+
+        # edges
+        for to_node, x_effects, y_effects in zip(m.yvars, eyx, eyy):
+            for from_node, eff in chain(
+                zip(m.xvars, x_effects), zip(m.yvars, y_effects)
+            ):
+                if not np.isnan(eff):
+                    g[from_node][to_node]["effect"] = eff
+
+        yield g
+
+
+NODE_PALETTE = "#ff7973 #FFC7AD #EEEEEE #BDE7BD #75cf73".split(" ")
+EDGE_PALETTE = "#ff7973 #FFC7AD #BBBBBB #aad3aa #75cf73".split(" ")
+PEN_WIDTH_PALETTE = [12, 8, 4, 8, 12]
+
+
+def color(val, max_val, palette):
+    """Choose element of palette based on `val`
+
+    val == -max_val will return palette[0]
+    val == +max_val will return palette[-1]
+    """
+    zero_one_scale = (val + max_val) / (2 * max_val)
+    ind = round(zero_one_scale * len(palette) - 0.5)
+    clipped_ind = np.clip(round(ind), 0, len(palette) - 1)
+    return palette[clipped_ind]
+
+
+GRAPH_OPTIONS_STR = """
+    node [style="filled,rounded"]
+    node [shape=box]
+    node [color="#444444"]
+    ratio="compress"
+    size="8,10"
+"""
+
+
+def graph_to_dot(
+    g: networkx.DiGraph,
+    invisible_edges={},
+    node_palette=NODE_PALETTE,
+    edge_palette=EDGE_PALETTE,
+    pen_width_palette=PEN_WIDTH_PALETTE,
+    graph_options_str=GRAPH_OPTIONS_STR,
+    in_percent=False,
+    min_sig_figures=3,
+    cutoff=0.0001,
+):
+    dot_str = "digraph {" + graph_options_str
+    max_val = max(
+        [abs(data["effect"]) for _, data in g.nodes(data=True)]
+        + [abs(data["effect"]) for _, _, data in g.edges(data=True)]
+    )
+
+    for node, data in g.nodes(data=True):
+        eff_str = utils.fmt_min_sig(
+            data["effect"] if abs(data["effect"]) > cutoff else 0,
+            min_sig_figures,
+            percent=in_percent,
+        )
+        label = data.get("label", node).replace("\n", r"\n") + r"\n" + eff_str
+        col_str = color(data["effect"], max_val, palette=node_palette)
+        dot_str += f'    "{node}"[label = "{label}" fillcolor="{col_str}"]\n'
+
+    for from_node, to_node, data in g.edges(data=True):
+        eff_str = utils.fmt_min_sig(
+            data["effect"] if abs(data["effect"]) > cutoff else 0,
+            min_sig_figures,
+            percent=in_percent,
+        )
+        col_str = color(data["effect"], max_val, palette=edge_palette)
+        penwidth = color(data["effect"], max_val, palette=pen_width_palette)
+        dot_str += (
+            f'    "{from_node}" -> "{to_node}" [label="{eff_str}" color="{col_str}" penwidth="{penwidth}", '
+            f"arrowsize=0.5]\n"
+        )
+
+    for from_node, to_node in invisible_edges:
+        dot_str += f'    "{from_node}" -> "{to_node}" [style = "invisible", arrowhead="none"]\n'
+
+    dot_str += "}"
+    return dot_str
+
+
+def create_graphs(graphs: Iterable[networkx.DiGraph], output_dir: Path, **kwargs):
+    for g in graphs:
+        filename = f"IME_{g.graph['id']}.svg"
+        print("Create", filename)
+        dot_str = graph_to_dot(g, **kwargs)
+        save_graph(output_dir / filename, dot_str)
+        # save the dot string
+        dot_path = output_dir / f"IME_{g.graph['id']}.dot"
+        with open(dot_path, "w") as f:
+            f.write(dot_str)
+
+
+def remove_node_keep_edges(graph, node):
+    """Keep transitive connections when removing node.
+
+    Removing B from A->B->C will result in A->C.
+
+    WARNING: This function only approximates the edge effects. To get accurate
+    results, you must shrink the model and recalculate the effects, instead.
+    """
+
+    total_out_effect = sum(
+        out_data["effect"] for _, _, out_data in graph.out_edges(node, data=True)
+    )
+    num_out_edges = len(graph.out_edges(node))
+    for a, _, in_data in graph.in_edges(node, data=True):
+        for _, b, out_data in graph.out_edges(node, data=True):
+            if total_out_effect == 0:
+                # If all outgoing edges have no effect, distribute the incoming effects
+                # evenly across all outgoing edges.
+                new_edge_effect = in_data["effect"] / num_out_edges
+            else:
+                new_edge_effect = (
+                    in_data["effect"] * out_data["effect"] / total_out_effect
+                )
+            if graph.has_edge(a, b):
+                graph[a][b]["effect"] += new_edge_effect
+            else:
+                graph.add_edge(a, b, effect=new_edge_effect)
+
+    graph.remove_node(node)
+
+
+def recalc_graphs(graphs, model, xdat) -> Iterable[networkx.DiGraph]:
+    """Recalculate node and edge effects in graph.
+
+    Do this after modifying the graphs (typically with `remove_node_keep_edges`)
+    to calculate exact effects.
+    `graphs` must be in the format generated by `annotated_graphs` and in the
+    same order as individuals within `xdat`.
+    """
+    yhat = model.compute(xdat)
+    yhat_mean = np.mean(yhat, axis=1)
+    xdat_mean = np.mean(xdat, axis=1)
+
+    for i, approx_graph in enumerate(graphs):
+        individual_xdat = xdat[:, i : i + 1]
+        removed_nodes = set(model.graph.nodes) - set(approx_graph.nodes)
+
+        # Calc effects on shrunken model
+        individual_model = model.shrink(removed_nodes)
+        effects = individual_model.calc_effects(
+            individual_xdat,
+            xdat_mean=xdat_mean,
+            yhat_mean=yhat_mean[[yvar not in removed_nodes for yvar in model.yvars]],
+        )
+
+        # Get graph for shrunken model
+        [g] = annotated_graphs(
+            individual_model,
+            effects,
+            node_labels={
+                n: data["label"]
+                for n, data in approx_graph.nodes(data=True)
+                if "label" in data
+            },
+        )
+        for xvar in set(model.xvars) & removed_nodes & g.nodes():
+            g.remove_node(xvar)
+
+        # Preserve graph attributes
+        g.graph = approx_graph.graph
+        yield g