repo_name stringlengths 8 38 | pr_number int64 3 47.1k | pr_title stringlengths 8 175 | pr_description stringlengths 2 19.8k ⌀ | author null | date_created stringlengths 25 25 | date_merged stringlengths 25 25 | filepath stringlengths 6 136 | before_content stringlengths 54 884k ⌀ | after_content stringlengths 56 884k | pr_author stringlengths 3 21 | previous_commit stringlengths 40 40 | pr_commit stringlengths 40 40 | comment stringlengths 2 25.4k | comment_author stringlengths 3 29 | __index_level_0__ int64 0 5.1k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | Right... that was confusing for me, I don't like the fit_estimator flag as that seems to be a functionality of the estimator instead of this function. I'll change the input parameter to be an object so that we can keep that functionality for this PR and modify this method in future PRs to add the `fit()` call | andresmor-ms | 284 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | moved the code into causal_model (for compatibility and removed the param from this function :) | andresmor-ms | 285 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | I moved all the code to initialize the estimator into the causal_model (for compatibility) and made the function accept the object as parameter, so that it works the way you suggest | andresmor-ms | 286 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | removing all the kwargs will be done in future PRs, however i did add the object as parameter which makes things a little bit better while keeping backwards compatibility on causal_model class | andresmor-ms | 287 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | treatment, outcome need to be added to docstring.
identifier_name to be added to docstring.
| amit-sharma | 288 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | since we are now passing the method object, fit_estimator makes more sense for the next line, the estimate_effect method of the Estimator.
Here we can simply do the two if-else checks and then sequentially do "method.update_input". Just the "if fit_estimator" line can be removed. | amit-sharma | 289 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | data should be one of the arguments for estimate_effect. Actually it should be the first argument. Just like sklearn, the `estimate_effect` method of an Estimator object (or later, the fit method) should be passed the data. | amit-sharma | 290 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | let's follow the sklearn protocol and provide "data" to the estimate_effect method. For backwards compatibility, the data parameter can be optional. Inside the estimate_effect method, we can check that if data parameter is None, then use self.data | amit-sharma | 291 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | actually, to be fully consistent, let's provide X and y. Here y is the outcome variable, provided as `data[outcome_name]` and X would be data.drop(columns=["outcome_name"]) | amit-sharma | 292 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | Right now, this `estimate_effect` should also take fit_estimator param. But the ideal solution later is:
```
if fit_estimate: method.fit()
method.effect()
``` | amit-sharma | 293 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | what should be desired functionality for these parameters? test_significance, evaluate_effect_strength, confidence_intervals, effect_modifiers, etc.?
Ideally, these should be passed to the estimator. It makes sense if the user does not provide any `method`, so then we can add these parameters when initializing the E... | amit-sharma | 294 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | I'll add this in a future PR when I start to refactor all the estimator objects | andresmor-ms | 295 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | Agree, I'll do this when I refactor all the estimator objects in a future PR, that's why I decided to leave it as it currently is | andresmor-ms | 296 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_estimator.py | import logging
from collections import namedtuple
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy.utils.api import parse_state
class CausalEstimator:
"""Base class for an estimator of causal effect.
Subclasses... | import logging
from collections import namedtuple
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import sympy as sp
from sklearn.utils import resample
import dowhy.interpreters as interpreters
from dowhy import causal_estimators
from dowhy.causal_graph import CausalGraph
from do... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | I think we should move those params into the estimator object, so when initializing it the user can provide those, when I start refactoring the estimators we can find where's the best place for each parameter | andresmor-ms | 297 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_model.py | """ Module containing the main model class for the dowhy package.
"""
import logging
from itertools import combinations
from sympy import init_printing
import dowhy.causal_estimators as causal_estimators
import dowhy.causal_refuters as causal_refuters
import dowhy.graph_learners as graph_learners
import dowhy.utils.... | """ Module containing the main model class for the dowhy package.
"""
import logging
from itertools import combinations
from sympy import init_printing
import dowhy.causal_estimators as causal_estimators
import dowhy.causal_refuters as causal_refuters
import dowhy.graph_learners as graph_learners
import dowhy.utils.... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | there is a repetition of parameters, e.g., "test_signficance", "treatment_value" in both estimator and estimate_effect method. We need to decide where each parameter goes. I suggest that `target_units`, `control_value`, `treatment_value` belong to the `effect` method of an Estimator. One can call effect multiple times ... | amit-sharma | 298 |
py-why/dowhy | 693 | Functional api/estimate effect function | #### Estimate Effect function
* Refactors the estimate effect into a separate function to keep backwards compatibility
#### TODO (future PRs):
* Add `fit(...)` method to estimators - Move data related parameters from the constructor to the `fit(...)` method
* Refactor code to avoid `**kwargs` in `__init__(...)` c... | null | 2022-10-18 15:49:21+00:00 | 2022-10-25 17:02:02+00:00 | dowhy/causal_model.py | """ Module containing the main model class for the dowhy package.
"""
import logging
from itertools import combinations
from sympy import init_printing
import dowhy.causal_estimators as causal_estimators
import dowhy.causal_refuters as causal_refuters
import dowhy.graph_learners as graph_learners
import dowhy.utils.... | """ Module containing the main model class for the dowhy package.
"""
import logging
from itertools import combinations
from sympy import init_printing
import dowhy.causal_estimators as causal_estimators
import dowhy.causal_refuters as causal_refuters
import dowhy.graph_learners as graph_learners
import dowhy.utils.... | andresmor-ms | 2044d216c322a4b32c6eadce5da7d83463f19c2f | 05bfa49dacf0061988c96c6f3e3756219df5422a | Got it, will take it into account for the PR where i refactor the estimator objects | andresmor-ms | 299 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_identifier/auto_identifier.py | import itertools
import logging
from enum import Enum
from typing import Dict, List, Optional, Union
import sympy as sp
import sympy.stats as spstats
from dowhy.causal_graph import CausalGraph
from dowhy.causal_identifier.efficient_backdoor import EfficientBackdoor
from dowhy.causal_identifier.identified_estimand imp... | import itertools
import logging
from enum import Enum
from typing import Dict, List, Optional, Union
import sympy as sp
import sympy.stats as spstats
from dowhy.causal_graph import CausalGraph
from dowhy.causal_identifier.efficient_backdoor import EfficientBackdoor
from dowhy.causal_identifier.identified_estimand imp... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | does it return None otherwise? If yes, good to add to the docstring on line 141 | amit-sharma | 300 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_identifier/auto_identifier.py | import itertools
import logging
from enum import Enum
from typing import Dict, List, Optional, Union
import sympy as sp
import sympy.stats as spstats
from dowhy.causal_graph import CausalGraph
from dowhy.causal_identifier.efficient_backdoor import EfficientBackdoor
from dowhy.causal_identifier.identified_estimand imp... | import itertools
import logging
from enum import Enum
from typing import Dict, List, Optional, Union
import sympy as sp
import sympy.stats as spstats
from dowhy.causal_graph import CausalGraph
from dowhy.causal_identifier.efficient_backdoor import EfficientBackdoor
from dowhy.causal_identifier.identified_estimand imp... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | I was reading the code and I believe it always returns an `IdentifiedEstimand` object, I'm not 100% sure if there's a case in which it returns `None`. It does raise errors in many places, but does not return None | andresmor-ms | 301 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuter.py | import logging
import random
import numpy as np
import scipy.stats as st
from dowhy.utils.api import parse_state
class CausalRefuter:
"""Base class for different refutation methods.
Subclasses implement specific refutations methods.
# todo: add docstring for common parameters here and remove from chi... | import logging
import random
from enum import Enum
from typing import List, Union
import numpy as np
import scipy.stats as st
from dowhy.utils.api import parse_state
class SignificanceTestType(Enum):
AUTO = "auto"
BOOTSTRAP = "bootstrap"
NORMAL = "normal_test"
logger = logging.getLogger(__name__)
c... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | typo in boostrap | amit-sharma | 302 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuter.py | import logging
import random
import numpy as np
import scipy.stats as st
from dowhy.utils.api import parse_state
class CausalRefuter:
"""Base class for different refutation methods.
Subclasses implement specific refutations methods.
# todo: add docstring for common parameters here and remove from chi... | import logging
import random
from enum import Enum
from typing import List, Union
import numpy as np
import scipy.stats as st
from dowhy.utils.api import parse_state
class SignificanceTestType(Enum):
AUTO = "auto"
BOOTSTRAP = "bootstrap"
NORMAL = "normal_test"
logger = logging.getLogger(__name__)
c... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | I assume that CausalRefuter class is kept only for backwards compatibility? In that case, it will be good to add that to the docstring. | amit-sharma | 303 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuter.py | import logging
import random
import numpy as np
import scipy.stats as st
from dowhy.utils.api import parse_state
class CausalRefuter:
"""Base class for different refutation methods.
Subclasses implement specific refutations methods.
# todo: add docstring for common parameters here and remove from chi... | import logging
import random
from enum import Enum
from typing import List, Union
import numpy as np
import scipy.stats as st
from dowhy.utils.api import parse_state
class SignificanceTestType(Enum):
AUTO = "auto"
BOOTSTRAP = "bootstrap"
NORMAL = "normal_test"
logger = logging.getLogger(__name__)
c... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | Yep, that's correct, I'll add it in the next commit | andresmor-ms | 304 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuter.py | import logging
import random
import numpy as np
import scipy.stats as st
from dowhy.utils.api import parse_state
class CausalRefuter:
"""Base class for different refutation methods.
Subclasses implement specific refutations methods.
# todo: add docstring for common parameters here and remove from chi... | import logging
import random
from enum import Enum
from typing import List, Union
import numpy as np
import scipy.stats as st
from dowhy.utils.api import parse_state
class SignificanceTestType(Enum):
AUTO = "auto"
BOOTSTRAP = "bootstrap"
NORMAL = "normal_test"
logger = logging.getLogger(__name__)
c... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | found more instances of this typo, fixed them all | andresmor-ms | 305 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | import copy
import logging
import math
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.caus... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | what would be a good naming convention? shall we keep the "_" prefix for non-user facing functions? Or is there a more pythonic way of doing this? | amit-sharma | 306 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | import copy
import logging
import math
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.caus... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | this is the list of estimator objects for estimating alpha_s. These objects should have fit() and predict() methods (relevant only for non-parametric-partial-R2 method) | amit-sharma | 307 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | import copy
import logging
import math
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.caus... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | Flag on whether to use the plugin estimator or the nonparametric estimator for reisz representer function (alpha_s). | amit-sharma | 308 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | import copy
import logging
import math
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.caus... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | with the functional API, is there a way to ensure that any future refuter functions follow the same basic signature?
E.g., all refute functions should have a data, target_estimand and estimate? I'm thinking of making it easier to for new contributors to know the basic protocol that they need to adhere to.
something ... | amit-sharma | 309 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | import copy
import logging
import math
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.caus... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | I'm adding the `_` everywhere I see a non-public function/method, also I'm adding the public facing functions into the `__init__.py` file of the module. I guess that's the pythonic way, I don't think there's a way to prevent the user from importing/using those functions. | andresmor-ms | 310 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | import copy
import logging
import math
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.caus... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | I believe there is not a specific way of doing this, however the main `refute_estimate(data, target_estimand, estimate, ...)` partially serves this purpose, in the future if any developer wants the refuter to be callable through this function then the signature must comply with the type: `Callable[..., Union[CausalRefu... | andresmor-ms | 311 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | import copy
import logging
import math
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.caus... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | This sound good. We can follow this policy throughout. | amit-sharma | 312 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | import copy
import logging
import math
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.caus... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | Got, thanks for clarifying. I do agree that adding a class as protocol may not be needed. We can do it through PR reviews and docs to communicate the expected signature.
Perhaps the flexibility will also be useful for any future method that may not require to take in the usual parameters. | amit-sharma | 313 |
py-why/dowhy | 672 | Functional api/refute estimate | * Refactor refuters into functions
* Rename functional_api notebook for clarity
* Add return types to identify_estimate
* Update `__init__.py` for imports
* Add joblib for bootstrap refuter
* Create `refute_estimate` function
* Add types for refuter parameters & return types | null | 2022-10-04 16:18:49+00:00 | 2022-10-07 04:30:22+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | import copy
import logging
import math
from typing import Dict, List, Optional, Union
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.caus... | andresmor-ms | 133e7b9a4ed32aae8ab5f39a01eb02b3a4d1c0ba | e1652ec3c6606b1bb2dfe91ef830e4b4b566712d | This removal is introducing a non-backwards-compatible change. Will create an issue to address this. | petergtz | 314 |
py-why/dowhy | 641 | Update README.rst | Added direct link to https://github.com/py-why/dowhy/blob/main/docs/source/contributing/contributing-code.rst that has detailed instructions for code contribution steps
Signed-off-by: emrekiciman <emrek@microsoft.com> | null | 2022-09-17 01:02:37+00:00 | 2022-09-22 18:33:00+00:00 | README.rst | |BuildStatus|_ |PyPiVersion|_ |PythonSupport|_ |Downloads|_
.. |PyPiVersion| image:: https://img.shields.io/pypi/v/dowhy.svg
.. _PyPiVersion: https://pypi.org/project/dowhy/
.. |PythonSupport| image:: https://img.shields.io/pypi/pyversions/dowhy.svg
.. _PythonSupport: https://pypi.org/project/dowhy/
.. |BuildStatus|... | |BuildStatus|_ |PyPiVersion|_ |PythonSupport|_ |Downloads|_
.. |PyPiVersion| image:: https://img.shields.io/pypi/v/dowhy.svg
.. _PyPiVersion: https://pypi.org/project/dowhy/
.. |PythonSupport| image:: https://img.shields.io/pypi/pyversions/dowhy.svg
.. _PythonSupport: https://pypi.org/project/dowhy/
.. |BuildStatus|... | emrekiciman | c74b024a16ef0634422ffdda2c715031f46309bb | 81fe5d9cbd998796f02d0d9f5b1d923ba0e85383 | @emrekiciman There are `_`s missing after the ``>` ``s. rst syntax is a bit of a pain... | petergtz | 315 |
py-why/dowhy | 641 | Update README.rst | Added direct link to https://github.com/py-why/dowhy/blob/main/docs/source/contributing/contributing-code.rst that has detailed instructions for code contribution steps
Signed-off-by: emrekiciman <emrek@microsoft.com> | null | 2022-09-17 01:02:37+00:00 | 2022-09-22 18:33:00+00:00 | README.rst | |BuildStatus|_ |PyPiVersion|_ |PythonSupport|_ |Downloads|_
.. |PyPiVersion| image:: https://img.shields.io/pypi/v/dowhy.svg
.. _PyPiVersion: https://pypi.org/project/dowhy/
.. |PythonSupport| image:: https://img.shields.io/pypi/pyversions/dowhy.svg
.. _PythonSupport: https://pypi.org/project/dowhy/
.. |BuildStatus|... | |BuildStatus|_ |PyPiVersion|_ |PythonSupport|_ |Downloads|_
.. |PyPiVersion| image:: https://img.shields.io/pypi/v/dowhy.svg
.. _PyPiVersion: https://pypi.org/project/dowhy/
.. |PythonSupport| image:: https://img.shields.io/pypi/pyversions/dowhy.svg
.. _PythonSupport: https://pypi.org/project/dowhy/
.. |BuildStatus|... | emrekiciman | c74b024a16ef0634422ffdda2c715031f46309bb | 81fe5d9cbd998796f02d0d9f5b1d923ba0e85383 | Those spaces should be there now. | emrekiciman | 316 |
py-why/dowhy | 640 | Functional api/identify effect | First of a series of PR to add a functional API according to: https://github.com/py-why/dowhy/wiki/API-proposal-for-v1
* Refactor `identify_effect` to have a functional API
* Created `BackdoorIdentifier` class and extracted the logic from `CausalIdentifier` to be just a Protocol
* Refactor the `identify_effect... | null | 2022-09-16 21:35:24+00:00 | 2022-09-27 01:38:27+00:00 | docs/source/example_notebooks/dowhy_efficient_backdoor_example.ipynb | {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Finding optimal adjustment sets"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Preliminaries"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This notebook illus... | {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Finding optimal adjustment sets"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Preliminaries"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This notebook illus... | andresmor-ms | 4d4df7a4637a5f5e9cd9c5362499b1fb38debeab | db953a63aae205951f028c1050f141e3cdc0c97a | need to remove outputs from this notebook. That's why it is showing a big diff. | amit-sharma | 317 |
py-why/dowhy | 640 | Functional api/identify effect | First of a series of PR to add a functional API according to: https://github.com/py-why/dowhy/wiki/API-proposal-for-v1
* Refactor `identify_effect` to have a functional API
* Created `BackdoorIdentifier` class and extracted the logic from `CausalIdentifier` to be just a Protocol
* Refactor the `identify_effect... | null | 2022-09-16 21:35:24+00:00 | 2022-09-27 01:38:27+00:00 | dowhy/causal_estimators/two_stage_regression_estimator.py | import copy
import itertools
import numpy as np
import pandas as pd
from dowhy.causal_estimator import CausalEstimate, CausalEstimator
from dowhy.causal_estimators.linear_regression_estimator import LinearRegressionEstimator
from dowhy.causal_identifier import CausalIdentifier
from dowhy.utils.api import parse_state
... | import copy
import itertools
import numpy as np
import pandas as pd
from dowhy.causal_estimator import CausalEstimate, CausalEstimator
from dowhy.causal_estimators.linear_regression_estimator import LinearRegressionEstimator
from dowhy.causal_identifier.identify_effect import EstimandType
from dowhy.utils.api import ... | andresmor-ms | 4d4df7a4637a5f5e9cd9c5362499b1fb38debeab | db953a63aae205951f028c1050f141e3cdc0c97a | we can simply call it CausalEstimandType. We do not need Identifier.
In fact, since dowhy is about causality, EstimandType would also work. | amit-sharma | 318 |
py-why/dowhy | 640 | Functional api/identify effect | First of a series of PR to add a functional API according to: https://github.com/py-why/dowhy/wiki/API-proposal-for-v1
* Refactor `identify_effect` to have a functional API
* Created `BackdoorIdentifier` class and extracted the logic from `CausalIdentifier` to be just a Protocol
* Refactor the `identify_effect... | null | 2022-09-16 21:35:24+00:00 | 2022-09-27 01:38:27+00:00 | dowhy/causal_estimators/two_stage_regression_estimator.py | import copy
import itertools
import numpy as np
import pandas as pd
from dowhy.causal_estimator import CausalEstimate, CausalEstimator
from dowhy.causal_estimators.linear_regression_estimator import LinearRegressionEstimator
from dowhy.causal_identifier import CausalIdentifier
from dowhy.utils.api import parse_state
... | import copy
import itertools
import numpy as np
import pandas as pd
from dowhy.causal_estimator import CausalEstimate, CausalEstimator
from dowhy.causal_estimators.linear_regression_estimator import LinearRegressionEstimator
from dowhy.causal_identifier.identify_effect import EstimandType
from dowhy.utils.api import ... | andresmor-ms | 4d4df7a4637a5f5e9cd9c5362499b1fb38debeab | db953a63aae205951f028c1050f141e3cdc0c97a | Would you say this should be defined in a more generic package instead of causal_identifier so that it can be reused in a more general way across all of dowhy? | andresmor-ms | 319 |
py-why/dowhy | 640 | Functional api/identify effect | First of a series of PR to add a functional API according to: https://github.com/py-why/dowhy/wiki/API-proposal-for-v1
* Refactor `identify_effect` to have a functional API
* Created `BackdoorIdentifier` class and extracted the logic from `CausalIdentifier` to be just a Protocol
* Refactor the `identify_effect... | null | 2022-09-16 21:35:24+00:00 | 2022-09-27 01:38:27+00:00 | dowhy/causal_estimators/two_stage_regression_estimator.py | import copy
import itertools
import numpy as np
import pandas as pd
from dowhy.causal_estimator import CausalEstimate, CausalEstimator
from dowhy.causal_estimators.linear_regression_estimator import LinearRegressionEstimator
from dowhy.causal_identifier import CausalIdentifier
from dowhy.utils.api import parse_state
... | import copy
import itertools
import numpy as np
import pandas as pd
from dowhy.causal_estimator import CausalEstimate, CausalEstimator
from dowhy.causal_estimators.linear_regression_estimator import LinearRegressionEstimator
from dowhy.causal_identifier.identify_effect import EstimandType
from dowhy.utils.api import ... | andresmor-ms | 4d4df7a4637a5f5e9cd9c5362499b1fb38debeab | db953a63aae205951f028c1050f141e3cdc0c97a | Let's keep it where it is right now. The current EstimandType is specific to the effect inference pipeline and the interface between identification and estimation. | emrekiciman | 320 |
py-why/dowhy | 625 | Overhaul GCM introduction | * Remove bibtex from GCM introduction. This is covered in docs/source/cite.rst.
* Add 'Typical usage' section in GCM introduction | null | 2022-09-05 14:12:41+00:00 | 2022-11-02 10:01:42+00:00 | docs/source/user_guide/gcm_based_inference/introduction.rst | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | petergtz | b43ce50d7cf58420b88605531b34b5c86f905112 | 560b3460aaf1106f7a053f99ede24cfed094db6f | I am a bit concerned that most structures will be `REJECTED` due to the statistical issues with the independence tests, even if the structures are correct. | bloebp | 321 |
py-why/dowhy | 625 | Overhaul GCM introduction | * Remove bibtex from GCM introduction. This is covered in docs/source/cite.rst.
* Add 'Typical usage' section in GCM introduction | null | 2022-09-05 14:12:41+00:00 | 2022-11-02 10:01:42+00:00 | docs/source/user_guide/gcm_based_inference/introduction.rst | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | petergtz | b43ce50d7cf58420b88605531b34b5c86f905112 | 560b3460aaf1106f7a053f99ede24cfed094db6f | `quality` is by default `GOOD`. Or do you want to emphasize here that this is a parameter? | bloebp | 322 |
py-why/dowhy | 625 | Overhaul GCM introduction | * Remove bibtex from GCM introduction. This is covered in docs/source/cite.rst.
* Add 'Typical usage' section in GCM introduction | null | 2022-09-05 14:12:41+00:00 | 2022-11-02 10:01:42+00:00 | docs/source/user_guide/gcm_based_inference/introduction.rst | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | petergtz | b43ce50d7cf58420b88605531b34b5c86f905112 | 560b3460aaf1106f7a053f99ede24cfed094db6f | (Not for this PR): What about renaming `bootstrap_training_and_sampling` to `fit_and_evaluate_subset` or something along the line? For me, this makes it clearer what it actually does. The multiple samples based on different data subsets are actually due to `confidence_intervals` calling it multiple times. | bloebp | 323 |
py-why/dowhy | 625 | Overhaul GCM introduction | * Remove bibtex from GCM introduction. This is covered in docs/source/cite.rst.
* Add 'Typical usage' section in GCM introduction | null | 2022-09-05 14:12:41+00:00 | 2022-11-02 10:01:42+00:00 | docs/source/user_guide/gcm_based_inference/introduction.rst | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | petergtz | b43ce50d7cf58420b88605531b34b5c86f905112 | 560b3460aaf1106f7a053f99ede24cfed094db6f | Yea, I'm open to renaming that. We could even make it short and call it `fit_and_compute`. Then it would also nice read "fit and compute direct arrow strength" or similar. | petergtz | 324 |
py-why/dowhy | 625 | Overhaul GCM introduction | * Remove bibtex from GCM introduction. This is covered in docs/source/cite.rst.
* Add 'Typical usage' section in GCM introduction | null | 2022-09-05 14:12:41+00:00 | 2022-11-02 10:01:42+00:00 | docs/source/user_guide/gcm_based_inference/introduction.rst | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | petergtz | b43ce50d7cf58420b88605531b34b5c86f905112 | 560b3460aaf1106f7a053f99ede24cfed094db6f | No, I guess this is a copy-and-paste issue. I'll remove it. | petergtz | 325 |
py-why/dowhy | 625 | Overhaul GCM introduction | * Remove bibtex from GCM introduction. This is covered in docs/source/cite.rst.
* Add 'Typical usage' section in GCM introduction | null | 2022-09-05 14:12:41+00:00 | 2022-11-02 10:01:42+00:00 | docs/source/user_guide/gcm_based_inference/introduction.rst | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | petergtz | b43ce50d7cf58420b88605531b34b5c86f905112 | 560b3460aaf1106f7a053f99ede24cfed094db6f | Wait, but didn't we discuss this at length and said that `REJECTED` would only be returned when you really shouldn't continue, whereas in other cases it might still not be correct, but it's somewhat inconclusive. It feels like we're re-discussing something that we've already resolved, no? | petergtz | 326 |
py-why/dowhy | 625 | Overhaul GCM introduction | * Remove bibtex from GCM introduction. This is covered in docs/source/cite.rst.
* Add 'Typical usage' section in GCM introduction | null | 2022-09-05 14:12:41+00:00 | 2022-11-02 10:01:42+00:00 | docs/source/user_guide/gcm_based_inference/introduction.rst | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | petergtz | b43ce50d7cf58420b88605531b34b5c86f905112 | 560b3460aaf1106f7a053f99ede24cfed094db6f | The discussion we had was to give a clear answer whether the graph is "correct", while we can only clearly say "no" if we `REJECTED` it. However, even if the graph is completely correct, there is a (very high) chance that we still return `REJECTED` here. At least, even in our artificial notebook examples, its often rej... | bloebp | 327 |
py-why/dowhy | 625 | Overhaul GCM introduction | * Remove bibtex from GCM introduction. This is covered in docs/source/cite.rst.
* Add 'Typical usage' section in GCM introduction | null | 2022-09-05 14:12:41+00:00 | 2022-11-02 10:01:42+00:00 | docs/source/user_guide/gcm_based_inference/introduction.rst | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | petergtz | b43ce50d7cf58420b88605531b34b5c86f905112 | 560b3460aaf1106f7a053f99ede24cfed094db6f | Created
- https://github.com/py-why/dowhy/issues/689 | petergtz | 328 |
py-why/dowhy | 625 | Overhaul GCM introduction | * Remove bibtex from GCM introduction. This is covered in docs/source/cite.rst.
* Add 'Typical usage' section in GCM introduction | null | 2022-09-05 14:12:41+00:00 | 2022-11-02 10:01:42+00:00 | docs/source/user_guide/gcm_based_inference/introduction.rst | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | petergtz | b43ce50d7cf58420b88605531b34b5c86f905112 | 560b3460aaf1106f7a053f99ede24cfed094db6f | We don't do the validation in the introduction anymore, right? | bloebp | 329 |
py-why/dowhy | 625 | Overhaul GCM introduction | * Remove bibtex from GCM introduction. This is covered in docs/source/cite.rst.
* Add 'Typical usage' section in GCM introduction | null | 2022-09-05 14:12:41+00:00 | 2022-11-02 10:01:42+00:00 | docs/source/user_guide/gcm_based_inference/introduction.rst | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | Introduction
============
Graphical causal model-based inference, or GCM-based inference for short, is an experimental addition to DoWhy, that
currently works separately from DoWhy's main API. Its experimental status also means that its API may
undergo breaking changes in the future. It will be forming a part of a joi... | petergtz | b43ce50d7cf58420b88605531b34b5c86f905112 | 560b3460aaf1106f7a053f99ede24cfed094db6f | Removed that paragraph. | petergtz | 330 |
py-why/dowhy | 621 | Add MVG projects docs | Hi @amit-sharma, @emrekiciman, @bloebp,
I'm doing some basic chores here to comply with our own MVG (doing the same for the other repos). Normally, you would "sign" the maintainers file yourself by adding your name, but I figured you approving this PR is equivalent.
Also, is there anyone else who should be in the... | null | 2022-09-05 08:01:55+00:00 | 2022-09-16 07:13:16+00:00 | CONTRIBUTING.md |
<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
[](#contributors-)
<!-- ALL-CONTRIBUTORS-BADGE:END -->
## Contributors ✨
Thanks goes to these wonderful people ([emoji key](https://allcontrib... |
<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
[](#contributors-)
<!-- ALL-CONTRIBUTORS-BADGE:END -->
## Contributors ✨
Thanks goes to these wonderful people ([emoji key](https://allcontrib... | petergtz | ad87aef3b728ec68cd81d5b33a618b543691f953 | 93f1852b326c06d8d06e4209078b1283555e8fc5 | shall we change Organization's to PyWhy's? | amit-sharma | 331 |
py-why/dowhy | 619 | Add support for controlled direct treatment effect | This PR adds a new estimand_type="nonparametric-cde" and associated identification method to compute the controlled direct effect.
The estimation can still be handled using standard backdoor estimators since the estimand is always a conditional expectation. | null | 2022-08-31 17:48:43+00:00 | 2022-09-02 08:37:56+00:00 | dowhy/causal_graph.py | import itertools
import logging
import re
import networkx as nx
from dowhy.utils.api import parse_state
from dowhy.utils.graph_operations import daggity_to_dot
class CausalGraph:
"""Class for creating and modifying the causal graph.
Accepts a graph string (or a text file) in gml format (preferred) and dot... | import itertools
import logging
import re
import networkx as nx
from dowhy.utils.api import parse_state
from dowhy.utils.graph_operations import daggity_to_dot
class CausalGraph:
"""Class for creating and modifying the causal graph.
Accepts a graph string (or a text file) in gml format (preferred) and dot... | amit-sharma | 2f2463be424093d720ebfa9cc625a06160a44cfe | d67da0e57eda5cc47d180f3de240182dde4aacad | from a variable naming perspective, the distinction between "node_names" and "target_node_names" is unclear. if target_node_names is for supporting direct_edges, can the name reflect that? Or, would it be better to have multiple surgery methods that each present cleaner APIs? | emrekiciman | 332 |
py-why/dowhy | 619 | Add support for controlled direct treatment effect | This PR adds a new estimand_type="nonparametric-cde" and associated identification method to compute the controlled direct effect.
The estimation can still be handled using standard backdoor estimators since the estimand is always a conditional expectation. | null | 2022-08-31 17:48:43+00:00 | 2022-09-02 08:37:56+00:00 | dowhy/causal_graph.py | import itertools
import logging
import re
import networkx as nx
from dowhy.utils.api import parse_state
from dowhy.utils.graph_operations import daggity_to_dot
class CausalGraph:
"""Class for creating and modifying the causal graph.
Accepts a graph string (or a text file) in gml format (preferred) and dot... | import itertools
import logging
import re
import networkx as nx
from dowhy.utils.api import parse_state
from dowhy.utils.graph_operations import daggity_to_dot
class CausalGraph:
"""Class for creating and modifying the causal graph.
Accepts a graph string (or a text file) in gml format (preferred) and dot... | amit-sharma | 2f2463be424093d720ebfa9cc625a06160a44cfe | d67da0e57eda5cc47d180f3de240182dde4aacad | instead of renaming target_node_names, maybe "remove_only_direct_edges" could be renamed to "remove_edges_to_targets"? | emrekiciman | 333 |
py-why/dowhy | 619 | Add support for controlled direct treatment effect | This PR adds a new estimand_type="nonparametric-cde" and associated identification method to compute the controlled direct effect.
The estimation can still be handled using standard backdoor estimators since the estimand is always a conditional expectation. | null | 2022-08-31 17:48:43+00:00 | 2022-09-02 08:37:56+00:00 | dowhy/causal_graph.py | import itertools
import logging
import re
import networkx as nx
from dowhy.utils.api import parse_state
from dowhy.utils.graph_operations import daggity_to_dot
class CausalGraph:
"""Class for creating and modifying the causal graph.
Accepts a graph string (or a text file) in gml format (preferred) and dot... | import itertools
import logging
import re
import networkx as nx
from dowhy.utils.api import parse_state
from dowhy.utils.graph_operations import daggity_to_dot
class CausalGraph:
"""Class for creating and modifying the causal graph.
Accepts a graph string (or a text file) in gml format (preferred) and dot... | amit-sharma | 2f2463be424093d720ebfa9cc625a06160a44cfe | d67da0e57eda5cc47d180f3de240182dde4aacad | thanks for the suggestion. I've renamed "remove_only_direct_edges" to "remove_only_direct_edges_to_targets", since we only want to remove the direct edges. It is long but I thought it is best to err on the side of clarity here. | amit-sharma | 334 |
py-why/dowhy | 615 | CI: Split tests into groups to speed them up | * Mark some slow tests as advanced
* Split tests into 4 shards in CI | null | 2022-08-25 22:09:18+00:00 | 2022-09-01 22:51:03+00:00 | poetry.lock | [[package]]
name = "absl-py"
version = "1.2.0"
description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py."
category = "dev"
optional = false
python-versions = ">=3.6"
[[package]]
name = "alabaster"
version = "0.7.12"
description = "A configurable sidebar-enabled Sphinx theme"
category = "d... | [[package]]
name = "absl-py"
version = "1.2.0"
description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py."
category = "dev"
optional = false
python-versions = ">=3.6"
[[package]]
name = "alabaster"
version = "0.7.12"
description = "A configurable sidebar-enabled Sphinx theme"
category = "d... | darthtrevino | ead8d47102f0ac6db51d84432874c331fb84f3cb | 2f2463be424093d720ebfa9cc625a06160a44cfe | Are the changes to lib versions in poetry.lock due to splitting the tests into groups, or are they unrelated changes? | emrekiciman | 335 |
py-why/dowhy | 615 | CI: Split tests into groups to speed them up | * Mark some slow tests as advanced
* Split tests into 4 shards in CI | null | 2022-08-25 22:09:18+00:00 | 2022-09-01 22:51:03+00:00 | poetry.lock | [[package]]
name = "absl-py"
version = "1.2.0"
description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py."
category = "dev"
optional = false
python-versions = ">=3.6"
[[package]]
name = "alabaster"
version = "0.7.12"
description = "A configurable sidebar-enabled Sphinx theme"
category = "d... | [[package]]
name = "absl-py"
version = "1.2.0"
description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py."
category = "dev"
optional = false
python-versions = ">=3.6"
[[package]]
name = "alabaster"
version = "0.7.12"
description = "A configurable sidebar-enabled Sphinx theme"
category = "d... | darthtrevino | ead8d47102f0ac6db51d84432874c331fb84f3cb | 2f2463be424093d720ebfa9cc625a06160a44cfe | Some are related to adding the new dependency, but it looks like it runs the solution engine whenever you add a dependency. We have a handful of deps that are tied to `main` branches on github, which will be resolved fresh - and there may be some path-version updates from other dependencies. | darthtrevino | 336 |
py-why/dowhy | 615 | CI: Split tests into groups to speed them up | * Mark some slow tests as advanced
* Split tests into 4 shards in CI | null | 2022-08-25 22:09:18+00:00 | 2022-09-01 22:51:03+00:00 | tests/causal_refuters/test_data_subset_refuter.py | import numpy as np
import pytest
from .base import TestRefuter
@pytest.mark.usefixtures("fixed_seed")
class TestDataSubsetRefuter(object):
@pytest.mark.parametrize(["error_tolerance", "estimator_method"], [(0.01, "iv.instrumental_variable")])
def test_refutation_data_subset_refuter_continuous(self, error_tol... | import numpy as np
import pytest
from pytest import mark
from .base import TestRefuter
@mark.usefixtures("fixed_seed")
class TestDataSubsetRefuter(object):
@mark.parametrize(["error_tolerance", "estimator_method"], [(0.01, "iv.instrumental_variable")])
def test_refutation_data_subset_refuter_continuous(self,... | darthtrevino | ead8d47102f0ac6db51d84432874c331fb84f3cb | 2f2463be424093d720ebfa9cc625a06160a44cfe | Most of the files use "mark.advanced" rather than pytest.mark.advanced. Is this contextual or would it be better to be consistent? or am I being too pedantic :) | emrekiciman | 337 |
py-why/dowhy | 615 | CI: Split tests into groups to speed them up | * Mark some slow tests as advanced
* Split tests into 4 shards in CI | null | 2022-08-25 22:09:18+00:00 | 2022-09-01 22:51:03+00:00 | tests/causal_refuters/test_data_subset_refuter.py | import numpy as np
import pytest
from .base import TestRefuter
@pytest.mark.usefixtures("fixed_seed")
class TestDataSubsetRefuter(object):
@pytest.mark.parametrize(["error_tolerance", "estimator_method"], [(0.01, "iv.instrumental_variable")])
def test_refutation_data_subset_refuter_continuous(self, error_tol... | import numpy as np
import pytest
from pytest import mark
from .base import TestRefuter
@mark.usefixtures("fixed_seed")
class TestDataSubsetRefuter(object):
@mark.parametrize(["error_tolerance", "estimator_method"], [(0.01, "iv.instrumental_variable")])
def test_refutation_data_subset_refuter_continuous(self,... | darthtrevino | ead8d47102f0ac6db51d84432874c331fb84f3cb | 2f2463be424093d720ebfa9cc625a06160a44cfe | I've found both in the codebase - basically which one you use depends on whether you have `import pytest` or `from pytest import mark` in your file. I'm fine standardizing on using `@mark.advanced` though. | darthtrevino | 338 |
py-why/dowhy | 615 | CI: Split tests into groups to speed them up | * Mark some slow tests as advanced
* Split tests into 4 shards in CI | null | 2022-08-25 22:09:18+00:00 | 2022-09-01 22:51:03+00:00 | tests/causal_refuters/test_data_subset_refuter.py | import numpy as np
import pytest
from .base import TestRefuter
@pytest.mark.usefixtures("fixed_seed")
class TestDataSubsetRefuter(object):
@pytest.mark.parametrize(["error_tolerance", "estimator_method"], [(0.01, "iv.instrumental_variable")])
def test_refutation_data_subset_refuter_continuous(self, error_tol... | import numpy as np
import pytest
from pytest import mark
from .base import TestRefuter
@mark.usefixtures("fixed_seed")
class TestDataSubsetRefuter(object):
@mark.parametrize(["error_tolerance", "estimator_method"], [(0.01, "iv.instrumental_variable")])
def test_refutation_data_subset_refuter_continuous(self,... | darthtrevino | ead8d47102f0ac6db51d84432874c331fb84f3cb | 2f2463be424093d720ebfa9cc625a06160a44cfe | Ok, let's standardize on mark.advanced then. | emrekiciman | 339 |
py-why/dowhy | 602 | Add dependency to resolve security alert | https://github.com/py-why/dowhy/security/dependabot/1
* Updates nbconvert to 7.0rc3 & mistune to a safe version
* Move documentation-generation dependencies into devDependencies area
* Run `poetry update` for dependency refresh | null | 2022-08-13 01:40:09+00:00 | 2022-08-19 21:01:53+00:00 | poetry.lock | [[package]]
name = "absl-py"
version = "1.2.0"
description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py."
category = "dev"
optional = false
python-versions = ">=3.6"
[[package]]
name = "alabaster"
version = "0.7.12"
description = "A configurable sidebar-enabled Sphinx theme"
category = "m... | [[package]]
name = "absl-py"
version = "1.2.0"
description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py."
category = "dev"
optional = false
python-versions = ">=3.6"
[[package]]
name = "alabaster"
version = "0.7.12"
description = "A configurable sidebar-enabled Sphinx theme"
category = "d... | darthtrevino | f947d98ffbc9d96b91be9bcfc43cf142fc2c0cd5 | eadb99cbe104d89dda62f73e331515df484e8d5a | Are all the other changes in this file a consequence of updating mistune? | emrekiciman | 340 |
py-why/dowhy | 602 | Add dependency to resolve security alert | https://github.com/py-why/dowhy/security/dependabot/1
* Updates nbconvert to 7.0rc3 & mistune to a safe version
* Move documentation-generation dependencies into devDependencies area
* Run `poetry update` for dependency refresh | null | 2022-08-13 01:40:09+00:00 | 2022-08-19 21:01:53+00:00 | poetry.lock | [[package]]
name = "absl-py"
version = "1.2.0"
description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py."
category = "dev"
optional = false
python-versions = ">=3.6"
[[package]]
name = "alabaster"
version = "0.7.12"
description = "A configurable sidebar-enabled Sphinx theme"
category = "m... | [[package]]
name = "absl-py"
version = "1.2.0"
description = "Abseil Python Common Libraries, see https://github.com/abseil/abseil-py."
category = "dev"
optional = false
python-versions = ">=3.6"
[[package]]
name = "alabaster"
version = "0.7.12"
description = "A configurable sidebar-enabled Sphinx theme"
category = "d... | darthtrevino | f947d98ffbc9d96b91be9bcfc43cf142fc2c0cd5 | eadb99cbe104d89dda62f73e331515df484e8d5a | It looks like it - I believe that it's generally recommended to run `poetry update` once in a while, which will update the resolved versions of your dependencies to the latest that matches the semver range, but these are all from just running `poetry add mistune` | darthtrevino | 341 |
py-why/dowhy | 602 | Add dependency to resolve security alert | https://github.com/py-why/dowhy/security/dependabot/1
* Updates nbconvert to 7.0rc3 & mistune to a safe version
* Move documentation-generation dependencies into devDependencies area
* Run `poetry update` for dependency refresh | null | 2022-08-13 01:40:09+00:00 | 2022-08-19 21:01:53+00:00 | pyproject.toml | [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | darthtrevino | f947d98ffbc9d96b91be9bcfc43cf142fc2c0cd5 | eadb99cbe104d89dda62f73e331515df484e8d5a | Is there a reason these lines related to causalml have changed together with the update to the mistune version? | emrekiciman | 342 |
py-why/dowhy | 602 | Add dependency to resolve security alert | https://github.com/py-why/dowhy/security/dependabot/1
* Updates nbconvert to 7.0rc3 & mistune to a safe version
* Move documentation-generation dependencies into devDependencies area
* Run `poetry update` for dependency refresh | null | 2022-08-13 01:40:09+00:00 | 2022-08-19 21:01:53+00:00 | pyproject.toml | [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | darthtrevino | f947d98ffbc9d96b91be9bcfc43cf142fc2c0cd5 | eadb99cbe104d89dda62f73e331515df484e8d5a | Those dependencies didn't change, but I grouped them together so it was clear that they were related. | darthtrevino | 343 |
py-why/dowhy | 584 | Use Poetry for Managing Dependencies, Tasks, and Package Builds | This PR includes the [Poetry](https://python-poetry.org/) tool for managing dependencies and packaging the library. This reduces a lot of boilerplate involved in defining and executing sequences of common tasks and with packaging & publishing the library.
* Use pytest-xdist; other test updates will be deferred for ano... | null | 2022-07-29 20:10:26+00:00 | 2022-08-13 01:12:53+00:00 | .github/workflows/python-package.yml | # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
name: DoWhy CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
j... | # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
name: DoWhy CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
job... | darthtrevino | eba2c1cc8217495797f9d5ed34cffe7ed457fe40 | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | Sorry, you might have already commented somewhere, but why is it necessary to remove 3.7? | petergtz | 344 |
py-why/dowhy | 584 | Use Poetry for Managing Dependencies, Tasks, and Package Builds | This PR includes the [Poetry](https://python-poetry.org/) tool for managing dependencies and packaging the library. This reduces a lot of boilerplate involved in defining and executing sequences of common tasks and with packaging & publishing the library.
* Use pytest-xdist; other test updates will be deferred for ano... | null | 2022-07-29 20:10:26+00:00 | 2022-08-13 01:12:53+00:00 | .github/workflows/python-package.yml | # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
name: DoWhy CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
j... | # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
name: DoWhy CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
job... | darthtrevino | eba2c1cc8217495797f9d5ed34cffe7ed457fe40 | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | I tracked my compatibility notes in pyproject.toml here: https://github.com/py-why/dowhy/blob/0bd42158d7aadcd2e4e5c5c9497b1df1c2e0967d/pyproject.toml#L40-L46
Basically, `pygraphviz` and `networkx` - at least recent versions of them - require >= 3.8. Since there's a proposal to extend networkx with causal graphs, it ... | darthtrevino | 345 |
py-why/dowhy | 584 | Use Poetry for Managing Dependencies, Tasks, and Package Builds | This PR includes the [Poetry](https://python-poetry.org/) tool for managing dependencies and packaging the library. This reduces a lot of boilerplate involved in defining and executing sequences of common tasks and with packaging & publishing the library.
* Use pytest-xdist; other test updates will be deferred for ano... | null | 2022-07-29 20:10:26+00:00 | 2022-08-13 01:12:53+00:00 | pyproject.toml | [tool.pytest.ini_options]
markers = [
"advanced: not be to run each time. only on package updates."
]
| [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | darthtrevino | eba2c1cc8217495797f9d5ed34cffe7ed457fe40 | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | should we include the LICENSE file here? | amit-sharma | 346 |
py-why/dowhy | 584 | Use Poetry for Managing Dependencies, Tasks, and Package Builds | This PR includes the [Poetry](https://python-poetry.org/) tool for managing dependencies and packaging the library. This reduces a lot of boilerplate involved in defining and executing sequences of common tasks and with packaging & publishing the library.
* Use pytest-xdist; other test updates will be deferred for ano... | null | 2022-07-29 20:10:26+00:00 | 2022-08-13 01:12:53+00:00 | pyproject.toml | [tool.pytest.ini_options]
markers = [
"advanced: not be to run each time. only on package updates."
]
| [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | darthtrevino | eba2c1cc8217495797f9d5ed34cffe7ed457fe40 | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | curious: why do we need to convert this notebook to html? | amit-sharma | 347 |
py-why/dowhy | 584 | Use Poetry for Managing Dependencies, Tasks, and Package Builds | This PR includes the [Poetry](https://python-poetry.org/) tool for managing dependencies and packaging the library. This reduces a lot of boilerplate involved in defining and executing sequences of common tasks and with packaging & publishing the library.
* Use pytest-xdist; other test updates will be deferred for ano... | null | 2022-07-29 20:10:26+00:00 | 2022-08-13 01:12:53+00:00 | pyproject.toml | [tool.pytest.ini_options]
markers = [
"advanced: not be to run each time. only on package updates."
]
| [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | darthtrevino | eba2c1cc8217495797f9d5ed34cffe7ed457fe40 | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | should we put llmvlite as a dev-dependency? It is not used by dowhy, but only relevant if someone is using causalml.
Another option is to mark it as an optional dependency. | amit-sharma | 348 |
py-why/dowhy | 584 | Use Poetry for Managing Dependencies, Tasks, and Package Builds | This PR includes the [Poetry](https://python-poetry.org/) tool for managing dependencies and packaging the library. This reduces a lot of boilerplate involved in defining and executing sequences of common tasks and with packaging & publishing the library.
* Use pytest-xdist; other test updates will be deferred for ano... | null | 2022-07-29 20:10:26+00:00 | 2022-08-13 01:12:53+00:00 | pyproject.toml | [tool.pytest.ini_options]
markers = [
"advanced: not be to run each time. only on package updates."
]
| [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | darthtrevino | eba2c1cc8217495797f9d5ed34cffe7ed457fe40 | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | Honestly I just moved this script over from the makefile. I'm not sure if it was part of your workflow for some reason | darthtrevino | 349 |
py-why/dowhy | 584 | Use Poetry for Managing Dependencies, Tasks, and Package Builds | This PR includes the [Poetry](https://python-poetry.org/) tool for managing dependencies and packaging the library. This reduces a lot of boilerplate involved in defining and executing sequences of common tasks and with packaging & publishing the library.
* Use pytest-xdist; other test updates will be deferred for ano... | null | 2022-07-29 20:10:26+00:00 | 2022-08-13 01:12:53+00:00 | pyproject.toml | [tool.pytest.ini_options]
markers = [
"advanced: not be to run each time. only on package updates."
]
| [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | darthtrevino | eba2c1cc8217495797f9d5ed34cffe7ed457fe40 | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | There's a license field above, which I think covers it | darthtrevino | 350 |
py-why/dowhy | 584 | Use Poetry for Managing Dependencies, Tasks, and Package Builds | This PR includes the [Poetry](https://python-poetry.org/) tool for managing dependencies and packaging the library. This reduces a lot of boilerplate involved in defining and executing sequences of common tasks and with packaging & publishing the library.
* Use pytest-xdist; other test updates will be deferred for ano... | null | 2022-07-29 20:10:26+00:00 | 2022-08-13 01:12:53+00:00 | pyproject.toml | [tool.pytest.ini_options]
markers = [
"advanced: not be to run each time. only on package updates."
]
| [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | darthtrevino | eba2c1cc8217495797f9d5ed34cffe7ed457fe40 | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | I can do that; if it's optional we would probably add it as a devDep and mark it as optional in the main deps. Should causalml be optional as well? | darthtrevino | 351 |
py-why/dowhy | 584 | Use Poetry for Managing Dependencies, Tasks, and Package Builds | This PR includes the [Poetry](https://python-poetry.org/) tool for managing dependencies and packaging the library. This reduces a lot of boilerplate involved in defining and executing sequences of common tasks and with packaging & publishing the library.
* Use pytest-xdist; other test updates will be deferred for ano... | null | 2022-07-29 20:10:26+00:00 | 2022-08-13 01:12:53+00:00 | pyproject.toml | [tool.pytest.ini_options]
markers = [
"advanced: not be to run each time. only on package updates."
]
| [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | darthtrevino | eba2c1cc8217495797f9d5ed34cffe7ed457fe40 | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | yes, causalml should be optional too. | amit-sharma | 352 |
py-why/dowhy | 584 | Use Poetry for Managing Dependencies, Tasks, and Package Builds | This PR includes the [Poetry](https://python-poetry.org/) tool for managing dependencies and packaging the library. This reduces a lot of boilerplate involved in defining and executing sequences of common tasks and with packaging & publishing the library.
* Use pytest-xdist; other test updates will be deferred for ano... | null | 2022-07-29 20:10:26+00:00 | 2022-08-13 01:12:53+00:00 | pyproject.toml | [tool.pytest.ini_options]
markers = [
"advanced: not be to run each time. only on package updates."
]
| [tool.poetry]
name = "dowhy"
#
# 0.0.0 is standard placeholder for poetry-dynamic-versioning
# any changes to this should not be checked in
#
version = "0.0.0"
description = "DoWhy is a Python library for causal inference that supports explicit modeling and testing of causal assumptions"
authors = [
"PyWhy Communi... | darthtrevino | eba2c1cc8217495797f9d5ed34cffe7ed457fe40 | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | haha, I also don't remember now why it was there. I guess we can safely remove it. Does not appear to do anything critical. | amit-sharma | 353 |
py-why/dowhy | 582 | CI: Update GH Action Trigger | The current trigger fired on 'master', which has been deprecated. | null | 2022-07-28 20:18:53+00:00 | 2022-07-29 09:18:25+00:00 | .github/workflows/python-package.yml | # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
name: Python package
on:
push:
branches: [ master ]
pull_request:
branches: [ ma... | # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
name: DoWhy CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
j... | darthtrevino | 96fa21848c4edcaa5e8c57a5d4c5efcbe39c408d | 0464798b03b6d19e81b8db71d4451ab30d20eac9 | You've removed the restriction to a specific branch (now `main`). What's the idea behind it? Do you think that's more appropriate? Asking, because I'm not sure we'd want to run this on every push to an arbitrary branch. | petergtz | 354 |
py-why/dowhy | 582 | CI: Update GH Action Trigger | The current trigger fired on 'master', which has been deprecated. | null | 2022-07-28 20:18:53+00:00 | 2022-07-29 09:18:25+00:00 | .github/workflows/python-package.yml | # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
name: Python package
on:
push:
branches: [ master ]
pull_request:
branches: [ ma... | # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
name: DoWhy CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
j... | darthtrevino | 96fa21848c4edcaa5e8c57a5d4c5efcbe39c408d | 0464798b03b6d19e81b8db71d4451ab30d20eac9 | That's fair - we use this terser form on some other open-source projects but I don't mind restoring the branch selector. | darthtrevino | 355 |
py-why/dowhy | 568 | Introduce PyData Sphinx theme and restructure docs accordingly | The PyData theme is being used by NumPy, Pandas, NetworkX, and others. I've re-arranged some sections to make it play nicely with the theme. The result can be seen here:
https://petergtz.github.io/dowhy/master
There is one open question, where I'd be curious for input: older versions of the documentation will now... | null | 2022-07-21 07:48:55+00:00 | 2022-08-03 12:56:58+00:00 | docs/source/conf.py | # -*- coding: utf-8 -*-
#
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/stable/config
# -- Path setup ------------------------------------------------------------... | # -*- coding: utf-8 -*-
#
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/stable/config
# -- Path setup ------------------------------------------------------------... | petergtz | 3db32b638414aea85ee3518afbc92b655db54a95 | 77f7064c85b3de740b5beefb0ad7067ffdb024fd | will be good to remove/comment this out. | amit-sharma | 356 |
py-why/dowhy | 568 | Introduce PyData Sphinx theme and restructure docs accordingly | The PyData theme is being used by NumPy, Pandas, NetworkX, and others. I've re-arranged some sections to make it play nicely with the theme. The result can be seen here:
https://petergtz.github.io/dowhy/master
There is one open question, where I'd be curious for input: older versions of the documentation will now... | null | 2022-07-21 07:48:55+00:00 | 2022-08-03 12:56:58+00:00 | docs/source/conf.py | # -*- coding: utf-8 -*-
#
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/stable/config
# -- Path setup ------------------------------------------------------------... | # -*- coding: utf-8 -*-
#
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/stable/config
# -- Path setup ------------------------------------------------------------... | petergtz | 3db32b638414aea85ee3518afbc92b655db54a95 | 77f7064c85b3de740b5beefb0ad7067ffdb024fd | 🤦 Removed | petergtz | 357 |
py-why/dowhy | 568 | Introduce PyData Sphinx theme and restructure docs accordingly | The PyData theme is being used by NumPy, Pandas, NetworkX, and others. I've re-arranged some sections to make it play nicely with the theme. The result can be seen here:
https://petergtz.github.io/dowhy/master
There is one open question, where I'd be curious for input: older versions of the documentation will now... | null | 2022-07-21 07:48:55+00:00 | 2022-08-03 12:56:58+00:00 | docs/source/index.rst | DoWhy documentation
===================
.. toctree::
:maxdepth: 3
:hidden:
:glob:
getting_started/index
User Guide <user_guide/index>
Examples <example_notebooks/nb_index>
dowhy
Contributing <contributing>
code_repo
.. image:: https://raw.githubusercontent.com/py-why/dowhy/master... | DoWhy documentation
===================
.. toctree::
:maxdepth: 3
:hidden:
:glob:
getting_started/index
User Guide <user_guide/index>
Examples <example_notebooks/nb_index>
dowhy
Contributing <contributing>
code_repo
.. image:: https://raw.githubusercontent.com/py-why/dowhy/master... | petergtz | 3db32b638414aea85ee3518afbc92b655db54a95 | 77f7064c85b3de740b5beefb0ad7067ffdb024fd | TBD text can be removed? | amit-sharma | 358 |
py-why/dowhy | 568 | Introduce PyData Sphinx theme and restructure docs accordingly | The PyData theme is being used by NumPy, Pandas, NetworkX, and others. I've re-arranged some sections to make it play nicely with the theme. The result can be seen here:
https://petergtz.github.io/dowhy/master
There is one open question, where I'd be curious for input: older versions of the documentation will now... | null | 2022-07-21 07:48:55+00:00 | 2022-08-03 12:56:58+00:00 | docs/source/index.rst | DoWhy documentation
===================
.. toctree::
:maxdepth: 3
:hidden:
:glob:
getting_started/index
User Guide <user_guide/index>
Examples <example_notebooks/nb_index>
dowhy
Contributing <contributing>
code_repo
.. image:: https://raw.githubusercontent.com/py-why/dowhy/master... | DoWhy documentation
===================
.. toctree::
:maxdepth: 3
:hidden:
:glob:
getting_started/index
User Guide <user_guide/index>
Examples <example_notebooks/nb_index>
dowhy
Contributing <contributing>
code_repo
.. image:: https://raw.githubusercontent.com/py-why/dowhy/master... | petergtz | 3db32b638414aea85ee3518afbc92b655db54a95 | 77f7064c85b3de740b5beefb0ad7067ffdb024fd | Well, I planned to put some text around it as in the other sections. | petergtz | 359 |
py-why/dowhy | 568 | Introduce PyData Sphinx theme and restructure docs accordingly | The PyData theme is being used by NumPy, Pandas, NetworkX, and others. I've re-arranged some sections to make it play nicely with the theme. The result can be seen here:
https://petergtz.github.io/dowhy/master
There is one open question, where I'd be curious for input: older versions of the documentation will now... | null | 2022-07-21 07:48:55+00:00 | 2022-08-03 12:56:58+00:00 | docs/source/index.rst | DoWhy documentation
===================
.. toctree::
:maxdepth: 3
:hidden:
:glob:
getting_started/index
User Guide <user_guide/index>
Examples <example_notebooks/nb_index>
dowhy
Contributing <contributing>
code_repo
.. image:: https://raw.githubusercontent.com/py-why/dowhy/master... | DoWhy documentation
===================
.. toctree::
:maxdepth: 3
:hidden:
:glob:
getting_started/index
User Guide <user_guide/index>
Examples <example_notebooks/nb_index>
dowhy
Contributing <contributing>
code_repo
.. image:: https://raw.githubusercontent.com/py-why/dowhy/master... | petergtz | 3db32b638414aea85ee3518afbc92b655db54a95 | 77f7064c85b3de740b5beefb0ad7067ffdb024fd | Added a little text around it. | petergtz | 360 |
py-why/dowhy | 567 | fixed warnings and progrss bar improvements | Fixed the warnings arising in propensity score estimators and added optional progress bars for refuters
Signed-off-by: Amey Varhade <ameyvarhade@gmail.com> | null | 2022-07-20 18:03:07+00:00 | 2022-08-19 03:36:42+00:00 | docs/source/example_notebooks/dowhy_simple_example.ipynb | {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Getting started with DoWhy: A simple example\n",
"This is a quick introduction to the DoWhy causal inference library.\n",
"We will load in a sample dataset and estimate the causal effect of a (pre-specified) treatment variabl... | {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Getting started with DoWhy: A simple example\n",
"This is a quick introduction to the DoWhy causal inference library.\n",
"We will load in a sample dataset and estimate the causal effect of a (pre-specified) treatment variabl... | yemaedahrav | a38a03f8b2daa0627833821e92c1b9117925e331 | f94638633ef23064c69c261c324cc4739d036ac0 | good to remove the vscode metadata. (you can just delete it) | amit-sharma | 361 |
py-why/dowhy | 567 | fixed warnings and progrss bar improvements | Fixed the warnings arising in propensity score estimators and added optional progress bars for refuters
Signed-off-by: Amey Varhade <ameyvarhade@gmail.com> | null | 2022-07-20 18:03:07+00:00 | 2022-08-19 03:36:42+00:00 | docs/source/example_notebooks/dowhy_simple_example.ipynb | {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Getting started with DoWhy: A simple example\n",
"This is a quick introduction to the DoWhy causal inference library.\n",
"We will load in a sample dataset and estimate the causal effect of a (pre-specified) treatment variabl... | {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Getting started with DoWhy: A simple example\n",
"This is a quick introduction to the DoWhy causal inference library.\n",
"We will load in a sample dataset and estimate the causal effect of a (pre-specified) treatment variabl... | yemaedahrav | a38a03f8b2daa0627833821e92c1b9117925e331 | f94638633ef23064c69c261c324cc4739d036ac0 | can you add the show_progress_bar=True to random common cause and placebo treatment refuter too? | amit-sharma | 362 |
py-why/dowhy | 567 | fixed warnings and progrss bar improvements | Fixed the warnings arising in propensity score estimators and added optional progress bars for refuters
Signed-off-by: Amey Varhade <ameyvarhade@gmail.com> | null | 2022-07-20 18:03:07+00:00 | 2022-08-19 03:36:42+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import numpy as np
import pandas as pd
import scipy.stats
import math
import statsmodels.api as sm
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from dowhy.causal_refuter import CausalRefutation
from dowhy.causal_refuter import CausalRef... | import copy
import logging
import numpy as np
import pandas as pd
import scipy.stats
from tqdm.auto import tqdm
import math
import statsmodels.api as sm
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from dowhy.causal_refuter import CausalRefutation
from dowhy.cau... | yemaedahrav | a38a03f8b2daa0627833821e92c1b9117925e331 | f94638633ef23064c69c261c324cc4739d036ac0 | we need tqdm.notebook only if user is running the code in a notebook. Otherwise we need tqdm.
better to use tqdm.auto. see this example: https://github.com/tqdm/tqdm/pull/1218 | amit-sharma | 363 |
py-why/dowhy | 567 | fixed warnings and progrss bar improvements | Fixed the warnings arising in propensity score estimators and added optional progress bars for refuters
Signed-off-by: Amey Varhade <ameyvarhade@gmail.com> | null | 2022-07-20 18:03:07+00:00 | 2022-08-19 03:36:42+00:00 | dowhy/causal_refuters/data_subset_refuter.py | import numpy as np
import logging
from joblib import Parallel, delayed
from dowhy.causal_refuter import CausalRefuter, CausalRefutation
from dowhy.causal_estimator import CausalEstimator
class DataSubsetRefuter(CausalRefuter):
"""Refute an estimate by rerunning it on a random subset of the original data.
Su... | import numpy as np
import logging
from joblib import Parallel, delayed
from tqdm.auto import tqdm
from dowhy.causal_refuter import CausalRefuter, CausalRefutation
from dowhy.causal_estimator import CausalEstimator
class DataSubsetRefuter(CausalRefuter):
"""Refute an estimate by rerunning it on a random subset o... | yemaedahrav | a38a03f8b2daa0627833821e92c1b9117925e331 | f94638633ef23064c69c261c324cc4739d036ac0 | better to define "green" as a static variable inside causalrefuter class. and then call it here as CausalRefuter.Progress_Bar_Color | amit-sharma | 364 |
py-why/dowhy | 564 | Small correction in estimate_ftest_pvalue | The error for the model without inputs should be based on the difference of the observed values to the mean in the training data set. However, the mean of the test set was used instead. | null | 2022-07-19 22:11:02+00:00 | 2022-08-16 13:11:57+00:00 | dowhy/gcm/stats.py | """Functions in this module should be considered experimental, meaning there might be breaking API changes in the
future.
"""
from typing import Union, List, Optional, Callable
import numpy as np
from numpy.matlib import repmat
from scipy import stats
from sklearn.linear_model import LinearRegression
from dowhy.gcm.... | """Functions in this module should be considered experimental, meaning there might be breaking API changes in the
future.
"""
from typing import Union, List, Optional, Callable
import numpy as np
from numpy.matlib import repmat
from scipy import stats
from sklearn.linear_model import LinearRegression
from dowhy.gcm.... | bloebp | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | fe22abab886c5aea768b8474295999a71d914be9 | But this is not the error of the model (without inputs) though. Why does this make sense? Can you also point to any articles where this is advocated or advised? | kailashbuki | 365 |
py-why/dowhy | 564 | Small correction in estimate_ftest_pvalue | The error for the model without inputs should be based on the difference of the observed values to the mean in the training data set. However, the mean of the test set was used instead. | null | 2022-07-19 22:11:02+00:00 | 2022-08-16 13:11:57+00:00 | dowhy/gcm/stats.py | """Functions in this module should be considered experimental, meaning there might be breaking API changes in the
future.
"""
from typing import Union, List, Optional, Callable
import numpy as np
from numpy.matlib import repmat
from scipy import stats
from sklearn.linear_model import LinearRegression
from dowhy.gcm.... | """Functions in this module should be considered experimental, meaning there might be breaking API changes in the
future.
"""
from typing import Union, List, Optional, Callable
import numpy as np
from numpy.matlib import repmat
from scipy import stats
from sklearn.linear_model import LinearRegression
from dowhy.gcm.... | bloebp | 2b4832a91e7ab54d31b116d19958fddecc2c8510 | fe22abab886c5aea768b8474295999a71d914be9 | This else condition is the scenario where we don't have input features, i.e. empty conditioning set. Then we have: ```E[Y | {}] = E[Y]```. Here, ```Y``` is based on ```Y_training```. Therefore, the prediction model we are looking at here is ```f({}) = E[Y | {}] = E[Y]``` and, thus, the sum of squared error in the test ... | bloebp | 366 |
py-why/dowhy | 561 | Auto generate documentation | This PR introduces a GitHub action to auto-generate versioned documentation and publish it to py-why.github.io/dowhy.
To facilitate automatically generating documentation on every commit to master, this PR introduces multiple things (separated by commits):
- It introduces [versioneer](https://github.com/python-vers... | null | 2022-07-19 20:38:04+00:00 | 2022-07-28 10:10:47+00:00 | setup.py | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | petergtz | 570bc06baddc7c29b233e6afbb156f58ae9ae200 | 9a025a2003d754aa9749e8569b72dc566a17c3c2 | This is cool. A few questions:
1. for a new release, where do we specify the new release version so that versioneer fills this correctly?
2. for an update to the master docs, I'm guessing no change is needed in the version? | amit-sharma | 367 |
py-why/dowhy | 561 | Auto generate documentation | This PR introduces a GitHub action to auto-generate versioned documentation and publish it to py-why.github.io/dowhy.
To facilitate automatically generating documentation on every commit to master, this PR introduces multiple things (separated by commits):
- It introduces [versioneer](https://github.com/python-vers... | null | 2022-07-19 20:38:04+00:00 | 2022-07-28 10:10:47+00:00 | setup.py | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | petergtz | 570bc06baddc7c29b233e6afbb156f58ae9ae200 | 9a025a2003d754aa9749e8569b72dc566a17c3c2 | > 1. for a new release, where do we specify the new release version so that versioneer fills this correctly?
You specify the version via `git tag`
See https://github.com/python-versioneer/python-versioneer/blob/master/INSTALL.md#post-installation-usage, which says:
> If you distribute your project through PyPI, ... | petergtz | 368 |
py-why/dowhy | 561 | Auto generate documentation | This PR introduces a GitHub action to auto-generate versioned documentation and publish it to py-why.github.io/dowhy.
To facilitate automatically generating documentation on every commit to master, this PR introduces multiple things (separated by commits):
- It introduces [versioneer](https://github.com/python-vers... | null | 2022-07-19 20:38:04+00:00 | 2022-07-28 10:10:47+00:00 | setup.py | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | petergtz | 570bc06baddc7c29b233e6afbb156f58ae9ae200 | 9a025a2003d754aa9749e8569b72dc566a17c3c2 | interesting, this automation will be useful. just to confirm: previously, I used to update the version manually in dowhy/version.py, and then create a release using the github UI (that created a tag and automatically [pypi publish workflow](https://github.com/py-why/dowhy/blob/main/.github/workflows/python-publish.yml)... | amit-sharma | 369 |
py-why/dowhy | 561 | Auto generate documentation | This PR introduces a GitHub action to auto-generate versioned documentation and publish it to py-why.github.io/dowhy.
To facilitate automatically generating documentation on every commit to master, this PR introduces multiple things (separated by commits):
- It introduces [versioneer](https://github.com/python-vers... | null | 2022-07-19 20:38:04+00:00 | 2022-07-28 10:10:47+00:00 | setup.py | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | petergtz | 570bc06baddc7c29b233e6afbb156f58ae9ae200 | 9a025a2003d754aa9749e8569b72dc566a17c3c2 | > Now, the steps will be:
>
> 1. create the release using the github UI (which also creates a tag)
> 2. let the pypi publish workflow run automatically.
>
> In this case, would versioneer automatically pick the latest version number?
Yes. Internally, versioneer uses a specially parameterized `git describe` in... | petergtz | 370 |
py-why/dowhy | 561 | Auto generate documentation | This PR introduces a GitHub action to auto-generate versioned documentation and publish it to py-why.github.io/dowhy.
To facilitate automatically generating documentation on every commit to master, this PR introduces multiple things (separated by commits):
- It introduces [versioneer](https://github.com/python-vers... | null | 2022-07-19 20:38:04+00:00 | 2022-07-28 10:10:47+00:00 | setup.py | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | petergtz | 570bc06baddc7c29b233e6afbb156f58ae9ae200 | 9a025a2003d754aa9749e8569b72dc566a17c3c2 | Oh, wait a second. Let me actually check the other workflows. To see how this would work. Sorry, I didn't realize PyPI publication also happens through a workflow. | petergtz | 371 |
py-why/dowhy | 561 | Auto generate documentation | This PR introduces a GitHub action to auto-generate versioned documentation and publish it to py-why.github.io/dowhy.
To facilitate automatically generating documentation on every commit to master, this PR introduces multiple things (separated by commits):
- It introduces [versioneer](https://github.com/python-vers... | null | 2022-07-19 20:38:04+00:00 | 2022-07-28 10:10:47+00:00 | setup.py | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | """A setuptools based setup module for dowhy.
Adapted from:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
from setuptools import setup, find_packages
from codecs import open
from os import path
import versioneer
here = path.abspath(path.dirname(__file__))
# Get ... | petergtz | 570bc06baddc7c29b233e6afbb156f58ae9ae200 | 9a025a2003d754aa9749e8569b72dc566a17c3c2 | Okay, yes, this should work. The moment you use the GitHub UI to create the release and the git tag, it will push this tag and that will trigger the publish workflow which then just relies on the usual `python setup.py sdist bdist_wheel` call which uses versioneer to choose the current/latest version from the just-crea... | petergtz | 372 |
py-why/dowhy | 549 | Algorithms for efficient adjustment (backdoor) sets | Implements the algorithms discussed [here](https://github.com/py-why/dowhy/issues/464).
I added the new algorithms [here](https://github.com/py-why/dowhy/pull/549/files#diff-cb99b05726571b36d65d193004d3c854cbf055d86eadd94dc1ce81bc4ac7b4b4), and made a few (small I think) changes to the CausalIdentifier class. I adde... | null | 2022-07-16 14:24:08+00:00 | 2022-08-08 04:09:13+00:00 | dowhy/causal_identifier.py | import copy
import itertools
import logging
import sympy as sp
import sympy.stats as spstats
import dowhy.utils.cli_helpers as cli
from dowhy.utils.api import parse_state
class CausalIdentifier:
"""Class that implements different identification methods.
Currently supports backdoor and instrumental variable... | import copy
import itertools
import logging
import sympy as sp
import sympy.stats as spstats
import dowhy.utils.cli_helpers as cli
from dowhy.causal_identifiers.efficient_backdoor import EfficientBackdoor
from dowhy.utils.api import parse_state
class CausalIdentifier:
"""Class that implements different identifi... | esmucler | 77f7064c85b3de740b5beefb0ad7067ffdb024fd | 824f5532c0644812867bb018bf22585f2466960c | I'm curious---what are these conditional_node_names graphically? are they parents of the treatment only? | amit-sharma | 373 |
py-why/dowhy | 549 | Algorithms for efficient adjustment (backdoor) sets | Implements the algorithms discussed [here](https://github.com/py-why/dowhy/issues/464).
I added the new algorithms [here](https://github.com/py-why/dowhy/pull/549/files#diff-cb99b05726571b36d65d193004d3c854cbf055d86eadd94dc1ce81bc4ac7b4b4), and made a few (small I think) changes to the CausalIdentifier class. I adde... | null | 2022-07-16 14:24:08+00:00 | 2022-08-08 04:09:13+00:00 | dowhy/causal_identifier.py | import copy
import itertools
import logging
import sympy as sp
import sympy.stats as spstats
import dowhy.utils.cli_helpers as cli
from dowhy.utils.api import parse_state
class CausalIdentifier:
"""Class that implements different identification methods.
Currently supports backdoor and instrumental variable... | import copy
import itertools
import logging
import sympy as sp
import sympy.stats as spstats
import dowhy.utils.cli_helpers as cli
from dowhy.causal_identifiers.efficient_backdoor import EfficientBackdoor
from dowhy.utils.api import parse_state
class CausalIdentifier:
"""Class that implements different identifi... | esmucler | 77f7064c85b3de740b5beefb0ad7067ffdb024fd | 824f5532c0644812867bb018bf22585f2466960c | See my answer in the [comment](https://github.com/py-why/dowhy/pull/549#issuecomment-1188730376) below | esmucler | 374 |
py-why/dowhy | 478 | Adding Non Linear Sensitivity Analysis | This PR implements the non-parametric sensitivity analysis from Chernozhukov et al. https://arxiv.org/abs/2112.13398
It implements two sensitivity analyzers:
1. For Partial Linear DGPs and estimators like LinearDML
2. For general non-parametric DGPs and estimators like KernelDML.
The notebook in this PR provid... | null | 2022-06-20 14:37:11+00:00 | 2022-09-16 03:57:26+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
from dowhy.causal_estimator import CausalEstimator
from dowhy.ca... | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | anusha0409 | 81841c697bd5e80ecf9e731432305f6186666f1f | bb446c333f2256074304b0dec9cb5628d284b542 | this is very nice, you can add the description of g, g_s, alpha etc to the notebook also | amit-sharma | 375 |
py-why/dowhy | 478 | Adding Non Linear Sensitivity Analysis | This PR implements the non-parametric sensitivity analysis from Chernozhukov et al. https://arxiv.org/abs/2112.13398
It implements two sensitivity analyzers:
1. For Partial Linear DGPs and estimators like LinearDML
2. For general non-parametric DGPs and estimators like KernelDML.
The notebook in this PR provid... | null | 2022-06-20 14:37:11+00:00 | 2022-09-16 03:57:26+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
from dowhy.causal_estimator import CausalEstimator
from dowhy.ca... | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | anusha0409 | 81841c697bd5e80ecf9e731432305f6186666f1f | bb446c333f2256074304b0dec9cb5628d284b542 | can be performed --> will be automatically chosen | amit-sharma | 376 |
py-why/dowhy | 478 | Adding Non Linear Sensitivity Analysis | This PR implements the non-parametric sensitivity analysis from Chernozhukov et al. https://arxiv.org/abs/2112.13398
It implements two sensitivity analyzers:
1. For Partial Linear DGPs and estimators like LinearDML
2. For general non-parametric DGPs and estimators like KernelDML.
The notebook in this PR provid... | null | 2022-06-20 14:37:11+00:00 | 2022-09-16 03:57:26+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
from dowhy.causal_estimator import CausalEstimator
from dowhy.ca... | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | anusha0409 | 81841c697bd5e80ecf9e731432305f6186666f1f | bb446c333f2256074304b0dec9cb5628d284b542 | Q: given that the array effect_strength_on_treatment (and other parameters) have different interpretations by methods, does that mean that the user would have to pass in different array values based on what simulation_method they chose? Or is the same set of values valid and roughly similar enough that the user can ch... | emrekiciman | 377 |
py-why/dowhy | 478 | Adding Non Linear Sensitivity Analysis | This PR implements the non-parametric sensitivity analysis from Chernozhukov et al. https://arxiv.org/abs/2112.13398
It implements two sensitivity analyzers:
1. For Partial Linear DGPs and estimators like LinearDML
2. For general non-parametric DGPs and estimators like KernelDML.
The notebook in this PR provid... | null | 2022-06-20 14:37:11+00:00 | 2022-09-16 03:57:26+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
from dowhy.causal_estimator import CausalEstimator
from dowhy.ca... | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | anusha0409 | 81841c697bd5e80ecf9e731432305f6186666f1f | bb446c333f2256074304b0dec9cb5628d284b542 | We don't have the architecture for it yet --- but an if condition such as this one --- that is checking to see what estimator was used --- makes me think that we should be prescribing the sensitivity analysis method at the same place in the code where we set the estimator method. Perhaps the estimator object registers... | emrekiciman | 378 |
py-why/dowhy | 478 | Adding Non Linear Sensitivity Analysis | This PR implements the non-parametric sensitivity analysis from Chernozhukov et al. https://arxiv.org/abs/2112.13398
It implements two sensitivity analyzers:
1. For Partial Linear DGPs and estimators like LinearDML
2. For general non-parametric DGPs and estimators like KernelDML.
The notebook in this PR provid... | null | 2022-06-20 14:37:11+00:00 | 2022-09-16 03:57:26+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
from dowhy.causal_estimator import CausalEstimator
from dowhy.ca... | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | anusha0409 | 81841c697bd5e80ecf9e731432305f6186666f1f | bb446c333f2256074304b0dec9cb5628d284b542 | great point, Emre. Yes, let's take it up when we discuss how to refactor refutations to work across the estimation pipeline. | amit-sharma | 379 |
py-why/dowhy | 478 | Adding Non Linear Sensitivity Analysis | This PR implements the non-parametric sensitivity analysis from Chernozhukov et al. https://arxiv.org/abs/2112.13398
It implements two sensitivity analyzers:
1. For Partial Linear DGPs and estimators like LinearDML
2. For general non-parametric DGPs and estimators like KernelDML.
The notebook in this PR provid... | null | 2022-06-20 14:37:11+00:00 | 2022-09-16 03:57:26+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
from dowhy.causal_estimator import CausalEstimator
from dowhy.ca... | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | anusha0409 | 81841c697bd5e80ecf9e731432305f6186666f1f | bb446c333f2256074304b0dec9cb5628d284b542 | This is a good point. For all the partial-r2 based methods (linear and non-parametric), it has the same interpretation.
But the interpretation is different between direct_simulation and partial-r2 based simulations.
So to avoid confusion, I have created two additional parameters. The first two (effect_strength) a... | amit-sharma | 380 |
py-why/dowhy | 478 | Adding Non Linear Sensitivity Analysis | This PR implements the non-parametric sensitivity analysis from Chernozhukov et al. https://arxiv.org/abs/2112.13398
It implements two sensitivity analyzers:
1. For Partial Linear DGPs and estimators like LinearDML
2. For general non-parametric DGPs and estimators like KernelDML.
The notebook in this PR provid... | null | 2022-06-20 14:37:11+00:00 | 2022-09-16 03:57:26+00:00 | dowhy/causal_refuters/add_unobserved_common_cause.py | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
from dowhy.causal_estimator import CausalEstimator
from dowhy.ca... | import copy
import logging
import math
import numpy as np
import pandas as pd
import scipy.stats
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from tqdm.auto import tqdm
import dowhy.causal_estimators.econml
from dowhy.causal_estimato... | anusha0409 | 81841c697bd5e80ecf9e731432305f6186666f1f | bb446c333f2256074304b0dec9cb5628d284b542 | Thanks for making this change. It is clearer, and will hopefully also make it easier to separate further in the future. | emrekiciman | 381 |
py-why/dowhy | 478 | Adding Non Linear Sensitivity Analysis | This PR implements the non-parametric sensitivity analysis from Chernozhukov et al. https://arxiv.org/abs/2112.13398
It implements two sensitivity analyzers:
1. For Partial Linear DGPs and estimators like LinearDML
2. For general non-parametric DGPs and estimators like KernelDML.
The notebook in this PR provid... | null | 2022-06-20 14:37:11+00:00 | 2022-09-16 03:57:26+00:00 | dowhy/causal_refuters/linear_sensitivity_analyzer.py | import logging
import sys
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import statsmodels.api as sm
from scipy.stats import t
from dowhy.utils.api import parse_state
class LinearSensitivityAnalyzer:
"""
Class to perform sensitivity analysis
See: https://carloscinelli.com/files/... | import logging
import sys
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import statsmodels.api as sm
from scipy.stats import t
from dowhy.utils.api import parse_state
class LinearSensitivityAnalyzer:
"""
Class to perform sensitivity analysis
See: https://carloscinelli.com/files/... | anusha0409 | 81841c697bd5e80ecf9e731432305f6186666f1f | bb446c333f2256074304b0dec9cb5628d284b542 | should this be y=r2yu_tw? | amit-sharma | 382 |
py-why/dowhy | 478 | Adding Non Linear Sensitivity Analysis | This PR implements the non-parametric sensitivity analysis from Chernozhukov et al. https://arxiv.org/abs/2112.13398
It implements two sensitivity analyzers:
1. For Partial Linear DGPs and estimators like LinearDML
2. For general non-parametric DGPs and estimators like KernelDML.
The notebook in this PR provid... | null | 2022-06-20 14:37:11+00:00 | 2022-09-16 03:57:26+00:00 | dowhy/causal_refuters/linear_sensitivity_analyzer.py | import logging
import sys
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import statsmodels.api as sm
from scipy.stats import t
from dowhy.utils.api import parse_state
class LinearSensitivityAnalyzer:
"""
Class to perform sensitivity analysis
See: https://carloscinelli.com/files/... | import logging
import sys
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import statsmodels.api as sm
from scipy.stats import t
from dowhy.utils.api import parse_state
class LinearSensitivityAnalyzer:
"""
Class to perform sensitivity analysis
See: https://carloscinelli.com/files/... | anusha0409 | 81841c697bd5e80ecf9e731432305f6186666f1f | bb446c333f2256074304b0dec9cb5628d284b542 | Why were r2tu_w and r2yu_tw swapped in the inner/outer loops here? It looks like this was a bug in the prior code? | emrekiciman | 383 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.