From e29bc0c59f8cc22933660861d3f316b25fecd826 Mon Sep 17 00:00:00 2001 From: Angel Droth <67913551+angeldrothqb@users.noreply.github.com> Date: Fri, 18 Sep 2020 16:24:44 +0100 Subject: [PATCH] Release/0.8.1 (#94) * Merge back to develop * Simplifying viz.draw syntax in tutorial notebook (#46) * Add non negativity constraint in numpy lasso (#41) * Add plotting tutorial to the documentation (#47) * Unpin some requirements * Mixed type data generation (#55) Added DAG-based synthetic data generator for mixed types (binary, categorical, continuous) using a linear SEM approach. * Merge back to develop (#59) * Pytorch NOTEARS (#63) * NoTears as ScoreSolver * refactor continuous solver * adding attribute to access weight matrix * refactoring continuous solver * Adding fit_lasso method * add data_gen_continuous.py and tests (#38) * add data_gen.py * rename * wrap SM * move data_gen_continous, create test * more coverage * test fixes * move discrete sem to another file * node list dupe check test * ValueError tests * replace dag and sem functions with Ben's verions * add Ben's tests * fix fstring * to_numpy_array coverage * Ben's comments * remove unreachable ValueError for coverage * remove unused fixture * remove redundant test * remove extensions Co-Authored-By: Ben Horsburgh * docstring Co-Authored-By: Ben Horsburgh * docstring Co-Authored-By: Ben Horsburgh * docs Co-Authored-By: Ben Horsburgh * doc Co-Authored-By: Ben Horsburgh * rename file, g_dag rename to sm * add new tests for equal weights * docstring * steve docstring, leq fix * steve comments + docstrings Co-authored-by: Ben Horsburgh * Adding check input and removing some inner functions * Removing attribute original_ndarray * Aligning from pandas with new implementation * Adding tests for fit_lasso * More tests for lasso * wrapping tabu params in a dict * Aligning tests with new tabu params * Aligning from_pandas with new tabu_params * Adding fit_intercept option to _fit method * Adding scaling option * fixing lasso tests * Adding a test for fit_intercept * scaling option only with mean * Correction in lasso bounds * Fix typos * Remove duplicated bounds function * adding comments * add torch files from xunzheng * add from_numpy_torch function that works like from_numpy_lasso * lint * add requirements * add debug functionality * add visual debug test * add license * allow running as main for viz, comments * move to contrib * make multi layer work a bit better * add comment for multi layer * use polynomial dag constraint for better speed comparison * revert unnecessary changes to keep PR lean * revert unnecessary changes to keep PR lean * revert unnecessary changes to keep PR lean * fixes * refactor * Integrated tests * Checkpoint * Refactoring * Finished initial refactoring * All tests passed * Cleaning * Git add testing * Get adjacency matrix * Done cleaning * Revert change to original notears * Revert change to original structuremodel * Revert change to pylintrc * Undo deletion * Apply suggestions from Zain Co-authored-by: Zain Patel * Addressed Zain comments * Migrated from_numpy * Delete contrib test * Migrated w_threshold * Some linting * Change to None * Undo deletion * List comprehension * Refactoring scipy and remove scipy optimiser * Refactoring * Refactoring * Refactoring complete * change from np to torch tensor * More refactoring * Remove hnew equal to None * Refactor again and remove commented line * Minor change * change to params * Addressing Philip's comment * Add property * Add fc2 property weights * Change to weights * Docstring * Linting * Linting completed * Add gpu code * Add gpu to from_numpy and from_pandas * cuda 0 run out of memory * Debugging * put 5 * debugging gpu * shift to inner loop * debugging not in place * Use cada instead of to * Support both interfaces * Benchmarking gpu * Minor fix * correct import path for test * change gpu from 5 to 1 * Debugging * Debugging * Experimenting * Linting * Remove hidden layer and gpu * Linting * Testing and linting * Correct pytorch to torch * Add init zeros * Change weight threshold to 0.25 * Revert requirements.txt * Update release.md * Address coments * Corrected release.md * fc1 to adjacency Co-authored-by: Ben Horsburgh Co-authored-by: LiseDiagneQB <60981366+LiseDiagneQB@users.noreply.github.com> Co-authored-by: Casey Juanxi Li <50737712+caseyliqb@users.noreply.github.com> Co-authored-by: qbphilip Co-authored-by: Zain Patel * Pinned sphinx-auto-doc-typehints (#66) * Corrected a spelling/grammar mistake (#55) * Fix/lint (#73) * Hotfix/0.4.3 (#7) - Address broken links and grammar * Fix documentation links in README (#2) * Fix links in README * library -> libraries * Fix github link in docs * Clean up grammar and consistency in documentation (#4) * Clean up grammar and consistency in `README` files * Add esses, mostly * Reword feature description to not appear automatic * Update docs/source/05_resources/05_faq.md Co-Authored-By: Ben Horsburgh Co-authored-by: Ben Horsburgh * hotfix/0.4.3: fix broken links Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta * Release/0.5.0 * Plotting now backed by pygraphviz. This allows: * More powerful layout manager * Cleaner fully customisable theme * Out-the-box styling for different node and edge types * Can now get subgraphs from StructureModel containing a specific node * Bugfix to resolve issue when fitting CPDs with some missing states in data * Minor documentation fixes and improvements * Release/0.6.0 * Release/0.7.0 (#57) * Added plottting tutorial to the documentation * Updated `viz.draw` syntax in tutorial notebooks * Bugfix on notears lasso (`from_numpy_lasso` and `from_pandas_lasso`) where the non-negativity constraint was not being set * Added DAG-based synthetic data generator for mixed types (binary, categorical, continuous) using a linear SEM approach. * Unpinned some requirements * black * pin pytorch version * pin pytorch version Co-authored-by: Ben Horsburgh Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta * Structure learning regressor (#68) * initial commit (local copy-paste) * fixed minor comments * minor bugfix * impute from children inital commit * bugfixes and method option * auto thresholding * autothreshold and bugfix * make threshold removal explicit * add l1 argument * remove child imputation * feat importance fix and tabu logic * moved threshold till dag * restructure with base class * coef mask * recipe * enable bias fitting * persist bias as node attribute * allow fit_intercept * minor PR comment fixes * minor comment adjustment * test coverage and l1 clarification * recipe * minor test fixes * more tests * full test coverage * revove python 3.5/3.6 unsupported import * add normalization option * idiomatic typing * correct pylint errors * update some tests * more typeing updates * more pylint requirements * more pylint disable * python 3.5 support * try to get to work with 3.5 * full coverage and 3.5 support * remove base class to pass test * remove unneeded supression * black formatting changes * remove unused import * pytlint supression * minor reformat change * isort fix * better defensive programming * fix unittests * docstring update * do Raises docstring properly * action SWE suggestions * hotfixes * minor update * minor black formatting change * final merge checkbox * fix end of file * Data Gen root node initialisation fix (#72) * Hotfix/0.4.3 (#7) - Address broken links and grammar * Fix documentation links in README (#2) * Fix links in README * library -> libraries * Fix github link in docs * Clean up grammar and consistency in documentation (#4) * Clean up grammar and consistency in `README` files * Add esses, mostly * Reword feature description to not appear automatic * Update docs/source/05_resources/05_faq.md Co-Authored-By: Ben Horsburgh Co-authored-by: Ben Horsburgh * hotfix/0.4.3: fix broken links Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta * Release/0.5.0 * Plotting now backed by pygraphviz. This allows: * More powerful layout manager * Cleaner fully customisable theme * Out-the-box styling for different node and edge types * Can now get subgraphs from StructureModel containing a specific node * Bugfix to resolve issue when fitting CPDs with some missing states in data * Minor documentation fixes and improvements * Release/0.6.0 * Release/0.7.0 (#57) * Added plottting tutorial to the documentation * Updated `viz.draw` syntax in tutorial notebooks * Bugfix on notears lasso (`from_numpy_lasso` and `from_pandas_lasso`) where the non-negativity constraint was not being set * Added DAG-based synthetic data generator for mixed types (binary, categorical, continuous) using a linear SEM approach. * Unpinned some requirements * fix for consinuous normal data * generalise across all dtypes * support fit_intercept * fixed many test errors * test logic fixes * lint test fixes * python 3.5 failure change * minor test bugfix * black * pin pytorch version * pin pytorch version * additional test parameter * black formatting * requested changes * test updates and docstring * black format change * disable too many lines * change * move recipe to tutorial folder * releaseMD changes Co-authored-by: Ben Horsburgh Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta Co-authored-by: Philip Pilgerstorfer <34248114+qbphilip@users.noreply.github.com> Co-authored-by: qbphilip * [1/2] Poisson data for data gen (#61) * Hotfix/0.4.3 (#7) - Address broken links and grammar * Fix documentation links in README (#2) * Fix links in README * library -> libraries * Fix github link in docs * Clean up grammar and consistency in documentation (#4) * Clean up grammar and consistency in `README` files * Add esses, mostly * Reword feature description to not appear automatic * Update docs/source/05_resources/05_faq.md Co-Authored-By: Ben Horsburgh Co-authored-by: Ben Horsburgh * hotfix/0.4.3: fix broken links Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta * Release/0.5.0 * Plotting now backed by pygraphviz. This allows: * More powerful layout manager * Cleaner fully customisable theme * Out-the-box styling for different node and edge types * Can now get subgraphs from StructureModel containing a specific node * Bugfix to resolve issue when fitting CPDs with some missing states in data * Minor documentation fixes and improvements * Release/0.6.0 * Release/0.7.0 (#57) * Added plottting tutorial to the documentation * Updated `viz.draw` syntax in tutorial notebooks * Bugfix on notears lasso (`from_numpy_lasso` and `from_pandas_lasso`) where the non-negativity constraint was not being set * Added DAG-based synthetic data generator for mixed types (binary, categorical, continuous) using a linear SEM approach. * Unpinned some requirements * refactor & docstring * remove unused helper object * add data gen to init * make test more robust * add count data and test, use logs for poisson samples for stability * fix tests * duplicate fixtures * remove unused fixtures * refactor data_generators into package with core and wrappers * move wrapper to test_wrapper * variable name change bugfix * fix tests Co-authored-by: Ben Horsburgh Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta Co-authored-by: angeldrothqb * [2/2] Nonlinear Data gen (#60) * Hotfix/0.4.3 (#7) - Address broken links and grammar * Fix documentation links in README (#2) * Fix links in README * library -> libraries * Fix github link in docs * Clean up grammar and consistency in documentation (#4) * Clean up grammar and consistency in `README` files * Add esses, mostly * Reword feature description to not appear automatic * Update docs/source/05_resources/05_faq.md Co-Authored-By: Ben Horsburgh Co-authored-by: Ben Horsburgh * hotfix/0.4.3: fix broken links Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta * Release/0.5.0 * Plotting now backed by pygraphviz. This allows: * More powerful layout manager * Cleaner fully customisable theme * Out-the-box styling for different node and edge types * Can now get subgraphs from StructureModel containing a specific node * Bugfix to resolve issue when fitting CPDs with some missing states in data * Minor documentation fixes and improvements * Release/0.6.0 * Release/0.7.0 (#57) * Added plottting tutorial to the documentation * Updated `viz.draw` syntax in tutorial notebooks * Bugfix on notears lasso (`from_numpy_lasso` and `from_pandas_lasso`) where the non-negativity constraint was not being set * Added DAG-based synthetic data generator for mixed types (binary, categorical, continuous) using a linear SEM approach. * Unpinned some requirements * refactor & docstring * remove unused helper object * add data gen to init * make test more robust * add count data and test, use logs for poisson samples for stability * add nonlinear * fix tests * duplicate fixtures * remove unused fixtures * refactor data_generators into package with core and wrappers * move wrapper to test_wrapper * add nonlinear to init * change order in all * change release.md * root node fix on core + count * nonlinear support to wrappers * docstring update * bugfix and reproducability fix * many tests and test updates * poiss bugfix and test fix * moar test coverage * categorical dataframe test coverage * full test coverage and linting * fix linting and fstring * black reformat * fix unused pylint argument * pytest fix * FINAL linting fix * Fix stuff (#75) CircleCI fixes Co-authored-by: Ben Horsburgh Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta Co-authored-by: angeldrothqb Co-authored-by: Zain Patel * update black version (#76) * fix black * Fix/check for NA or Infinity when notears is used (#54) * update scipy version (#77) * add DYNOTEARS implementation (#50) Adds DYNOTEARS and corresponding data generator (for testing) * Pytorch NOTEARS extension - Non-Linear/Hidden Layer (#65) * NoTears as ScoreSolver * refactor continuous solver * adding attribute to access weight matrix * refactoring continuous solver * Adding fit_lasso method * add data_gen_continuous.py and tests (#38) * add data_gen.py * rename * wrap SM * move data_gen_continous, create test * more coverage * test fixes * move discrete sem to another file * node list dupe check test * ValueError tests * replace dag and sem functions with Ben's verions * add Ben's tests * fix fstring * to_numpy_array coverage * Ben's comments * remove unreachable ValueError for coverage * remove unused fixture * remove redundant test * remove extensions Co-Authored-By: Ben Horsburgh * docstring Co-Authored-By: Ben Horsburgh * docstring Co-Authored-By: Ben Horsburgh * docs Co-Authored-By: Ben Horsburgh * doc Co-Authored-By: Ben Horsburgh * rename file, g_dag rename to sm * add new tests for equal weights * docstring * steve docstring, leq fix * steve comments + docstrings Co-authored-by: Ben Horsburgh * Adding check input and removing some inner functions * Removing attribute original_ndarray * Aligning from pandas with new implementation * Adding tests for fit_lasso * More tests for lasso * wrapping tabu params in a dict * Aligning tests with new tabu params * Aligning from_pandas with new tabu_params * Adding fit_intercept option to _fit method * Adding scaling option * fixing lasso tests * Adding a test for fit_intercept * scaling option only with mean * Correction in lasso bounds * Fix typos * Remove duplicated bounds function * adding comments * add torch files from xunzheng * add from_numpy_torch function that works like from_numpy_lasso * lint * add requirements * add debug functionality * add visual debug test * add license * allow running as main for viz, comments * move to contrib * make multi layer work a bit better * add comment for multi layer * use polynomial dag constraint for better speed comparison * revert unnecessary changes to keep PR lean * revert unnecessary changes to keep PR lean * revert unnecessary changes to keep PR lean * fixes * refactor * Integrated tests * Checkpoint * Refactoring * Finished initial refactoring * All tests passed * Cleaning * Git add testing * Get adjacency matrix * Done cleaning * Revert change to original notears * Revert change to original structuremodel * Revert change to pylintrc * Undo deletion * Apply suggestions from Zain Co-authored-by: Zain Patel * Addressed Zain comments * Migrated from_numpy * Delete contrib test * Migrated w_threshold * Some linting * Change to None * Undo deletion * List comprehension * Refactoring scipy and remove scipy optimiser * Refactoring * Refactoring * Refactoring complete * change from np to torch tensor * More refactoring * Remove hnew equal to None * Refactor again and remove commented line * Minor change * change to params * Addressing Philip's comment * Add property * Add fc2 property weights * Change to weights * Docstring * Linting * Linting completed * Add gpu code * Add gpu to from_numpy and from_pandas * cuda 0 run out of memory * Debugging * put 5 * debugging gpu * shift to inner loop * debugging not in place * Use cada instead of to * Support both interfaces * Benchmarking gpu * Minor fix * correct import path for test * change gpu from 5 to 1 * Debugging * Debugging * Experimenting * Linting * Remove hidden layer and gpu * Linting * Testing and linting * Correct pytorch to torch * Add init zeros * Change weight threshold to 0.25 * Revert requirements.txt * Add hidden layer * small refactor * directional adj * minor edits * fix bias issues * breaking changes update to the interface * typo * new regressor regularisation interface * update forward method * forward(X) predictions work * working! * bugfix data normalisation * some fixes * average regularisation and adj calc at end * give credit! Co-authored-by: Philip Pilgerstorfer <34248114+qbphilip@users.noreply.github.com> * loc lin docstring update Co-authored-by: Philip Pilgerstorfer <34248114+qbphilip@users.noreply.github.com> * docstring + fc1/fc2 name updates * moar docstring updates * more minor updates * remove normalize option * plotting util * rename to DAGRegressor * rename and checks * more util functions * fix bias * fix bias with no intercept * fix linear adj * add tests * minor fix * minor fixes * extend interface to bias * differentialte coef_ and feature_imporances * seperate bias element * tests * more test coverage * nonlinear test coverage * test hotfix * more test coverage * test requirements update * more test coverage * formatting changes * final pylint change * more linting * more bestpractice structuring * more minor fixes * FINAL linting updates * actual last change * update to reg defaults, additions to the tutorial * nonlinear regularisation updates * regressor tutorial * almost finishing touches * gradient based h function! * soft clamp and coef feature importance seperation * small api update, closer to batchnorm * docstring updates * stronger soft clamping * gradient L1 rather than L2 * fcpos neg removal, gradient optim * revert back to create_graph=True for 2nd derivative * remove print and test fix * black reformatting * new black version * full test coverage * isort fix * pylint fix * first layer h(W) for speed optimization * fix batch norm system * add nonlinear test * test hotfix * black reformat * isort fix * remove X requirement from h_func * regressor tutorial final commit and black update * LayerNorm replacement Co-authored-by: Philip Pilgerstorfer <34248114+qbphilip@users.noreply.github.com> * major changes * add standardization * minort changes * fix tests * rename reg parameters * linting * test coverage, docstting * check array for infs * fix isinstance to base type * fix isort, add test coverage * new tutorial * docstring fix Co-authored-by: Zain Patel * test string match Co-authored-by: Zain Patel * assert improvement Co-authored-by: Zain Patel * SWE suggestions * minor bugfix * more test fixing Co-authored-by: Ben Horsburgh Co-authored-by: LiseDiagneQB <60981366+LiseDiagneQB@users.noreply.github.com> Co-authored-by: Casey Juanxi Li <50737712+caseyliqb@users.noreply.github.com> Co-authored-by: qbphilip Co-authored-by: Zain Patel Co-authored-by: angeldrothqb Co-authored-by: angeldrothqb <67913551+angeldrothqb@users.noreply.github.com> Co-authored-by: Philip Pilgerstorfer <34248114+qbphilip@users.noreply.github.com> * Merge release/0.8.0 back into develop for release 0.8.0 (#82) * Hotfix/0.4.3 (#7) - Address broken links and grammar * Fix documentation links in README (#2) * Fix links in README * library -> libraries * Fix github link in docs * Clean up grammar and consistency in documentation (#4) * Clean up grammar and consistency in `README` files * Add esses, mostly * Reword feature description to not appear automatic * Update docs/source/05_resources/05_faq.md Co-Authored-By: Ben Horsburgh Co-authored-by: Ben Horsburgh * hotfix/0.4.3: fix broken links Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta * Release/0.5.0 * Plotting now backed by pygraphviz. This allows: * More powerful layout manager * Cleaner fully customisable theme * Out-the-box styling for different node and edge types * Can now get subgraphs from StructureModel containing a specific node * Bugfix to resolve issue when fitting CPDs with some missing states in data * Minor documentation fixes and improvements * Release/0.6.0 * Release/0.7.0 (#57) * Added plottting tutorial to the documentation * Updated `viz.draw` syntax in tutorial notebooks * Bugfix on notears lasso (`from_numpy_lasso` and `from_pandas_lasso`) where the non-negativity constraint was not being set * Added DAG-based synthetic data generator for mixed types (binary, categorical, continuous) using a linear SEM approach. * Unpinned some requirements * release.md, version bump, docs Co-authored-by: Ben Horsburgh Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta Co-authored-by: Philip Pilgerstorfer <34248114+qbphilip@users.noreply.github.com> * fix tests (#87) * Fix pygments fail (#84) Thanks Zain! * update notebook beginning (#89) * Add Binary distribution type support (#85) * binary dtype folder and __init__ * dtype base class * continuous dtype * binary dtype * update core * make plural * update interface for idx * minor variable name change * notears update * python 3.5 support * fix fstring * remove categorical methods, doctrings * formatting and docstrings * remove redundant cat code * isort * indexerror check * defensive check tests * datatype loss tests * more test coverage * more tests and formatting * fix test import * remove double test * linting * docstring and pylint * docstring fix Co-authored-by: Zain Patel * fix long string Co-authored-by: Zain Patel * docstring fix Co-authored-by: Zain Patel * remove relative imports * docstring fix * dict comprehension * list comprehension and neatness * remove unuesd import to __init__ * fix test * remove unused return interface * add binary f1score tests * one datatype instane per feature * rename dtype -> disttype, attach dists to nodes * fix tests * fix linting * fix preserve node dtyper * fix tests * fix tests * fix tests * final docstring and test fixes * lint fix * test_fix, warning * linting * fix test * fix tests * reduce threshold of test * raise better error * black linting * remove warning * remove useless supression and import Co-authored-by: Zain Patel * Add sklearn binary classifier (#90) * binary dtype folder and __init__ * dtype base class * continuous dtype * binary dtype * update core * make plural * update interface for idx * minor variable name change * notears update * python 3.5 support * fix fstring * remove categorical methods, doctrings * formatting and docstrings * remove redundant cat code * isort * indexerror check * defensive check tests * datatype loss tests * more test coverage * more tests and formatting * fix test import * remove double test * linting * docstring and pylint * docstring fix Co-authored-by: Zain Patel * fix long string Co-authored-by: Zain Patel * docstring fix Co-authored-by: Zain Patel * remove relative imports * docstring fix * dict comprehension * list comprehension and neatness * remove unuesd import to __init__ * fix test * remove unused return interface * new sklearn folder structure * sklearn class outline * new dtype interface * docstring clarification * inverse link function * add binary f1score tests * one datatype instane per feature * rename dtype -> disttype, attach dists to nodes * fix tests * fix linting * fix preserve node dtyper * fix tests * fix tests * fix tests * final docstring and test fixes * lint fix * test_fix, warning * linting * fix test * fix tests * reduce threshold of test * docstring clarification * _target_dist_type injection * docstring updates + clf fit outline * old doctring deprecation * clf predict_proba and predict * return bugfix * docstring update * import fix, linting, clf fit finished * args docstring and None schema * raise better error * black linting * linting * revert to public interface * remove warning * remove useless supression and import * add useless change to resolve merge conflict * update inits * standardization and data reconstruction * remove unused imports * fix clf .precit() * regressor fit_predict * remove useless regressor predict * test import fix * fix warnings * pass series name thru * fix schema pass thru * better dict comprehension Co-authored-by: Zain Patel * import and comment fixes * update to .format() * fig sklearn is fitted test * more dtype schema insertion * DAGRegressor test fix * dag regressor test * more linting * big test restructure * combined test suite * error string update * more test coverage * linting and isort * move test to combined test * return float64 preds * moar clf tests * remove untestable (multiclass) code * class number error test * balck reformat * docstrings, pylint * fix test bug * standard scaler for _base * pull classes direct from LabelEncoder * update tutorial Co-authored-by: Zain Patel * Fix/uniform discretisation (#65) * Fix uniform discretiser * Fix uniform discretiser Co-authored-by: Philip Pilgerstorfer <34248114+qbphilip@users.noreply.github.com> * release.MD * version bump * Update causalnex/structure/pytorch/dist_type/_base.py Co-authored-by: Zain Patel * Update causalnex/structure/pytorch/dist_type/__init__.py Co-authored-by: Zain Patel Co-authored-by: Ben Horsburgh Co-authored-by: GabrielAzevedoFerreiraQB <57528979+GabrielAzevedoFerreiraQB@users.noreply.github.com> Co-authored-by: Philip Pilgerstorfer <34248114+qbphilip@users.noreply.github.com> Co-authored-by: stevelersl <55385183+SteveLerQB@users.noreply.github.com> Co-authored-by: LiseDiagneQB <60981366+LiseDiagneQB@users.noreply.github.com> Co-authored-by: Casey Juanxi Li <50737712+caseyliqb@users.noreply.github.com> Co-authored-by: qbphilip Co-authored-by: Zain Patel Co-authored-by: KING-SID Co-authored-by: Zain Patel <30357972+mzjp2@users.noreply.github.com> Co-authored-by: Nikos Tsaousis Co-authored-by: Deepyaman Datta Co-authored-by: Jebq Co-authored-by: Shuhei Ishida --- RELEASE.md | 11 +- causalnex/__init__.py | 2 +- causalnex/discretiser/discretiser.py | 5 +- causalnex/structure/__init__.py | 11 +- causalnex/structure/dynotears.py | 3 +- causalnex/structure/pytorch/__init__.py | 3 +- causalnex/structure/pytorch/core.py | 42 ++- .../structure/pytorch/dist_type/__init__.py | 45 +++ .../structure/pytorch/dist_type/_base.py | 79 +++++ .../structure/pytorch/dist_type/binary.py | 77 +++++ .../structure/pytorch/dist_type/continuous.py | 70 +++++ causalnex/structure/pytorch/notears.py | 57 +++- .../structure/pytorch/sklearn/__init__.py | 35 +++ .../{sklearn.py => pytorch/sklearn/_base.py} | 144 +++++---- causalnex/structure/pytorch/sklearn/clf.py | 132 ++++++++ causalnex/structure/pytorch/sklearn/reg.py | 86 +++++ doc_requirements.txt | 1 + ..._tutorial.ipynb => sklearn_tutorial.ipynb} | 288 ++++++++++++++--- docs/source/api_docs/index.rst | 2 +- tests/structure/data_generators/test_core.py | 4 +- .../data_generators/test_wrappers.py | 1 - tests/structure/test_dist_type.py | 110 +++++++ tests/structure/test_pytorch_notears.py | 67 +++- tests/structure/test_sklearn.py | 297 ++++++++++++------ tests/test_preprocessing.py | 36 +-- 25 files changed, 1356 insertions(+), 252 deletions(-) create mode 100644 causalnex/structure/pytorch/dist_type/__init__.py create mode 100644 causalnex/structure/pytorch/dist_type/_base.py create mode 100644 causalnex/structure/pytorch/dist_type/binary.py create mode 100644 causalnex/structure/pytorch/dist_type/continuous.py create mode 100644 causalnex/structure/pytorch/sklearn/__init__.py rename causalnex/structure/{sklearn.py => pytorch/sklearn/_base.py} (75%) create mode 100644 causalnex/structure/pytorch/sklearn/clf.py create mode 100644 causalnex/structure/pytorch/sklearn/reg.py rename docs/source/03_tutorial/{regressor_tutorial.ipynb => sklearn_tutorial.ipynb} (59%) create mode 100644 tests/structure/test_dist_type.py 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"""