diff --git a/RELEASE.md b/RELEASE.md index 6ea6d4b..51828c7 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -1,5 +1,14 @@ # Upcoming release +# Release 0.8.1 + +* Added `DAGClassifier` sklearn interface using the Pytorch NOTEARS implementation. Supports binary classification. +* Added binary distributed data support for pytorch NOTEARS. +* Added a "distribution type" schema system for pytorch NOTEARS (`pytorch.dist_type`). +* Rename "data type" to "distribution type" in internal language. +* Fixed uniform discretiser (`Discretiser(method='uniform')`) where all bins have identical widths. +* Fixed and updated sklearn tutorial in docs. + # Release 0.8.0 * Add DYNOTEARS (`from_numpy_dynamic`, an algorithm for structure learning on Dynamic Bayesian Networks). @@ -52,6 +61,6 @@ The initial release of CausalNex. ## Thanks for supporting contributions CausalNex was originally designed by [Paul Beaumont](https://www.linkedin.com/in/pbeaumont/) and [Ben Horsburgh](https://www.linkedin.com/in/benhorsburgh/) to solve challenges they faced in inferencing causality in their project work. This work was later turned into a product thanks to the following contributors: -[Yetunde Dada](https://github.com/yetudada), [Wesley Leong](https://www.linkedin.com/in/wesleyleong/), [Steve Ler](https://www.linkedin.com/in/song-lim-steve-ler-380366106/), [Viktoriia Oliinyk](https://www.linkedin.com/in/victoria-oleynik/), [Roxana Pamfil](https://www.linkedin.com/in/roxana-pamfil-1192053b/), [Nisara Sriwattanaworachai](https://www.linkedin.com/in/nisara-sriwattanaworachai-795b357/), [Nikolaos Tsaousis](https://www.linkedin.com/in/ntsaousis/), [Angel Droth](https://www.linkedin.com/in/angeldroth/), and [Zain Patel](https://www.linkedin.com/in/zain-patel/). +[Yetunde Dada](https://github.com/yetudada), [Wesley Leong](https://www.linkedin.com/in/wesleyleong/), [Steve Ler](https://www.linkedin.com/in/song-lim-steve-ler-380366106/), [Viktoriia Oliinyk](https://www.linkedin.com/in/victoria-oleynik/), [Roxana Pamfil](https://www.linkedin.com/in/roxana-pamfil-1192053b/), [Nisara Sriwattanaworachai](https://www.linkedin.com/in/nisara-sriwattanaworachai-795b357/), [Nikolaos Tsaousis](https://www.linkedin.com/in/ntsaousis/), [Angel Droth](https://www.linkedin.com/in/angeldroth/), [Zain Patel](https://www.linkedin.com/in/zain-patel/), and [Shuhei Ishida](https://www.linkedin.com/in/shuhei-i/). CausalNex would also not be possible without the generous sharing from leading researches in the field of causal inference and we are grateful to everyone who advised and supported us, filed issues or helped resolve them, asked and answered questions or simply be part of inspiring discussions. diff --git a/causalnex/__init__.py b/causalnex/__init__.py index 01312ed..c3b0fb1 100644 --- a/causalnex/__init__.py +++ b/causalnex/__init__.py @@ -30,6 +30,6 @@ causalnex toolkit for causal reasoning (Bayesian Networks / Inference) """ -__version__ = "0.8.0" +__version__ = "0.8.1" __all__ = ["structure", "discretiser", "evaluation", "inference", "network", "plots"] diff --git a/causalnex/discretiser/discretiser.py b/causalnex/discretiser/discretiser.py index 763a38e..c3e26f8 100644 --- a/causalnex/discretiser/discretiser.py +++ b/causalnex/discretiser/discretiser.py @@ -174,10 +174,9 @@ def fit(self, data: np.ndarray) -> "Discretiser": x.sort() if self.method == "uniform": - bucket_width = len(x) / self.num_buckets + bucket_width = (np.max(x) - np.min(x)) / self.num_buckets self.numeric_split_points = [ - x[int(np.floor((n + 1) * bucket_width))] - for n in range(self.num_buckets - 1) + np.min(x) + bucket_width * (n + 1) for n in range(self.num_buckets - 1) ] elif self.method == "quantile": diff --git a/causalnex/structure/__init__.py b/causalnex/structure/__init__.py index 3651f9a..7699e22 100644 --- a/causalnex/structure/__init__.py +++ b/causalnex/structure/__init__.py @@ -30,7 +30,14 @@ ``causalnex.structure`` provides functionality to define or learn structure. """ -__all__ = ["StructureModel", "notears", "dynotears", "data_generators", "DAGRegressor"] +__all__ = [ + "StructureModel", + "notears", + "dynotears", + "data_generators", + "DAGRegressor", + "DAGClassifier", +] -from .sklearn import DAGRegressor +from .pytorch import DAGClassifier, DAGRegressor from .structuremodel import StructureModel diff --git a/causalnex/structure/dynotears.py b/causalnex/structure/dynotears.py index e7d1202..cee0115 100644 --- a/causalnex/structure/dynotears.py +++ b/causalnex/structure/dynotears.py @@ -39,8 +39,7 @@ import scipy.optimize as sopt from causalnex.structure import StructureModel - -from .transformers import DynamicDataTransformer +from causalnex.structure.transformers import DynamicDataTransformer def from_pandas_dynamic( # pylint: disable=too-many-arguments diff --git a/causalnex/structure/pytorch/__init__.py b/causalnex/structure/pytorch/__init__.py index a17bd56..cf44b77 100644 --- a/causalnex/structure/pytorch/__init__.py +++ b/causalnex/structure/pytorch/__init__.py @@ -30,7 +30,8 @@ ``causalnex.structure.pytorch`` provides functionality to define or learn structure using pytorch. """ -__all__ = ["from_numpy", "from_pandas", "NotearsMLP"] +__all__ = ["from_numpy", "from_pandas", "NotearsMLP", "DAGRegressor", "DAGClassifier"] from .core import NotearsMLP from .notears import from_numpy, from_pandas +from .sklearn import DAGClassifier, DAGRegressor diff --git a/causalnex/structure/pytorch/core.py b/causalnex/structure/pytorch/core.py index 58564d9..87f9893 100644 --- a/causalnex/structure/pytorch/core.py +++ b/causalnex/structure/pytorch/core.py @@ -45,7 +45,8 @@ import torch.nn as nn from sklearn.base import BaseEstimator -from .nonlinear import LocallyConnected +from causalnex.structure.pytorch.dist_type._base import DistTypeBase +from causalnex.structure.pytorch.nonlinear import LocallyConnected class NotearsMLP(nn.Module, BaseEstimator): @@ -56,9 +57,11 @@ class NotearsMLP(nn.Module, BaseEstimator): loc_lin_layer weights are the weight of hidden layers after the first fully connected layer """ + # pylint: disable=too-many-arguments def __init__( self, n_features: int, + dist_types: List[DistTypeBase], use_bias: bool = False, hidden_layer_units: Iterable[int] = (0,), bounds: List[Tuple[int, int]] = None, @@ -70,7 +73,8 @@ def __init__( Constructor for NOTEARS MLP class. Args: - n_features: number of input features + n_features: number of input features. + dist_types: list of data type objects used to fit the NOTEARS algorithm. use_bias: True to add the intercept to the model hidden_layer_units: An iterable where its length determine the number of layers used, and the numbers determine the number of nodes used for the layer in order. @@ -116,6 +120,8 @@ def __init__( # set the bounds as an attribute on the weights object self.dag_layer.weight.bounds = bounds + # set the dist types + self.dist_types = dist_types # type the adjacency matrix self.adj = None self.adj_mean_effect = None @@ -175,6 +181,31 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: # [n, d] -> [n, d] x = x.squeeze(dim=2) # [n, d] return x + def reconstruct_data(self, X: np.ndarray) -> np.ndarray: + """ + Performs X_hat reconstruction, + then converts latent space to original data space via link function. + + Args: + X: input data used to reconstruct + + Returns: + reconstructed data + """ + + with torch.no_grad(): + # convert the predict data to pytorch tensor + X = torch.from_numpy(X).float().to(self.device) + + # perform forward reconstruction + X_hat = self(X) + + # recover each one of the latent space projections + for dist_type in self.dist_types: + X_hat = dist_type.inverse_link_function(X_hat) + + return np.asarray(X_hat.cpu().detach().numpy().astype(np.float64)) + @property def bias(self) -> Union[np.ndarray, None]: """ @@ -334,7 +365,12 @@ def _func(flat_params: np.ndarray) -> Tuple[float, np.ndarray]: X_hat = self(X) h_val = self._h_func() - loss = (0.5 / X.shape[0]) * torch.sum((X_hat - X) ** 2) + # preallocate loss tensor + loss = torch.tensor(0, device=X.device) # pylint: disable=not-callable + # sum the losses across all dist types + for dist_type in self.dist_types: + loss = loss + dist_type.loss(X, X_hat) + lagrange_penalty = 0.5 * rho * h_val * h_val + alpha * h_val # NOTE: both the l2 and l1 regularization are NOT applied to the bias parameters l2_reg = 0.5 * self.ridge_beta * self._l2_reg(n_features) diff --git a/causalnex/structure/pytorch/dist_type/__init__.py b/causalnex/structure/pytorch/dist_type/__init__.py new file mode 100644 index 0000000..02c0b8e --- /dev/null +++ b/causalnex/structure/pytorch/dist_type/__init__.py @@ -0,0 +1,45 @@ +# Copyright 2019-2020 QuantumBlack Visual Analytics Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND +# NONINFRINGEMENT. IN NO EVENT WILL THE LICENSOR OR OTHER CONTRIBUTORS +# BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN +# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN +# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# The QuantumBlack Visual Analytics Limited ("QuantumBlack") name and logo +# (either separately or in combination, "QuantumBlack Trademarks") are +# trademarks of QuantumBlack. The License does not grant you any right or +# license to the QuantumBlack Trademarks. You may not use the QuantumBlack +# Trademarks or any confusingly similar mark as a trademark for your product, +# or use the QuantumBlack Trademarks in any other manner that might cause +# confusion in the marketplace, including but not limited to in advertising, +# on websites, or on software. +# +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +``causalnex.pytorch.dist_type`` provides distribution type support classes for the pytorch NOTEARS algorithm. +""" + +from .binary import DistTypeBinary +from .continuous import DistTypeContinuous + +dist_type_aliases = { + "bin": DistTypeBinary, + "cont": DistTypeContinuous, +} + + +__all__ = [ + "DistTypeBinary", + "DistTypeContinuous", +] diff --git a/causalnex/structure/pytorch/dist_type/_base.py b/causalnex/structure/pytorch/dist_type/_base.py new file mode 100644 index 0000000..ec61400 --- /dev/null +++ b/causalnex/structure/pytorch/dist_type/_base.py @@ -0,0 +1,79 @@ +# Copyright 2019-2020 QuantumBlack Visual Analytics Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND +# NONINFRINGEMENT. IN NO EVENT WILL THE LICENSOR OR OTHER CONTRIBUTORS +# BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN +# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN +# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# The QuantumBlack Visual Analytics Limited ("QuantumBlack") name and logo +# (either separately or in combination, "QuantumBlack Trademarks") are +# trademarks of QuantumBlack. The License does not grant you any right or +# license to the QuantumBlack Trademarks. You may not use the QuantumBlack +# Trademarks or any confusingly similar mark as a trademark for your product, +# or use the QuantumBlack Trademarks in any other manner that might cause +# confusion in the marketplace, including but not limited to in advertising, +# on websites, or on software. +# +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +``causalnex.pytorch.dist_type._base`` defines the distribution type class interface and default behavior. +""" + +from abc import ABCMeta, abstractmethod + +import torch + + +class DistTypeBase(metaclass=ABCMeta): + """ Base class defining the distribution default behavior and interface """ + + def __init__(self, idx: int): + """ + Default constructor for the DistTypeBase class. + Unless overridden, provides default behavior to all subclasses. + + Args: + idx: Positional index in data passed to the NOTEARS algorithm + which correspond to this datatype. + """ + self.idx = idx + + @abstractmethod + def loss(self, X: torch.Tensor, X_hat: torch.Tensor) -> torch.Tensor: + """ + Args: + X: The original data passed into NOTEARS (i.e. the reconstruction target). + + X_hat: The reconstructed data. + + Returns: + Scalar pytorch tensor of the reconstruction loss between X and X_hat. + """ + raise NotImplementedError("Must implement the loss() method") + + @abstractmethod + def inverse_link_function(self, X_hat: torch.Tensor) -> torch.Tensor: + """ + Convert the transformed data from the latent space to the original dtype + using the inverse link function. + + Args: + X_hat: Reconstructed data in the latent space. + + Returns: + Modified X_hat. + MUST be same shape as passed in data. + Projects the self.idx column from the latent space to the dist_type space. + """ + raise NotImplementedError("Must implement the inverse_link_function() method") diff --git a/causalnex/structure/pytorch/dist_type/binary.py b/causalnex/structure/pytorch/dist_type/binary.py new file mode 100644 index 0000000..0dfa293 --- /dev/null +++ b/causalnex/structure/pytorch/dist_type/binary.py @@ -0,0 +1,77 @@ +# Copyright 2019-2020 QuantumBlack Visual Analytics Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND +# NONINFRINGEMENT. IN NO EVENT WILL THE LICENSOR OR OTHER CONTRIBUTORS +# BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN +# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN +# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# The QuantumBlack Visual Analytics Limited ("QuantumBlack") name and logo +# (either separately or in combination, "QuantumBlack Trademarks") are +# trademarks of QuantumBlack. The License does not grant you any right or +# license to the QuantumBlack Trademarks. You may not use the QuantumBlack +# Trademarks or any confusingly similar mark as a trademark for your product, +# or use the QuantumBlack Trademarks in any other manner that might cause +# confusion in the marketplace, including but not limited to in advertising, +# on websites, or on software. +# +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +``causalnex.pytorch.data_type.continuous`` defines the binary distribution type. +""" + +import torch +import torch.nn as nn + +from causalnex.structure.pytorch.dist_type._base import DistTypeBase + + +class DistTypeBinary(DistTypeBase): + """ Class defining binary distribution type functionality """ + + def loss(self, X: torch.Tensor, X_hat: torch.Tensor) -> torch.Tensor: + """ + https://pytorch.org/docs/stable/nn.html#torch.nn.BCEWithLogitsLoss + Uses the functional implementation of the BCEWithLogitsLoss class. + + The average logit binary cross entropy loss. + Averages across sample dimension (dim=0). + + Args: + X: The original data passed into NOTEARS (i.e. the reconstruction target). + + X_hat: The reconstructed data. + + Returns: + Scalar pytorch tensor of the reconstruction loss between X and X_hat. + """ + return nn.functional.binary_cross_entropy_with_logits( + input=X_hat[:, self.idx], + target=X[:, self.idx], + reduction="mean", + ) + + def inverse_link_function(self, X_hat: torch.Tensor) -> torch.Tensor: + """ + Inverse-logit (sigmoid) inverse link function for binary data. + + Args: + X_hat: Reconstructed data in the latent space. + + Returns: + Modified X_hat. + MUST be same shape as passed in data. + Projects the self.idx column from the latent space to the dist_type space. + """ + X_hat[:, self.idx] = torch.sigmoid(X_hat[:, self.idx]) + return X_hat diff --git a/causalnex/structure/pytorch/dist_type/continuous.py b/causalnex/structure/pytorch/dist_type/continuous.py new file mode 100644 index 0000000..7aab8d0 --- /dev/null +++ b/causalnex/structure/pytorch/dist_type/continuous.py @@ -0,0 +1,70 @@ +# Copyright 2019-2020 QuantumBlack Visual Analytics Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND +# NONINFRINGEMENT. IN NO EVENT WILL THE LICENSOR OR OTHER CONTRIBUTORS +# BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN +# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN +# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# The QuantumBlack Visual Analytics Limited ("QuantumBlack") name and logo +# (either separately or in combination, "QuantumBlack Trademarks") are +# trademarks of QuantumBlack. The License does not grant you any right or +# license to the QuantumBlack Trademarks. You may not use the QuantumBlack +# Trademarks or any confusingly similar mark as a trademark for your product, +# or use the QuantumBlack Trademarks in any other manner that might cause +# confusion in the marketplace, including but not limited to in advertising, +# on websites, or on software. +# +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +``causalnex.pytorch.data_type.continuous`` defines the continuous distribution type. +""" + +import torch + +from causalnex.structure.pytorch.dist_type._base import DistTypeBase + + +class DistTypeContinuous(DistTypeBase): + """ Class defining continuous distribution type functionality """ + + def loss(self, X: torch.Tensor, X_hat: torch.Tensor) -> torch.Tensor: + """ + The average gaussian loss. + + Args: + X: The original data passed into NOTEARS (i.e. the reconstruction target). + + X_hat: The reconstructed data. + + Returns: + Scalar pytorch tensor of the reconstruction loss between X and X_hat. + """ + + return (0.5 / X.shape[0]) * torch.sum( + (X_hat[:, self.idx] - X[:, self.idx]) ** 2 + ) + + def inverse_link_function(self, X_hat: torch.Tensor) -> torch.Tensor: + """ + Identity inverse link function for continuous data. + + Args: + X_hat: Reconstructed data in the latent space. + + Returns: + Modified X_hat. + MUST be same shape as passed in data. + Projects the self.idx column from the latent space to the dist_type space. + """ + return X_hat diff --git a/causalnex/structure/pytorch/notears.py b/causalnex/structure/pytorch/notears.py index dd88ca6..79159fd 100644 --- a/causalnex/structure/pytorch/notears.py +++ b/causalnex/structure/pytorch/notears.py @@ -31,13 +31,14 @@ import logging from copy import deepcopy -from typing import Iterable, List, Tuple +from typing import Dict, Iterable, List, Tuple, Union import numpy as np import pandas as pd from sklearn.utils import check_array from causalnex.structure.pytorch.core import NotearsMLP +from causalnex.structure.pytorch.dist_type import DistTypeContinuous, dist_type_aliases from causalnex.structure.structuremodel import StructureModel __all__ = ["from_numpy", "from_pandas"] @@ -47,6 +48,7 @@ # pylint: disable=too-many-arguments def from_numpy( X: np.ndarray, + dist_type_schema: Dict[int, str] = None, lasso_beta: float = 0.0, ridge_beta: float = 0.0, use_bias: bool = False, @@ -74,6 +76,11 @@ def from_numpy( Args: X: 2d input data, axis=0 is data rows, axis=1 is data columns. Data must be row oriented. + dist_type_schema: The dist type schema corresponding to the passed in data X. + It maps the positional column in X to the string alias of a dist type. + A list of alias names can be found in ``dist_type/__init__.py``. + If None, assumes that all data in X is continuous. + lasso_beta: Constant that multiplies the lasso term (l1 regularisation). NOTE when using nonlinearities, the l1 loss only applies to the dag_layer. @@ -102,6 +109,7 @@ def from_numpy( Raises: ValueError: If X does not contain data. + ValueError: If schema does not correspond to columns. """ # n examples, d properties if not X.size: @@ -110,6 +118,25 @@ def from_numpy( # Check array for NaN or inf values check_array(X) + if dist_type_schema is not None: + + # make sure that there is one provided key per column + if set(range(X.shape[1])).symmetric_difference(set(dist_type_schema.keys())): + raise ValueError( + "Difference indices and expected indices. Got {} schema".format( + dist_type_schema + ) + ) + + # if dist_type_schema is None, assume all columns are continuous, else ini + dist_types = ( + [DistTypeContinuous(idx=idx) for idx in np.arange(X.shape[1])] + if dist_type_schema is None + else [ + dist_type_aliases[alias](idx=idx) for idx, alias in dist_type_schema.items() + ] + ) + _, d = X.shape # if None or empty, convert into a list with single item @@ -139,6 +166,7 @@ def from_numpy( model = NotearsMLP( n_features=d, + dist_types=dist_types, hidden_layer_units=hidden_layer_units, lasso_beta=lasso_beta, ridge_beta=ridge_beta, @@ -171,6 +199,10 @@ def from_numpy( value = bias[node] sm.nodes[node]["bias"] = value + for dist_type in dist_types: + # attach each dist_type object to corresponding node + sm.nodes[dist_type.idx]["dist_type"] = dist_type + # preserve the structure_learner as a graph attribute sm.graph["structure_learner"] = model @@ -181,15 +213,16 @@ def from_numpy( # pylint: disable=too-many-arguments def from_pandas( X: pd.DataFrame, + dist_type_schema: Dict[Union[str, int], str] = None, lasso_beta: float = 0.0, ridge_beta: float = 0.0, + use_bias: bool = False, hidden_layer_units: Iterable[int] = None, max_iter: int = 100, w_threshold: float = None, tabu_edges: List[Tuple[str, str]] = None, tabu_parent_nodes: List[str] = None, tabu_child_nodes: List[str] = None, - use_bias: bool = False, **kwargs ) -> StructureModel: """ @@ -215,6 +248,11 @@ def from_pandas( Args: X: 2d input data, axis=0 is data rows, axis=1 is data columns. Data must be row oriented. + dist_type_schema: The dist type schema corresponding to the passed in data X. + It maps the pandas column name in X to the string alias of a dist type. + A list of alias names can be found in ``dist_type/__init__.py``. + If None, assumes that all data in X is continuous. + lasso_beta: Constant that multiplies the lasso term (l1 regularisation). NOTE when using nonlinearities, the l1 loss only applies to the dag_layer. @@ -247,6 +285,13 @@ def from_pandas( data = deepcopy(X) + # if dist_type_schema is not None, convert dist_type_schema from cols to idx + dist_type_schema = ( + dist_type_schema + if dist_type_schema is None + else {X.columns.get_loc(col): alias for col, alias in dist_type_schema.items()} + ) + non_numeric_cols = data.select_dtypes(exclude="number").columns if len(non_numeric_cols) > 0: @@ -269,6 +314,7 @@ def from_pandas( g = from_numpy( X=data.values, + dist_type_schema=dist_type_schema, lasso_beta=lasso_beta, ridge_beta=ridge_beta, use_bias=use_bias, @@ -294,7 +340,7 @@ def from_pandas( mean_effect=edge_dict["mean_effect"], ) - # retrieve dtype information from graph attribute + # retrieve all graphs attrs for key, val in g.graph.items(): sm.graph[key] = val @@ -303,4 +349,9 @@ def from_pandas( node_name = idx_col[node[0]] sm.nodes[node_name]["bias"] = node[1]["bias"] + # recover and preseve the node dist_types + for node in g.nodes(data=True): + node_name = idx_col[node[0]] + sm.nodes[node_name]["dist_type"] = node[1]["dist_type"] + return sm diff --git a/causalnex/structure/pytorch/sklearn/__init__.py b/causalnex/structure/pytorch/sklearn/__init__.py new file mode 100644 index 0000000..4836361 --- /dev/null +++ b/causalnex/structure/pytorch/sklearn/__init__.py @@ -0,0 +1,35 @@ +# Copyright 2019-2020 QuantumBlack Visual Analytics Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND +# NONINFRINGEMENT. IN NO EVENT WILL THE LICENSOR OR OTHER CONTRIBUTORS +# BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN +# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN +# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# The QuantumBlack Visual Analytics Limited ("QuantumBlack") name and logo +# (either separately or in combination, "QuantumBlack Trademarks") are +# trademarks of QuantumBlack. The License does not grant you any right or +# license to the QuantumBlack Trademarks. You may not use the QuantumBlack +# Trademarks or any confusingly similar mark as a trademark for your product, +# or use the QuantumBlack Trademarks in any other manner that might cause +# confusion in the marketplace, including but not limited to in advertising, +# on websites, or on software. +# +# See the License for the specific language governing permissions and +# limitations under the License. +""" +``causalnex.structure.pytorch.sklearn`` provides sklearn style functionality to NOTEARS. +""" + +__all__ = ["DAGRegressor", "DAGClassifier"] + +from .clf import DAGClassifier +from .reg import DAGRegressor diff --git a/causalnex/structure/sklearn.py b/causalnex/structure/pytorch/sklearn/_base.py similarity index 75% rename from causalnex/structure/sklearn.py rename to causalnex/structure/pytorch/sklearn/_base.py index cabe896..152a17c 100644 --- a/causalnex/structure/sklearn.py +++ b/causalnex/structure/pytorch/sklearn/_base.py @@ -26,19 +26,18 @@ # See the License for the specific language governing permissions and # limitations under the License. """ -This module contains the implementation of ``DAGRegressor``. +This module contains the implementation of ``DAGBase``. -``DAGRegressor`` is a class which wraps the StructureModel in an sklearn interface for regression. +``DAGBase`` is a class which provides an interface and common function for sklearn style NOTEARS functions. """ - import copy import warnings -from typing import Iterable, List, Union +from abc import ABCMeta, abstractmethod +from typing import Dict, Iterable, List, Union import numpy as np import pandas as pd -import torch -from sklearn.base import BaseEstimator, RegressorMixin +from sklearn.base import BaseEstimator from sklearn.preprocessing import StandardScaler from sklearn.utils.validation import check_is_fitted, check_X_y @@ -46,37 +45,18 @@ from causalnex.structure.pytorch import notears -class DAGRegressor( - BaseEstimator, RegressorMixin +class DAGBase( + BaseEstimator, metaclass=ABCMeta ): # pylint: disable=too-many-instance-attributes """ - Regressor wrapper of the StructureModel. + Base class for all sklearn wrappers of the StructureModel. Implements the sklearn .fit and .predict interface. - Currently only supports linear NOTEARS fitting by the DAG. - - Example: - :: - >>> from causalnex.sklearn import DAGRegressor - >>> - >>> smr = DAGRegressor(threshold=0.1) - >>> smr.fit(X_train, y_train) - >>> - >>> y_preds = smr.predict(X_test) - >>> type(y_preds) - np.ndarray - >>> - >>> type(smr.feature_importances_) - np.ndarray - :: - - Attributes: - feature_importances_ (np.ndarray): An array of edge weights corresponding - positionally to the feature X. """ # pylint: disable=too-many-arguments def __init__( self, + dist_type_schema: Dict[Union[str, int], str] = None, alpha: float = 0.0, beta: float = 0.0, fit_intercept: bool = True, @@ -92,6 +72,12 @@ def __init__( ): """ Args: + dist_type_schema: The dist type schema corresponding to the X data passed to fit or predict. + It maps the pandas column name in X to the string alias of a dist type. + If X is a np.ndarray, it maps the positional index to the string alias of a dist type. + A list of alias names can be found in ``dist_type/__init__.py``. + If None, assumes that all data in X is continuous. + alpha: l1 loss weighting. When using nonlinear layers this is only applied to the first layer. @@ -140,6 +126,7 @@ def __init__( self.beta = beta self.fit_intercept = fit_intercept self.hidden_layer_units = hidden_layer_units + self.dist_type_schema = dist_type_schema self.threshold = threshold self.tabu_edges = tabu_edges self.tabu_parent_nodes = tabu_parent_nodes @@ -160,9 +147,15 @@ def __init__( self.enforce_dag = enforce_dag self.standardize = standardize - def fit( - self, X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray] - ) -> "DAGRegressor": + @abstractmethod + def _target_dist_type(self) -> str: + """ + NOTE: + When extending this class override this method to return a dist_type alias + """ + raise NotImplementedError("Must implement _target_dist_type()") + + def fit(self, X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray]): """ Fits the sm model using the concat of X and y. """ @@ -170,21 +163,40 @@ def fit( # defensive X, y checks check_X_y(X, y, y_numeric=True) - # force as DataFrame and Series (for later calculations) + # force X, y to DataFrame, Series for later calculations X = pd.DataFrame(X) y = pd.Series(y) # force name so that name != None (causes errors in notears) y.name = y.name or "__target" + # if self.dist_type_schema is None, assume all columns are continuous + dist_type_schema = self.dist_type_schema or {col: "cont" for col in X.columns} + if self.standardize: - self.ss_X = StandardScaler() - self.ss_y = StandardScaler() - X = pd.DataFrame(self.ss_X.fit_transform(X), columns=X.columns) - y = pd.Series( - self.ss_y.fit_transform(y.values.reshape(-1, 1)).reshape(-1), - name=y.name, + # only standardize the continuous dist type columns. + self.continuous_col_idxs = [ + X.columns.get_loc(col) + for col, alias in dist_type_schema.items() + if alias == "cont" + ] + + # copy X to prevet changes to underlying array data + X = X.copy() + self._ss_X = StandardScaler() + X.iloc[:, self.continuous_col_idxs] = self._ss_X.fit_transform( + X.iloc[:, self.continuous_col_idxs] ) + # if its a continuous target also standardize + if self._target_dist_type() == "cont": + y = y.copy() + self._ss_y = StandardScaler() + y[:] = self._ss_y.fit_transform(y.values.reshape(-1, 1)).reshape(-1) + + # add the target to the dist_type_schema + # NOTE: this must be done AFTER standardize + dist_type_schema[y.name] = self._target_dist_type() + # preserve the feature and target colnames self._features = tuple(X.columns) self._target = y.name @@ -203,6 +215,7 @@ def fit( # fit the structured model self.graph_ = notears.from_pandas( X, + dist_type_schema=dist_type_schema, lasso_beta=self.alpha, ridge_beta=self.beta, hidden_layer_units=self.hidden_layer_units, @@ -220,42 +233,39 @@ def fit( return self - def _predict_from_parents(self, X: Union[pd.DataFrame, np.ndarray]): - - # extract the base solver - structure_learner = self.graph_.graph["structure_learner"] - - # convert the predict data to pytorch tensor - X = torch.from_numpy(X).float().to(structure_learner.device) - # need to concat y onto X so that the dimensions are the same - y = torch.zeros(X.shape[0], 1).float().to(structure_learner.device) - X = torch.cat([X, y], dim=1) - - # perform forward reconstruction - X_hat = structure_learner(X) - - # FUTURE NOTE: with dtypes the projection from latent -> dtype goes here - - # extract the desired y column, return as array - y_pred = X_hat[:, -1] - return y_pred.cpu().detach().numpy() - def predict(self, X: Union[pd.DataFrame, np.ndarray]) -> np.ndarray: """ - Get the predictions of the structured model. - This is done by multiplying the edge weights with the feature i.e. X @ W + Uses the fitted NOTEARS algorithm to reconstruct y from known X data. + + Returns: + Predicted y values for each row of X. """ # force convert to ndarray X = np.asarray(X) if self.standardize: - X = self.ss_X.transform(X) + X = X.copy() + X[:, self.continuous_col_idxs] = self._ss_X.transform( + X[:, self.continuous_col_idxs] + ) + + # insert dummy y column + y_fill = np.zeros(shape=(X.shape[0], 1)) + X = np.hstack([X, y_fill]) # check that the model has been fit check_is_fitted(self, "graph_") - y_pred = np.asarray(self._predict_from_parents(X)) - if self.standardize: - y_pred = self.ss_y.inverse_transform(y_pred.reshape(-1, 1)).reshape(-1) + # extract the base solver + structure_learner = self.graph_.graph["structure_learner"] + # use base solver to reconstruct data + X_hat = structure_learner.reconstruct_data(X) + # pull off reconstructed y column + y_pred = X_hat[:, -1] + + # inverse-standardize + if self.standardize and self._target_dist_type() == "cont": + y_pred = self._ss_y.inverse_transform(y_pred.reshape(-1, 1)).reshape(-1) + return y_pred def get_edges_to_node(self, name: str, data: str = "weight") -> pd.Series: @@ -321,9 +331,7 @@ def plot_dag(self, enforce_dag: bool = False, filename: str = "./graph.png"): # pylint: disable=import-outside-toplevel from IPython.display import Image except ImportError as e: - raise ImportError( - "DAGRegressor.plot_dag method requires IPython installed." - ) from e + raise ImportError("plot_dag method requires IPython installed.") from e check_is_fitted(self, "graph_") diff --git a/causalnex/structure/pytorch/sklearn/clf.py b/causalnex/structure/pytorch/sklearn/clf.py new file mode 100644 index 0000000..880b7f8 --- /dev/null +++ b/causalnex/structure/pytorch/sklearn/clf.py @@ -0,0 +1,132 @@ +# Copyright 2019-2020 QuantumBlack Visual Analytics Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND +# NONINFRINGEMENT. IN NO EVENT WILL THE LICENSOR OR OTHER CONTRIBUTORS +# BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN +# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN +# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# The QuantumBlack Visual Analytics Limited ("QuantumBlack") name and logo +# (either separately or in combination, "QuantumBlack Trademarks") are +# trademarks of QuantumBlack. The License does not grant you any right or +# license to the QuantumBlack Trademarks. You may not use the QuantumBlack +# Trademarks or any confusingly similar mark as a trademark for your product, +# or use the QuantumBlack Trademarks in any other manner that might cause +# confusion in the marketplace, including but not limited to in advertising, +# on websites, or on software. +# +# See the License for the specific language governing permissions and +# limitations under the License. +""" +This module contains the implementation of ``DAGClassifier``. + +``DAGClassifier`` is a class which wraps the StructureModel in an sklearn interface for classification. +""" + +from typing import Union + +import numpy as np +import pandas as pd +from sklearn.base import ClassifierMixin +from sklearn.preprocessing import LabelEncoder +from sklearn.utils.multiclass import check_classification_targets + +from causalnex.structure.pytorch.sklearn._base import DAGBase + + +class DAGClassifier(ClassifierMixin, DAGBase): + """ + Classifier wrapper of the StructureModel. + Implements the sklearn .fit and .predict interface. + + Example: + :: + >>> from causalnex.sklearn import DAGRegressor + >>> + >>> clf = DAGClassifier(threshold=0.1) + >>> clf.fit(X_train, y_train) + >>> + >>> y_preds = clf.predict(X_test) + >>> type(y_preds) + np.ndarray + >>> + >>> type(clf.feature_importances_) + np.ndarray + :: + + Attributes: + feature_importances_ (np.ndarray): An array of edge weights corresponding + positionally to the feature X. + + coef_ (np.ndarray): An array of edge weights corresponding + positionally to the feature X. + + intercept_ (float): The target node bias value. + """ + + def _target_dist_type(self) -> str: + return self.__target_dist_type + + def fit( + self, X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray] + ) -> "DAGClassifier": + """ + Fits the sm model using the concat of X and y. + """ + # clf target check + check_classification_targets(y) + + # encode the categories to be numeric + enc = LabelEncoder() + y = y.copy() + y[:] = enc.fit_transform(y) + # store the classes from the LabelEncoder + self.classes_ = enc.classes_ + + # class number checks + n_classes = len(self.classes_) + if n_classes < 2: + raise ValueError( + "This solver needs samples of at least 2 classes" + " in the data, but the data contains only one" + " class: {}".format(self.classes_[0]) + ) + if n_classes > 2: + raise ValueError("This solver does not support more than 2 classes") + + # store the private attr __target_dist_type + self.__target_dist_type = "bin" + # fit the NOTEARS model + super().fit(X, y) + return self + + def predict(self, X: Union[pd.DataFrame, np.ndarray]) -> np.ndarray: + """ + Uses the fitted NOTEARS algorithm to reconstruct y from known X data. + + Returns: + Predicted y values for each row of X. + """ + probs = self.predict_proba(X) + + # get the class by rounding the (0, 1) bound probability + indices = probs.round().astype(np.int64) + + return self.classes_[indices] + + def predict_proba(self, X: Union[pd.DataFrame, np.ndarray]) -> np.ndarray: + """ + Uses the fitted NOTEARS algorithm to reconstruct y from known X data. + + Returns: + Predicted y class probabilities for each row of X. + """ + return super().predict(X) diff --git a/causalnex/structure/pytorch/sklearn/reg.py b/causalnex/structure/pytorch/sklearn/reg.py new file mode 100644 index 0000000..378dc33 --- /dev/null +++ b/causalnex/structure/pytorch/sklearn/reg.py @@ -0,0 +1,86 @@ +# Copyright 2019-2020 QuantumBlack Visual Analytics Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND +# NONINFRINGEMENT. IN NO EVENT WILL THE LICENSOR OR OTHER CONTRIBUTORS +# BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN +# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN +# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# The QuantumBlack Visual Analytics Limited ("QuantumBlack") name and logo +# (either separately or in combination, "QuantumBlack Trademarks") are +# trademarks of QuantumBlack. The License does not grant you any right or +# license to the QuantumBlack Trademarks. You may not use the QuantumBlack +# Trademarks or any confusingly similar mark as a trademark for your product, +# or use the QuantumBlack Trademarks in any other manner that might cause +# confusion in the marketplace, including but not limited to in advertising, +# on websites, or on software. +# +# See the License for the specific language governing permissions and +# limitations under the License. +""" +This module contains the implementation of ``DAGRegressor``. + +``DAGRegressor`` is a class which wraps the StructureModel in an sklearn interface for regression. +""" + +from typing import Union + +import numpy as np +import pandas as pd +from sklearn.base import RegressorMixin + +from causalnex.structure.pytorch.sklearn._base import DAGBase + + +class DAGRegressor(RegressorMixin, DAGBase): + """ + Regressor wrapper of the StructureModel. + Implements the sklearn .fit and .predict interface. + + Example: + :: + >>> from causalnex.sklearn import DAGRegressor + >>> + >>> reg = DAGRegressor(threshold=0.1) + >>> reg.fit(X_train, y_train) + >>> + >>> y_preds = reg.predict(X_test) + >>> type(y_preds) + np.ndarray + >>> + >>> type(reg.feature_importances_) + np.ndarray + :: + + Attributes: + feature_importances_ (np.ndarray): An array of edge weights corresponding + positionally to the feature X. + + coef_ (np.ndarray): An array of edge weights corresponding + positionally to the feature X. + + intercept_ (float): The target node bias value. + """ + + def _target_dist_type(self) -> str: + return self.__target_dist_type + + def fit( + self, X: Union[pd.DataFrame, np.ndarray], y: Union[pd.Series, np.ndarray] + ) -> "DAGRegressor": + """ + Fits the sm model using the concat of X and y. + """ + # store the private attr __target_dist_type + self.__target_dist_type = "cont" + # fit the NOTEARS model + super().fit(X, y) + return self diff --git a/doc_requirements.txt b/doc_requirements.txt index 744f4c3..e248479 100644 --- a/doc_requirements.txt +++ b/doc_requirements.txt @@ -4,6 +4,7 @@ jupyter_client>=5.1.0, <6.0 nbsphinx==0.4.2 nbstripout==0.3.3 patchy>=1.5, <2.0 +pygments>=2.6.1, <3.0 recommonmark==0.5.0 sphinx-autodoc-typehints>=1.6.0, < 1.11.0 sphinx-markdown-tables==0.0.9 diff --git a/docs/source/03_tutorial/regressor_tutorial.ipynb b/docs/source/03_tutorial/sklearn_tutorial.ipynb similarity index 59% rename from docs/source/03_tutorial/regressor_tutorial.ipynb rename to docs/source/03_tutorial/sklearn_tutorial.ipynb index 648653c..6eb0540 100644 --- a/docs/source/03_tutorial/regressor_tutorial.ipynb +++ b/docs/source/03_tutorial/sklearn_tutorial.ipynb @@ -1,35 +1,17 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 1, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "import os\n", - "import sys\n", - "module_path = os.path.abspath(os.path.join(\"../../..\"))\n", - "if module_path not in sys.path:\n", - " sys.path.append(module_path)" + "# Sklearn Tutorial" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Contents\n", - "\n", - "This notebook walks through using the DAGRegressor model.\n", - "\n", - "The material covered here is as follows:\n", - "- Linear Interface\n", - "- Nonlinear Interface" + "This notebook walks through using the sklearn style DAGRegressor and DAGClassifier models." ] }, { @@ -37,11 +19,11 @@ "metadata": {}, "source": [ "___\n", - "## Real Data (boston housing)\n", - "\n", - "This section demonstrates the performance of the algorithm on a real-world dataset. The main things to note in this section are:\n", + "## DAGRegressor\n", + "This section demonstrates the performance of the DAGRegressor on a real-world dataset. The main things to note in this section are:\n", "- The scale sensitivity of the algorithm\n", "- Interpretability of nonlinear `.coef_`\n", + "### The Data: Boston Housing\n", "\n", "The boston housing dataset is a classic benchmark regression task. The objective is to predict a set of house prices given a small set of features.\n", "\n", @@ -112,6 +94,8 @@ } ], "source": [ + "import numpy as np\n", + "import pandas as pd\n", "from sklearn.datasets import load_boston\n", "print(load_boston(return_X_y=False)[\"DESCR\"])" ] @@ -120,7 +104,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Lets initially benchmark the performance of an `ElasticNetCV` fitted across the entire dataset." + "Lets initially benchmark the performance of an `ElasticNetCV` fitted across the entire dataset." ] }, { @@ -160,13 +144,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Linear DAGRegressor" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + "### Linear DAGRegressor\n", + "\n", "The DAGRegressor has several parameters which can be used to better fit a more complicated noisy DAG:\n", "- `alpha`: The l1 (lasso) regularisation parameter. Increasing this creates a sparser DAG.\n", "- `beta`: The l2 (ridge) regularisation parameter.\n", @@ -251,13 +230,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### NonLinear DAGRegressor" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + "### NonLinear DAGRegressor\n", + "\n", "Specifying a nonlinear model is extremely simple, only a single parameter needs to be altered: `hidden_layer_units`\n", "\n", "`hidden_layer_units` takes _any_ **iterable** of **integers**: \n", @@ -332,7 +306,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Interpereting the Nonlinear DAG\n", + "#### Interpereting the Nonlinear DAG\n", "\n", "For nonlinear analysis, understanding the impact of one feature on another is not as simple as taking the mean effect as in the linear case.\n", "Instead, a combination of `reg.coef_` and `reg.feature_importances` should be used:\n", @@ -516,7 +490,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Dependent Target\n", + "#### Dependent Target\n", "\n", "Setting the `dependent_target=False` has an impact on performance as shown below, but can give better insight into the overall nonlinear structure of the data.\n", "\n", @@ -605,6 +579,236 @@ "reg.plot_dag(True)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "___\n", + "## DAGClassifier\n", + "This section demonstrates the performance of the algorithm on a real-world dataset.\n", + "\n", + "The interface is very similar to the DAGRegressor so key details should be found there.\n", + "### The Data: Breast Cancer" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ".. _breast_cancer_dataset:\n", + "\n", + "Breast cancer wisconsin (diagnostic) dataset\n", + "--------------------------------------------\n", + "\n", + "**Data Set Characteristics:**\n", + "\n", + " :Number of Instances: 569\n", + "\n", + " :Number of Attributes: 30 numeric, predictive attributes and the class\n", + "\n", + " :Attribute Information:\n", + " - radius (mean of distances from center to points on the perimeter)\n", + " - texture (standard deviation of gray-scale values)\n", + " - perimeter\n", + " - area\n", + " - smoothness (local variation in radius lengths)\n", + " - compactness (perimeter^2 / area - 1.0)\n", + " - concavity (severity of concave portions of the contour)\n", + " - concave points (number of concave portions of the contour)\n", + " - symmetry \n", + " - fractal dimension (\"coastline approximation\" - 1)\n", + "\n", + " The mean, standard error, and \"worst\" or largest (mean of the three\n", + " largest values) of these features were computed for each image,\n", + " resulting in 30 features. For instance, field 3 is Mean Radius, field\n", + " 13 is Radius SE, field 23 is Worst Radius.\n", + "\n", + " - class:\n", + " - WDBC-Malignant\n", + " - WDBC-Benign\n", + "\n", + " :Summary Statistics:\n", + "\n", + " ===================================== ====== ======\n", + " Min Max\n", + " ===================================== ====== ======\n", + " radius (mean): 6.981 28.11\n", + " texture (mean): 9.71 39.28\n", + " perimeter (mean): 43.79 188.5\n", + " area (mean): 143.5 2501.0\n", + " smoothness (mean): 0.053 0.163\n", + " compactness (mean): 0.019 0.345\n", + " concavity (mean): 0.0 0.427\n", + " concave points (mean): 0.0 0.201\n", + " symmetry (mean): 0.106 0.304\n", + " fractal dimension (mean): 0.05 0.097\n", + " radius (standard error): 0.112 2.873\n", + " texture (standard error): 0.36 4.885\n", + " perimeter (standard error): 0.757 21.98\n", + " area (standard error): 6.802 542.2\n", + " smoothness (standard error): 0.002 0.031\n", + " compactness (standard error): 0.002 0.135\n", + " concavity (standard error): 0.0 0.396\n", + " concave points (standard error): 0.0 0.053\n", + " symmetry (standard error): 0.008 0.079\n", + " fractal dimension (standard error): 0.001 0.03\n", + " radius (worst): 7.93 36.04\n", + " texture (worst): 12.02 49.54\n", + " perimeter (worst): 50.41 251.2\n", + " area (worst): 185.2 4254.0\n", + " smoothness (worst): 0.071 0.223\n", + " compactness (worst): 0.027 1.058\n", + " concavity (worst): 0.0 1.252\n", + " concave points (worst): 0.0 0.291\n", + " symmetry (worst): 0.156 0.664\n", + " fractal dimension (worst): 0.055 0.208\n", + " ===================================== ====== ======\n", + "\n", + " :Missing Attribute Values: None\n", + "\n", + " :Class Distribution: 212 - Malignant, 357 - Benign\n", + "\n", + " :Creator: Dr. William H. Wolberg, W. Nick Street, Olvi L. Mangasarian\n", + "\n", + " :Donor: Nick Street\n", + "\n", + " :Date: November, 1995\n", + "\n", + "This is a copy of UCI ML Breast Cancer Wisconsin (Diagnostic) datasets.\n", + "https://goo.gl/U2Uwz2\n", + "\n", + "Features are computed from a digitized image of a fine needle\n", + "aspirate (FNA) of a breast mass. They describe\n", + "characteristics of the cell nuclei present in the image.\n", + "\n", + "Separating plane described above was obtained using\n", + "Multisurface Method-Tree (MSM-T) [K. P. Bennett, \"Decision Tree\n", + "Construction Via Linear Programming.\" Proceedings of the 4th\n", + "Midwest Artificial Intelligence and Cognitive Science Society,\n", + "pp. 97-101, 1992], a classification method which uses linear\n", + "programming to construct a decision tree. Relevant features\n", + "were selected using an exhaustive search in the space of 1-4\n", + "features and 1-3 separating planes.\n", + "\n", + "The actual linear program used to obtain the separating plane\n", + "in the 3-dimensional space is that described in:\n", + "[K. P. Bennett and O. L. Mangasarian: \"Robust Linear\n", + "Programming Discrimination of Two Linearly Inseparable Sets\",\n", + "Optimization Methods and Software 1, 1992, 23-34].\n", + "\n", + "This database is also available through the UW CS ftp server:\n", + "\n", + "ftp ftp.cs.wisc.edu\n", + "cd math-prog/cpo-dataset/machine-learn/WDBC/\n", + "\n", + ".. topic:: References\n", + "\n", + " - W.N. Street, W.H. Wolberg and O.L. Mangasarian. Nuclear feature extraction \n", + " for breast tumor diagnosis. IS&T/SPIE 1993 International Symposium on \n", + " Electronic Imaging: Science and Technology, volume 1905, pages 861-870,\n", + " San Jose, CA, 1993.\n", + " - O.L. Mangasarian, W.N. Street and W.H. Wolberg. Breast cancer diagnosis and \n", + " prognosis via linear programming. Operations Research, 43(4), pages 570-577, \n", + " July-August 1995.\n", + " - W.H. Wolberg, W.N. Street, and O.L. Mangasarian. Machine learning techniques\n", + " to diagnose breast cancer from fine-needle aspirates. Cancer Letters 77 (1994) \n", + " 163-171.\n" + ] + } + ], + "source": [ + "from sklearn.datasets import load_breast_cancer\n", + "print(load_breast_cancer(return_X_y=False)[\"DESCR\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MEAN Score: 0.977\n", + "MEAN EFFECT DIRECTIONAL:\n", + "fractal dimension error 0.183807\n", + "compactness error 0.151190\n", + "mean fractal dimension 0.141346\n", + "symmetry error 0.066475\n", + "concavity error 0.001481\n", + "texture error 0.000643\n", + "smoothness error 0.000028\n", + "mean compactness -0.000081\n", + "mean symmetry -0.000104\n", + "concave points error -0.011845\n", + "worst fractal dimension -0.039221\n", + "worst compactness -0.074652\n", + "mean smoothness -0.096894\n", + "perimeter error -0.301725\n", + "mean concavity -0.302624\n", + "area error -0.315381\n", + "mean area -0.335588\n", + "mean perimeter -0.349792\n", + "mean texture -0.360211\n", + "mean radius -0.362093\n", + "worst concavity -0.364120\n", + "worst symmetry -0.388658\n", + "worst smoothness -0.444673\n", + "mean concave points -0.454980\n", + "radius error -0.457226\n", + "worst area -0.458990\n", + "worst perimeter -0.488915\n", + "worst radius -0.538895\n", + "worst texture -0.555389\n", + "worst concave points -0.559847\n", + "dtype: float64\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from causalnex.structure import DAGClassifier\n", + "from sklearn.model_selection import cross_val_score\n", + "\n", + "from sklearn.datasets import load_breast_cancer\n", + "X, y = load_breast_cancer(return_X_y=True)\n", + "names = load_breast_cancer(return_X_y=False)[\"feature_names\"]\n", + "\n", + "reg = DAGClassifier(\n", + " alpha=0.1,\n", + " beta=0.5,\n", + " hidden_layer_units=[0],\n", + " fit_intercept=True,\n", + " standardize=True\n", + " )\n", + "from sklearn.model_selection import KFold\n", + "scores = cross_val_score(reg, X, y, cv=KFold(shuffle=True, random_state=42))\n", + "print(f'MEAN Score: {np.mean(scores).mean():.3f}')\n", + "\n", + "X_pd = pd.DataFrame(X, columns=names)\n", + "y_pd = pd.Series(y, name=\"NOT CANCER\")\n", + "reg.fit(X_pd, y_pd)\n", + "print(\"MEAN EFFECT DIRECTIONAL:\")\n", + "print(pd.Series(reg.coef_, index=names).sort_values(ascending=False))\n", + "reg.plot_dag(True)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -636,7 +840,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/docs/source/api_docs/index.rst b/docs/source/api_docs/index.rst index 61e55e4..b73ed2e 100644 --- a/docs/source/api_docs/index.rst +++ b/docs/source/api_docs/index.rst @@ -61,7 +61,7 @@ Welcome to CausalNex's API docs and tutorials! 03_tutorial/03_tutorial.md 03_tutorial/plotting_tutorial.md - 03_tutorial/regressor_tutorial.md + 03_tutorial/sklearn_tutorial.md .. toctree:: :maxdepth: 2 diff --git a/tests/structure/data_generators/test_core.py b/tests/structure/data_generators/test_core.py index e1dad0d..ffeb112 100644 --- a/tests/structure/data_generators/test_core.py +++ b/tests/structure/data_generators/test_core.py @@ -335,7 +335,7 @@ def test_mixed_type_independence( seed=seed, ) - atol = 0.05 # 5% difference bewteen joint & factored! + atol = 0.02 # at least 2% difference bewteen joint & factored! # 1. dependent links # 0 -> 1 (we look at the class with the highest deviation from uniform # to avoid small values) @@ -360,7 +360,7 @@ def test_mixed_type_independence( atol=atol, ) - tol = 0.15 # relative tolerance of +- 15% of the + tol = 0.20 # at most relative tolerance of +- 20% of the # 2. independent links # categorical c, _ = max( diff --git a/tests/structure/data_generators/test_wrappers.py b/tests/structure/data_generators/test_wrappers.py index 486db8c..c2ae19f 100644 --- a/tests/structure/data_generators/test_wrappers.py +++ b/tests/structure/data_generators/test_wrappers.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # Copyright 2019-2020 QuantumBlack Visual Analytics Limited # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/tests/structure/test_dist_type.py b/tests/structure/test_dist_type.py new file mode 100644 index 0000000..8187301 --- /dev/null +++ b/tests/structure/test_dist_type.py @@ -0,0 +1,110 @@ +# Copyright 2019-2020 QuantumBlack Visual Analytics Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND +# NONINFRINGEMENT. IN NO EVENT WILL THE LICENSOR OR OTHER CONTRIBUTORS +# BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN +# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN +# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# The QuantumBlack Visual Analytics Limited ("QuantumBlack") name and logo +# (either separately or in combination, "QuantumBlack Trademarks") are +# trademarks of QuantumBlack. The License does not grant you any right or +# license to the QuantumBlack Trademarks. You may not use the QuantumBlack +# Trademarks or any confusingly similar mark as a trademark for your product, +# or use the QuantumBlack Trademarks in any other manner that might cause +# confusion in the marketplace, including but not limited to in advertising, +# on websites, or on software. +# +# See the License for the specific language governing permissions and +# limitations under the License. + +import numpy as np +import pandas as pd +import pytest +import torch + +from causalnex.structure.pytorch.dist_type import DistTypeBinary, DistTypeContinuous +from causalnex.structure.pytorch.notears import from_numpy, from_pandas + + +class TestDistTypeClasses: + @pytest.mark.parametrize("dist_type", [DistTypeBinary, DistTypeContinuous]) + def test_default_init(self, dist_type): + idx = 1 + dt = dist_type(idx=idx) + + assert dt.idx == idx + + @pytest.mark.parametrize( + "dist_type, X, X_hat", + [ + ( + DistTypeContinuous, + torch.from_numpy(np.random.normal(size=(5, 2))), + torch.from_numpy(np.random.normal(size=(5, 2))), + ), + ( + DistTypeBinary, + torch.from_numpy(np.random.randint(2, size=(5, 2))).float(), + torch.from_numpy(np.random.randint(2, size=(5, 2))).float(), + ), + ], + ) + def test_loss(self, dist_type, X, X_hat): + dist_types = [dist_type(idx=idx) for idx in np.arange(X.shape[1])] + loss = 0.0 + with torch.no_grad(): + for dt in dist_types: + loss = loss + dt.loss(X, X_hat) + + assert isinstance(loss, torch.Tensor) + assert loss.shape == torch.Size([]) + + +class TestDistTypeNotears: + def test_schema_mismatch_error(self): + X = np.ones(shape=(10, 2)) + schema = {0: "cont", 1: "cont", 2: "cont"} + with pytest.raises(ValueError): + from_numpy(X, schema) + + @pytest.mark.parametrize( + "X, schema", + [ + (np.random.normal(size=(10, 3)), {0: "cont", 1: "cont", 2: "cont"}), + (np.random.randint(2, size=(10, 3)), {0: "bin", 1: "bin", 2: "bin"}), + ( + np.hstack( + [np.random.normal(size=(5, 2)), np.random.randint(2, size=(5, 2))] + ), + {0: "cont", 1: "cont", 2: "bin", 3: "bin"}, + ), + ], + ) + def test_numpy_notears_with_schema(self, X, schema): + from_numpy(X, schema) + + @pytest.mark.parametrize( + "X, schema", + [ + (np.random.normal(size=(10, 3)), {0: "cont", 1: "cont", 2: "cont"}), + (np.random.randint(2, size=(10, 3)), {0: "bin", 1: "bin", 2: "bin"}), + ( + np.hstack( + [np.random.normal(size=(5, 2)), np.random.randint(2, size=(5, 2))] + ), + {0: "cont", 1: "cont", 2: "bin", 3: "bin"}, + ), + ], + ) + def test_pandas_notears_with_schema(self, X, schema): + X = pd.DataFrame(X) + from_pandas(X, schema) diff --git a/tests/structure/test_pytorch_notears.py b/tests/structure/test_pytorch_notears.py index 6ec5f8d..db87cf0 100644 --- a/tests/structure/test_pytorch_notears.py +++ b/tests/structure/test_pytorch_notears.py @@ -36,7 +36,12 @@ from mock import patch from causalnex.structure import StructureModel -from causalnex.structure.data_generators import generate_continuous_dataframe +from causalnex.structure.data_generators import ( + generate_binary_data, + generate_binary_dataframe, + generate_continuous_dataframe, + generate_structure, +) from causalnex.structure.pytorch.notears import from_numpy, from_pandas @@ -58,7 +63,7 @@ def test_isolated_nodes_exist(self, train_data_idx): def test_expected_structure_learned(self, train_data_idx, train_model): """Given a small data set that can be examined by hand, the structure should be deterministic""" - g = from_pandas(train_data_idx, w_threshold=0.25) + g = from_pandas(train_data_idx, w_threshold=0.15) assert set(g.edges) == set(train_model.edges) def test_empty_data_raises_error(self): @@ -220,6 +225,35 @@ def test_check_array(self, data): ): from_pandas(pd.DataFrame(data=data, columns=["a"])) + def test_f1score_generated_binary(self): + """ Binary strucutre learned should have good f1 score """ + np.random.seed(10) + sm = generate_structure(5, 2.0) + df = generate_binary_dataframe( + sm, 1000, intercept=False, noise_scale=0.1, seed=10 + ) + + dist_type_schema = {i: "bin" for i in range(df.shape[1])} + sm_fitted = from_pandas( + df, + dist_type_schema=dist_type_schema, + lasso_beta=0.1, + ridge_beta=0.0, + w_threshold=0.1, + use_bias=False, + ) + + right_edges = sm.edges + n_predictions_made = len(sm_fitted.edges) + n_correct_predictions = len(set(sm_fitted.edges).intersection(set(right_edges))) + n_relevant_predictions = len(right_edges) + + precision = n_correct_predictions / n_predictions_made + recall = n_correct_predictions / n_relevant_predictions + f1_score = 2 * (precision * recall) / (precision + recall) + + assert f1_score > 0.8 + class TestFromNumpy: """Test behaviour of the from_numpy_lasso method""" @@ -239,7 +273,7 @@ def test_isolated_nodes_exist(self, train_data_idx): def test_expected_structure_learned(self, train_data_idx, train_model_idx): """Given a small data set that can be examined by hand, the structure should be deterministic""" - g = from_numpy(train_data_idx.values, w_threshold=0.25) + g = from_numpy(train_data_idx.values, w_threshold=0.15) assert set(g.edges) == set(train_model_idx.edges) def test_empty_data_raises_error(self): @@ -420,3 +454,30 @@ def test_check_array(self, data): match="Input contains NaN, infinity or a value too large for dtype*", ): from_numpy(np.array([data])) + + def test_f1score_generated_binary(self): + """ Binary strucutre learned should have good f1 score """ + np.random.seed(10) + sm = generate_structure(5, 2.0) + df = generate_binary_data(sm, 1000, intercept=False, noise_scale=0.1, seed=10) + + dist_type_schema = {i: "bin" for i in range(df.shape[1])} + sm_fitted = from_numpy( + df, + dist_type_schema=dist_type_schema, + lasso_beta=0.1, + ridge_beta=0.0, + w_threshold=0.1, + use_bias=False, + ) + + right_edges = sm.edges + n_predictions_made = len(sm_fitted.edges) + n_correct_predictions = len(set(sm_fitted.edges).intersection(set(right_edges))) + n_relevant_predictions = len(right_edges) + + precision = n_correct_predictions / n_predictions_made + recall = n_correct_predictions / n_relevant_predictions + f1_score = 2 * (precision * recall) / (precision + recall) + + assert f1_score > 0.8 diff --git a/tests/structure/test_sklearn.py b/tests/structure/test_sklearn.py index bbb2a97..18fa154 100644 --- a/tests/structure/test_sklearn.py +++ b/tests/structure/test_sklearn.py @@ -36,11 +36,14 @@ from sklearn.gaussian_process.kernels import RBF from sklearn.model_selection import KFold, cross_val_score +from causalnex.structure import DAGClassifier, DAGRegressor from causalnex.structure import data_generators as dg -from causalnex.structure.sklearn import DAGRegressor -class TestStructureModel: +class TestDAGSklearn: + """ Tests aspects common to both DAGRegressor and DAGClassifier """ + + @pytest.mark.parametrize("model", [DAGRegressor, DAGClassifier]) @pytest.mark.parametrize( "val, msg, error", [ @@ -50,38 +53,162 @@ class TestStructureModel: ({"threshold": "0.0"}, "threshold should be numeric", TypeError), ], ) - def test_input_type_assertion(self, val, msg, error): + def test_input_type_assertion(self, val, msg, error, model): with pytest.raises(error, match=msg): - DAGRegressor(**val) + model(**val) - def test_pandas_fit(self): - reg = DAGRegressor() - X, y = np.random.normal(size=(100, 2)), np.random.normal(size=(100,)) + @pytest.mark.parametrize("model", [DAGRegressor, DAGClassifier]) + def test_notfitted_error(self, model): + m = model() + X = np.random.normal(size=(100, 2)) + with pytest.raises(NotFittedError): + m.predict(X) + + @pytest.mark.parametrize( + "model, y", + [ + (DAGRegressor, np.random.normal(size=(100,))), + (DAGClassifier, np.random.randint(2, size=(100,))), + ], + ) + def test_tabu_parent_nodes(self, model, y): + X = np.random.normal(size=(100, 2)) + X, y = pd.DataFrame(X), pd.Series(y, name="test") + + m = model(dependent_target=True, tabu_parent_nodes=["test"]) + assert "test" in m.tabu_parent_nodes + + m = model(dependent_target=True, tabu_parent_nodes=[]) + m.fit(X, y) + assert "test" not in m.tabu_parent_nodes + + @pytest.mark.parametrize( + "model, y", + [ + (DAGRegressor, np.random.normal(size=(100,))), + (DAGClassifier, np.random.randint(2, size=(100,))), + ], + ) + def test_numpy_fit(self, model, y): + m = model() + X = np.random.normal(size=(100, 2)) + m.fit(X, y) + + @pytest.mark.parametrize( + "model, y", + [ + (DAGRegressor, np.random.normal(size=(100,))), + (DAGClassifier, np.random.randint(2, size=(100,))), + ], + ) + def test_pandas_fit(self, model, y): + m = model() + X = np.random.normal(size=(100, 2)) X, y = pd.DataFrame(X), pd.Series(y) - reg.fit(X, y) + m.fit(X, y) - def test_numpy_fit(self): - reg = DAGRegressor() - X, y = np.random.normal(size=(100, 2)), np.random.normal(size=(100,)) - reg.fit(X, y) + @pytest.mark.parametrize( + "model, y", + [ + (DAGRegressor, np.random.normal(size=(100,))), + (DAGClassifier, np.random.randint(2, size=(100,))), + ], + ) + @pytest.mark.parametrize( + "fit_intercept, equals_zero", [(True, False), (False, True)] + ) + def test_intercept(self, fit_intercept, equals_zero, model, y): + m = model(fit_intercept=fit_intercept) + X = np.random.normal(size=(100, 2)) + X, y = pd.DataFrame(X), pd.Series(y) + m.fit(X, y) + # intercept should return zero when fit_intercept == False + assert (m.intercept_ == 0) is equals_zero + assert isinstance(m.intercept_, float) - def test_predict_type(self): - reg = DAGRegressor() - X, y = np.random.normal(size=(100, 2)), np.random.normal(size=(100,)) - reg.fit(X, y) - assert isinstance(reg.predict(X), np.ndarray) - reg = DAGRegressor() - X, y = np.random.normal(size=(100, 2)), np.random.normal(size=(100,)) + @pytest.mark.parametrize( + "model, y", + [ + (DAGRegressor, np.random.normal(size=(100,))), + (DAGClassifier, np.random.randint(2, size=(100,))), + ], + ) + @pytest.mark.parametrize("enforce_dag", [True, False]) + def test_plot_dag(self, enforce_dag, model, y): + m = model() + X = np.random.normal(size=(100, 2)) + m.fit(X, y) + image = m.plot_dag(enforce_dag=enforce_dag) + assert isinstance(image, Image) + + @pytest.mark.parametrize( + "model, y", + [ + (DAGRegressor, np.random.normal(size=(100,))), + (DAGClassifier, np.random.randint(2, size=(100,))), + ], + ) + def test_plot_dag_importerror(self, model, y): + with patch.dict("sys.modules", {"IPython.display": None}): + m = model() + X = np.random.normal(size=(100, 2)) + m.fit(X, y) + + with pytest.raises( + ImportError, + match=r"plot_dag method requires IPython installed.", + ): + m.plot_dag() + + @pytest.mark.parametrize( + "model, y", + [ + (DAGRegressor, np.random.normal(size=(100,))), + (DAGClassifier, np.random.randint(2, size=(100,))), + ], + ) + @pytest.mark.parametrize( + "hidden_layer_units", [None, [], [0], [1], (0,), (1,), [1, 1], (1, 1)] + ) + def test_hidden_layer_units(self, hidden_layer_units, model, y): + m = model(hidden_layer_units=hidden_layer_units) + X = np.random.normal(size=(100, 2)) + m.fit(X, y) + + @pytest.mark.parametrize( + "model, y", + [ + (DAGRegressor, np.random.normal(size=(100,))), + (DAGClassifier, np.random.randint(2, size=(100,))), + ], + ) + def test_enforce_dag(self, model, y): + m = model(enforce_dag=True) + X = np.random.normal(size=(100, 2)) X, y = pd.DataFrame(X), pd.Series(y) - reg.fit(X, y) - assert isinstance(reg.predict(X), np.ndarray) + m.fit(X, y) + assert nx.algorithms.is_directed_acyclic_graph(m.graph_) - def test_notfitted_error(self): - reg = DAGRegressor() + @pytest.mark.parametrize( + "model, y", + [ + (DAGRegressor, np.random.normal(size=(100,))), + (DAGClassifier, np.random.randint(2, size=(100,))), + ], + ) + def test_container_predict_type(self, model, y): + m = model() X = np.random.normal(size=(100, 2)) - with pytest.raises(NotFittedError): - reg.predict(X) + m.fit(X, y) + assert isinstance(m.predict(X), np.ndarray) + m = model() + X = np.random.normal(size=(100, 2)) + X, y = pd.DataFrame(X), pd.Series(y) + m.fit(X, y) + assert isinstance(m.predict(X), np.ndarray) + +class TestDAGRegressor: @pytest.mark.parametrize("hidden_layer_units", [None, [2], [2, 2]]) def test_coef(self, hidden_layer_units): reg = DAGRegressor(hidden_layer_units=hidden_layer_units) @@ -110,64 +237,6 @@ def test_feature_importances(self, hidden_layer_units): # assert that the sign of the coefficient is positive for both nonlinear and linear cases assert coef_["true_feat"] > 0 - def test_tabu_parent_nodes(self): - X, y = np.random.normal(size=(100, 2)), np.random.normal(size=(100,)) - X, y = pd.DataFrame(X), pd.Series(y, name="test") - - reg = DAGRegressor(dependent_target=True, tabu_parent_nodes=["test"]) - assert "test" in reg.tabu_parent_nodes - - reg = DAGRegressor(dependent_target=True, tabu_parent_nodes=[]) - reg.fit(X, y) - assert "test" not in reg.tabu_parent_nodes - - @pytest.mark.parametrize( - "fit_intercept, equals_zero", [(True, False), (False, True)] - ) - def test_intercept(self, fit_intercept, equals_zero): - reg = DAGRegressor(fit_intercept=fit_intercept) - X, y = np.random.normal(size=(100, 2)), np.random.normal(size=(100,)) - X, y = pd.DataFrame(X), pd.Series(y) - reg.fit(X, y) - # intercept should return zero when fit_intercept == False - assert (reg.intercept_ == 0) is equals_zero - assert isinstance(reg.intercept_, float) - - @pytest.mark.parametrize("enforce_dag", [True, False]) - def test_plot_dag(self, enforce_dag): - reg = DAGRegressor() - X, y = np.random.normal(size=(100, 2)), np.random.normal(size=(100,)) - reg.fit(X, y) - image = reg.plot_dag(enforce_dag=enforce_dag) - assert isinstance(image, Image) - - def test_plot_dag_importerror(self): - with patch.dict("sys.modules", {"IPython.display": None}): - reg = DAGRegressor() - X, y = np.random.normal(size=(100, 2)), np.random.normal(size=(100,)) - reg.fit(X, y) - - with pytest.raises( - ImportError, - match=r"DAGRegressor\.plot_dag method requires IPython installed\.", - ): - reg.plot_dag() - - @pytest.mark.parametrize( - "hidden_layer_units", [None, [], [0], [1], (0,), (1,), [1, 1], (1, 1)] - ) - def test_hidden_layer_units(self, hidden_layer_units): - reg = DAGRegressor(hidden_layer_units=hidden_layer_units) - X, y = np.random.normal(size=(100, 2)), np.random.normal(size=(100,)) - reg.fit(X, y) - - def test_enforce_dag(self): - reg = DAGRegressor(enforce_dag=True) - X, y = np.random.normal(size=(100, 2)), np.random.normal(size=(100,)) - X, y = pd.DataFrame(X), pd.Series(y) - reg.fit(X, y) - assert nx.algorithms.is_directed_acyclic_graph(reg.graph_) - @pytest.mark.parametrize("standardize", [True, False]) def test_nonlinear_performance(self, standardize): np.random.seed(42) @@ -182,10 +251,8 @@ def test_nonlinear_performance(self, standardize): reg = DAGRegressor( alpha=0.0, - l1_ratio=0.0, fit_intercept=True, dependent_target=True, - enforce_dag=False, hidden_layer_units=[0], standardize=standardize, ) @@ -195,9 +262,7 @@ def test_nonlinear_performance(self, standardize): reg = DAGRegressor( alpha=0.1, - l1_ratio=1.0, fit_intercept=True, - enforce_dag=False, hidden_layer_units=[2], standardize=standardize, ) @@ -207,9 +272,7 @@ def test_nonlinear_performance(self, standardize): reg = DAGRegressor( alpha=0.1, - l1_ratio=1.0, fit_intercept=True, - enforce_dag=False, hidden_layer_units=[4], standardize=standardize, ) @@ -219,3 +282,59 @@ def test_nonlinear_performance(self, standardize): assert small_nl_score > linear_score assert medium_nl_score > small_nl_score + + +class TestDAGClassifier: + @pytest.mark.parametrize("hidden_layer_units", [None, [2], [2, 2]]) + def test_coef(self, hidden_layer_units): + clf = DAGClassifier(alpha=0.1, hidden_layer_units=hidden_layer_units) + X, y = ( + pd.DataFrame(np.random.normal(size=(100, 2))), + pd.Series(np.zeros(shape=(100,), dtype=int)), + ) + y[X[0] < 0] = 1 + clf.fit(X, y) + + assert isinstance(clf.coef_, np.ndarray) + coef_ = pd.Series(clf.coef_, index=X.columns) + # assert that the sign of the coefficient is correct for both nonlinear and linear cases + assert coef_[0] < 0 + + @pytest.mark.parametrize("hidden_layer_units", [None, [2], [2, 2]]) + def test_feature_importances(self, hidden_layer_units): + clf = DAGClassifier(alpha=0.1, hidden_layer_units=hidden_layer_units) + X, y = ( + pd.DataFrame(np.random.normal(size=(100, 2))), + pd.Series(np.zeros(shape=(100,), dtype=int)), + ) + y[X[0] < 0] = 1 + clf.fit(X, y) + + assert isinstance(clf.feature_importances_, np.ndarray) + coef_ = pd.Series(clf.feature_importances_, index=X.columns) + # assert that the sign of the coefficient is positive for both nonlinear and linear cases + assert coef_[0] > 0 + + @pytest.mark.parametrize("y_type", [float, str, np.int32, np.int64, np.float32]) + def test_value_predict_type(self, y_type): + clf = DAGClassifier(alpha=0.1) + X, y = ( + pd.DataFrame(np.random.normal(size=(100, 2))), + pd.Series(np.zeros(shape=(100,), dtype=y_type)), + ) + y[X[0] < 0] = y_type(1) + clf.fit(X, y) + + y_pred = clf.predict(X) + assert isinstance(y_pred[0], y_type) + y_pred_proba = clf.predict_proba(X) + assert isinstance(y_pred_proba[0], np.float64) + + @pytest.mark.parametrize( + "y", [np.random.randint(1, size=(100,)), np.random.randint(3, size=(100,))] + ) + def test_class_number_error(self, y): + clf = DAGClassifier(alpha=0.1) + X = (pd.DataFrame(np.random.normal(size=(100, 2))),) + with pytest.raises(ValueError): + clf.fit(X, y) diff --git a/tests/test_preprocessing.py b/tests/test_preprocessing.py index 78f2d37..6104d5b 100644 --- a/tests/test_preprocessing.py +++ b/tests/test_preprocessing.py @@ -36,26 +36,16 @@ class TestUniform: def test_fit_creates_exactly_uniform_splits_when_possible(self): - """splits should be exactly uniform if possible""" + """splits should be exactly uniform""" - arr = np.array(range(20)) + arr = np.array(range(21)) np.random.shuffle(arr) - d = Discretiser(method="uniform", num_buckets=4) + d = Discretiser(method="uniform", num_buckets=5) d.fit(arr) for n in range(2): - assert 4 < (d.numeric_split_points[n + 1] - d.numeric_split_points[n]) <= 5 - - def test_fit_creates_close_to_uniform_splits_when_uniform_not_possible(self): - """splits should be close to uniform if uniform is not possible""" - - arr = np.array(range(9)) - np.random.shuffle(arr) - d = Discretiser(method="uniform", num_buckets=4) - d.fit(arr) - - assert len(d.numeric_split_points) == 3 - for n in range(2): - assert 2 <= (d.numeric_split_points[n + 1] - d.numeric_split_points[n]) <= 3 + assert (d.numeric_split_points[n + 1] - d.numeric_split_points[n]) == ( + (d.numeric_split_points[n + 2] - d.numeric_split_points[n + 1]) + ) def test_fit_does_not_attempt_to_deal_with_identical_split_points(self): """if all data is identical, and num_buckets>1, then this is not possible. @@ -70,20 +60,6 @@ def test_fit_does_not_attempt_to_deal_with_identical_split_points(self): d.numeric_split_points, ) - def test_transform_uneven_split(self): - """Data that cannot be split evenly between buckets should be transformed - into near-even buckets""" - - arr = np.array([n + 1 for n in range(10)]) - np.random.shuffle(arr) - d = Discretiser(method="uniform", num_buckets=4) - d.fit(arr) - unique, counts = np.unique(d.transform(arr), return_counts=True) - # check all 4 buckets are used - assert np.array_equal([0, 1, 2, 3], unique) - # check largest difference in distribution is 1 item - assert (np.max(counts) - np.min(counts)) <= 1 - def test_transform_larger_than_fit_range_goes_into_last_bucket(self): """If a value larger than the input is transformed, then it should go into the maximum bucket"""