Add files using upload-large-folder tool

testbed/pgmpy__pgmpy/.codacy.yaml

@@ -0,0 +1,5 @@
+exclude_paths:
+        - '**.md'
+        - 'pgmpy/tests/**'
+        - 'docs/**'
+        - 'pgmpy/extern/**'

testbed/pgmpy__pgmpy/.gitignore

@@ -0,0 +1,44 @@
+*.py[cod]
+*.swp
+.idea/*
+# C extensions
+*.so
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+_build
+eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+lib
+lib64
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+nosetests.xml
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Auto examples generated
+docs/auto_examples/*
+docs/examples/*
+
+# Macos files
+.DS_Store

testbed/pgmpy__pgmpy/.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+  - repo: https://github.com/pycqa/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort
+        args: ["--profile", "black", "--filter-files"]
+  - repo: https://github.com/psf/black
+    rev: 24.8.0
+    hooks:
+      - id: black

testbed/pgmpy__pgmpy/AUTHORS.rst

@@ -0,0 +1,119 @@
+People
+------
+   
+Organisation Admins
+===================
+
+* Ankur Ankan <ankurankan@gmail.com>
+
+* Abinash Panda <mailme.abinashpanda@gmail.com>
+
+Contributors
+============
+
+* Ankur Ankan <ankurankan@gmail.com>
+* Abinash Panda <abinash.panda.ece10@itbhu.ac.in>
+* Yashu Seth <yashuseth2503@gmail.com>
+* palashahuja <abhor902@gmail.com>
+* Utkarsh Gupta <utkarsh.gupta550@gmail.com>
+* Vivek Jain <vivek425ster@gmail.com>
+* Utkarsh <utkarsh.gupta550@gmail.com>
+* Pratyaksh Sharma <pratyaksh@me.com>
+* ankurankan <ankurankan@gmail.com>
+* chrisittner <mail@chrisittner.de>
+* navin <navinchandak92@gmail.com>
+* Abinash Panda <mailme.abinashpanda@gmail.com>
+* kislayabhi <abhijeetkislay@gmail.com>
+* finn42 <finnlattimore@gmail.com>
+* Raghav Gupta <raghavg7796@gmail.com>
+* abinashpanda <abinash.panda.ece10@itbhu.ac.in>
+* joncrall <erotemic@gmail.com>
+* lohani2280 <lohani.ayush01@gmail.com>
+* Anavil Tripathi <anaviltripathi@gmail.com>
+* jp111 <jaspreetsingh112@gmail.com>
+* snigam3112 <snigam3112@gmail.com>
+* Ashwini Chaudhary <monty.sinngh@gmail.com>
+* Kshitij Saraogi <KshitijSaraogi@gmail.com>
+* nehasoni <neha.soni.ece10@itbhu.ac.in>
+* Christian Ittner <mail@chrisittner.de>
+* Harish Kashyap <harish.k.kashyap@gmail.com>
+* cs15mtech11007@iith.ac.in <krishankant.singh@suiit.ac.in>
+* Shikhar Nigam <snigam3112@gmail.com>
+* Zhongpeng Lin <zholin@microsoft.com>
+* loudly-soft <hipnet@yahoo.com>
+* Pratik151 <pratikpatel15133@gmail.com>
+* Simon Brugman <sbrugman@users.noreply.github.com>
+* Sitesh Ranjan <siteshjaiswal@gmail.com>
+* Zhongpeng Lin <lin.zhp@gmail.com>
+* Anchit Jain <anchitjain1234@gmail.com>
+* Demyanov <artyom.demyanov96@gmail.com>
+* Justin Tervala <Tervala_Justin@bah.com>
+* Pratyaksh <pratyaksh@me.com>
+* Utkarsh Sinha <sinha.utkarsh1990@gmail.com>
+* abhi95 <abhi.r.j95@gmail.com>
+* mailman_anchit <mailman@anchitja.in>
+* Alaa ElNouby <alaaelnouby@gmail.com>
+* Max Baak <maxbaak@gmail.com>
+* Melissa Turcotte <meturcot@microsoft.com>
+* elkbrsathuji <elkana.baris@mail.huji.ac.il>
+* karttikeya <mangalam@iitk.ac.in>
+* Alex Perusse <perusse.a@gmail.com>
+* Ashutosh-Adhikari <aashu.ad@gmail.com>
+* Ayan Das <dasayan05@hotmail.com>
+* Daan Knoope <daanknoope@gmail.com>
+* Jon Crall <erotemic@gmail.com>
+* Marco Tamassia <tamassia.marco@gmail.com>
+* Pratyaksh Sharma <pratyakshs@users.noreply.github.com>
+* Randy Julian <rkjulian@indigobio.com>
+* Tristan Deleu <tristandeleu@users.noreply.github.com>
+* all3fox <all3fox@gmail.com>
+* heldmo <52459329+heldmo@users.noreply.github.com>
+* joncrall <crallj@rpi.edu>
+* sudarshan <ssudk1896@gmail.com>
+* vivek425ster <vivek425ster@gmail.com>
+* Alireza Mehrtash <alireza.mehrtash@gmail.com>
+* Arijit-hydrated <parijit10@gmail.com>
+* Bhavya Bahl <bhavyabahl.1@gmail.com>
+* BrettW <brettwitty@brettwitty.net>
+* Chris Kamphuis <mail@chriskamphuis.com>
+* Céline Comte <celine.comte@nokia.com>
+* Deepak Garg <deepakgargi99e@gmail.com>
+* Fabio Colella <fcole90@gmail.com>
+* IvanaXu <1440420407@qq.com>
+* Jaidev Deshpande <deshpande.jaidev@gmail.com>
+* Jinyan Guan <jig189@ucsd.edu>
+* Joan Zheng <jzheng@sift.net>
+* Jon Badger <jonathancbadger@gmail.com>
+* JustinTervala <Tervala_Justin@bah.com>
+* Kris Singh <krishnakant.singh@suiit.ac.in>
+* Lorenzo Mario Amorosa <38985168+Lostefra@users.noreply.github.com>
+* Marcus Östling <mpt.ostling@gmail.com>
+* Maximilian Kurthen <MKurthen@live.de>
+* Nishant Nikhil <nishantiam@gmail.com>
+* Paul Chaignon <paul.chaignon@orange.com>
+* Rafael Ballester-Ripoll <rballri@gmail.com>
+* Randy <sharmane578@gmail.com>
+* Roy Abitbol <roy.abitbol@gmail.com>
+* Sahithi Kilaru <Sahithi Kilaru>
+* Saket Choudhary <saketkc@gmail.com>
+* Sandeep Narayanaswami <Sandeep.Narayanaswami@capitalone.com>
+* Sandeep Narayanaswami <scoffes@gmail.com>
+* Sandhya Kumari <sandhya05jan@gmail.com>
+* Steffen Roecker <sroecker@gmail.com>
+* The Gitter Badger <badger@gitter.im>
+* Ubuntu <ubuntu@ip-172-31-32-148.us-west-2.compute.internal>
+* William Lyon <wlyon@quantpost.com>
+* Yi(Amy) Sui <suiyiamy@gmail.com>
+* Yichuan <63798002+yzh211@users.noreply.github.com>
+* Yidi Huang <huangy6@yahoo.com>
+* abinash <abinash@abinash-Inspiron-N4010.(none)>
+* davenza <daries100@gmail.com>
+* fabriziov <venfab@gmail.com>
+* julian.reichinger <julian.reichinger@dynatrace.com>
+* mjmt05 <melissa.turcotte@gmail.com>
+* njwhite <n.j.white@gmail.com>
+* pdoongarwal <pdoongarwal@gmail.com>
+* pheman <rbzhang100@gmail.com>
+* rishabmarkand <rishab.markand@gmail.com>
+* sleepy-owl <sleepy-owl@github.com>
+* yashml <yashml@outlook.com>

testbed/pgmpy__pgmpy/CHANGELOG.md

@@ -0,0 +1,293 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.26] - 2024-08-09
+### Added
+1. Support for returning Belief Propagation messages in Factor Graph BP.
+2. Maximum Likelihood Estimator for Junction Tree.
+3. Adds a simple discretization method: `pgmpy.utils.discretize`.
+4. Two new metrics for model testing: `pgmpy.metrics.implied_cis` and `pgmpy.metrics.fisher_c`.
+5. Support for Linear Gaussian Bayesian Networks: estimation, prediction, simulation and random model generation.
+7. New mixed data Conditional Independence test based on canonical correlations.
+8. New LLM based structure learning / causal discovery algorithm. Also LLM based pairwise variable orientation method.
+
+
+### Fixed
+1. Reading and Writing from XBN file format.
+2. Documentation for plotting models.
+3. Fixes PC algorithm to add disconnected nodes in the final model.
+4. Allows `.` in variables names in BIF file format.
+
+### Changed
+1. Allows `virtual_evidence` parameter in inference methods to accept DiscreteFactor objects.
+
+## [0.1.25] - 2024-03-08
+### Added
+1. `init_cpds` argument to `ExpecattionMaximiation.get_parameters` to specify initialization values.
+2. BeliefPropagation with message passing for Factor Graphs.
+3. Marginal Inference for undirected graphs.
+
+### Fixed
+1. Incompatibality with networkx==3.2.
+2. `CausalInference.get_minimal_adjustment_set` to accept string variable names.
+3. Bug in EM when latent varaibles are present.
+4. `compat_fns.copy` to consider the case when int or float is passed.
+5. Fixes issue with `BayesianNetwork.fit_update` when running with CUDA backend.
+
+### Changed
+1. Documentation Updates
+2. Optimizations for Hill Climb Search algorithm.
+3. Tests shutdown parallel workers in teardown.
+4. Removes the `complete_samples_only` argument from `BaseEstimator.state_counts`.
+5. Default number of cores to use changed to 1 for parameter estimation methods.
+
+## [0.1.24] - 2023-06-30
+### Added
+1. Added support for python 3.11.
+2. Adds `DAG.to_graphviz` and `PDAG.to_graphviz` methods to convert model to graphviz objects.
+3. Adds pytorch as an alternative backend.
+4. Adds unicode support for BIFReader.
+
+### Fixed
+1. Warnings use a logger instance.
+2. Fixes documentation.
+3. Fixes variables name arguments for `CausalInference.get_minimal_adjustment_set`
+
+### Changed
+1. Adds argument to specify samples for ApproxInference.
+2. Memory optimizations for computing structure scores.
+3. Switches joblib backed to loky.
+4. Runtime optimizations for sampling.
+5. Runtime optimizations for Variable Elimination.
+6. All config variables moved to `pgmpy.global_vars`.
+
+## [0.1.23] - 2023-06-30
+### Added
+1. BIFReader made compatible with the output of PyAgrum
+2. Support for all available CI tests in PC algorithm.
+3. References for read/write file formats.
+
+### Removed
+1. Removes `DAG.to_pdag` method.
+
+### Changed
+1. Fixes for ApproxInference for DBNs.
+2. Make `xml.etree` the default parser instead of using lxml.
+
+## [0.1.22] - 2023-04-08
+### Added
+1. AIC score metric from score based structure learning.
+2. Adds support for NET (HUGIN) file format.
+3. Adds argument reindex to `state_counts` method.
+
+### Fixed
+1. Bug in GibbsSampling when sampling from Bayesian Networks.
+2. Fix seed for all simulation methods.
+3. Memory leaks when using `lru_cache`.
+
+### Changed
+1. Caching disabled for computing state name counts during structure learning.
+2. Pre-computation for sampling methods are optimized.
+
+## [0.1.21] - 2022-12-31
+### Added
+1. `BayesianNetwork.get_state_probability` method to compute the probability of a given evidence.
+2. `BayesianEstimator.estimate_cpd` accepts weighted datasets.
+
+### Fixed
+1. Fixes bug in `CausalInference.estimate_ate` with front-door criterion.
+2. Fixes inference bugs when variable has a single state.
+
+## [0.1.20] - 2022-09-30
+### Added
+1. `BayesianNetwork.get_random_cpds` method to randomly parameterize a network structure.
+2. Faster Variable Elimination using tensor contraction.
+3. `factors.factor_sum_product` method for faster sum-product operations using tensor contraction.
+
+### Fixed
+1. Bug in `DynamicBayesianNetwork.initialize_initial_state`. #1564
+2. Bug in `factors.factor_product`. #1565
+
+### Changed
+1. Runtime improvements in `DiscreteFactor.marginalize` and `DiscreteFactor.copy` methods.
+
+## [0.1.19] - 2022-06-30
+### Added
+1. Adds checks for arguments to `BayesianNetwork.simulate` method.
+
+### Fixed
+1. Fixes TAN algorithm to use conditional information metric.
+2. Speed ups for all estimation and inference methods.
+3. Fix in stable variant of PC algorithm to give reproducible results.
+4. Fix in `GibbsSampling` for it to work with variables with integral names.
+5. `DAG.active_trail_nodes` allows tuples as variable names.
+6. Fixes CPD and edge creation in `UAIReader`.
+
+## [0.1.18] - 2022-03-30
+### Fixed
+1. Fixes `CausalInference.is_valid_backdoor_adjustment_set` to accept str arguments for `Z`.
+2. Fixes `BayesianNetwork.remove_cpd` to work with integral node names.
+3. Fixes `MPLP.map_query` to return the variable states instead of probability values.
+4. Fixes BIFWriter to generate output in standard BIF format.
+
+## [0.1.17] - 2021-12-30
+### Added
+1. Adds BayesianNetwork.states property to store states of all the variables.
+2. Adds extra checks in check model for state names
+
+### Fixed
+1. Fixes typos in BayesianModel deprecation warning
+2. Bug fix in printing Linear Gaussian CPD
+3. Update example notebooks to work on latest dev.
+
+## [0.1.16] - 2021-09-30
+### Added
+1. Adds a `fit_update` method to `BayesianNetwork` for updating model using new data.
+2. Adds `simulate` method to `BayesianNetwork` and `DynamicBayesianNetwork` to simulated data under different conditions.
+3. Adds `DynamicBayesianNetwork.fit` method to learn model paramters from data.
+4. `ApproxInference` class to do approximate inference on models using sampling.
+5. Robust tests for all sampling methods.
+6. Adds `BayesianNetwork.load` and `BayesianNetwork.save` to quickly read and write files.
+
+### Changed
+1. `BayesianModel` and `MarkovModel` renamed to `BayesianNetwork` and `MarkovNetwork` respectively.
+2. The default value of node position in `DAG.to_daft` method.
+3. Documentation updated on the website.
+
+### Fixed
+1. Fixes bug in `DAG.is_iequivalent` method.
+2. Automatically truncate table when CPD is too large.
+3. Auto-adjustment of probability values when they don't exactly sum to 1.
+4. tqdm works both in notebooks and terminal.
+5. Fixes bug in `CausalInference.query` method.
+
+## [0.1.15] - 2021-06-30
+### Added
+1. Adds network pruning for inference algrithms to reduce the size of network before
+   running inference.
+2. Adds support for latent variables in DAG and BayesianModel.
+3. Parallel implementation for parameter estimation algorithms.
+4. Adds `DAG.get_random` and `BayesianModel.get_random` methods to be able to generate random models.
+5. Adds `CausalInference.query` method for doing do operation inference with or without adjustment sets.
+6. Adds functionality to treesearch to do auto root and class node selection (#1418)
+7. Adds option to specify virtual evidence in bayesian network inference.
+8. Adds Expectation-Maximization (EM) algorithm for parameter estimation in latent variable models.
+9. Add `BDeuScore` as another option for structure score when using HillClimbSearch.
+10. Adds CausalInference.get_minimal_adjustment_set` for finding adjustment sets.
+
+### Changed
+1. Renames `DAG.is_active_trail` to `is_dconnected`.
+2. `DAG.do` can accept multiple variables in the argument.
+3. Optimizes sampling methods.
+4. CI moved from travis and appveyor to github actions.
+5. Drops support for python 3.6. Requires 3.7+.
+
+### Fixed
+1. Example model files were not getting included in the pypi and conda packages.
+2. The order of values returned by CI tests was wrong. #1403
+3. Adjusted and normalized MI wasn't working properly in TreeSearch.
+4. #1423: Value error in bayesian estimation.
+5. Fixes bug in `DiscreteFactor.__eq__` to also consider the state names order.
+
+## [0.1.14] - 2021-03-31
+### Added
+1. Adds support for python 3.9.
+2. `BayesianModelProbability` class for calculating pmf for BNs.
+3. BayesianModel.predict has a new argument `stochastic` which returns stochastic results instead of MAP.
+4. Adds new method pgmpy.base.DAG.to_daft to easily convert models into publishable plots.
+
+### Changed
+1. `pgmpy.utils.get_example_model` now doesn't need internet connection to work. Files moved locally.
+
+### Fixed
+1. Latex output of `pgmpy.DAG.get_independencies`.
+2. Bug fix in PC algorithm as it was skipping some combinations.
+3. Error in sampling because of seed not correctly set.
+
+## [0.1.13] - 2020-12-30
+### Added
+1. New conditional independence tests for discrete variables
+
+### Changed
+1. Adds warning in BayesianEstimator when using dirichlet prior.
+
+### Fixed
+1. Bug in `PC.skeleton_to_pdag`.
+2. Bug in `HillClimbSearch` when no legal operations.
+
+### Removed
+
+## [0.1.12] - 2020-09-30
+### Added
+1. PC estimator with original, stable, and parallel variants.
+2. PDAG class to represent partially directed DAGs.
+3. `pgmpy.utils.get_example_model` function to fetch models from bnlearn repository.
+4. Refactor HillClimbSearch with a new feature to specify fixed edges in the model.
+5. Adds a global `SHOW_PROGRESS` variable.
+6. Adds Chow-Liu structure learning algorithm.
+7. Add `pgmpy.utils.get_example_model` to fetch models from bnlearn's repository.
+8. Adds `get_value` and `set_value` method to `DiscreteFactor` to get/set a single value.
+9. Adds `get_acestral_graph` to `DAG`.
+
+### Changed
+1. Refactors ConstraintBasedEstimators into PC with a lot of general improvements.
+2. Improved (faster, new arguments) indepenedence tests with changes in argument.
+3. Refactors `sample_discrete` method. Sampling algorithms much faster.
+4. Refactors `HillClimbSearch` to be faster.
+5. Sampling methods now return dataframe of type categorical.
+
+### Fixed
+
+### Removed
+1. `Data` class.
+
+## [0.1.11] - 2020-06-30
+### Added
+- New example notebook: Alarm.ipynb
+- Support for python 3.8
+- Score Caching support for scoring methods.
+
+### Changed
+- Code quality check moved to codacy from landscape
+- Additional parameter `max_ci_vars` for `ConstraintBasedEstimator`.
+- Additional parameter `pseudo_count` for K2 score.
+- Sampling methods return state names instead of number when available.
+- XMLBIFReader and BIFReader not accepts argument for specifying state name type.
+
+### Fixed
+- Additional checks for TabularCPD values shape.
+- `DiscreteFactor.reduce` accepts both state names and state numbers for variables.
+- `BeliefPropagation.query` fixed to return normalized CPDs.
+- Bug in flip operation in `HillClimbSearch`.
+- BIFWriter to write the state names to file if available.
+- `BayesianModel.to_markov_model` fixed to work with disconnected graphs.
+- VariableElimination fixed to not ignore identifical factors.
+- Fixes automatic sorting of state names in estimators.
+
+### Removed
+- No support for ProbModelXML file format.
+
+## [0.1.10] - 2020-01-22
+### Added
+- Documentation updated to include Structural Equation Models(SEM) and Causal Inference.
+- Adds Mmhc estimator.
+
+### Changed
+- BdeuScore is renamed to BDeuScore.
+- Refactoring of NaiveBayes
+- Overhaul of CI and setup infrastructure.
+- query methods check for common variabls in variable and evidence argument.
+
+### Fixed
+- Example notebooks for Inference.
+- DAG.moralize gives consistent results for disconnected graphs.
+- Fixes problems with XMLBIF and BIF reader and writer classes to be consistent.
+- Better integration of state names throughout the package.
+- Improves remove_factors and add_factors methods of FactorGraph
+- copy method of TabularCPD and DiscreteFactor now makes a copy of state names.
+
+### Removed
+- six not a dependency anymore.

testbed/pgmpy__pgmpy/CITATION.cff

@@ -0,0 +1,23 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+- family-names: "Ankan"
+  given-names: "Ankur"
+- family-names: "Textor"
+  given-names: "Johannes"
+title: "pgmpy: A Python Toolkit for Bayesian Networks"
+version: 0.1.26
+url: "https://github.com/pgmpy/pgmpy"
+preferred-citation:
+  type: article
+  authors:
+  - family-names: "Ankan"
+    given-names: "Ankur"
+  - family-names: "Textor"
+    given-names: "Johannes"
+  journal: "Journal Of Machine Learning Research"
+  start: 1
+  end: 8
+  title: "pgmpy: A Python Toolkit for Bayesian Networks"
+  issue: 25
+  year: 2024

testbed/pgmpy__pgmpy/CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project maintainer at ankurankan@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

testbed/pgmpy__pgmpy/Contributing.md

@@ -0,0 +1,106 @@
+# Contributing to pgmpy
+
+Hi! Thanks for your interest in contributing to [pgmpy](https://pgmpy.org). This
+document summarizes everything that you need to know to get started.
+
+## Code and Issues
+
+We use [Github](https://github.com/pgmpy/pgmpy) to host all our code. We also use github
+as our [issue tracker](https://github.com/pgmpy/pgmpy/issues). Please feel free to
+create a new issue for any bugs, questions etc. It is very helpful if you follow the
+issue template while creating new issues as it gives us enough information to reproduce
+the problem. You can also refer to github's
+[guide](https://guides.github.com/features/issues/) on how to efficiently use github
+issues.
+
+### Git and our Branching model
+
+#### Git
+
+We use [Git](http://git-scm.com/) as our [version control
+system](http://en.wikipedia.org/wiki/Revision_control), so the best way to contribute is
+to learn how to use it and put your changes on a Git repository. There is plenty of
+online resources available to get started with Git:
+- Online tool to try git: [try git
+  tutorial](https://try.github.io/levels/1/challenges/1)
+- Quick intro to opening your first Pull Request:
+  https://www.freecodecamp.org/news/how-to-make-your-first-pull-request-on-github-3/
+- Git reference: [Pro Git book](http://git-scm.com/book/).
+
+#### Forks + GitHub Pull Requests
+
+We use [gitflow](http://nvie.com/posts/a-successful-git-branching-model/) to manage our
+branches.
+
+Summary of our git branching model:
+- Fork the desired repository on GitHub to your account.
+- Clone your forked repository locally: `git clone git@github.com:your-username/repository-name.git`.
+- Create a new branch off of `dev` branch with a descriptive name (for example:
+  `feature/portuguese-sentiment-analysis`, `hotfix/bug-on-downloader`). You can
+  do it by switching to `dev` branch: `git checkout dev` and then
+  creating a new branch: `git checkout -b name-of-the-new-branch`.
+- Make changes to the codebase and commit it. <b> [Imp] </b> Make sure that tests pass for each of your commits.
+- Rebase your branch on the current dev and push to your fork on GitHub (with the name as your local branch:
+  `git push origin branch-name`
+- Create a pull request using GitHub's Web interface (asking us to pull the
+  changes from your new branch and add the changes to our `dev` branch).;
+- Wait for reviews and comments.
+
+
+#### Tips
+
+- <b> [Imp] </b>  Write [helpful commit
+  messages](http://robots.thoughtbot.com/5-useful-tips-for-a-better-commit-message).
+- Anything in the `dev` branch should be deployable (no failing tests).
+- Never use `git add .`: it can add unwanted files;
+- Avoid using `git commit -a` unless you know what you're doing;
+- Check every change with `git diff` before adding then to the index (stage
+  area) and with `git diff --cached` before committing;
+- If you have push access to the main repository, please do not commit directly
+  to `dev`: your access should be used only to accept pull requests; if you
+  want to make a new feature, you should use the same process as other
+  developers so that your code can be reviewed.
+
+
+### Code Guidelines
+
+- We use `black`(https://black.readthedocs.io/en/stable/) for our code formatting.
+- Write tests for your new features (please see "Tests" topic below);
+- Always remember that [commented code is dead
+  code](http://www.codinghorror.com/blog/2008/07/coding-without-comments.html);
+- Name identifiers (variables, classes, functions, module names) with readable
+  names (`x` is always wrong);
+- When manipulating strings, use [Python's f-Strings](https://realpython.com/python-f-strings/)
+  (`f'{a} = {b}'` instead of `'{} = {}'.format(a, b)`);
+- When working with files use `with open(<filename>, <option>) as f` instead of
+  ` f = open(<filename>, <option>)`;
+- All `#TODO` comments should be turned into issues (use our
+  [GitHub issue system](https://github.com/pgmpy/pgmpy/issues));
+- Run all tests before pushing (just execute `nosetests`) so you will know if your
+  changes broke something;
+
+### Tests
+
+We use [Travis CI](https://travis-ci.org/) for continuous integration for linux systems
+and [AppVeyor](https://www.appveyor.com/) for Windows systems.  We use python [unittest
+module](https://docs.python.org/2/library/unittest.html) for writing tests.  You should
+write tests for every feature you add or bug you solve in the code.  Having automated
+tests for every line of our code let us make big changes without worries: there will
+always be tests to verify if the changes introduced bugs or lack of features. If we
+don't have tests we will be blind and every change will come with some fear of possibly
+breaking something.
+
+For a better design of your code, we recommend using a technique called [test-driven
+development](https://en.wikipedia.org/wiki/Test-driven_development), where you write
+your tests **before** writing the actual code that implements the desired feature.
+
+
+## Discussion
+
+Please feel free to contact us through the mailing list if you have any questions or
+suggestions. Connect with us at [gitter](https://gitter.im/pgmpy/pgmpy).  All
+contributions are very welcome!
+
+*Mailing list* : pgmpy@googlegroups.com
+
+Happy hacking! ;)

testbed/pgmpy__pgmpy/LICENSE

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

testbed/pgmpy__pgmpy/MANIFEST.in

@@ -0,0 +1 @@
+include pgmpy/utils/example_models/*.bif.gz

testbed/pgmpy__pgmpy/README.md

@@ -0,0 +1,113 @@
+<div align="center">
+  <img src="https://raw.githubusercontent.com/pgmpy/pgmpy/dev/logo/logo_color.png" width="318" height="300"/>
+</div>
+<br/>
+<div align="center">
+
+![Build](https://github.com/pgmpy/pgmpy/actions/workflows/ci.yml/badge.svg?branch=dev)
+[![Downloads](https://img.shields.io/pypi/dm/pgmpy.svg)](https://pypistats.org/packages/pgmpy)
+[![Version](https://img.shields.io/pypi/v/pgmpy?color=blue)](https://pypi.org/project/pgmpy/)
+[![Python Version](https://img.shields.io/pypi/pyversions/pgmpy.svg?color=blue)](https://pypi.org/project/pgmpy/)
+[![License](https://img.shields.io/github/license/pgmpy/pgmpy)](https://github.com/pgmpy/pgmpy/blob/dev/LICENSE)
+[![asv](http://img.shields.io/badge/benchmarked%20by-asv-blue.svg?style=flat)](http://pgmpy.org/pgmpy-benchmarks/)
+
+
+</div>
+
+<div align="center">
+
+[![Join the pgmpy Discord server](https://img.shields.io/badge/Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/DRkdKaumBs)
+[![Read the Docs](https://img.shields.io/badge/-Docs-blue?style=for-the-badge&logo=Read-the-Docs&logoColor=white&link=https://inseq.org)](https://pgmpy.org)
+[![Examples](https://img.shields.io/badge/-Examples-orange?style=for-the-badge&logo=Jupyter&logoColor=white&link=https://github.com/pgmpy/pgmpy/tree/dev/examples)](https://github.com/pgmpy/pgmpy/tree/dev/examples)
+[![Tutorial](https://img.shields.io/badge/-Tutorial-orange?style=for-the-badge&logo=Jupyter&logoColor=white&link=https://github.com/pgmpy/pgmpy_notebook)](https://github.com/pgmpy/pgmpy_notebook)
+
+</div>
+
+pgmpy is a Python package for working with Bayesian Networks and related models such as Directed Acyclic Graphs, Dynamic Bayesian Networks, and Structural Equation Models. It combines features from causal inference and probabilistic inference literature to allow users to seamlessly work between them. It implements algorithms for structure learning, causal discovery, parameter estimation, probabilistic and causal inference, and simulations.
+
+- **Documentation:** https://pgmpy.org/
+- **Installation:** https://pgmpy.org/started/install.html
+- **Mailing List:** https://groups.google.com/forum/#!forum/pgmpy .
+- **Community chat:** [discord](https://discord.gg/DRkdKaumBs) (Older chat at: [gitter](https://gitter.im/pgmpy/pgmpy))
+
+
+Examples
+--------
+- Creating a Bayesian Network: [view](https://pgmpy.org/examples/Creating%20a%20Discrete%20Bayesian%20Network.html) | <a target="_blank" href="https://colab.research.google.com/github/ankurankan/pgmpy/blob/dev/examples/Creating%20a%20Discrete%20Bayesian%20Network.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+- Structure Learning/Causal Discovery: [view](https://pgmpy.org/examples/Structure%20Learning%20in%20Bayesian%20Networks.html) | <a target="_blank" href="https://colab.research.google.com/github/ankurankan/pgmpy/blob/dev/examples/Structure%20Learning%20in%20Bayesian%20Networks.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+- Parameter Learning: [view](https://pgmpy.org/examples/Learning%20Parameters%20in%20Discrete%20Bayesian%20Networks.html) | <a target="_blank" href="https://colab.research.google.com/github/ankurankan/pgmpy/blob/dev/examples/Learning%20Parameters%20in%20Discrete%20Bayesian%20Networks.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+- Probabilistic Inference: [view](https://pgmpy.org/examples/Inference%20in%20Discrete%20Bayesian%20Networks.html) | <a target="_blank" href="https://colab.research.google.com/github/ankurankan/pgmpy/blob/dev/examples/Inference%20in%20Discrete%20Bayesian%20Networks.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+- Causal Inference: [view](https://pgmpy.org/examples/Causal%20Inference.html) | <a target="_blank" href="https://colab.research.google.com/github/https://pgmpy.org/examples/Causal%20Inference.html"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+- Extending pgmpy: [view](https://pgmpy.org/examples/Extending%20pgmpy.html) | <a target="_blank" href="https://colab.research.google.com/github/ankurankan/pgmpy/blob/dev/examples/Extending%20pgmpy.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>
+
+<br/>
+
+- Full List of Examples: https://github.com/pgmpy/pgmpy/tree/dev/examples
+- Tutorials: https://github.com/pgmpy/pgmpy_notebook/
+
+Citing
+======
+If you use `pgmpy` in your scientific work, please consider citing us:
+
+```
+Ankur Ankan, & Johannes Textor (2024). pgmpy: A Python Toolkit for Bayesian Networks. Journal of Machine Learning Research, 25(265), 1–8.
+```
+
+Bibtex:
+```
+@article{Ankan2024,
+  author  = {Ankur Ankan and Johannes Textor},
+  title   = {pgmpy: A Python Toolkit for Bayesian Networks},
+  journal = {Journal of Machine Learning Research},
+  year    = {2024},
+  volume  = {25},
+  number  = {265},
+  pages   = {1--8},
+  url     = {http://jmlr.org/papers/v25/23-0487.html}
+}
+```
+
+Development
+============
+
+Code
+----
+The latest codebase is available in the `dev` branch of the repository.
+
+Building from Source
+--------------------
+To install pgmpy from the source code:
+```
+$ git clone https://github.com/pgmpy/pgmpy
+$ cd pgmpy/
+$ pip install -r requirements.txt
+$ python setup.py install
+```
+
+To run the tests, you can use pytest:
+```
+$ pytest -v pgmpy
+```
+
+If you face any problems during installation let us know, via issues, mail or at our discord channel.
+
+Contributing
+------------
+Please feel free to report any issues on GitHub: https://github.com/pgmpy/pgmpy/issues.
+
+Before opening a pull request, please have a look at our [contributing guide](
+https://github.com/pgmpy/pgmpy/blob/dev/Contributing.md) If you face any
+problems in pull request, feel free to ask them on the mailing list or gitter.
+
+If you would like to implement any new features, please have a discussion about it before starting to work on it.
+If you are looking for some ideas for projects, we a list of **mentored projects** available at: https://github.com/pgmpy/pgmpy/wiki/Mentored-Projects.
+
+Building Documentation
+----------------------
+We use sphinx to build the documentation. Please refer: https://github.com/pgmpy/pgmpy/wiki/Maintenance-Guide#building-docs for steps to build docs locally.
+
+
+
+License
+=======
+pgmpy is released under MIT License. You can read about our license at [here](https://github.com/pgmpy/pgmpy/blob/dev/LICENSE)

testbed/pgmpy__pgmpy/examples/Linear Gaussian Bayesian Network.ipynb

@@ -0,0 +1,54 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 3,  8, 10])"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from pgmpy.factors.continuous import LinearGaussianCPD\n",
+    "import numpy as np\n",
+    "\n",
+    "mu = np.array([2, 3, 8, 10])\n",
+    "sigma = np.array([[2.3, 0, 0, 0], [0, 1.5, 0, 0], [0, 0, 1.7, 0], [0, 0, 0, 2]])\n",
+    "\n",
+    "cpd = LinearGaussianCPD(\"Y\", mu, sigma, [\"U1\", \"U2\", \"U3\"])\n",
+    "cpd.variable\n",
+    "cpd.evidence\n",
+    "cpd.beta_vector"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

testbed/pgmpy__pgmpy/examples/Monty Hall Problem.ipynb

@@ -0,0 +1,246 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Monty Hall Problem"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Problem Description:\n",
+    "The Monty Hall Problem is a very famous problem in Probability Theory. The question goes like:\n",
+    "\n",
+    "\n",
+    "Suppose you're on a game show, and you're given the choice of three doors: Behind one door is a car; behind the others, goats. You pick a door, say No. 1, and the host, who knows what's behind the doors, opens another door, say No. 3, which has a goat. He then says to you, \"Do you want to pick door No. 2?\" Is it to your advantage to switch your choice?\n",
+    "\n",
+    "By intution it seems that there shouldn't be any benefit of switching the door. But using Bayes' Theorem we can show that by switching the door the contestant has more chances of winning.\n",
+    "\n",
+    "You can also checkout the wikipedia page: https://en.wikipedia.org/wiki/Monty_Hall_problem"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Probabilistic Interpretetion:\n",
+    "So have 3 random variables Contestant $C \\in \\{1, 2, 3\\}$, Host $H \\in \\{1, 2, 3\\}$ and prize $P \\in \\{1, 2, 3 \\}$. The prize has been put randomly behind the doors therefore: $P(P=1) = P(P=2) = P(P=3) = \\frac{1}{3}$. Also, the contestant is going to choose the door randomly, therefore: $P(C=1) = P(C=2) = P(C=3) = \\frac{1}{3}$. For this problem we can build a Bayesian Network structure like:\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Image\n",
+    "\n",
+    "Image(\"images/monty.png\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "with the following CPDs:\n",
+    "\n",
+    "<pre>\n",
+    "\n",
+    "P(C):\n",
+    "+----------+----------+-----------+-----------+\n",
+    "|    C     |     0    |     1     |      2    |\n",
+    "+----------+----------+-----------+-----------+\n",
+    "|          |    0.33  |    0.33   |    0.33   |\n",
+    "+----------+----------+-----------+-----------+\n",
+    "\n",
+    "P(P):\n",
+    "+----------+----------+-----------+-----------+\n",
+    "|    P     |     0    |     1     |      2    |\n",
+    "+----------+----------+-----------+-----------+\n",
+    "|          |    0.33  |    0.33   |    0.33   |\n",
+    "+----------+----------+-----------+-----------+\n",
+    "\n",
+    "P(H | P, C):\n",
+    "+------+------+------+------+------+------+------+------+------+------+\n",
+    "|   C  |          0         |          1         |          2         |\n",
+    "+------+------+------+------+------+------+------+------+------+------+\n",
+    "|   P  |   0  |   1  |   2  |   0  |   1  |   2  |   0  |   1  |   2  |\n",
+    "+------+------+------+------+------+------+------+------+------+------+\n",
+    "|  H=0 |   0  |   0  |   0  |   0  |  0.5 |   1  |   0  |   1  |  0.5 | \n",
+    "+------+------+------+------+------+------+------+------+------+------+\n",
+    "|  H=1 |  0.5 |   0  |   1  |   0  |   0  |   0  |   1  |   0  |  0.5 |\n",
+    "+------+------+------+------+------+------+------+------+------+------+\n",
+    "|  H=2 |  0.5 |   1  |   0  |   1  |  0.5 |   0  |   0  |   0  |   0  |\n",
+    "+------+------+------+------+------+------+------+------+------+------+\n",
+    "</pre>\n",
+    "\n",
+    "Let's say that the contestant selected door 0 and the host opened door 2, we need to find the probability of the prize i.e. $P(P|H=2, C=0)$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Finding Elimination Order: : : 0it [00:19, ?it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[<TabularCPD representing P(C:3) at 0x7f580a175310>,\n",
+       " <TabularCPD representing P(P:3) at 0x7f58128ad520>,\n",
+       " <TabularCPD representing P(H:3 | C:3, P:3) at 0x7f580a175340>]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from pgmpy.models import BayesianNetwork\n",
+    "from pgmpy.factors.discrete import TabularCPD\n",
+    "\n",
+    "# Defining the network structure\n",
+    "model = BayesianNetwork([(\"C\", \"H\"), (\"P\", \"H\")])\n",
+    "\n",
+    "# Defining the CPDs:\n",
+    "cpd_c = TabularCPD(\"C\", 3, [[0.33], [0.33], [0.33]])\n",
+    "cpd_p = TabularCPD(\"P\", 3, [[0.33], [0.33], [0.33]])\n",
+    "cpd_h = TabularCPD(\n",
+    "    \"H\",\n",
+    "    3,\n",
+    "    [\n",
+    "        [0, 0, 0, 0, 0.5, 1, 0, 1, 0.5],\n",
+    "        [0.5, 0, 1, 0, 0, 0, 1, 0, 0.5],\n",
+    "        [0.5, 1, 0, 1, 0.5, 0, 0, 0, 0],\n",
+    "    ],\n",
+    "    evidence=[\"C\", \"P\"],\n",
+    "    evidence_card=[3, 3],\n",
+    ")\n",
+    "\n",
+    "# Associating the CPDs with the network structure.\n",
+    "model.add_cpds(cpd_c, cpd_p, cpd_h)\n",
+    "\n",
+    "# Some other methods\n",
+    "model.get_cpds()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# check_model check for the model structure and the associated CPD and returns True if everything is correct otherwise throws an exception\n",
+    "model.check_model()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Finding Elimination Order: : : 0it [00:00, ?it/s]\n",
+      "0it [00:00, ?it/s]\u001b[A"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+------+----------+\n",
+      "| P    |   phi(P) |\n",
+      "+======+==========+\n",
+      "| P(0) |   0.3333 |\n",
+      "+------+----------+\n",
+      "| P(1) |   0.6667 |\n",
+      "+------+----------+\n",
+      "| P(2) |   0.0000 |\n",
+      "+------+----------+\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Infering the posterior probability\n",
+    "from pgmpy.inference import VariableElimination\n",
+    "\n",
+    "infer = VariableElimination(model)\n",
+    "posterior_p = infer.query([\"P\"], evidence={\"C\": 0, \"H\": 2})\n",
+    "print(posterior_p)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We see that the posterior probability of having the prize behind door 1 is more that door 0. Therefore the contestant should switch the door."
+   ]
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": {},
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

testbed/pgmpy__pgmpy/funding.json

@@ -0,0 +1,52 @@
+{
+    "version": "v1.0.0",
+    "entity": {
+        "type": "individual",
+        "role": "maintainer",
+        "name": "Ankur Ankan",
+        "email": "ankurankan@gmail.com",
+        "description": "I lead the development and maintain the pgmpy package.",
+        "webpageUrl": {
+            "url": "https://github.com/pgmpy/pgmpy"
+        }
+    },
+    "projects": [{
+     "guid": "pgmpy",
+     "name": "pgmpy",
+     "description": "pgmpy is a Python package for learning (Structure and Parameter), inference (Probabilistic and Causal), and simulations in Bayesian Networks.",
+     "webpageUrl": {
+         "url": "https://github.com/pgmpy/pgmpy"
+     },
+     "repositoryUrl": {
+         "url": "https://github.com/pgmpy/pgmpy"
+     },
+     "licenses": ["spdx:MIT"],
+     "tags": ["machine-learning", "causal-inference", "bayesian-networks", "statistics", "python"]
+    }],
+
+    "funding": {
+        "channels": [{
+            "guid": "github",
+            "type": "other",
+            "address": "https://github.com/sponsors/pgmpy",
+            "description": "Github Sponsor"
+        },
+	{
+            "guid": "bank",
+            "type": "bank",
+            "description": "Please reach out for bank details"
+        }
+	],
+
+        "plans": [{
+            "guid": "dev-part",
+            "status": "active",
+            "name": "Part-time Developer",
+            "description": "This would go towards funding a part-time developer",
+            "amount": 25000,
+            "currency": "USD",
+            "frequency": "yearly",
+            "channels": ["github", "bank"]
+        }]
+    }
+}

testbed/pgmpy__pgmpy/meta.yaml

@@ -0,0 +1,42 @@
+{% set name = "pgmpy" %}
+{% set version = "0.1.26" %}
+
+package:
+  name: "{{ name|lower }}"
+  version: "{{ version }}"
+
+source:
+  url: https://pypi.io/packages/source/{{ name[0] }}/{{ name }}/{{ name }}-{{ version }}.tar.gz
+  #sha256: 668a34220342f211d4112c48b64ad696a3592b4758f9e3aac3553f968ed231b7
+
+build:
+  number: 0
+  script: "{{ PYTHON }} -m pip install . --ignore-installed -vv"
+
+requirements:
+  host:
+    - pip
+    - python
+    - pytorch
+  run:
+    - python
+    - networkx
+    - numpy
+    - scipy
+    - pandas
+    - pyparsing
+    - pytorch
+    - statsmodels
+    - tqdm
+    - joblib
+    - opt_einsum
+
+test:
+  imports:
+    - pgmpy
+
+about:
+  home: http://pgmpy.org/
+  license: MIT
+  license_family: MIT
+  summary: Python Library for Probabilistic Graphical Models

testbed/pgmpy__pgmpy/pgmpy/__init__.py

@@ -0,0 +1,4 @@
+from .global_vars import config
+
+__all__ = ["config", "logger"]
+__version__ = "0.1.26"

testbed/pgmpy__pgmpy/pgmpy/base/DAG.py

@@ -0,0 +1,1319 @@
+#!/usr/bin/env python3
+
+import itertools
+
+import networkx as nx
+import numpy as np
+import pandas as pd
+
+from pgmpy.base import UndirectedGraph
+from pgmpy.global_vars import logger
+from pgmpy.independencies import Independencies
+
+
+class DAG(nx.DiGraph):
+    """
+    Base class for all Directed Graphical Models.
+
+    Each node in the graph can represent either a random variable, `Factor`,
+    or a cluster of random variables. Edges in the graph represent the
+    dependencies between these.
+
+    Parameters
+    ----------
+    data: input graph
+        Data to initialize graph. If data=None (default) an empty graph is
+        created. The data can be an edge list or any Networkx graph object.
+
+    Examples
+    --------
+    Create an empty DAG with no nodes and no edges
+
+    >>> from pgmpy.base import DAG
+    >>> G = DAG()
+
+    G can be grown in several ways:
+
+    **Nodes:**
+
+    Add one node at a time:
+
+    >>> G.add_node(node='a')
+
+    Add the nodes from any container (a list, set or tuple or the nodes
+    from another graph).
+
+    >>> G.add_nodes_from(nodes=['a', 'b'])
+
+    **Edges:**
+
+    G can also be grown by adding edges.
+
+    Add one edge,
+
+    >>> G.add_edge(u='a', v='b')
+
+    a list of edges,
+
+    >>> G.add_edges_from(ebunch=[('a', 'b'), ('b', 'c')])
+
+    If some edges connect nodes not yet in the model, the nodes
+    are added automatically. There are no errors when adding
+    nodes or edges that already exist.
+
+    **Shortcuts:**
+
+    Many common graph features allow python syntax for speed reporting.
+
+    >>> 'a' in G     # check if node in graph
+    True
+    >>> len(G)  # number of nodes in graph
+    3
+    """
+
+    def __init__(self, ebunch=None, latents=set()):
+        super(DAG, self).__init__(ebunch)
+        self.latents = set(latents)
+        cycles = []
+        try:
+            cycles = list(nx.find_cycle(self))
+        except nx.NetworkXNoCycle:
+            pass
+        else:
+            out_str = "Cycles are not allowed in a DAG."
+            out_str += "\nEdges indicating the path taken for a loop: "
+            out_str += "".join([f"({u},{v}) " for (u, v) in cycles])
+            raise ValueError(out_str)
+
+    def add_node(self, node, weight=None, latent=False):
+        """
+        Adds a single node to the Graph.
+
+        Parameters
+        ----------
+        node: str, int, or any hashable python object.
+            The node to add to the graph.
+
+        weight: int, float
+            The weight of the node.
+
+        latent: boolean (default: False)
+            Specifies whether the variable is latent or not.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> G = DAG()
+        >>> G.add_node(node='A')
+        >>> sorted(G.nodes())
+        ['A']
+
+        Adding a node with some weight.
+        >>> G.add_node(node='B', weight=0.3)
+
+        The weight of these nodes can be accessed as:
+        >>> G.nodes['B']
+        {'weight': 0.3}
+        >>> G.nodes['A']
+        {'weight': None}
+        """
+
+        # Check for networkx 2.0 syntax
+        if isinstance(node, tuple) and len(node) == 2 and isinstance(node[1], dict):
+            node, attrs = node
+            if attrs.get("weight", None) is not None:
+                attrs["weight"] = weight
+        else:
+            attrs = {"weight": weight}
+
+        if latent:
+            self.latents.add(node)
+
+        super(DAG, self).add_node(node, weight=weight)
+
+    def add_nodes_from(self, nodes, weights=None, latent=False):
+        """
+        Add multiple nodes to the Graph.
+
+        **The behviour of adding weights is different than in networkx.
+
+        Parameters
+        ----------
+        nodes: iterable container
+            A container of nodes (list, dict, set, or any hashable python
+            object).
+
+        weights: list, tuple (default=None)
+            A container of weights (int, float). The weight value at index i
+            is associated with the variable at index i.
+
+        latent: list, tuple (default=False)
+            A container of boolean. The value at index i tells whether the
+            node at index i is latent or not.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> G = DAG()
+        >>> G.add_nodes_from(nodes=['A', 'B', 'C'])
+        >>> G.nodes()
+        NodeView(('A', 'B', 'C'))
+
+        Adding nodes with weights:
+        >>> G.add_nodes_from(nodes=['D', 'E'], weights=[0.3, 0.6])
+        >>> G.nodes['D']
+        {'weight': 0.3}
+        >>> G.nodes['E']
+        {'weight': 0.6}
+        >>> G.nodes['A']
+        {'weight': None}
+        """
+        nodes = list(nodes)
+
+        if isinstance(latent, bool):
+            latent = [latent] * len(nodes)
+
+        if weights:
+            if len(nodes) != len(weights):
+                raise ValueError(
+                    "The number of elements in nodes and weights" "should be equal."
+                )
+            for index in range(len(nodes)):
+                self.add_node(
+                    node=nodes[index], weight=weights[index], latent=latent[index]
+                )
+        else:
+            for index in range(len(nodes)):
+                self.add_node(node=nodes[index], latent=latent[index])
+
+    def add_edge(self, u, v, weight=None):
+        """
+        Add an edge between u and v.
+
+        The nodes u and v will be automatically added if they are
+        not already in the graph.
+
+        Parameters
+        ----------
+        u, v : nodes
+            Nodes can be any hashable Python object.
+
+        weight: int, float (default=None)
+            The weight of the edge
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> G = DAG()
+        >>> G.add_nodes_from(nodes=['Alice', 'Bob', 'Charles'])
+        >>> G.add_edge(u='Alice', v='Bob')
+        >>> G.nodes()
+        NodeView(('Alice', 'Bob', 'Charles'))
+        >>> G.edges()
+        OutEdgeView([('Alice', 'Bob')])
+
+        When the node is not already present in the graph:
+        >>> G.add_edge(u='Alice', v='Ankur')
+        >>> G.nodes()
+        NodeView(('Alice', 'Ankur', 'Bob', 'Charles'))
+        >>> G.edges()
+        OutEdgeView([('Alice', 'Bob'), ('Alice', 'Ankur')])
+
+        Adding edges with weight:
+        >>> G.add_edge('Ankur', 'Maria', weight=0.1)
+        >>> G.edge['Ankur']['Maria']
+        {'weight': 0.1}
+        """
+        super(DAG, self).add_edge(u, v, weight=weight)
+
+    def add_edges_from(self, ebunch, weights=None):
+        """
+        Add all the edges in ebunch.
+
+        If nodes referred in the ebunch are not already present, they
+        will be automatically added. Node names can be any hashable python
+        object.
+
+        **The behavior of adding weights is different than networkx.
+
+        Parameters
+        ----------
+        ebunch : container of edges
+            Each edge given in the container will be added to the graph.
+            The edges must be given as 2-tuples (u, v).
+
+        weights: list, tuple (default=None)
+            A container of weights (int, float). The weight value at index i
+            is associated with the edge at index i.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> G = DAG()
+        >>> G.add_nodes_from(nodes=['Alice', 'Bob', 'Charles'])
+        >>> G.add_edges_from(ebunch=[('Alice', 'Bob'), ('Bob', 'Charles')])
+        >>> G.nodes()
+        NodeView(('Alice', 'Bob', 'Charles'))
+        >>> G.edges()
+        OutEdgeView([('Alice', 'Bob'), ('Bob', 'Charles')])
+
+        When the node is not already in the model:
+        >>> G.add_edges_from(ebunch=[('Alice', 'Ankur')])
+        >>> G.nodes()
+        NodeView(('Alice', 'Bob', 'Charles', 'Ankur'))
+        >>> G.edges()
+        OutEdgeView([('Alice', 'Bob'), ('Bob', 'Charles'), ('Alice', 'Ankur')])
+
+        Adding edges with weights:
+        >>> G.add_edges_from([('Ankur', 'Maria'), ('Maria', 'Mason')],
+        ...                  weights=[0.3, 0.5])
+        >>> G.edge['Ankur']['Maria']
+        {'weight': 0.3}
+        >>> G.edge['Maria']['Mason']
+        {'weight': 0.5}
+        """
+        ebunch = list(ebunch)
+
+        if weights:
+            if len(ebunch) != len(weights):
+                raise ValueError(
+                    "The number of elements in ebunch and weights" "should be equal"
+                )
+            for index in range(len(ebunch)):
+                self.add_edge(ebunch[index][0], ebunch[index][1], weight=weights[index])
+        else:
+            for edge in ebunch:
+                self.add_edge(edge[0], edge[1])
+
+    def get_parents(self, node):
+        """
+        Returns a list of parents of node.
+
+        Throws an error if the node is not present in the graph.
+
+        Parameters
+        ----------
+        node: string, int or any hashable python object.
+            The node whose parents would be returned.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> G = DAG(ebunch=[('diff', 'grade'), ('intel', 'grade')])
+        >>> G.get_parents(node='grade')
+        ['diff', 'intel']
+        """
+        return list(self.predecessors(node))
+
+    def moralize(self):
+        """
+        Removes all the immoralities in the DAG and creates a moral
+        graph (UndirectedGraph).
+
+        A v-structure X->Z<-Y is an immorality if there is no directed edge
+        between X and Y.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> G = DAG(ebunch=[('diff', 'grade'), ('intel', 'grade')])
+        >>> moral_graph = G.moralize()
+        >>> moral_graph.edges()
+        EdgeView([('intel', 'grade'), ('intel', 'diff'), ('grade', 'diff')])
+        """
+        moral_graph = UndirectedGraph()
+        moral_graph.add_nodes_from(self.nodes())
+        moral_graph.add_edges_from(self.to_undirected().edges())
+
+        for node in self.nodes():
+            moral_graph.add_edges_from(
+                itertools.combinations(self.get_parents(node), 2)
+            )
+
+        return moral_graph
+
+    def get_leaves(self):
+        """
+        Returns a list of leaves of the graph.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> graph = DAG([('A', 'B'), ('B', 'C'), ('B', 'D')])
+        >>> graph.get_leaves()
+        ['C', 'D']
+        """
+        return [node for node, out_degree in self.out_degree_iter() if out_degree == 0]
+
+    def out_degree_iter(self, nbunch=None, weight=None):
+        if nx.__version__.startswith("1"):
+            return super(DAG, self).out_degree_iter(nbunch, weight)
+        else:
+            return iter(self.out_degree(nbunch, weight))
+
+    def in_degree_iter(self, nbunch=None, weight=None):
+        if nx.__version__.startswith("1"):
+            return super(DAG, self).in_degree_iter(nbunch, weight)
+        else:
+            return iter(self.in_degree(nbunch, weight))
+
+    def get_roots(self):
+        """
+        Returns a list of roots of the graph.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> graph = DAG([('A', 'B'), ('B', 'C'), ('B', 'D'), ('E', 'B')])
+        >>> graph.get_roots()
+        ['A', 'E']
+        """
+        return [
+            node for node, in_degree in dict(self.in_degree()).items() if in_degree == 0
+        ]
+
+    def get_children(self, node):
+        """
+        Returns a list of children of node.
+        Throws an error if the node is not present in the graph.
+
+        Parameters
+        ----------
+        node: string, int or any hashable python object.
+            The node whose children would be returned.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> g = DAG(ebunch=[('A', 'B'), ('C', 'B'), ('B', 'D'),
+                                      ('B', 'E'), ('B', 'F'), ('E', 'G')])
+        >>> g.get_children(node='B')
+        ['D', 'E', 'F']
+        """
+        return list(self.successors(node))
+
+    def get_independencies(self, latex=False, include_latents=False):
+        """
+        Computes independencies in the DAG, by checking minimal d-seperation.
+
+        Parameters
+        ----------
+        latex: boolean
+            If latex=True then latex string of the independence assertion
+            would be created.
+
+        include_latents: boolean
+            If True, includes latent variables in the independencies. Otherwise,
+            only generates independencies on observed variables.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> chain = DAG([('X', 'Y'), ('Y', 'Z')])
+        >>> chain.get_independencies()
+        (X \u27C2 Z | Y)
+        """
+        nodes = set(self.nodes())
+        if not include_latents:
+            nodes -= self.latents
+
+        independencies = Independencies()
+        for x, y in itertools.combinations(nodes, 2):
+            if not self.has_edge(x, y) and not self.has_edge(y, x):
+                minimal_separator = self.minimal_dseparator(
+                    start=x, end=y, include_latents=include_latents
+                )
+                if minimal_separator is not None:
+                    independencies.add_assertions([x, y, minimal_separator])
+
+        independencies = independencies.reduce()
+
+        if not latex:
+            return independencies
+        else:
+            return independencies.latex_string()
+
+    def local_independencies(self, variables):
+        """
+        Returns an instance of Independencies containing the local independencies
+        of each of the variables.
+
+        Parameters
+        ----------
+        variables: str or array like
+            variables whose local independencies are to be found.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> student = DAG()
+        >>> student.add_edges_from([('diff', 'grade'), ('intel', 'grade'),
+        >>>                         ('grade', 'letter'), ('intel', 'SAT')])
+        >>> ind = student.local_independencies('grade')
+        >>> ind
+        (grade \u27C2 SAT | diff, intel)
+        """
+
+        independencies = Independencies()
+        for variable in (
+            variables if isinstance(variables, (list, tuple)) else [variables]
+        ):
+            non_descendents = (
+                set(self.nodes())
+                - {variable}
+                - set(nx.dfs_preorder_nodes(self, variable))
+            )
+            parents = set(self.get_parents(variable))
+            if non_descendents - parents:
+                independencies.add_assertions(
+                    [variable, non_descendents - parents, parents]
+                )
+        return independencies
+
+    def is_iequivalent(self, model):
+        """
+        Checks whether the given model is I-equivalent
+
+        Two graphs G1 and G2 are said to be I-equivalent if they have same skeleton
+        and have same set of immoralities.
+
+        Parameters
+        ----------
+        model : A DAG object, for which you want to check I-equivalence
+
+        Returns
+        --------
+        I-equivalence: boolean
+            True if both are I-equivalent, False otherwise
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> G = DAG()
+        >>> G.add_edges_from([('V', 'W'), ('W', 'X'),
+        ...                   ('X', 'Y'), ('Z', 'Y')])
+        >>> G1 = DAG()
+        >>> G1.add_edges_from([('W', 'V'), ('X', 'W'),
+        ...                    ('X', 'Y'), ('Z', 'Y')])
+        >>> G.is_iequivalent(G1)
+        True
+
+        """
+        if not isinstance(model, DAG):
+            raise TypeError(
+                f"Model must be an instance of DAG. Got type: {type(model)}"
+            )
+
+        if (self.to_undirected().edges() == model.to_undirected().edges()) and (
+            self.get_immoralities() == model.get_immoralities()
+        ):
+            return True
+        return False
+
+    def get_immoralities(self):
+        """
+        Finds all the immoralities in the model
+        A v-structure X -> Z <- Y is an immorality if there is no direct edge between X and Y .
+
+        Returns
+        -------
+        Immoralities: set
+            A set of all the immoralities in the model
+
+        Examples
+        ---------
+        >>> from pgmpy.base import DAG
+        >>> student = DAG()
+        >>> student.add_edges_from([('diff', 'grade'), ('intel', 'grade'),
+        ...                         ('intel', 'SAT'), ('grade', 'letter')])
+        >>> student.get_immoralities()
+        {('diff', 'intel')}
+        """
+        immoralities = dict()
+        for node in self.nodes():
+            parent_pairs = []
+            for parents in itertools.combinations(self.predecessors(node), 2):
+                if not self.has_edge(parents[0], parents[1]) and not self.has_edge(
+                    parents[1], parents[0]
+                ):
+                    parent_pairs.append(tuple(sorted(parents)))
+            immoralities[node] = parent_pairs
+        return immoralities
+
+    def is_dconnected(self, start, end, observed=None, include_latents=False):
+        """
+        Returns True if there is an active trail (i.e. d-connection) between
+        `start` and `end` node given that `observed` is observed.
+
+        Parameters
+        ----------
+        start, end : int, str, any hashable python object.
+            The nodes in the DAG between which to check the d-connection/active trail.
+
+        observed : list, array-like (optional)
+            If given the active trail would be computed assuming these nodes to
+            be observed.
+
+        include_latents: boolean (default: False)
+            If true, latent variables are return as part of the active trail.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> student = DAG()
+        >>> student.add_nodes_from(['diff', 'intel', 'grades', 'letter', 'sat'])
+        >>> student.add_edges_from([('diff', 'grades'), ('intel', 'grades'), ('grades', 'letter'),
+        ...                         ('intel', 'sat')])
+        >>> student.is_dconnected('diff', 'intel')
+        False
+        >>> student.is_dconnected('grades', 'sat')
+        True
+        """
+        if (
+            end
+            in self.active_trail_nodes(
+                variables=start, observed=observed, include_latents=include_latents
+            )[start]
+        ):
+            return True
+        else:
+            return False
+
+    def minimal_dseparator(self, start, end, include_latents=False):
+        """
+        Finds the minimal d-separating set for `start` and `end`.
+
+        Parameters
+        ----------
+        start: node
+            The first node.
+
+        end: node
+            The second node.
+
+        include_latents: boolean (default: False)
+            If true, latent variables are consider for minimal d-seperator.
+
+        Examples
+        --------
+        >>> dag = DAG([('A', 'B'), ('B', 'C')])
+        >>> dag.minimal_dseparator(start='A', end='C')
+        {'B'}
+
+        References
+        ----------
+        [1] Algorithm 4, Page 10: Tian, Jin, Azaria Paz, and Judea Pearl. Finding minimal d-separators. Computer Science Department, University of California, 1998.
+        """
+        if (end in self.neighbors(start)) or (start in self.neighbors(end)):
+            raise ValueError(
+                "No possible separators because start and end are adjacent"
+            )
+        an_graph = self.get_ancestral_graph([start, end])
+        separator = set(
+            itertools.chain(self.predecessors(start), self.predecessors(end))
+        )
+
+        if not include_latents:
+            # If any of the parents were latents, take the latent's parent
+            while len(separator.intersection(self.latents)) != 0:
+                separator_copy = separator.copy()
+                for u in separator:
+                    if u in self.latents:
+                        separator_copy.remove(u)
+                        separator_copy.update(set(self.predecessors(u)))
+                separator = separator_copy
+
+        # Remove the start and end nodes in case it reaches there while removing latents.
+        separator.difference_update({start, end})
+
+        # If the initial set is not able to d-separate, no d-separator is possible.
+        if an_graph.is_dconnected(start, end, observed=separator):
+            return None
+
+        # Go through the separator set, remove one element and check if it remains
+        # a dseparating set.
+        minimal_separator = separator.copy()
+
+        for u in separator:
+            if not an_graph.is_dconnected(start, end, observed=minimal_separator - {u}):
+                minimal_separator.remove(u)
+
+        return minimal_separator
+
+    def get_markov_blanket(self, node):
+        """
+        Returns a markov blanket for a random variable. In the case
+        of Bayesian Networks, the markov blanket is the set of
+        node's parents, its children and its children's other parents.
+
+        Returns
+        -------
+        Markov Blanket: list
+            List of nodes in the markov blanket of `node`.
+
+        Parameters
+        ----------
+        node: string, int or any hashable python object.
+              The node whose markov blanket would be returned.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> from pgmpy.factors.discrete import TabularCPD
+        >>> G = DAG([('x', 'y'), ('z', 'y'), ('y', 'w'), ('y', 'v'), ('u', 'w'),
+                               ('s', 'v'), ('w', 't'), ('w', 'm'), ('v', 'n'), ('v', 'q')])
+        >>> G.get_markov_blanket('y')
+        ['s', 'w', 'x', 'u', 'z', 'v']
+        """
+        children = self.get_children(node)
+        parents = self.get_parents(node)
+        blanket_nodes = children + parents
+        for child_node in children:
+            blanket_nodes.extend(self.get_parents(child_node))
+        blanket_nodes = set(blanket_nodes)
+        blanket_nodes.discard(node)
+        return list(blanket_nodes)
+
+    def active_trail_nodes(self, variables, observed=None, include_latents=False):
+        """
+        Returns a dictionary with the given variables as keys and all the nodes reachable
+        from that respective variable as values.
+
+        Parameters
+        ----------
+        variables: str or array like
+            variables whose active trails are to be found.
+
+        observed : List of nodes (optional)
+            If given the active trails would be computed assuming these nodes to be
+            observed.
+
+        include_latents: boolean (default: False)
+            Whether to include the latent variables in the returned active trail nodes.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> student = DAG()
+        >>> student.add_nodes_from(['diff', 'intel', 'grades'])
+        >>> student.add_edges_from([('diff', 'grades'), ('intel', 'grades')])
+        >>> student.active_trail_nodes('diff')
+        {'diff': {'diff', 'grades'}}
+        >>> student.active_trail_nodes(['diff', 'intel'], observed='grades')
+        {'diff': {'diff', 'intel'}, 'intel': {'diff', 'intel'}}
+
+        References
+        ----------
+        Details of the algorithm can be found in 'Probabilistic Graphical Model
+        Principles and Techniques' - Koller and Friedman
+        Page 75 Algorithm 3.1
+        """
+        if observed:
+            if isinstance(observed, set):
+                observed = list(observed)
+
+            observed_list = (
+                observed if isinstance(observed, (list, tuple)) else [observed]
+            )
+        else:
+            observed_list = []
+        ancestors_list = self._get_ancestors_of(observed_list)
+
+        # Direction of flow of information
+        # up ->  from parent to child
+        # down -> from child to parent
+
+        active_trails = {}
+        for start in variables if isinstance(variables, list) else [variables]:
+            visit_list = set()
+            visit_list.add((start, "up"))
+            traversed_list = set()
+            active_nodes = set()
+            while visit_list:
+                node, direction = visit_list.pop()
+                if (node, direction) not in traversed_list:
+                    if node not in observed_list:
+                        active_nodes.add(node)
+                    traversed_list.add((node, direction))
+                    if direction == "up" and node not in observed_list:
+                        for parent in self.predecessors(node):
+                            visit_list.add((parent, "up"))
+                        for child in self.successors(node):
+                            visit_list.add((child, "down"))
+                    elif direction == "down":
+                        if node not in observed_list:
+                            for child in self.successors(node):
+                                visit_list.add((child, "down"))
+                        if node in ancestors_list:
+                            for parent in self.predecessors(node):
+                                visit_list.add((parent, "up"))
+            if include_latents:
+                active_trails[start] = active_nodes
+            else:
+                active_trails[start] = active_nodes - self.latents
+
+        return active_trails
+
+    def _get_ancestors_of(self, nodes):
+        """
+        Returns a dictionary of all ancestors of all the observed nodes including the
+        node itself.
+
+        Parameters
+        ----------
+        nodes: string, list-type
+            name of all the observed nodes
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> model = DAG([('D', 'G'), ('I', 'G'), ('G', 'L'),
+        ...                        ('I', 'L')])
+        >>> model._get_ancestors_of('G')
+        {'D', 'G', 'I'}
+        >>> model._get_ancestors_of(['G', 'I'])
+        {'D', 'G', 'I'}
+        """
+        if not isinstance(nodes, (list, tuple)):
+            nodes = [nodes]
+
+        for node in nodes:
+            if node not in self.nodes():
+                raise ValueError(f"Node {node} not in graph")
+
+        ancestors_list = set()
+        nodes_list = set(nodes)
+        while nodes_list:
+            node = nodes_list.pop()
+            if node not in ancestors_list:
+                nodes_list.update(self.predecessors(node))
+            ancestors_list.add(node)
+        return ancestors_list
+
+    # TODO: Commented out till the method is implemented.
+    #     def to_pdag(self):
+    #         """
+    #         Returns the PDAG (the equivalence class of DAG; also known as CPDAG) of the DAG.
+    #
+    #         Returns
+    #         -------
+    #         Partially oriented DAG: pgmpy.base.PDAG
+    #             An instance of pgmpy.base.PDAG.
+    #
+    #         Examples
+    #         --------
+    #
+    #         """
+    #         pass
+
+    def do(self, nodes, inplace=False):
+        """
+        Applies the do operator to the graph and returns a new DAG with the
+        transformed graph.
+
+        The do-operator, do(X = x) has the effect of removing all edges from
+        the parents of X and setting X to the given value x.
+
+        Parameters
+        ----------
+        nodes : list, array-like
+            The names of the nodes to apply the do-operator for.
+
+        inplace: boolean (default: False)
+            If inplace=True, makes the changes to the current object,
+            otherwise returns a new instance.
+
+        Returns
+        -------
+        Modified DAG: pgmpy.base.DAG
+            A new instance of DAG modified by the do-operator
+
+        Examples
+        --------
+        Initialize a DAG
+        >>> graph = DAG()
+        >>> graph.add_edges_from([('X', 'A'),
+        ...                       ('A', 'Y'),
+        ...                       ('A', 'B')])
+        >>> # Applying the do-operator will return a new DAG with the desired structure.
+        >>> graph_do_A = graph.do('A')
+        >>> # Which we can verify is missing the edges we would expect.
+        >>> graph_do_A.edges
+        OutEdgeView([('A', 'B'), ('A', 'Y')])
+
+        References
+        ----------
+        Causality: Models, Reasoning, and Inference, Judea Pearl (2000). p.70.
+        """
+        dag = self if inplace else self.copy()
+
+        if isinstance(nodes, (str, int)):
+            nodes = [nodes]
+        else:
+            nodes = list(nodes)
+
+        if not set(nodes).issubset(set(self.nodes())):
+            raise ValueError(
+                f"Nodes not found in the model: {set(nodes) - set(self.nodes)}"
+            )
+
+        for node in nodes:
+            parents = list(dag.predecessors(node))
+            for parent in parents:
+                dag.remove_edge(parent, node)
+        return dag
+
+    def get_ancestral_graph(self, nodes):
+        """
+        Returns the ancestral graph of the given `nodes`. The ancestral graph only
+        contains the nodes which are ancestors of atleast one of the variables in
+        node.
+
+        Parameters
+        ----------
+        node: iterable
+            List of nodes whose ancestral graph needs to be computed.
+
+        Returns
+        -------
+        Ancestral Graph: pgmpy.base.DAG
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> dag = DAG([('A', 'C'), ('B', 'C'), ('D', 'A'), ('D', 'B')])
+        >>> anc_dag = dag.get_ancestral_graph(nodes=['A', 'B'])
+        >>> anc_dag.edges()
+        OutEdgeView([('D', 'A'), ('D', 'B')])
+        """
+        return self.subgraph(nodes=self._get_ancestors_of(nodes=nodes))
+
+    def to_daft(
+        self,
+        node_pos="circular",
+        latex=True,
+        pgm_params={},
+        edge_params={},
+        node_params={},
+    ):
+        """
+        Returns a daft (https://docs.daft-pgm.org/en/latest/) object which can be rendered for
+        publication quality plots. The returned object's render method can be called to see the plots.
+
+        Parameters
+        ----------
+        node_pos: str or dict (default: circular)
+            If str: Must be one of the following: circular, kamada_kawai, planar, random, shell, sprint,
+                spectral, spiral. Please refer: https://networkx.org/documentation/stable//reference/drawing.html#module-networkx.drawing.layout for details on these layouts.
+
+            If dict should be of the form {node: (x coordinate, y coordinate)} describing the x and y coordinate of each
+            node.
+
+            If no argument is provided uses circular layout.
+
+        latex: boolean
+            Whether to use latex for rendering the node names.
+
+        pgm_params: dict (optional)
+            Any additional parameters that need to be passed to `daft.PGM` initializer.
+            Should be of the form: {param_name: param_value}
+
+        edge_params: dict (optional)
+            Any additional edge parameters that need to be passed to `daft.add_edge` method.
+            Should be of the form: {(u1, v1): {param_name: param_value}, (u2, v2): {...} }
+
+        node_params: dict (optional)
+            Any additional node parameters that need to be passed to `daft.add_node` method.
+            Should be of the form: {node1: {param_name: param_value}, node2: {...} }
+
+        Returns
+        -------
+        Daft object: daft.PGM object
+            Daft object for plotting the DAG.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> dag = DAG([('a', 'b'), ('b', 'c'), ('d', 'c')])
+        >>> dag.to_daft(node_pos={'a': (0, 0), 'b': (1, 0), 'c': (2, 0), 'd': (1, 1)})
+        <daft.PGM at 0x7fc756e936d0>
+        >>> dag.to_daft(node_pos="circular")
+        <daft.PGM at 0x7f9bb48c5eb0>
+        >>> dag.to_daft(node_pos="circular", pgm_params={'observed_style': 'inner'})
+        <daft.PGM at 0x7f9bb48b0bb0>
+        >>> dag.to_daft(node_pos="circular",
+        ...             edge_params={('a', 'b'): {'label': 2}},
+        ...             node_params={'a': {'shape': 'rectangle'}})
+        <daft.PGM at 0x7f9bb48b0bb0>
+        """
+        try:
+            from daft import PGM
+        except ImportError as e:
+            raise ImportError(
+                "Package daft required. Please visit: https://docs.daft-pgm.org/en/latest/ for installation instructions."
+            )
+
+        if isinstance(node_pos, str):
+            supported_layouts = {
+                "circular": nx.circular_layout,
+                "kamada_kawai": nx.kamada_kawai_layout,
+                "planar": nx.planar_layout,
+                "random": nx.random_layout,
+                "shell": nx.shell_layout,
+                "spring": nx.spring_layout,
+                "spectral": nx.spectral_layout,
+                "spiral": nx.spiral_layout,
+            }
+            if node_pos not in supported_layouts.keys():
+                raise ValueError(
+                    "Unknown node_pos argument. Please refer docstring for accepted values"
+                )
+            else:
+                node_pos = supported_layouts[node_pos](self)
+        elif isinstance(node_pos, dict):
+            for node in self.nodes():
+                if node not in node_pos.keys():
+                    raise ValueError(f"No position specified for {node}.")
+        else:
+            raise ValueError(
+                "Argument node_pos not valid. Please refer to the docstring."
+            )
+
+        daft_pgm = PGM(**pgm_params)
+        for node in self.nodes():
+            try:
+                extra_params = node_params[node]
+            except KeyError:
+                extra_params = dict()
+
+            if latex:
+                daft_pgm.add_node(
+                    node,
+                    rf"${node}$",
+                    node_pos[node][0],
+                    node_pos[node][1],
+                    observed=True,
+                    **extra_params,
+                )
+            else:
+                daft_pgm.add_node(
+                    node,
+                    f"{node}",
+                    node_pos[node][0],
+                    node_pos[node][1],
+                    observed=True,
+                    **extra_params,
+                )
+
+        for u, v in self.edges():
+            try:
+                extra_params = edge_params[(u, v)]
+            except KeyError:
+                extra_params = dict()
+            daft_pgm.add_edge(u, v, **extra_params)
+
+        return daft_pgm
+
+    @staticmethod
+    def get_random(n_nodes=5, edge_prob=0.5, node_names=None, latents=False, seed=None):
+        """
+        Returns a randomly generated DAG with `n_nodes` number of nodes with
+        edge probability being `edge_prob`.
+
+        Parameters
+        ----------
+        n_nodes: int
+            The number of nodes in the randomly generated DAG.
+
+        edge_prob: float
+            The probability of edge between any two nodes in the topologically
+            sorted DAG.
+
+        node_names: list (default: None)
+            A list of variables names to use in the random graph.
+            If None, the node names are integer values starting from 0.
+
+        latents: bool (default: False)
+            If True, includes latent variables in the generated DAG.
+
+        seed: int (default: None)
+            The seed for the random number generator.
+
+        Returns
+        -------
+        Random DAG: pgmpy.base.DAG
+            The randomly generated DAG.
+
+        Examples
+        --------
+        >>> from pgmpy.base import DAG
+        >>> random_dag = DAG.get_random(n_nodes=10, edge_prob=0.3)
+        >>> random_dag.nodes()
+        NodeView((0, 1, 2, 3, 4, 5, 6, 7, 8, 9))
+        >>> random_dag.edges()
+        OutEdgeView([(0, 6), (1, 6), (1, 7), (7, 9), (2, 5), (2, 7), (2, 8), (5, 9), (3, 7)])
+        """
+        # Step 1: Generate a matrix of 0 and 1. Prob of choosing 1 = edge_prob
+        gen = np.random.default_rng(seed=seed)
+        adj_mat = gen.choice(
+            [0, 1], size=(n_nodes, n_nodes), p=[1 - edge_prob, edge_prob]
+        )
+
+        # Step 2: Use the upper triangular part of the matrix as adjacency.
+        if node_names is None:
+            node_names = list(range(n_nodes))
+
+        adj_pd = pd.DataFrame(
+            np.triu(adj_mat, k=1), columns=node_names, index=node_names
+        )
+        nx_dag = nx.from_pandas_adjacency(adj_pd, create_using=nx.DiGraph)
+
+        dag = DAG(nx_dag)
+        dag.add_nodes_from(node_names)
+
+        if latents:
+            dag.latents = set(
+                gen.choice(dag.nodes(), gen.integers(low=0, high=len(dag.nodes())))
+            )
+        return dag
+
+    def to_graphviz(self):
+        """
+        Retuns a pygraphviz object for the DAG. pygraphviz is useful for
+        visualizing the network structure.
+
+        Examples
+        --------
+        >>> from pgmpy.utils import get_example_model
+        >>> model = get_example_model('alarm')
+        >>> model.to_graphviz()
+        <AGraph <Swig Object of type 'Agraph_t *' at 0x7fdea4cde040>>
+        >>> model.draw('model.png', prog='neato')
+        """
+        return nx.nx_agraph.to_agraph(self)
+
+    def fit(self, data, estimator=None, state_names=[], n_jobs=1, **kwargs):
+        """
+        Estimates the CPD for each variable based on a given data set.
+
+        Parameters
+        ----------
+        data: pandas DataFrame object
+            DataFrame object with column names identical to the variable names of the network.
+            (If some values in the data are missing the data cells should be set to `numpy.nan`.
+            Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+        estimator: Estimator class
+            One of:
+            - MaximumLikelihoodEstimator (default)
+            - BayesianEstimator: In this case, pass 'prior_type' and either 'pseudo_counts'
+            or 'equivalent_sample_size' as additional keyword arguments.
+            See `BayesianEstimator.get_parameters()` for usage.
+            - ExpectationMaximization
+
+        state_names: dict (optional)
+            A dict indicating, for each variable, the discrete set of states
+            that the variable can take. If unspecified, the observed values
+            in the data set are taken to be the only possible states.
+
+        n_jobs: int (default: 1)
+            Number of threads/processes to use for estimation. Using n_jobs > 1
+            for small models or datasets might be slower.
+
+        Returns
+        -------
+        Fitted Model: BayesianNetwork
+            Returns a BayesianNetwork object with learned CPDs.
+            The DAG structure is preserved, and parameters (CPDs) are added.
+            This allows the DAG to represent both the structure and the parameters of a Bayesian Network.
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> from pgmpy.models import BayesianNetwork
+        >>> from pgmpy.base import DAG
+        >>> data = pd.DataFrame(data={'A': [0, 0, 1], 'B': [0, 1, 0], 'C': [1, 1, 0]})
+        >>> model = DAG([('A', 'C'), ('B', 'C')])
+        >>> fitted_model = model.fit(data)
+        >>> fitted_model.get_cpds()
+        [<TabularCPD representing P(A:2) at 0x17945372c30>,
+        <TabularCPD representing P(B:2) at 0x17945a19760>,
+        <TabularCPD representing P(C:2 | A:2, B:2) at 0x17944f42690>]
+        """
+        from pgmpy.estimators import BaseEstimator, MaximumLikelihoodEstimator
+        from pgmpy.models import BayesianNetwork
+
+        if isinstance(self, BayesianNetwork):
+            bn = self
+        else:
+            bn = BayesianNetwork(self.edges())
+
+        if estimator is None:
+            estimator = MaximumLikelihoodEstimator
+        else:
+            if not issubclass(estimator, BaseEstimator):
+                raise TypeError("Estimator object should be a valid pgmpy estimator.")
+
+        _estimator = estimator(
+            bn,
+            data,
+            state_names=state_names,
+        )
+        cpds_list = _estimator.get_parameters(n_jobs=n_jobs, **kwargs)
+        bn.add_cpds(*cpds_list)
+        return bn
+
+
+class PDAG(nx.DiGraph):
+    """
+    Class for representing PDAGs (also known as CPDAG). PDAGs are the equivalence classes of
+    DAGs and contain both directed and undirected edges.
+
+    Note: In this class, undirected edges are represented using two edges in both direction i.e.
+    an undirected edge between X - Y is represented using X -> Y and X <- Y.
+    """
+
+    def __init__(self, directed_ebunch=[], undirected_ebunch=[], latents=[]):
+        """
+        Initializes a PDAG class.
+
+        Parameters
+        ----------
+        directed_ebunch: list, array-like of 2-tuples
+            List of directed edges in the PDAG.
+
+        undirected_ebunch: list, array-like of 2-tuples
+            List of undirected edges in the PDAG.
+
+        latents: list, array-like
+            List of nodes which are latent variables.
+
+        Returns
+        -------
+        An instance of the PDAG object.
+
+        Examples
+        --------
+        """
+        super(PDAG, self).__init__(
+            directed_ebunch
+            + undirected_ebunch
+            + [(Y, X) for (X, Y) in undirected_ebunch]
+        )
+        self.latents = set(latents)
+        self.directed_edges = set(directed_ebunch)
+        self.undirected_edges = set(undirected_ebunch)
+        # TODO: Fix the cycle issue
+        # import pdb; pdb.set_trace()
+        # try:
+        #     # Filter out undirected edges as they also form a cycle in
+        #     # themself when represented using directed edges.
+        #     cycles = filter(lambda t: len(t) > 2, nx.simple_cycles(self))
+        #     if cycles:
+        #         out_str = "Cycles are not allowed in a PDAG. "
+        #         out_str += "The following path forms a loop: "
+        #         out_str += "".join(["({u},{v}) ".format(u=u, v=v) for (u, v) in cycles])
+        #         raise ValueError(out_str)
+        # except nx.NetworkXNoCycle:
+        #     pass
+
+    def copy(self):
+        """
+        Returns a copy of the object instance.
+
+        Returns
+        -------
+        Copy of PDAG: pgmpy.dag.PDAG
+            Returns a copy of self.
+        """
+        return PDAG(
+            directed_ebunch=list(self.directed_edges.copy()),
+            undirected_ebunch=list(self.undirected_edges.copy()),
+            latents=self.latents,
+        )
+
+    def to_dag(self, required_edges=[]):
+        """
+        Returns one possible DAG which is represented using the PDAG.
+
+        Parameters
+        ----------
+        required_edges: list, array-like of 2-tuples
+            The list of edges that should be included in the DAG.
+
+        Returns
+        -------
+        Returns an instance of DAG.
+
+        Examples
+        --------
+
+        """
+        # Add required edges if it doesn't form a new v-structure or an opposite edge
+        # is already present in the network.
+        dag = DAG()
+        # Add all the nodes and the directed edges
+        dag.add_nodes_from(self.nodes())
+        dag.add_edges_from(self.directed_edges)
+        dag.latents = self.latents
+
+        pdag = self.copy()
+        while pdag.number_of_nodes() > 0:
+            # find node with (1) no directed outgoing edges and
+            #                (2) the set of undirected neighbors is either empty or
+            #                    undirected neighbors + parents of X are a clique
+            found = False
+            for X in pdag.nodes():
+                directed_outgoing_edges = set(pdag.successors(X)) - set(
+                    pdag.predecessors(X)
+                )
+                undirected_neighbors = set(pdag.successors(X)) & set(
+                    pdag.predecessors(X)
+                )
+                neighbors_are_clique = all(
+                    (
+                        pdag.has_edge(Y, Z)
+                        for Z in pdag.predecessors(X)
+                        for Y in undirected_neighbors
+                        if not Y == Z
+                    )
+                )
+
+                if not directed_outgoing_edges and (
+                    not undirected_neighbors or neighbors_are_clique
+                ):
+                    found = True
+                    # add all edges of X as outgoing edges to dag
+                    for Y in pdag.predecessors(X):
+                        dag.add_edge(Y, X)
+                    pdag.remove_node(X)
+                    break
+
+            if not found:
+                logger.warning(
+                    "PDAG has no faithful extension (= no oriented DAG with the "
+                    + "same v-structures as PDAG). Remaining undirected PDAG edges "
+                    + "oriented arbitrarily."
+                )
+                for X, Y in pdag.edges():
+                    if not dag.has_edge(Y, X):
+                        try:
+                            dag.add_edge(X, Y)
+                        except ValueError:
+                            pass
+                break
+        return dag
+
+    def to_graphviz(self):
+        """
+        Retuns a pygraphviz object for the DAG. pygraphviz is useful for
+        visualizing the network structure.
+
+        Examples
+        --------
+        >>> from pgmpy.utils import get_example_model
+        >>> model = get_example_model('alarm')
+        >>> model.to_graphviz()
+        <AGraph <Swig Object of type 'Agraph_t *' at 0x7fdea4cde040>>
+        """
+        return nx.nx_agraph.to_agraph(self)

testbed/pgmpy__pgmpy/pgmpy/base/UndirectedGraph.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+
+import itertools
+
+import networkx as nx
+
+
+class UndirectedGraph(nx.Graph):
+    """
+    Base class for all the Undirected Graphical models.
+
+    Each node in the graph can represent either a random variable, `Factor`,
+    or a cluster of random variables. Edges in the graph are interactions
+    between the nodes.
+
+    Parameters
+    ----------
+    data: input graph
+        Data to initialize graph. If data=None (default) an empty graph is
+        created. The data can be an edge list or any Networkx graph object.
+
+    Examples
+    --------
+    Create an empty UndirectedGraph with no nodes and no edges
+
+    >>> from pgmpy.base import UndirectedGraph
+    >>> G = UndirectedGraph()
+
+    G can be grown in several ways
+
+    **Nodes:**
+
+    Add one node at a time:
+
+    >>> G.add_node('a')
+
+    Add the nodes from any container (a list, set or tuple or the nodes
+    from another graph).
+
+    >>> G.add_nodes_from(['a', 'b'])
+
+    **Edges:**
+
+    G can also be grown by adding edges.
+
+    Add one edge,
+
+    >>> G.add_edge('a', 'b')
+
+    a list of edges,
+
+    >>> G.add_edges_from([('a', 'b'), ('b', 'c')])
+
+    If some edges connect nodes not yet in the model, the nodes
+    are added automatically.  There are no errors when adding
+    nodes or edges that already exist.
+
+    **Shortcuts:**
+
+    Many common graph features allow python syntax for speed reporting.
+
+    >>> 'a' in G     # check if node in graph
+    True
+    >>> len(G)  # number of nodes in graph
+    3
+    """
+
+    def __init__(self, ebunch=None):
+        super(UndirectedGraph, self).__init__(ebunch)
+
+    def add_node(self, node, weight=None):
+        """
+        Add a single node to the Graph.
+
+        Parameters
+        ----------
+        node: str, int, or any hashable python object.
+            The node to add to the graph.
+
+        weight: int, float
+            The weight of the node.
+
+        Examples
+        --------
+        >>> from pgmpy.base import UndirectedGraph
+        >>> G = UndirectedGraph()
+        >>> G.add_node(node='A')
+        >>> G.nodes()
+        NodeView(('A',))
+
+        Adding a node with some weight.
+        >>> G.add_node(node='B', weight=0.3)
+
+        The weight of these nodes can be accessed as:
+        >>> G.nodes['B']
+        {'weight': 0.3}
+        >>> G.nodes['A']
+        {'weight': None}
+        """
+        # Check for networkx 2.0 syntax
+        if isinstance(node, tuple) and len(node) == 2 and isinstance(node[1], dict):
+            node, attrs = node
+            if attrs.get("weight", None) is not None:
+                attrs["weight"] = weight
+        else:
+            attrs = {"weight": weight}
+        super(UndirectedGraph, self).add_node(node, weight=weight)
+
+    def add_nodes_from(self, nodes, weights=None):
+        """
+        Add multiple nodes to the Graph.
+
+        **The behaviour of adding weights is different than in networkx.
+
+        Parameters
+        ----------
+        nodes: iterable container
+            A container of nodes (list, dict, set, or any hashable python
+            object).
+
+        weights: list, tuple (default=None)
+            A container of weights (int, float). The weight value at index i
+            is associated with the variable at index i.
+
+        Examples
+        --------
+        >>> from pgmpy.base import UndirectedGraph
+        >>> G = UndirectedGraph()
+        >>> G.add_nodes_from(nodes=['A', 'B', 'C'])
+        >>> G.nodes()
+        NodeView(('A', 'B', 'C'))
+
+        Adding nodes with weights:
+        >>> G.add_nodes_from(nodes=['D', 'E'], weights=[0.3, 0.6])
+        >>> G.nodes['D']
+        {'weight': 0.3}
+        >>> G.nodes['E']
+        {'weight': 0.6}
+        >>> G.nodes['A']
+        {'weight': None}
+        """
+        nodes = list(nodes)
+
+        if weights:
+            if len(nodes) != len(weights):
+                raise ValueError(
+                    "The number of elements in nodes and weights" "should be equal."
+                )
+            for index in range(len(nodes)):
+                self.add_node(node=nodes[index], weight=weights[index])
+        else:
+            for node in nodes:
+                self.add_node(node=node)
+
+    def add_edge(self, u, v, weight=None):
+        """
+        Add an edge between u and v.
+
+        The nodes u and v will be automatically added if they are
+        not already in the graph.
+
+        Parameters
+        ----------
+        u, v : nodes
+            Nodes can be any hashable Python object.
+
+        weight: int, float (default=None)
+            The weight of the edge.
+
+        Examples
+        --------
+        >>> from pgmpy.base import UndirectedGraph
+        >>> G = UndirectedGraph()
+        >>> G.add_nodes_from(nodes=['Alice', 'Bob', 'Charles'])
+        >>> G.add_edge(u='Alice', v='Bob')
+        >>> G.nodes()
+        NodeView(('Alice', 'Bob', 'Charles'))
+        >>> G.edges()
+        EdgeView([('Alice', 'Bob')])
+
+        When the node is not already present in the graph:
+        >>> G.add_edge(u='Alice', v='Ankur')
+        >>> G.nodes()
+        NodeView('Alice', 'Ankur', 'Bob', 'Charles'))
+        >>> G.edges()
+        EdgeView([('Alice', 'Bob'), ('Alice', 'Ankur')])
+
+        Adding edges with weight:
+        >>> G.add_edge('Ankur', 'Maria', weight=0.1)
+        >>> G.edge['Ankur']['Maria']
+        {'weight': 0.1}
+        """
+        super(UndirectedGraph, self).add_edge(u, v, weight=weight)
+
+    def add_edges_from(self, ebunch, weights=None):
+        """
+        Add all the edges in ebunch.
+
+        If nodes referred in the ebunch are not already present, they
+        will be automatically added. Node names can be any hashable python
+        object.
+
+        **The behavior of adding weights is different than networkx.
+
+        Parameters
+        ----------
+        ebunch : container of edges
+            Each edge given in the container will be added to the graph.
+            The edges must be given as 2-tuples (u, v).
+
+        weights: list, tuple (default=None)
+            A container of weights (int, float). The weight value at index i
+            is associated with the edge at index i.
+
+        Examples
+        --------
+        >>> from pgmpy.base import UndirectedGraph
+        >>> G = UndirectedGraph()
+        >>> G.add_nodes_from(nodes=['Alice', 'Bob', 'Charles'])
+        >>> G.add_edges_from(ebunch=[('Alice', 'Bob'), ('Bob', 'Charles')])
+        >>> G.nodes()
+        NodeView(('Alice', 'Bob', 'Charles'))
+        >>> G.edges()
+        EdgeView([('Alice', 'Bob'), ('Bob', 'Charles')])
+
+        When the node is not already in the model:
+        >>> G.add_edges_from(ebunch=[('Alice', 'Ankur')])
+        >>> G.nodes()
+        NodeView(('Alice', 'Ankur', 'Charles', 'Bob'))
+        >>> G.edges()
+        EdgeView([('Alice', 'Bob'), ('Bob', 'Charles'), ('Alice', 'Ankur')])
+
+        Adding edges with weights:
+        >>> G.add_edges_from([('Ankur', 'Maria'), ('Maria', 'Mason')],
+        ...                  weights=[0.3, 0.5])
+        >>> G.edge['Ankur']['Maria']
+        {'weight': 0.3}
+        >>> G.edge['Maria']['Mason']
+        {'weight': 0.5}
+        """
+        ebunch = list(ebunch)
+
+        if weights:
+            if len(ebunch) != len(weights):
+                raise ValueError(
+                    "The number of elements in ebunch and weights" "should be equal"
+                )
+            for index in range(len(ebunch)):
+                self.add_edge(ebunch[index][0], ebunch[index][1], weight=weights[index])
+        else:
+            for edge in ebunch:
+                self.add_edge(edge[0], edge[1])
+
+    def is_clique(self, nodes):
+        """
+        Check if the given nodes form a clique.
+
+        Parameters
+        ----------
+        nodes: list, array-like
+            List of nodes to check if they are a part of any clique.
+
+        Examples
+        --------
+        >>> from pgmpy.base import UndirectedGraph
+        >>> G = UndirectedGraph(ebunch=[('A', 'B'), ('C', 'B'), ('B', 'D'),
+                                        ('B', 'E'), ('D', 'E'), ('E', 'F'),
+                                        ('D', 'F'), ('B', 'F')])
+        >>> G.is_clique(nodes=['A', 'B', 'C', 'D'])
+        False
+        >>> G.is_clique(nodes=['B', 'D', 'E', 'F'])
+        True
+
+        Since B, D, E and F are clique, any subset of these should also
+        be clique.
+        >>> G.is_clique(nodes=['D', 'E', 'B'])
+        True
+        """
+        for node1, node2 in itertools.combinations(nodes, 2):
+            if not self.has_edge(node1, node2):
+                return False
+        return True
+
+    def is_triangulated(self):
+        """
+        Checks whether the undirected graph is triangulated (also known
+        as chordal) or not.
+
+        Chordal Graph: A chordal graph is one in which all cycles of four
+                       or more vertices have a chord.
+
+        Examples
+        --------
+        >>> from pgmpy.base import UndirectedGraph
+        >>> G = UndirectedGraph()
+        >>> G.add_edges_from(ebunch=[('x1', 'x2'), ('x1', 'x3'),
+        ...                          ('x2', 'x4'), ('x3', 'x4')])
+        >>> G.is_triangulated()
+        False
+        >>> G.add_edge(u='x1', v='x4')
+        >>> G.is_triangulated()
+        True
+        """
+        return nx.is_chordal(self)

testbed/pgmpy__pgmpy/pgmpy/base/__init__.py

@@ -0,0 +1,4 @@
+from .UndirectedGraph import UndirectedGraph
+from .DAG import DAG, PDAG
+
+__all__ = ["UndirectedGraph", "DAG", "PDAG"]

testbed/pgmpy__pgmpy/pgmpy/estimators/EM.py

@@ -0,0 +1,295 @@
+from itertools import chain, product
+from math import log
+
+import numpy as np
+import pandas as pd
+from joblib import Parallel, delayed
+from tqdm.auto import tqdm
+
+from pgmpy import config
+from pgmpy.estimators import MaximumLikelihoodEstimator, ParameterEstimator
+from pgmpy.factors.discrete import TabularCPD
+from pgmpy.models import BayesianNetwork
+from pgmpy.base import DAG
+
+
+class ExpectationMaximization(ParameterEstimator):
+    """
+    Class used to compute parameters for a model using Expectation
+    Maximization (EM).
+
+    EM is an iterative algorithm commonly used for
+    estimation in the case when there are latent variables in the model.
+    The algorithm iteratively improves the parameter estimates maximizing
+    the likelihood of the given data.
+
+    Parameters
+    ----------
+    model: A pgmpy.models.BayesianNetwork instance
+
+    data: pandas DataFrame object
+        DataFrame object with column names identical to the variable names
+        of the network.  (If some values in the data are missing the data
+        cells should be set to `numpy.nan`.  Note that pandas converts each
+        column containing `numpy.nan`s to dtype `float`.)
+
+    state_names: dict (optional)
+        A dict indicating, for each variable, the discrete set of states
+        that the variable can take. If unspecified, the observed values in
+        the data set are taken to be the only possible states.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import pandas as pd
+    >>> from pgmpy.models import BayesianNetwork
+    >>> from pgmpy.estimators import ExpectationMaximization
+    >>> data = pd.DataFrame(np.random.randint(low=0, high=2, size=(1000, 5)),
+    ...                       columns=['A', 'B', 'C', 'D', 'E'])
+    >>> model = BayesianNetwork([('A', 'B'), ('C', 'B'), ('C', 'D'), ('B', 'E')])
+    >>> estimator = ExpectationMaximization(model, data)
+    """
+
+    def __init__(self, model, data, **kwargs):
+        if not isinstance(model, (DAG, BayesianNetwork)):
+            raise NotImplementedError(
+                "Expectation Maximization is only implemented for DAG or BayesianNetwork"
+            )
+
+        if isinstance(model, DAG):
+            model_bn = BayesianNetwork(model.edges())
+            model_bn.add_nodes_from(model.nodes())
+            model_bn.latents = model.latents
+            model = model_bn
+
+        super(ExpectationMaximization, self).__init__(model, data, **kwargs)
+        self.model_copy = self.model.copy()
+
+    def _get_log_likelihood(self, datapoint):
+        """
+        Computes the likelihood of a given datapoint. Goes through each
+        CPD matching the combination of states to get the value and multiplies
+        them together.
+        """
+        likelihood = 0
+        for cpd in self.model_copy.cpds:
+            scope = set(cpd.scope())
+            likelihood += log(
+                max(
+                    cpd.get_value(
+                        **{
+                            key: value
+                            for key, value in datapoint.items()
+                            if key in scope
+                        }
+                    ),
+                    1e-10,
+                )
+            )
+        return likelihood
+
+    def _parallel_compute_weights(
+        self, data_unique, latent_card, n_counts, offset, batch_size
+    ):
+        cache = []
+
+        for i in range(offset, min(offset + batch_size, data_unique.shape[0])):
+            v = list(product(*[range(card) for card in latent_card.values()]))
+            latent_combinations = np.array(v, dtype=int)
+            df = data_unique.iloc[[i] * latent_combinations.shape[0]].reset_index(
+                drop=True
+            )
+            for index, latent_var in enumerate(latent_card.keys()):
+                df[latent_var] = latent_combinations[:, index]
+            weights = np.e ** (
+                df.apply(lambda t: self._get_log_likelihood(dict(t)), axis=1)
+            )
+            df["_weight"] = (weights / weights.sum()) * n_counts[
+                tuple(data_unique.iloc[i])
+            ]
+            cache.append(df)
+
+        return pd.concat(cache, copy=False)
+
+    def _compute_weights(self, n_jobs, latent_card, batch_size):
+        """
+        For each data point, creates extra data points for each possible combination
+        of states of latent variables and assigns weights to each of them.
+        """
+
+        data_unique = self.data.drop_duplicates()
+        n_counts = (
+            self.data.groupby(list(self.data.columns), observed=True).size().to_dict()
+        )
+
+        cache = Parallel(n_jobs=n_jobs)(
+            delayed(self._parallel_compute_weights)(
+                data_unique, latent_card, n_counts, i, batch_size
+            )
+            for i in range(0, data_unique.shape[0], batch_size)
+        )
+
+        return pd.concat(cache, copy=False)
+
+    def _is_converged(self, new_cpds, atol=1e-08):
+        """
+        Checks if the values of `new_cpds` is within tolerance limits of current
+        model cpds.
+        """
+        for cpd in new_cpds:
+            if not cpd.__eq__(self.model_copy.get_cpds(node=cpd.scope()[0]), atol=atol):
+                return False
+        return True
+
+    def get_parameters(
+        self,
+        latent_card=None,
+        max_iter=100,
+        atol=1e-08,
+        n_jobs=1,
+        batch_size=1000,
+        seed=None,
+        init_cpds={},
+        show_progress=True,
+    ):
+        """
+        Method to estimate all model parameters (CPDs) using Expecation Maximization.
+
+        Parameters
+        ----------
+        latent_card: dict (default: None)
+            A dictionary of the form {latent_var: cardinality} specifying the
+            cardinality (number of states) of each latent variable. If None,
+            assumes `2` states for each latent variable.
+
+        max_iter: int (default: 100)
+            The maximum number of iterations the algorithm is allowed to run for.
+            If max_iter is reached, return the last value of parameters.
+
+        atol: int (default: 1e-08)
+            The absolute accepted tolerance for checking convergence. If the parameters
+            change is less than atol in an iteration, the algorithm will exit.
+
+        n_jobs: int (default: 1)
+            Number of jobs to run in parallel.
+            Using n_jobs > 1 for small models or datasets might be slower.
+
+        batch_size: int (default: 1000)
+            Number of data used to compute weights in a batch.
+
+        seed: int
+            The random seed to use for generating the intial values.
+
+        init_cpds: dict
+            A dictionary of the form {variable: instance of TabularCPD}
+            specifying the initial CPD values for the EM optimizer to start
+            with. If not specified, CPDs involving latent variables are
+            initialized randomly, and CPDs involving only observed variables are
+            initialized with their MLE estimates.
+
+        show_progress: boolean (default: True)
+            Whether to show a progress bar for iterations.
+
+        Returns
+        -------
+        Estimated paramters (CPDs): list
+            A list of estimated CPDs for the model.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import pandas as pd
+        >>> from pgmpy.models import BayesianNetwork
+        >>> from pgmpy.estimators import ExpectationMaximization as EM
+        >>> data = pd.DataFrame(np.random.randint(low=0, high=2, size=(1000, 3)),
+        ...                       columns=['A', 'C', 'D'])
+        >>> model = BayesianNetwork([('A', 'B'), ('C', 'B'), ('C', 'D')], latents={'B'})
+        >>> estimator = EM(model, data)
+        >>> estimator.get_parameters(latent_card={'B': 3})
+        [<TabularCPD representing P(C:2) at 0x7f7b534251d0>,
+        <TabularCPD representing P(B:3 | C:2, A:2) at 0x7f7b4dfd4da0>,
+        <TabularCPD representing P(A:2) at 0x7f7b4dfd4fd0>,
+        <TabularCPD representing P(D:2 | C:2) at 0x7f7b4df822b0>]
+        """
+        # Step 1: Parameter checks
+        if latent_card is None:
+            latent_card = {var: 2 for var in self.model_copy.latents}
+
+        # Step 2: Create structures/variables to be used later.
+        n_states_dict = {key: len(value) for key, value in self.state_names.items()}
+        n_states_dict.update(latent_card)
+        for var in self.model_copy.latents:
+            self.state_names[var] = list(range(n_states_dict[var]))
+
+        # Step 3: Initialize CPDs.
+        # Step 3.1: Learn the CPDs of variables which don't involve
+        #           latent variables using MLE if their init_cpd is
+        #           not specified.
+        fixed_cpds = []
+        fixed_cpd_vars = (
+            set(self.model.nodes())
+            - self.model.latents
+            - set(chain(*[self.model.get_children(var) for var in self.model.latents]))
+            - set(init_cpds.keys())
+        )
+
+        mle = MaximumLikelihoodEstimator.__new__(MaximumLikelihoodEstimator)
+        mle.model = self.model
+        mle.data = self.data
+        mle.state_names = self.state_names
+
+        for var in fixed_cpd_vars:
+            fixed_cpds.append(mle.estimate_cpd(var))
+
+        # Step 3.2: Randomly initialize the CPDs involving latent variables if init_cpds is not specified.
+        latent_cpds = []
+        vars_with_latents = (
+            set(self.model_copy.nodes()) - fixed_cpd_vars - set(init_cpds.keys())
+        )
+        for node in vars_with_latents:
+            parents = list(self.model_copy.predecessors(node))
+            latent_cpds.append(
+                TabularCPD.get_random(
+                    variable=node,
+                    evidence=parents,
+                    cardinality={
+                        var: n_states_dict[var] for var in chain([node], parents)
+                    },
+                    state_names={
+                        var: self.state_names[var] for var in chain([node], parents)
+                    },
+                    seed=seed,
+                )
+            )
+
+        self.model_copy.add_cpds(
+            *list(chain(fixed_cpds, latent_cpds, list(init_cpds.values())))
+        )
+
+        if show_progress and config.SHOW_PROGRESS:
+            pbar = tqdm(total=max_iter)
+
+        mle.model = self.model_copy
+        # Step 4: Run the EM algorithm.
+        for _ in range(max_iter):
+            # Step 4.1: E-step: Expands the dataset and computes the likelihood of each
+            #           possible state of latent variables.
+            weighted_data = self._compute_weights(n_jobs, latent_card, batch_size)
+            # Step 4.2: M-step: Uses the weights of the dataset to do a weighted MLE.
+            new_cpds = fixed_cpds.copy()
+            mle.data = weighted_data
+            for var in vars_with_latents.union(set(init_cpds.keys())):
+                new_cpds.append(mle.estimate_cpd(var, weighted=True))
+
+            # Step 4.3: Check of convergence and max_iter
+            if self._is_converged(new_cpds, atol=atol):
+                if show_progress and config.SHOW_PROGRESS:
+                    pbar.close()
+                return new_cpds
+
+            else:
+                self.model_copy.cpds = new_cpds
+                if show_progress and config.SHOW_PROGRESS:
+                    pbar.update(1)
+
+        return new_cpds

testbed/pgmpy__pgmpy/pgmpy/estimators/ExhaustiveSearch.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+
+from itertools import combinations
+
+import networkx as nx
+
+from pgmpy.base import DAG
+from pgmpy.estimators import K2, ScoreCache, StructureEstimator
+from pgmpy.global_vars import logger
+from pgmpy.utils.mathext import powerset
+
+
+class ExhaustiveSearch(StructureEstimator):
+    """
+    Search class for exhaustive searches over all DAGs with a given set of variables.
+    Takes a `StructureScore`-Instance as parameter; `estimate` finds the model with maximal score.
+
+    Parameters
+    ----------
+    data: pandas DataFrame object
+        dataframe object where each column represents one variable.
+        (If some values in the data are missing the data cells should be set to `numpy.NaN`.
+        Note that pandas converts each column containing `numpy.NaN`s to dtype `float`.)
+
+    scoring_method: Instance of a `StructureScore`-subclass (`K2` is used as default)
+        An instance of `K2`, `BDeu`, `BIC` or 'AIC'.
+        This score is optimized during structure estimation by the `estimate`-method.
+
+    state_names: dict (optional)
+        A dict indicating, for each variable, the discrete set of states (or values)
+        that the variable can take. If unspecified, the observed values in the data set
+        are taken to be the only possible states.
+
+    use_caching: boolean
+        If True, uses caching of score for faster computation.
+        Note: Caching only works for scoring methods which are decomposable. Can
+        give wrong results in case of custom scoring methods.
+    """
+
+    def __init__(self, data, scoring_method=None, use_cache=True, **kwargs):
+        if scoring_method is not None:
+            if use_cache:
+                self.scoring_method = ScoreCache.ScoreCache(scoring_method, data)
+            else:
+                self.scoring_method = scoring_method
+        else:
+            self.scoring_method = ScoreCache.ScoreCache(K2(data, **kwargs), data)
+
+        super(ExhaustiveSearch, self).__init__(data, **kwargs)
+
+    def all_dags(self, nodes=None):
+        """
+        Computes all possible directed acyclic graphs with a given set of nodes,
+        sparse ones first. `2**(n*(n-1))` graphs need to be searched, given `n` nodes,
+        so this is likely not feasible for n>6. This is a generator.
+
+        Parameters
+        ----------
+        nodes: list of nodes for the DAGs (optional)
+            A list of the node names that the generated DAGs should have.
+            If not provided, nodes are taken from data.
+
+        Returns
+        -------
+        dags: Generator object for nx.DiGraphs
+            Generator that yields all acyclic nx.DiGraphs, ordered by number of edges. Empty DAG first.
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> from pgmpy.estimators import ExhaustiveSearch
+        >>> s = ExhaustiveSearch(pd.DataFrame(data={'Temperature': [23, 19],
+                                                    'Weather': ['sunny', 'cloudy'],
+                                                    'Humidity': [65, 75]}))
+        >>> list(s.all_dags())
+        [<networkx.classes.digraph.DiGraph object at 0x7f6955216438>,
+         <networkx.classes.digraph.DiGraph object at 0x7f6955216518>,
+        ....
+        >>> [dag.edges() for dag in s.all_dags()]
+        [[], [('Humidity', 'Temperature')], [('Humidity', 'Weather')],
+        [('Temperature', 'Weather')], [('Temperature', 'Humidity')],
+        ....
+        [('Weather', 'Humidity'), ('Weather', 'Temperature'), ('Temperature', 'Humidity')]]
+
+        """
+        if nodes is None:
+            nodes = sorted(self.state_names.keys())
+        if len(nodes) > 6:
+            logger.info("Generating all DAGs of n nodes likely not feasible for n>6!")
+            logger.info(
+                "Attempting to search through {n} graphs".format(
+                    n=2 ** (len(nodes) * (len(nodes) - 1))
+                )
+            )
+
+        edges = list(combinations(nodes, 2))  # n*(n-1) possible directed edges
+        edges.extend([(y, x) for x, y in edges])
+        all_graphs = powerset(edges)  # 2^(n*(n-1)) graphs
+
+        for graph_edges in all_graphs:
+            graph = nx.DiGraph(graph_edges)
+            graph.add_nodes_from(nodes)
+            if nx.is_directed_acyclic_graph(graph):
+                yield graph
+
+    def all_scores(self):
+        """
+        Computes a list of DAGs and their structure scores, ordered by score.
+
+        Returns
+        -------
+        A list of (score, dag) pairs: list
+            A list of (score, dag)-tuples, where score is a float and model a acyclic nx.DiGraph.
+            The list is ordered by score values.
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>> from pgmpy.estimators import ExhaustiveSearch, K2
+        >>> # create random data sample with 3 variables, where B and C are identical:
+        >>> data = pd.DataFrame(np.random.randint(0, 5, size=(5000, 2)), columns=list('AB'))
+        >>> data['C'] = data['B']
+        >>> searcher = ExhaustiveSearch(data, scoring_method=K2(data))
+        >>> for score, model in searcher.all_scores():
+        ...   print("{0}\t{1}".format(score, model.edges()))
+        -24234.44977974726      [('A', 'B'), ('A', 'C')]
+        -24234.449760691063     [('A', 'B'), ('C', 'A')]
+        -24234.449760691063     [('A', 'C'), ('B', 'A')]
+        -24203.700955937973     [('A', 'B')]
+        -24203.700955937973     [('A', 'C')]
+        -24203.700936881774     [('B', 'A')]
+        -24203.700936881774     [('C', 'A')]
+        -24203.700936881774     [('B', 'A'), ('C', 'A')]
+        -24172.952132128685     []
+        -16597.30920265254      [('A', 'B'), ('A', 'C'), ('B', 'C')]
+        -16597.30920265254      [('A', 'B'), ('A', 'C'), ('C', 'B')]
+        -16597.309183596342     [('A', 'B'), ('C', 'A'), ('C', 'B')]
+        -16597.309183596342     [('A', 'C'), ('B', 'A'), ('B', 'C')]
+        -16566.560378843253     [('A', 'B'), ('C', 'B')]
+        -16566.560378843253     [('A', 'C'), ('B', 'C')]
+        -16268.324549347722     [('A', 'B'), ('B', 'C')]
+        -16268.324549347722     [('A', 'C'), ('C', 'B')]
+        -16268.324530291524     [('B', 'A'), ('B', 'C')]
+        -16268.324530291524     [('B', 'C'), ('C', 'A')]
+        -16268.324530291524     [('B', 'A'), ('C', 'B')]
+        -16268.324530291524     [('C', 'A'), ('C', 'B')]
+        -16268.324530291524     [('B', 'A'), ('B', 'C'), ('C', 'A')]
+        -16268.324530291524     [('B', 'A'), ('C', 'A'), ('C', 'B')]
+        -16237.575725538434     [('B', 'C')]
+        -16237.575725538434     [('C', 'B')]
+        """
+
+        scored_dags = sorted(
+            [(self.scoring_method.score(dag), dag) for dag in self.all_dags()],
+            key=lambda x: x[0],
+        )
+        return scored_dags
+
+    def estimate(self):
+        """
+        Estimates the `DAG` structure that fits best to the given data set,
+        according to the scoring method supplied in the constructor.
+        Exhaustively searches through all models. Only estimates network structure, no parametrization.
+
+        Returns
+        -------
+        Estimated Model: pgmpy.base.DAG
+            A `DAG` with maximal score.
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>> from pgmpy.estimators import ExhaustiveSearch
+        >>> # create random data sample with 3 variables, where B and C are identical:
+        >>> data = pd.DataFrame(np.random.randint(0, 5, size=(5000, 2)), columns=list('AB'))
+        >>> data['C'] = data['B']
+        >>> est = ExhaustiveSearch(data)
+        >>> best_model = est.estimate()
+        >>> best_model
+        <pgmpy.base.DAG.DAG object at 0x7f695c535470>
+        >>> best_model.edges()
+        [('B', 'C')]
+        """
+
+        best_dag = max(self.all_dags(), key=self.scoring_method.score)
+
+        best_model = DAG()
+        best_model.add_nodes_from(sorted(best_dag.nodes()))
+        best_model.add_edges_from(sorted(best_dag.edges()))
+        return best_model

testbed/pgmpy__pgmpy/pgmpy/estimators/GES.py

@@ -0,0 +1,240 @@
+from itertools import combinations
+
+import networkx as nx
+import numpy as np
+
+from pgmpy import config
+from pgmpy.base import DAG
+from pgmpy.estimators import (
+    AIC,
+    BIC,
+    K2,
+    AICCondGauss,
+    AICGauss,
+    BDeu,
+    BDs,
+    BICCondGauss,
+    BICGauss,
+    LogLikelihoodCondGauss,
+    LogLikelihoodGauss,
+    ScoreCache,
+    StructureEstimator,
+    StructureScore,
+)
+from pgmpy.global_vars import logger
+
+
+class GES(StructureEstimator):
+    """
+    Implementation of Greedy Equivalence Search (GES) causal discovery / structure learning algorithm.
+
+    GES is a score-based casual discovery / structure learning algorithm that works in three phases:
+        1. Forward phase: New edges are added such that the model score improves.
+        2. Backward phase: Edges are removed from the model such that the model score improves.
+        3. Edge flipping phase: Edge orientations are flipped such that model score improves.
+
+    Parameters
+    ----------
+    data: pandas DataFrame object
+        dataframe object where each column represents one variable.
+        (If some values in the data are missing the data cells should be set to `numpy.nan`.
+        Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+    use_caching: boolean
+        If True, uses caching of score for faster computation.
+        Note: Caching only works for scoring methods which are decomposable. Can
+        give wrong results in case of custom scoring methods.
+
+    References
+    ----------
+    Chickering, David Maxwell. "Optimal structure identification with greedy search." Journal of machine learning research 3.Nov (2002): 507-554.
+    """
+
+    def __init__(self, data, use_cache=True, **kwargs):
+        self.use_cache = use_cache
+
+        super(GES, self).__init__(data=data, **kwargs)
+
+    def _legal_edge_additions(self, current_model):
+        """
+        Returns a list of all edges that can be added to the graph such that it remains a DAG.
+        """
+        edges = []
+        for u, v in combinations(current_model.nodes(), 2):
+            if not (current_model.has_edge(u, v) or current_model.has_edge(v, u)):
+                if not nx.has_path(current_model, v, u):
+                    edges.append((u, v))
+                if not nx.has_path(current_model, u, v):
+                    edges.append((v, u))
+        return edges
+
+    def _legal_edge_flips(self, current_model):
+        """
+        Returns a list of all the edges in the `current_model` that can be flipped such that the model
+        remains a DAG.
+        """
+        potential_flips = []
+        edges = list(current_model.edges())
+        for u, v in edges:
+            current_model.remove_edge(u, v)
+            if not nx.has_path(current_model, u, v):
+                potential_flips.append((v, u))
+
+            # Restore the edge to get to the original model
+            current_model.add_edge(u, v)
+        return potential_flips
+
+    def estimate(self, scoring_method="bic-d", min_improvement=1e-6, debug=False):
+        """
+        Estimates the DAG from the data.
+
+        Parameters
+        ----------
+        scoring_method: str or StructureScore instance
+            The score to be optimized during structure estimation.  Supported
+            structure scores: k2, bdeu, bds, bic-d, aic-d, ll-g, aic-g, bic-g,
+            ll-cg, aic-cg, bic-cg. Also accepts a custom score, but it should
+            be an instance of `StructureScore`.
+
+        min_improvement: float
+            The operation (edge addition, removal, or flipping) would only be performed if the
+            model score improves by atleast `min_improvement`.
+
+        Returns
+        -------
+        Estimated model: pgmpy.base.DAG
+            A `DAG` at a (local) score maximum.
+
+        Examples
+        --------
+        >>> # Simulate some sample data from a known model to learn the model structure from
+        >>> from pgmpy.utils import get_example_model
+        >>> model = get_example_model('alarm')
+        >>> df = model.simulate(int(1e3))
+
+        >>> # Learn the model structure using GES algorithm from `df`
+        >>> from pgmpy.estimators import GES
+        >>> est = GES(data)
+        >>> dag = est.estimate(scoring_method='bic-d')
+        >>> len(dag.nodes())
+        37
+        >>> len(dag.edges())
+        45
+        """
+
+        # Step 0: Initial checks and setup for arguments
+        supported_methods = {
+            "k2": K2,
+            "bdeu": BDeu,
+            "bds": BDs,
+            "bic-d": BIC,
+            "aic-d": AIC,
+            "ll-g": LogLikelihoodGauss,
+            "aic-g": AICGauss,
+            "bic-g": BICGauss,
+            "ll-cg": LogLikelihoodCondGauss,
+            "aic-cg": AICCondGauss,
+            "bic-cg": BICCondGauss,
+        }
+        if isinstance(scoring_method, str):
+            if scoring_method.lower() in [
+                "k2score",
+                "bdeuscore",
+                "bdsscore",
+                "bicscore",
+                "aicscore",
+            ]:
+                raise ValueError(
+                    f"The scoring method names have been changed. Please refer the documentation."
+                )
+            elif scoring_method.lower() not in list(supported_methods.keys()):
+                raise ValueError(
+                    f"Unknown scoring method. Please refer documentation for a list of supported score metrics."
+                )
+        elif not isinstance(scoring_method, StructureScore):
+            raise ValueError(
+                "scoring_method should either be one of k2score, bdeuscore, bicscore, bdsscore, aicscore, or an instance of StructureScore"
+            )
+
+        if isinstance(scoring_method, str):
+            score = supported_methods[scoring_method.lower()](data=self.data)
+        else:
+            score = scoring_method
+
+        if self.use_cache:
+            score_fn = ScoreCache(score, self.data).local_score
+        else:
+            score_fn = score.local_score
+
+        # Step 1: Initialize an empty model.
+        current_model = DAG()
+        current_model.add_nodes_from(list(self.data.columns))
+
+        # Step 2: Forward step: Iteratively add edges till score stops improving.
+        while True:
+            potential_edges = self._legal_edge_additions(current_model)
+            score_deltas = np.zeros(len(potential_edges))
+            for index, (u, v) in enumerate(potential_edges):
+                current_parents = current_model.get_parents(v)
+                score_delta = score_fn(v, current_parents + [u]) - score_fn(
+                    v, current_parents
+                )
+                score_deltas[index] = score_delta
+
+            if (len(potential_edges) == 0) or (np.all(score_deltas < min_improvement)):
+                break
+
+            edge_to_add = potential_edges[np.argmax(score_deltas)]
+            current_model.add_edge(edge_to_add[0], edge_to_add[1])
+            if debug:
+                logger.info(
+                    f"Adding edge {edge_to_add[0]} -> {edge_to_add[1]}. Improves score by: {score_deltas.max()}"
+                )
+
+        # Step 3: Backward Step: Iteratively remove edges till score stops improving.
+        while True:
+            potential_removals = list(current_model.edges())
+            score_deltas = np.zeros(len(potential_removals))
+
+            for index, (u, v) in enumerate(potential_removals):
+                current_parents = current_model.get_parents(v)
+                score_deltas[index] = score_fn(
+                    v, [node for node in current_parents if node != u]
+                ) - score_fn(v, current_parents)
+            if (len(potential_removals) == 0) or (
+                np.all(score_deltas < min_improvement)
+            ):
+                break
+            edge_to_remove = potential_removals[np.argmax(score_deltas)]
+            current_model.remove_edge(edge_to_remove[0], edge_to_remove[1])
+            if debug:
+                logger.info(
+                    f"Removing edge {edge_to_remove[0]} -> {edge_to_remove[1]}. Improves score by: {score_deltas.max()}"
+                )
+
+        # Step 4: Flip Edges: Iteratively try to flip edges till score stops improving.
+        while True:
+            potential_flips = self._legal_edge_flips(current_model)
+            score_deltas = np.zeros(len(potential_flips))
+            for index, (u, v) in enumerate(potential_flips):
+                v_parents = current_model.get_parents(v)
+                u_parents = current_model.get_parents(u)
+                score_deltas[index] = (
+                    score_fn(v, v_parents + [u]) - score_fn(v, v_parents)
+                ) + (
+                    score_fn(u, [node for node in u_parents if node != v])
+                    - score_fn(u, u_parents)
+                )
+
+            if (len(potential_flips) == 0) or (np.all(score_deltas < min_improvement)):
+                break
+            edge_to_flip = potential_flips[np.argmax(score_deltas)]
+            current_model.remove_edge(edge_to_flip[1], edge_to_flip[0])
+            current_model.add_edge(edge_to_flip[0], edge_to_flip[1])
+            if debug:
+                logger.info(
+                    f"Fliping edge {edge_to_flip[1]} -> {edge_to_flip[0]}. Improves score by: {score_deltas.max()}"
+                )
+
+        # Step 5: Return the model.
+        return current_model

testbed/pgmpy__pgmpy/pgmpy/estimators/HillClimbSearch.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python
+from collections import deque
+from itertools import permutations
+
+import networkx as nx
+from tqdm.auto import trange
+
+from pgmpy import config
+from pgmpy.base import DAG
+from pgmpy.estimators import (
+    AIC,
+    BIC,
+    K2,
+    AICCondGauss,
+    AICGauss,
+    BDeu,
+    BDs,
+    BICCondGauss,
+    BICGauss,
+    LogLikelihoodCondGauss,
+    LogLikelihoodGauss,
+    ScoreCache,
+    StructureEstimator,
+    StructureScore,
+)
+
+
+class HillClimbSearch(StructureEstimator):
+    """
+    Class for heuristic hill climb searches for DAGs, to learn
+    network structure from data. `estimate` attempts to find a model with optimal score.
+
+    Parameters
+    ----------
+    data: pandas DataFrame object
+        dataframe object where each column represents one variable.
+        (If some values in the data are missing the data cells should be set to `numpy.nan`.
+        Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+    state_names: dict (optional)
+        A dict indicating, for each variable, the discrete set of states (or values)
+        that the variable can take. If unspecified, the observed values in the data set
+        are taken to be the only possible states.
+
+    use_caching: boolean
+        If True, uses caching of score for faster computation.
+        Note: Caching only works for scoring methods which are decomposable. Can
+        give wrong results in case of custom scoring methods.
+
+    References
+    ----------
+    Koller & Friedman, Probabilistic Graphical Models - Principles and Techniques, 2009
+    Section 18.4.3 (page 811ff)
+    """
+
+    def __init__(self, data, use_cache=True, **kwargs):
+        self.use_cache = use_cache
+
+        super(HillClimbSearch, self).__init__(data, **kwargs)
+
+    def _legal_operations(
+        self,
+        model,
+        score,
+        structure_score,
+        tabu_list,
+        max_indegree,
+        black_list,
+        white_list,
+        fixed_edges,
+    ):
+        """Generates a list of legal (= not in tabu_list) graph modifications
+        for a given model, together with their score changes. Possible graph modifications:
+        (1) add, (2) remove, or (3) flip a single edge. For details on scoring
+        see Koller & Friedman, Probabilistic Graphical Models, Section 18.4.3.3 (page 818).
+        If a number `max_indegree` is provided, only modifications that keep the number
+        of parents for each node below `max_indegree` are considered. A list of
+        edges can optionally be passed as `black_list` or `white_list` to exclude those
+        edges or to limit the search.
+        """
+
+        tabu_list = set(tabu_list)
+
+        # Step 1: Get all legal operations for adding edges.
+        potential_new_edges = (
+            set(permutations(self.variables, 2))
+            - set(model.edges())
+            - set([(Y, X) for (X, Y) in model.edges()])
+        )
+
+        for X, Y in potential_new_edges:
+            # Check if adding (X, Y) will create a cycle.
+            if not nx.has_path(model, Y, X):
+                operation = ("+", (X, Y))
+                if (
+                    (operation not in tabu_list)
+                    and ((X, Y) not in black_list)
+                    and ((X, Y) in white_list)
+                ):
+                    old_parents = model.get_parents(Y)
+                    new_parents = old_parents + [X]
+                    if len(new_parents) <= max_indegree:
+                        score_delta = score(Y, new_parents) - score(Y, old_parents)
+                        score_delta += structure_score("+")
+                        yield (operation, score_delta)
+
+        # Step 2: Get all legal operations for removing edges
+        for X, Y in model.edges():
+            operation = ("-", (X, Y))
+            if (operation not in tabu_list) and ((X, Y) not in fixed_edges):
+                old_parents = model.get_parents(Y)
+                new_parents = [var for var in old_parents if var != X]
+                score_delta = score(Y, new_parents) - score(Y, old_parents)
+                score_delta += structure_score("-")
+                yield (operation, score_delta)
+
+        # Step 3: Get all legal operations for flipping edges
+        for X, Y in model.edges():
+            # Check if flipping creates any cycles
+            if not any(
+                map(lambda path: len(path) > 2, nx.all_simple_paths(model, X, Y))
+            ):
+                operation = ("flip", (X, Y))
+                if (
+                    ((operation not in tabu_list) and ("flip", (Y, X)) not in tabu_list)
+                    and ((X, Y) not in fixed_edges)
+                    and ((Y, X) not in black_list)
+                    and ((Y, X) in white_list)
+                ):
+                    old_X_parents = model.get_parents(X)
+                    old_Y_parents = model.get_parents(Y)
+                    new_X_parents = old_X_parents + [Y]
+                    new_Y_parents = [var for var in old_Y_parents if var != X]
+                    if len(new_X_parents) <= max_indegree:
+                        score_delta = (
+                            score(X, new_X_parents)
+                            + score(Y, new_Y_parents)
+                            - score(X, old_X_parents)
+                            - score(Y, old_Y_parents)
+                        )
+                        score_delta += structure_score("flip")
+                        yield (operation, score_delta)
+
+    def estimate(
+        self,
+        scoring_method="k2",
+        start_dag=None,
+        fixed_edges=set(),
+        tabu_length=100,
+        max_indegree=None,
+        black_list=None,
+        white_list=None,
+        epsilon=1e-4,
+        max_iter=1e6,
+        show_progress=True,
+    ):
+        """
+        Performs local hill climb search to estimates the `DAG` structure that
+        has optimal score, according to the scoring method supplied. Starts at
+        model `start_dag` and proceeds by step-by-step network modifications
+        until a local maximum is reached. Only estimates network structure, no
+        parametrization.
+
+        Parameters
+        ----------
+        scoring_method: str or StructureScore instance
+            The score to be optimized during structure estimation.  Supported
+            structure scores: k2, bdeu, bds, bic-d, aic-d, ll-g, aic-g, bic-g,
+            ll-cg, aic-cg, bic-cg. Also accepts a custom score, but it should
+            be an instance of `StructureScore`.
+
+        start_dag: DAG instance
+            The starting point for the local search. By default, a completely
+            disconnected network is used.
+
+        fixed_edges: iterable
+            A list of edges that will always be there in the final learned model.
+            The algorithm will add these edges at the start of the algorithm and
+            will never change it.
+
+        tabu_length: int
+            If provided, the last `tabu_length` graph modifications cannot be reversed
+            during the search procedure. This serves to enforce a wider exploration
+            of the search space. Default value: 100.
+
+        max_indegree: int or None
+            If provided and unequal None, the procedure only searches among models
+            where all nodes have at most `max_indegree` parents. Defaults to None.
+
+        black_list: list or None
+            If a list of edges is provided as `black_list`, they are excluded from the search
+            and the resulting model will not contain any of those edges. Default: None
+
+        white_list: list or None
+            If a list of edges is provided as `white_list`, the search is limited to those
+            edges. The resulting model will then only contain edges that are in `white_list`.
+            Default: None
+
+        epsilon: float (default: 1e-4)
+            Defines the exit condition. If the improvement in score is less than `epsilon`,
+            the learned model is returned.
+
+        max_iter: int (default: 1e6)
+            The maximum number of iterations allowed. Returns the learned model when the
+            number of iterations is greater than `max_iter`.
+
+        Returns
+        -------
+        Estimated model: pgmpy.base.DAG
+            A `DAG` at a (local) score maximum.
+
+        Examples
+        --------
+        >>> # Simulate some sample data from a known model to learn the model structure from
+        >>> from pgmpy.utils import get_example_model
+        >>> model = get_example_model('alarm')
+        >>> df = model.simulate(int(1e3))
+
+        >>> # Learn the model structure using HillClimbSearch algorithm from `df`
+        >>> from pgmpy.estimators import HillClimbSearch
+        >>> est = HillClimbSearch(data)
+        >>> dag = est.estimate(scoring_method='bic-d')
+        >>> len(dag.nodes())
+        37
+        >>> len(dag.edges())
+        45
+        """
+
+        # Step 1: Initial checks and setup for arguments
+        # Step 1.1: Check scoring_method
+        supported_methods = {
+            "k2": K2,
+            "bdeu": BDeu,
+            "bds": BDs,
+            "bic-d": BIC,
+            "aic-d": AIC,
+            "ll-g": LogLikelihoodGauss,
+            "aic-g": AICGauss,
+            "bic-g": BICGauss,
+            "ll-cg": LogLikelihoodCondGauss,
+            "aic-cg": AICCondGauss,
+            "bic-cg": BICCondGauss,
+        }
+
+        if isinstance(scoring_method, str):
+            if scoring_method.lower() in [
+                "k2score",
+                "bdeuscore",
+                "bdsscore",
+                "bicscore",
+                "aicscore",
+            ]:
+                raise ValueError(
+                    f"The scoring method names have been changed. Please refer the documentation."
+                )
+            elif scoring_method.lower() not in list(supported_methods.keys()):
+                raise ValueError(
+                    f"Unknown scoring method. Please refer documentation for a list of supported score metrics."
+                )
+        elif not isinstance(scoring_method, StructureScore):
+            raise ValueError(
+                "scoring_method should either be one of k2score, bdeuscore, bicscore, bdsscore, aicscore, or an instance of StructureScore"
+            )
+
+        if isinstance(scoring_method, str):
+            score = supported_methods[scoring_method.lower()](data=self.data)
+        else:
+            score = scoring_method
+
+        if self.use_cache:
+            score_fn = ScoreCache.ScoreCache(score, self.data).local_score
+        else:
+            score_fn = score.local_score
+
+        # Step 1.2: Check the start_dag
+        if start_dag is None:
+            start_dag = DAG()
+            start_dag.add_nodes_from(self.variables)
+        elif not isinstance(start_dag, DAG) or not set(start_dag.nodes()) == set(
+            self.variables
+        ):
+            raise ValueError(
+                "'start_dag' should be a DAG with the same variables as the data set, or 'None'."
+            )
+
+        # Step 1.3: Check fixed_edges
+        if not hasattr(fixed_edges, "__iter__"):
+            raise ValueError("fixed_edges must be an iterable")
+        else:
+            fixed_edges = set(fixed_edges)
+            start_dag.add_edges_from(fixed_edges)
+            if not nx.is_directed_acyclic_graph(start_dag):
+                raise ValueError(
+                    "fixed_edges creates a cycle in start_dag. Please modify either fixed_edges or start_dag."
+                )
+
+        # Step 1.4: Check black list and white list
+        black_list = set() if black_list is None else set(black_list)
+        white_list = (
+            set([(u, v) for u in self.variables for v in self.variables])
+            if white_list is None
+            else set(white_list)
+        )
+
+        # Step 1.5: Initialize max_indegree, tabu_list, and progress bar
+        if max_indegree is None:
+            max_indegree = float("inf")
+
+        tabu_list = deque(maxlen=tabu_length)
+        current_model = start_dag
+
+        if show_progress and config.SHOW_PROGRESS:
+            iteration = trange(int(max_iter))
+        else:
+            iteration = range(int(max_iter))
+
+        # Step 2: For each iteration, find the best scoring operation and
+        #         do that to the current model. If no legal operation is
+        #         possible, sets best_operation=None.
+        for _ in iteration:
+            best_operation, best_score_delta = max(
+                self._legal_operations(
+                    current_model,
+                    score_fn,
+                    score.structure_prior_ratio,
+                    tabu_list,
+                    max_indegree,
+                    black_list,
+                    white_list,
+                    fixed_edges,
+                ),
+                key=lambda t: t[1],
+                default=(None, None),
+            )
+
+            if best_operation is None or best_score_delta < epsilon:
+                break
+            elif best_operation[0] == "+":
+                current_model.add_edge(*best_operation[1])
+                tabu_list.append(("-", best_operation[1]))
+            elif best_operation[0] == "-":
+                current_model.remove_edge(*best_operation[1])
+                tabu_list.append(("+", best_operation[1]))
+            elif best_operation[0] == "flip":
+                X, Y = best_operation[1]
+                current_model.remove_edge(X, Y)
+                current_model.add_edge(Y, X)
+                tabu_list.append(best_operation)
+
+        # Step 3: Return if no more improvements or maximum iterations reached.
+        return current_model

testbed/pgmpy__pgmpy/pgmpy/estimators/LinearModel.py

@@ -0,0 +1,33 @@
+import statsmodels.api as sm
+from statsmodels.api import OLS, GLS, WLS
+
+
+class LinearEstimator(object):
+    """
+    A simple linear model built on statmodels.
+    """
+
+    def __init__(self, graph, estimator_type="linear", **kwargs):
+        self._supported_models = {"linear": OLS, "OLS": OLS, "GLS": GLS, "WLS": WLS}
+        if estimator_type not in self._supported_models.keys():
+            raise NotImplementedError(
+                "We currently only support OLS, GLS, and WLS. Please specify which you would like to use."
+            )
+        else:
+            self.estimator = self._supported_models[estimator_type]
+
+    def _model(self, X, Y, Z, data, **kwargs):
+        exog = sm.add_constant(data[[X] + list(Z)])
+        endog = data[Y]
+        return self.estimator(endog=endog, exog=exog, **kwargs)
+
+    def fit(self, X, Y, Z, data, **kwargs):
+        self.estimator = self._model(X, Y, Z, data, **kwargs).fit()
+        self.ate = self.estimator.params[X]
+        return self
+
+    def _get_ate(self):
+        return self.ate
+
+    def summary(self):
+        return self.estimator.summary()

testbed/pgmpy__pgmpy/pgmpy/estimators/MLE.py

@@ -0,0 +1,293 @@
+# coding:utf-8
+
+from itertools import chain
+
+import numpy as np
+from joblib import Parallel, delayed
+
+from pgmpy.estimators import ParameterEstimator
+from pgmpy.factors import FactorDict
+from pgmpy.factors.discrete import TabularCPD
+from pgmpy.models import BayesianNetwork, JunctionTree
+from pgmpy.base import DAG
+
+
+class MaximumLikelihoodEstimator(ParameterEstimator):
+    """
+    Class used to compute parameters for a model using Maximum Likelihood Estimation.
+
+    Parameters
+    ----------
+    model: A pgmpy.models.BayesianNetwork or pgmpy.models.JunctionTree instance
+
+    data: pandas DataFrame object
+        DataFrame object with column names identical to the variable names of the network.
+        (If some values in the data are missing the data cells should be set to `numpy.nan`.
+        Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+    state_names: dict (optional)
+        A dict indicating, for each variable, the discrete set of states
+        that the variable can take. If unspecified, the observed values
+        in the data set are taken to be the only possible states.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import pandas as pd
+    >>> from pgmpy.models import BayesianNetwork
+    >>> from pgmpy.estimators import MaximumLikelihoodEstimator
+    >>> data = pd.DataFrame(np.random.randint(low=0, high=2, size=(1000, 5)),
+    ...                       columns=['A', 'B', 'C', 'D', 'E'])
+    >>> model = BayesianNetwork([('A', 'B'), ('C', 'B'), ('C', 'D'), ('B', 'E')])
+    >>> estimator = MaximumLikelihoodEstimator(model, data)
+    """
+
+    def __init__(self, model, data, **kwargs):
+        if not isinstance(model, (BayesianNetwork, JunctionTree, DAG)):
+            raise NotImplementedError(
+                "Maximum Likelihood Estimate is only implemented for BayesianNetwork, JunctionTree, and DAG"
+            )
+
+        if isinstance(model, (DAG, BayesianNetwork)):
+            if len(model.latents) > 0:
+                raise ValueError(
+                    f"Found latent variables: {model.latents}. Maximum Likelihood doesn't support latent variables, please use ExpectationMaximization."
+                )
+
+            elif set(model.nodes()) > set(data.columns):
+                raise ValueError(
+                    f"Nodes detected in the model that are not present in the dataset: {set(model.nodes) - set(data.columns)}. "
+                    "Refine the model so that all parameters can be estimated from the data."
+                )
+
+            if isinstance(model, JunctionTree):
+                if len(set(data.columns) - set(chain(*model.nodes()))) != 0:
+                    raise ValueError(
+                        f"Nodes detected in the JunctionTree that are not present in the dataset: {set(data.columns) - set(chain(*model.nodes()))} "
+                        "Refine the model to ensure all parameters can be estimated."
+                    )
+
+        super(MaximumLikelihoodEstimator, self).__init__(model, data, **kwargs)
+
+    def get_parameters(self, n_jobs=1, weighted=False):
+        """
+        Method to estimate the model parameters using Maximum Likelihood Estimation.
+
+        Parameters
+        ----------
+        n_jobs: int (default: 1)
+            Number of jobs to run in parallel. Default: 1 uses all the processors.
+            Using n_jobs > 1 for small models might be slower.
+
+        weighted: bool
+            If weighted=True, the data must contain a `_weight` column specifying the
+            weight of each datapoint (row). If False, assigns an equal weight to each
+            datapoint.
+
+        Returns
+        -------
+        Estimated parameters: list or pgmpy.factors.FactorDict
+            List of pgmpy.factors.discrete.TabularCPDs, one for each variable of the model
+            Or a FactorDict representing potential values of a Junction Tree
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import pandas as pd
+        >>> from pgmpy.models import BayesianNetwork
+        >>> from pgmpy.estimators import MaximumLikelihoodEstimator
+        >>> values = pd.DataFrame(np.random.randint(low=0, high=2, size=(1000, 4)),
+        ...                       columns=['A', 'B', 'C', 'D'])
+        >>> model = BayesianNetwork([('A', 'B'), ('C', 'B'), ('C', 'D')])
+        >>> estimator = MaximumLikelihoodEstimator(model, values)
+        >>> estimator.get_parameters()
+        [<TabularCPD representing P(C:2) at 0x7f7b534251d0>,
+        <TabularCPD representing P(B:2 | C:2, A:2) at 0x7f7b4dfd4da0>,
+        <TabularCPD representing P(A:2) at 0x7f7b4dfd4fd0>,
+        <TabularCPD representing P(D:2 | C:2) at 0x7f7b4df822b0>]
+        """
+
+        if isinstance(self.model, JunctionTree):
+            return self.estimate_potentials()
+
+        parameters = Parallel(n_jobs=n_jobs)(
+            delayed(self.estimate_cpd)(node, weighted) for node in self.model.nodes()
+        )
+        # TODO: A hacky solution to return correct value for the chosen backend. Ref #1675
+        parameters = [p.copy() for p in parameters]
+
+        return parameters
+
+    def estimate_cpd(self, node, weighted=False):
+        """
+        Method to estimate the CPD for a given variable.
+
+        Parameters
+        ----------
+        node: int, string (any hashable python object)
+            The name of the variable for which the CPD is to be estimated.
+
+        weighted: bool
+            If weighted=True, the data must contain a `_weight` column specifying the
+            weight of each datapoint (row). If False, assigns an equal weight to each
+            datapoint.
+
+        Returns
+        -------
+        Estimated CPD: pgmpy.factors.discrete.TabularCPD
+            Estimated CPD for `node`.
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> from pgmpy.models import BayesianNetwork
+        >>> from pgmpy.estimators import MaximumLikelihoodEstimator
+        >>> data = pd.DataFrame(data={'A': [0, 0, 1], 'B': [0, 1, 0], 'C': [1, 1, 0]})
+        >>> model = BayesianNetwork([('A', 'C'), ('B', 'C')])
+        >>> cpd_A = MaximumLikelihoodEstimator(model, data).estimate_cpd('A')
+        >>> print(cpd_A)
+        ╒══════╤══════════╕
+        │ A(0) │ 0.666667 │
+        ├──────┼──────────┤
+        │ A(1) │ 0.333333 │
+        ╘══════╧══════════╛
+        >>> cpd_C = MaximumLikelihoodEstimator(model, data).estimate_cpd('C')
+        >>> print(cpd_C)
+        ╒══════╤══════╤══════╤══════╤══════╕
+        │ A    │ A(0) │ A(0) │ A(1) │ A(1) │
+        ├──────┼──────┼──────┼──────┼──────┤
+        │ B    │ B(0) │ B(1) │ B(0) │ B(1) │
+        ├──────┼──────┼──────┼──────┼──────┤
+        │ C(0) │ 0.0  │ 0.0  │ 1.0  │ 0.5  │
+        ├──────┼──────┼──────┼──────┼──────┤
+        │ C(1) │ 1.0  │ 1.0  │ 0.0  │ 0.5  │
+        ╘══════╧══════╧══════╧══════╧══════╛
+        """
+
+        state_counts = self.state_counts(node, weighted=weighted)
+
+        # if a column contains only `0`s (no states observed for some configuration
+        # of parents' states) fill that column uniformly instead
+        state_counts.iloc[:, (state_counts.values == 0).all(axis=0)] = 1.0
+
+        parents = sorted(self.model.get_parents(node))
+        parents_cardinalities = [len(self.state_names[parent]) for parent in parents]
+        node_cardinality = len(self.state_names[node])
+
+        # Get the state names for the CPD
+        state_names = {node: list(state_counts.index)}
+        if parents:
+            state_names.update(
+                {
+                    state_counts.columns.names[i]: list(state_counts.columns.levels[i])
+                    for i in range(len(parents))
+                }
+            )
+
+        cpd = TabularCPD(
+            node,
+            node_cardinality,
+            np.array(state_counts),
+            evidence=parents,
+            evidence_card=parents_cardinalities,
+            state_names={var: self.state_names[var] for var in chain([node], parents)},
+        )
+        cpd.normalize()
+        return cpd
+
+    def estimate_potentials(self):
+        """
+        Implements Iterative Proportional Fitting to estimate potentials specifically
+        for a Decomposable Undirected Graphical Model. Decomposability is enforced
+        by using a Junction Tree.
+
+        Returns
+        -------
+        Estimated potentials: pgmpy.factors.FactorDict
+            Estimated potentials for the entire graphical model.
+
+        References
+        ---------
+        [1] Kevin P. Murphy, ML Machine Learning - A Probabilistic Perspective
+            Algorithm 19.2 Iterative Proportional Fitting algorithm for tabular MRFs & Section 19.5.7.4 IPF for decomposable graphical models.
+        [2] Eric P. Xing, Meng Song, Li Zhou, Probabilistic Graphical Models 10-708, Spring 2014.
+            https://www.cs.cmu.edu/~epxing/Class/10708-14/scribe_notes/scribe_note_lecture8.pdf.
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> from pgmpy.models import JunctionTree
+        >>> from pgmpy.estimators import MaximumLikelihoodEstimator
+        >>> data = pd.DataFrame(data={'A': [0, 0, 1], 'B': [0, 1, 0], 'C': [1, 1, 0]})
+        >>> model = JunctionTree()
+        >>> model.add_edges_from([(("A", "C"), ("B", "C"))])
+        >>> potentials = MaximumLikelihoodEstimator(model, data).estimate_potentials()
+        >>> print(potentials[("A", "C")])
+        +------+------+------------+
+        | A    | C    |   phi(A,C) |
+        +======+======+============+
+        | A(0) | C(0) |     0.0000 |
+        +------+------+------------+
+        | A(0) | C(1) |     0.6667 |
+        +------+------+------------+
+        | A(1) | C(0) |     0.3333 |
+        +------+------+------------+
+        | A(1) | C(1) |     0.0000 |
+        +------+------+------------+
+        >>> print(potentials[("B", "C")])
+        +------+------+------------+
+        | B    | C    |   phi(B,C) |
+        +======+======+============+
+        | B(0) | C(0) |     1.0000 |
+        +------+------+------------+
+        | B(0) | C(1) |     0.5000 |
+        +------+------+------------+
+        | B(1) | C(0) |     0.0000 |
+        +------+------+------------+
+        | B(1) | C(1) |     0.5000 |
+        +------+------+------------+
+        """
+        if not isinstance(self.model, JunctionTree):
+            raise NotImplementedError(
+                "Iterative Proportional Fitting is only implemented for Junction Trees."
+            )
+
+        if not hasattr(self.model, "clique_beliefs"):
+            raise NotImplementedError(
+                "A model containing clique beliefs is required to estimate parameters."
+            )
+
+        clique_beliefs = self.model.clique_beliefs
+
+        if not isinstance(clique_beliefs, FactorDict):
+            raise TypeError(
+                "`UndirectedMaximumLikelihoodEstimator.model.clique_beliefs` must be a `FactorDict`."
+            )
+
+        # These are the variables as represented by the `JunctionTree`.
+        cliques = list(clique_beliefs.keys())
+        empirical_marginals = FactorDict.from_dataframe(df=self.data, marginals=cliques)
+        potentials = FactorDict({})
+        seen = set()
+
+        # ML Machine Learning - A Probabilistic Perspective
+        # Chapter 19, Algorithm 19.2, Page 682:
+        # Update each clique by multiplying the potential value by
+        # the ratio of the empirical counts over expected counts.
+        # Since the potential values are equal to the expected counts
+        # for a JunctionTree, we can simplify this to just the empirical counts.
+        # This is also described in section 19.5.7.4.
+        for clique in cliques:
+            # Calculate the running sepset between the new clique and all of the
+            # variables we have previously seen.
+            variables = tuple(set(clique) - seen)
+            seen.update(clique)
+            potentials[clique] = empirical_marginals[clique]
+
+            # Divide out the sepset.
+            if variables:
+                marginalized = empirical_marginals[clique].marginalize(
+                    variables=variables, inplace=False
+                )
+                potentials[clique] = potentials[clique] / marginalized
+        return potentials

testbed/pgmpy__pgmpy/pgmpy/estimators/MirrorDescentEstimator.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+import numpy as np
+from scipy.special import logsumexp
+from tqdm.auto import tqdm
+
+from pgmpy.estimators.base import MarginalEstimator
+from pgmpy.factors import FactorDict
+from pgmpy.utils import compat_fns
+
+
+class MirrorDescentEstimator(MarginalEstimator):
+    """
+    Class for estimation of a undirected graphical model based upon observed
+    marginals from a tabular dataset. Estimated parameters are found from an
+    entropic mirror descent algorithm for solving convex optimization problems
+    over the probability simplex.
+
+    Parameters
+    ----------
+    model: MarkovNetwork | FactorGraph | JunctionTree
+        A model to optimize, using Belief Propagation and an estimation method.
+
+    data: pandas DataFrame object
+        dataframe object where each column represents one variable.
+        (If some values in the data are missing the data cells should be set to `numpy.nan`.
+        Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+    state_names: dict (optional)
+        A dict indicating, for each variable, the discrete set of states (or values)
+        that the variable can take. If unspecified, the observed values in the data set
+        are taken to be the only possible states.
+
+    References
+    ----------
+    [1] McKenna, Ryan, Daniel Sheldon, and Gerome Miklau.
+        "Graphical-model based estimation and inference for differential  privacy." In Proceedings of the 36th International Conference on Machine Learning. 2019, Appendix A.1.
+        https://arxiv.org/abs/1901.09136.
+    [2] Beck, A. and Teboulle, M. Mirror descent and nonlinear projected subgradient methods for convex optimization. Operations Research Letters, 31(3):167–175, 2003
+        https://www.sciencedirect.com/science/article/abs/pii/S0167637702002316.
+    [3] Wainwright, M. J. and Jordan, M. I.
+        Graphical models, exponential families, and variational inference. Foundations and Trends in Machine Learning, 1(1-2):1–305, 2008, Section 3.6 Conjugate Duality: Maximum Likelihood and Maximum Entropy.
+        https://people.eecs.berkeley.edu/~wainwrig/Papers/WaiJor08_FTML.pdf
+    """
+
+    def _calibrate(self, theta, n):
+        """
+        Wrapper for JunctionTree.calibrate that handles:
+            1) getting and setting clique_beliefs
+            2) normalizing cliques in log-space
+            3) returning marginal values in the original space
+
+        Parameters
+        ----------
+        theta: FactorDict
+            Mapping of clique to factors in a JunctionTree.
+
+        n: int
+            Total number of observations from a dataset.
+
+        Returns
+        -------
+        mu: FactorDict
+            Mapping of clique to factors representing marginal beliefs.
+        """
+        # Assign a new value for theta.
+        self.belief_propagation.junction_tree.clique_beliefs = theta
+
+        # TODO: Currently, belief propagation operates in the original space.
+        # To be compatible with this function and for better numerical conditioning,
+        # allow calibration to happen in log-space.
+        self.belief_propagation.calibrate()
+        mu = self.belief_propagation.junction_tree.clique_beliefs
+        cliques = list(mu.keys())
+        clique = cliques[0]
+
+        # Normalize each clique (in log-space) for numerical stability
+        # and then convert the marginals back to probability space so
+        # they are comparable with the observed marginals.
+        log_z = logsumexp(mu[clique].values)
+        for clique in cliques:
+            mu[clique] += np.log(n) - log_z
+            mu[clique].values = compat_fns.exp(mu[clique].values)
+        return mu
+
+    def estimate(
+        self,
+        marginals,
+        metric="L2",
+        iterations=100,
+        stepsize=None,
+        show_progress=True,
+    ):
+        """
+        Method to estimate the marginals for a given dataset.
+
+        Parameters
+        ----------
+        marginals: List[Tuple[str, ...]]
+            The names of the marginals to be estimated. These marginals must be present
+            in the data passed to the `__init__()` method.
+
+        metric: str
+            One of either 'L1' or 'L2'.
+
+        iterations: int
+            The number of iterations to run mirror descent optimization.
+
+        stepsize: Optional[float]
+            The step size of each mirror descent gradient.
+            If None, stepsize is defaulted as: `alpha = 2.0 / len(self.data) ** 2`
+            and a line search is conducted each iteration.
+
+        show_progress: bool
+            Whether to show a tqdm progress bar during during optimization.
+
+        Notes
+        -------
+        Estimation occurs in log-space.
+
+
+        Returns
+        -------
+        Estimated Junction Tree: pgmpy.models.JunctionTree.JunctionTree
+            Estimated Junction Tree with potentials optimized to faithfully
+            represent `marginals` from a dataset.
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>> from pgmpy.models import FactorGraph
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> from pgmpy.estimators import MirrorDescentEstimator
+        >>> data = pd.DataFrame(data={"a": [0, 0, 1, 1, 1], "b": [0, 1, 0, 1, 1]})
+        >>> model = FactorGraph()
+        >>> model.add_nodes_from(["a", "b"])
+        >>> phi1 = DiscreteFactor(["a", "b"], [2, 2], np.zeros(4))
+        >>> model.add_factors(phi1)
+        >>> model.add_edges_from([("a", phi1), ("b", phi1)])
+        >>> tree1 = MirrorDescentEstimator(model=model, data=data).estimate(marginals=[("a", "b")])
+        >>> print(tree1.factors[0])
+        +------+------+------------+
+        | a    | b    |   phi(a,b) |
+        +======+======+============+
+        | a(0) | b(0) |     1.0000 |
+        +------+------+------------+
+        | a(0) | b(1) |     1.0000 |
+        +------+------+------------+
+        | a(1) | b(0) |     1.0000 |
+        +------+------+------------+
+        | a(1) | b(1) |     2.0000 |
+        +------+------+------------+
+        >>> tree2 = MirrorDescentEstimator(model=model, data=data).estimate(marginals=[("a",)])
+        >>> print(tree2.factors[0])
+        +------+------+------------+
+        | a    | b    |   phi(a,b) |
+        +======+======+============+
+        | a(0) | b(0) |     1.0000 |
+        +------+------+------------+
+        | a(0) | b(1) |     1.0000 |
+        +------+------+------------+
+        | a(1) | b(0) |     1.5000 |
+        +------+------+------------+
+        | a(1) | b(1) |     1.5000 |
+        +------+------+------------+
+        """
+        # Step 1: Setup variables such as data, step size, and clique to marginal mapping.
+        if self.data is None:
+            raise ValueError(f"No data was found to fit to the marginals {marginals}")
+
+        n = len(self.data)
+
+        _no_line_search = stepsize is not None
+        alpha = stepsize if isinstance(stepsize, float) else 1.0 / n**2
+
+        clique_to_marginal = self._clique_to_marginal(
+            marginals=FactorDict.from_dataframe(df=self.data, marginals=marginals),
+            clique_nodes=self.belief_propagation.junction_tree.nodes(),
+        )
+
+        # Step 2: Perform calibration to initialize variables.
+        theta = (
+            self.theta
+            if self.theta
+            else self.belief_propagation.junction_tree.clique_beliefs
+        )
+        mu = self._calibrate(theta=theta, n=n)
+        answer = self._marginal_loss(
+            marginals=mu, clique_to_marginal=clique_to_marginal, metric=metric
+        )
+
+        # Step 3: Optimize the potentials based off the observed marginals.
+        pbar = tqdm(range(iterations)) if show_progress else range(iterations)
+        for _ in pbar:
+            omega, nu = theta, mu
+            curr_loss, dL = answer
+            if not _no_line_search:
+                alpha *= 2
+
+            if isinstance(pbar, tqdm):
+                pbar.set_description_str(
+                    ",\t".join(
+                        [
+                            "Loss: {:e}".format(curr_loss),
+                            "Grad Norm: {:e}".format(np.sqrt(dL.dot(dL))),
+                            "alpha: {:e}".format(alpha),
+                        ]
+                    )
+                )
+
+            for __ in range(25):
+                # Take gradient step.
+                theta = omega - alpha * dL
+
+                # Calibrate to propogate gradients through the graph.
+                mu = self._calibrate(theta=theta, n=n)
+
+                # Compute the new loss with respect to the updated beliefs.
+                answer = self._marginal_loss(
+                    marginals=mu, clique_to_marginal=clique_to_marginal, metric=metric
+                )
+                # If we haven't appreciably improved, try reducing the step size.
+                # Otherwise, we break to the next iteration.
+                _step = 0.5 * alpha * dL.dot(nu - mu)
+                if _no_line_search or curr_loss - answer[0] >= _step:
+                    break
+                alpha *= 0.5
+
+        self.theta = theta
+        self.belief_propagation.junction_tree.clique_beliefs = mu
+        return self.belief_propagation.junction_tree

testbed/pgmpy__pgmpy/pgmpy/estimators/MmhcEstimator.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python
+from pgmpy.base import UndirectedGraph
+from pgmpy.estimators import BDeu, HillClimbSearch, StructureEstimator
+from pgmpy.estimators.CITests import chi_square
+from pgmpy.independencies import IndependenceAssertion, Independencies
+from pgmpy.models import BayesianNetwork
+from pgmpy.utils.mathext import powerset
+
+
+class MmhcEstimator(StructureEstimator):
+    """
+    Implements the MMHC hybrid structure estimation procedure for
+    learning BayesianNetworks from discrete data.
+
+    Parameters
+    ----------
+    data: pandas DataFrame object
+        dataframe object where each column represents one variable.
+        (If some values in the data are missing the data cells should be set to `numpy.nan`.
+        Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+    state_names: dict (optional)
+        A dict indicating, for each variable, the discrete set of states (or values)
+        that the variable can take. If unspecified, the observed values in the data set
+        are taken to be the only possible states.
+
+    References
+    ----------
+    Tsamardinos et al., The max-min hill-climbing Bayesian network structure learning algorithm (2005)
+    http://www.dsl-lab.org/supplements/mmhc_paper/paper_online.pdf
+    """
+
+    def __init__(self, data, **kwargs):
+        super(MmhcEstimator, self).__init__(data, **kwargs)
+
+    def estimate(self, scoring_method=None, tabu_length=10, significance_level=0.01):
+        """
+        Estimates a BayesianNetwork for the data set, using MMHC. First estimates a
+        graph skeleton using MMPC and then orients the edges using score-based local
+        search (hill climbing).
+
+        Parameters
+        ----------
+        significance_level: float, default: 0.01
+            The significance level to use for conditional independence tests in the data set. See `mmpc`-method.
+
+        scoring_method: instance of a Scoring method (default: BDeu)
+            The method to use for scoring during Hill Climb Search. Can be an instance of any of the
+            scoring methods implemented in pgmpy.
+
+        tabu_length: int
+            If provided, the last `tabu_length` graph modifications cannot be reversed
+            during the search procedure. This serves to enforce a wider exploration
+            of the search space. Default value: 100.
+
+        Returns
+        -------
+        Estimated model: pgmpy.base.DAG
+            The estimated model without the parameterization.
+
+        References
+        ----------
+        Tsamardinos et al., The max-min hill-climbing Bayesian network structure learning algorithm (2005),
+        Algorithm 3
+        http://www.dsl-lab.org/supplements/mmhc_paper/paper_online.pdf
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>> from pgmpy.estimators import MmhcEstimator
+        >>> data = pd.DataFrame(np.random.randint(0, 2, size=(2500, 4)), columns=list('XYZW'))
+        >>> data['sum'] = data.sum(axis=1)
+        >>> est = MmhcEstimator(data)
+        >>> model = est.estimate()
+        >>> print(model.edges())
+        [('Z', 'sum'), ('X', 'sum'), ('W', 'sum'), ('Y', 'sum')]
+        """
+        if scoring_method is None:
+            scoring_method = BDeu(self.data, equivalent_sample_size=10)
+
+        skel = self.mmpc(significance_level)
+
+        hc = HillClimbSearch(self.data)
+
+        model = hc.estimate(
+            scoring_method=scoring_method,
+            white_list=skel.to_directed().edges(),
+            tabu_length=tabu_length,
+        )
+
+        return model
+
+    def mmpc(self, significance_level=0.01):
+        """Estimates a graph skeleton (UndirectedGraph) for the data set, using then
+        MMPC (max-min parents-and-children) algorithm.
+
+        Parameters
+        ----------
+        significance_level: float, default=0.01
+            The significance level to use for conditional independence tests in the data set.
+
+            `significance_level` is the desired Type 1 error probability of
+            falsely rejecting the null hypothesis that variables are independent,
+            given that they are. The lower `significance_level`, the less likely
+            we are to accept dependencies, resulting in a sparser graph.
+
+        Returns
+        -------
+        skeleton: pgmpy.base.UndirectedGraph
+            An estimate for the undirected graph skeleton of the BN underlying the data.
+
+        seperating_sets: dict
+            A dict containing for each pair of not directly connected nodes a
+            seperating set ("witnessing set") of variables that makes then
+            conditionally independent. (needed for edge orientation)
+
+        References
+        ----------
+        Tsamardinos et al., The max-min hill-climbing Bayesian network structure
+        learning algorithm (2005), Algorithm 1 & 2
+        http://www.dsl-lab.org/supplements/mmhc_paper/paper_online.pdf
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>> from pgmpy.estimators import MmhcEstimator
+        >>> data = pd.DataFrame(np.random.randint(0, 2, size=(5000, 5)), columns=list('ABCDE'))
+        >>> data['F'] = data['A'] + data['B'] + data ['C']
+        >>> est = PC(data)
+        >>> skel, sep_sets = est.estimate_skeleton()
+        >>> skel.edges()
+        [('A', 'F'), ('B', 'F'), ('C', 'F')]
+        >>> # all independencies are unconditional:
+        >>> sep_sets
+        {('D', 'A'): (), ('C', 'A'): (), ('C', 'E'): (), ('E', 'F'): (), ('B', 'D'): (),
+         ('B', 'E'): (), ('D', 'F'): (), ('D', 'E'): (), ('A', 'E'): (), ('B', 'A'): (),
+         ('B', 'C'): (), ('C', 'D'): ()}
+        >>> data = pd.DataFrame(np.random.randint(0, 2, size=(5000, 3)), columns=list('XYZ'))
+        >>> data['X'] += data['Z']
+        >>> data['Y'] += data['Z']
+        >>> est = PC(data)
+        >>> skel, sep_sets = est.estimate_skeleton()
+        >>> skel.edges()
+        [('X', 'Z'), ('Y', 'Z')]
+        >>> # X, Y dependent, but conditionally independent given Z:
+        >>> sep_sets
+        {('X', 'Y'): ('Z',)}
+        """
+
+        nodes = self.state_names.keys()
+
+        def assoc(X, Y, Zs):
+            """Measure for (conditional) association between variables. Use negative
+            p-value of independence test.
+            """
+            return 1 - chi_square(X, Y, Zs, self.data, boolean=False)[1]
+
+        def min_assoc(X, Y, Zs):
+            "Minimal association of X, Y given any subset of Zs."
+            return min(assoc(X, Y, Zs_subset) for Zs_subset in powerset(Zs))
+
+        def max_min_heuristic(X, Zs):
+            "Finds variable that maximizes min_assoc with `node` relative to `neighbors`."
+            max_min_assoc = 0
+            best_Y = None
+
+            for Y in set(nodes) - set(Zs + [X]):
+                min_assoc_val = min_assoc(X, Y, Zs)
+                if min_assoc_val >= max_min_assoc:
+                    best_Y = Y
+                    max_min_assoc = min_assoc_val
+
+            return (best_Y, max_min_assoc)
+
+        # Find parents and children for each node
+        neighbors = dict()
+        for node in nodes:
+            neighbors[node] = []
+
+            # Forward Phase
+            while True:
+                new_neighbor, new_neighbor_min_assoc = max_min_heuristic(
+                    node, neighbors[node]
+                )
+                if new_neighbor_min_assoc > 0:
+                    neighbors[node].append(new_neighbor)
+                else:
+                    break
+
+            # Backward Phase
+            for neigh in neighbors[node]:
+                other_neighbors = [n for n in neighbors[node] if n != neigh]
+                for sep_set in powerset(other_neighbors):
+                    if chi_square(
+                        X=node,
+                        Y=neigh,
+                        Z=sep_set,
+                        data=self.data,
+                        significance_level=significance_level,
+                    ):
+                        neighbors[node].remove(neigh)
+                        break
+
+        # correct for false positives
+        for node in nodes:
+            for neigh in neighbors[node]:
+                if node not in neighbors[neigh]:
+                    neighbors[node].remove(neigh)
+
+        skel = UndirectedGraph()
+        skel.add_nodes_from(nodes)
+        for node in nodes:
+            skel.add_edges_from([(node, neigh) for neigh in neighbors[node]])
+
+        return skel

testbed/pgmpy__pgmpy/pgmpy/estimators/SEMEstimator.py

@@ -0,0 +1,451 @@
+import numpy as np
+import pandas as pd
+import statsmodels.api as sm
+import torch
+
+from pgmpy import config
+from pgmpy.models import SEM, SEMAlg, SEMGraph
+from pgmpy.utils import optimize, pinverse
+
+
+class SEMEstimator(object):
+    """
+    Base class of SEM estimators. All the estimators inherit this class.
+    """
+
+    def __init__(self, model):
+        if config.BACKEND == "numpy":
+            raise ValueError(
+                f"SEMEstimator requires torch backend. Currently it's numpy. Call pgmpy.config.set_backend('torch') to switch"
+            )
+
+        if isinstance(model, (SEMGraph, SEM)):
+            self.model = model.to_lisrel()
+        elif isinstance(model, SEMAlg):
+            self.model = model
+        else:
+            raise ValueError(
+                f"Model should be an instance of either SEMGraph or SEMAlg class. Got type: {type(model)}"
+            )
+
+        # Initialize trainable and fixed mask tensors
+        self.B_mask = torch.tensor(
+            self.model.B_mask,
+            device=config.DEVICE,
+            dtype=config.DTYPE,
+            requires_grad=False,
+        )
+        self.zeta_mask = torch.tensor(
+            self.model.zeta_mask,
+            device=config.DEVICE,
+            dtype=config.DTYPE,
+            requires_grad=False,
+        )
+
+        self.B_fixed_mask = torch.tensor(
+            self.model.B_fixed_mask,
+            device=config.DEVICE,
+            dtype=config.DTYPE,
+            requires_grad=False,
+        )
+        self.zeta_fixed_mask = torch.tensor(
+            self.model.zeta_fixed_mask,
+            device=config.DEVICE,
+            dtype=config.DTYPE,
+            requires_grad=False,
+        )
+
+        self.wedge_y = torch.tensor(
+            self.model.wedge_y,
+            device=config.DEVICE,
+            dtype=config.DTYPE,
+            requires_grad=False,
+        )
+        self.B_eye = torch.eye(
+            self.B_mask.shape[0],
+            device=config.DEVICE,
+            dtype=config.DTYPE,
+            requires_grad=False,
+        )
+
+    def _get_implied_cov(self, B, zeta):
+        """
+        Computes the implied covariance matrix from the given parameters.
+        """
+        B_masked = torch.mul(B, self.B_mask) + self.B_fixed_mask
+        B_inv = pinverse(self.B_eye - B_masked)
+        zeta_masked = torch.mul(zeta, self.zeta_mask) + self.zeta_fixed_mask
+
+        return self.wedge_y @ B_inv @ zeta_masked @ B_inv.t() @ self.wedge_y.t()
+
+    def ml_loss(self, params, loss_args):
+        r"""
+        Method to compute the Maximum Likelihood loss function. The optimizer calls this
+        method after each iteration with updated params to compute the new loss.
+
+        The fitting function for ML is:
+        .. math:: F_{ML} = \log |\Sigma(\theta)| + tr(S \Sigma^{-1}(\theta)) - \log S - (p+q)
+
+        Parameters
+        ----------
+        params: dict
+            params contain all the variables which are updated in each iteration of the
+            optimization.
+
+        loss_args: dict
+            loss_args contain all the variable which are not updated in each iteration but
+            are required to compute the loss.
+
+        Returns
+        -------
+        torch.tensor: The loss value for the given params and loss_args
+        """
+        S = loss_args["S"]
+        sigma = self._get_implied_cov(params["B"], params["zeta"])
+
+        return (
+            sigma.det().clamp(min=1e-4).log()
+            + (S @ pinverse(sigma)).trace()
+            - S.logdet()
+            - len(self.model.y)
+        )
+
+    def uls_loss(self, params, loss_args):
+        r"""
+        Method to compute the Unweighted Least Squares fitting function. The optimizer calls
+        this method after each iteration with updated params to compute the new loss.
+
+        The fitting function for ML is:
+        .. math:: F_{ULS} = tr[(S - \Sigma(\theta))^2]
+
+        Parameters
+        ----------
+        params: dict
+            params contain all the variables which are updated in each iteration of the
+            optimization.
+
+        loss_args: dict
+            loss_args contain all the variable which are not updated in each iteration but
+            are required to compute the loss.
+
+        Returns
+        -------
+        torch.tensor: The loss value for the given params and loss_args
+        """
+        S = loss_args["S"]
+        sigma = self._get_implied_cov(params["B"], params["zeta"])
+        return (S - sigma).pow(2).trace()
+
+    def gls_loss(self, params, loss_args):
+        r"""
+        Method to compute the Weighted Least Squares fitting function. The optimizer calls
+        this method after each iteration with updated params to compute the new loss.
+
+        The fitting function for ML is:
+        .. math:: F_{ULS} = tr \{ [(S - \Sigma(\theta)) W^{-1}]^2 \}
+
+        Parameters
+        ----------
+        params: dict
+            params contain all the variables which are updated in each iteration of the
+            optimization.
+
+        loss_args: dict
+            loss_args contain all the variable which are not updated in each iteration but
+            are required to compute the loss.
+
+        Returns
+        -------
+        torch.tensor: The loss value for the given params and loss_args
+        """
+        S = loss_args["S"]
+        W_inv = pinverse(loss_args["W"])
+        sigma = self._get_implied_cov(params["B"], params["zeta"])
+        return ((S - sigma) @ W_inv).pow(2).trace()
+
+    def get_init_values(self, data, method):
+        """
+        Computes the starting values for the optimizer.
+
+        Reference
+        ---------
+        .. [1] Table 4C.1: Bollen, K. (2014). Structural Equations with Latent Variables.
+                New York, NY: John Wiley & Sons.
+
+        """
+        # Initialize all the values even if the edge doesn't exist, masks would take care of that.
+        a = 0.4
+        scaling_vars = self.model.to_SEMGraph().get_scaling_indicators()
+        eta, m = self.model.eta, len(self.model.eta)
+
+        if method == "random":
+            B = np.random.rand(m, m)
+            zeta = np.random.rand(m, m)
+
+        elif method == "std":
+            # Add observed vars to `scaling_vars to point to itself. Trick to keep code short.
+            for observed_var in self.model.y:
+                scaling_vars[observed_var] = observed_var
+
+            B = np.random.rand(m, m)
+            for i in range(m):
+                for j in range(m):
+                    if scaling_vars[eta[i]] == eta[j]:
+                        B[i, j] = 1.0
+                    elif i != j:
+                        B[i, j] = a * (
+                            data.loc[:, scaling_vars[eta[i]]].std()
+                            / data.loc[:, scaling_vars[eta[j]]].std()
+                        )
+            zeta = np.random.rand(m, m)
+            for i in range(m):
+                zeta[i, i] = a * ((data.loc[:, scaling_vars[eta[i]]].std()) ** 2)
+            for i in range(m):
+                for j in range(m):
+                    zeta[i, j] = zeta[j, i] = a * np.sqrt(zeta[i, i] * zeta[j, j])
+
+        elif method.lower() == "iv":
+            raise NotImplementedError("IV initialization not supported yet.")
+
+        return B, zeta
+
+    def fit(
+        self,
+        data,
+        method,
+        opt="adam",
+        init_values="random",
+        exit_delta=1e-4,
+        max_iter=1000,
+        **kwargs,
+    ):
+        """
+        Estimate the parameters of the model from the data.
+
+        Parameters
+        ----------
+        data: pandas DataFrame or pgmpy.data.Data instance
+            The data from which to estimate the parameters of the model.
+
+        method: str ("ml"|"uls"|"gls"|"2sls")
+            The fitting function to use.
+            ML : Maximum Likelihood
+            ULS: Unweighted Least Squares
+            GLS: Generalized Least Squares
+            2sls: 2-SLS estimator
+
+        init_values: str or dict
+            Options for str: random | std | iv
+            dict: dictionary with keys `B` and `zeta`.
+
+        **kwargs: dict
+            Extra parameters required in case of some estimators.
+            GLS:
+                W: np.array (n x n) where n is the number of observe variables.
+            2sls:
+                x:
+                y:
+
+        Returns
+        -------
+            pgmpy.model.SEM instance: Instance of the model with estimated parameters
+
+        References
+        ----------
+        .. [1] Bollen, K. A. (2010). Structural equations with latent variables. New York: Wiley.
+        """
+        # Check if given arguments are valid
+        if not isinstance(data, pd.DataFrame):
+            raise ValueError(f"data must be a pandas DataFrame. Got type: {type(data)}")
+
+        if not sorted(data.columns) == sorted(self.model.y):
+            raise ValueError(
+                f"The column names data do not match the variables in the model. Expected: {sorted(self.model.observed)}. Got: {sorted(data.columns)}"
+            )
+
+        # Initialize the values of parameters as tensors.
+        if isinstance(init_values, dict):
+            B_init, zeta_init = init_values["B"], init_values["zeta"]
+        else:
+            B_init, zeta_init = self.get_init_values(data, method=init_values.lower())
+        B = torch.tensor(
+            B_init, device=config.DEVICE, dtype=config.DTYPE, requires_grad=True
+        )
+        zeta = torch.tensor(
+            zeta_init, device=config.DEVICE, dtype=config.DTYPE, requires_grad=True
+        )
+
+        # Compute the covariance of the data
+        variable_order = self.model.y
+        S = data.cov().reindex(variable_order, axis=1).reindex(variable_order, axis=0)
+        S = torch.tensor(
+            S.values, device=config.DEVICE, dtype=config.DTYPE, requires_grad=False
+        )
+
+        # Optimize the parameters
+        if method.lower() == "ml":
+            params = optimize(
+                self.ml_loss,
+                params={"B": B, "zeta": zeta},
+                loss_args={"S": S},
+                opt=opt,
+                exit_delta=exit_delta,
+                max_iter=max_iter,
+            )
+
+        elif method.lower() == "uls":
+            params = optimize(
+                self.uls_loss,
+                params={"B": B, "zeta": zeta},
+                loss_args={"S": S},
+                opt=opt,
+                exit_delta=exit_delta,
+                max_iter=max_iter,
+            )
+
+        elif method.lower() == "gls":
+            W = torch.tensor(
+                kwargs["W"],
+                device=config.DEVICE,
+                dtype=config.DTYPE,
+                requires_grad=False,
+            )
+            params = optimize(
+                self.gls_loss,
+                params={"B": B, "zeta": zeta},
+                loss_args={"S": S, "W": W},
+                opt=opt,
+                exit_delta=exit_delta,
+                max_iter=max_iter,
+            )
+
+        elif method.lower() == "2sls" or method.lower() == "2-sls":
+            raise NotImplementedError("2-SLS is not implemented yet")
+
+        B = params["B"] * self.B_mask + self.B_fixed_mask
+        zeta = params["zeta"] * self.zeta_mask + self.zeta_fixed_mask
+
+        # Compute goodness of fit statistics.
+        N = data.shape[0]
+        sample_cov = S.detach().numpy()
+        sigma_hat = self._get_implied_cov(B, zeta).detach().numpy()
+        residual = sample_cov - sigma_hat
+
+        norm_residual = np.zeros(residual.shape)
+        for i in range(norm_residual.shape[0]):
+            for j in range(norm_residual.shape[1]):
+                norm_residual[i, j] = (sample_cov[i, j] - sigma_hat[i, j]) / np.sqrt(
+                    ((sigma_hat[i, i] * sigma_hat[j, j]) + (sigma_hat[i, j] ** 2)) / N
+                )
+
+        # Compute chi-square value.
+        likelihood_ratio = -(N - 1) * (
+            np.log(np.linalg.det(sigma_hat))
+            + (np.linalg.inv(sigma_hat) @ S).trace()
+            - np.log(np.linalg.det(S))
+            - S.shape[0]
+        )
+        if method.lower() == "ml":
+            error = self.ml_loss(params, loss_args={"S": S})
+        elif method.lower() == "uls":
+            error = self.uls_loss(params, loss_args={"S": S})
+        elif method.lower() == "gls":
+            error = self.gls_loss(params, loss_args={"S": S, "W": W})
+        chi_square = likelihood_ratio / error.detach().numpy()
+
+        free_params = self.B_mask.sum()
+        dof = ((S.shape[0] * (S.shape[0] + 1)) / 2) - free_params
+
+        summary = {
+            "Sample Size": N,
+            "Sample Covariance": sample_cov,
+            "Model Implied Covariance": sigma_hat,
+            "Residual": residual,
+            "Normalized Residual": norm_residual,
+            "chi_square": chi_square,
+            "dof": dof,
+        }
+
+        # Update the model with the learned params
+        self.model.set_params(
+            B=params["B"].detach().numpy(), zeta=params["B"].detach().numpy()
+        )
+        return summary
+
+
+class IVEstimator:
+    """
+    Initialize IVEstimator object.
+
+    Parameters
+    ----------
+    model: pgmpy.models.SEM
+        The model for which estimation need to be done.
+
+    Examples
+    --------
+    """
+
+    def __init__(self, model):
+        self.model = model
+
+    def fit(self, X, Y, data, ivs=None, civs=None):
+        """
+        Estimates the parameter X -> Y.
+
+        Parameters
+        ----------
+        X: str
+            The covariate variable of the parameter being estimated.
+
+        Y: str
+            The predictor variable of the parameter being estimated.
+
+        data: pd.DataFrame
+            The data from which to learn the parameter.
+
+        ivs: List (default: None)
+            List of variable names which should be used as Instrumental Variables (IV).
+            If not specified, tries to find the IVs from the model structure, fails if
+            can't find either IV or Conditional IV.
+
+        civs: List of tuples (tuple form: (var, coditional_var))
+            List of conditional IVs to use for estimation.
+            If not specified, tries to find the IVs from the model structure, fails if
+            can't find either IV or Conditional IVs.
+
+        Examples
+        --------
+        >>> from pgmpy.estimators import IVEstimator # TODO: Finish example.
+        """
+        if (ivs is None) and (civs is None):
+            ivs = self.model.get_ivs(X, Y)
+            civs = self.model.get_conditional_ivs(X, Y)
+
+        civs = [civ for civ in civs if civ[0] not in ivs]
+
+        reg_covars = []
+        for var in self.model.graph.predecessors(X):
+            if var in self.model.observed:
+                reg_covars.append(var)
+
+        # Get CIV conditionals
+        civ_conditionals = []
+        for civ in civs:
+            civ_conditionals.extend(civ[1])
+
+        # First stage regression.
+        params = (
+            sm.OLS(data.loc[:, X], data.loc[:, reg_covars + civ_conditionals])
+            .fit()
+            .params
+        )
+
+        data["X_pred"] = np.zeros(data.shape[0])
+        for var in reg_covars:
+            data.X_pred += params[var] * data.loc[:, var]
+
+        summary = sm.OLS(
+            data.loc[:, Y], data.loc[:, ["X_pred"] + civ_conditionals]
+        ).fit()
+        return summary.params["X_pred"], summary

testbed/pgmpy__pgmpy/pgmpy/estimators/TreeSearch.py

@@ -0,0 +1,390 @@
+#!/usr/bin/env python
+
+from itertools import combinations
+
+import networkx as nx
+import numpy as np
+import pandas as pd
+from joblib import Parallel, delayed
+from sklearn.metrics import (
+    adjusted_mutual_info_score,
+    mutual_info_score,
+    normalized_mutual_info_score,
+)
+from tqdm.auto import tqdm
+
+from pgmpy import config
+from pgmpy.base import DAG
+from pgmpy.estimators import StructureEstimator
+
+
+class TreeSearch(StructureEstimator):
+    """
+    Search class for learning tree related graph structure. The algorithms
+    supported are Chow-Liu and Tree-augmented naive bayes (TAN).
+
+    Chow-Liu constructs the maximum-weight spanning tree with mutual information
+    score as edge weights.
+
+    TAN is an extension of Naive Bayes classifier to allow a tree structure over
+    the independent variables to account for interaction.
+
+    Parameters
+    ----------
+    data: pandas.DataFrame object
+        dataframe object where each column represents one variable.
+
+    root_node: str, int, or any hashable python object, default is None.
+        The root node of the tree structure. If None then root node is auto-picked
+        as the node with the highest sum of edge weights.
+
+    n_jobs: int (default: -1)
+        Number of jobs to run in parallel. `-1` means use all processors.
+
+    References
+    ----------
+    [1] Chow, C. K.; Liu, C.N. (1968), "Approximating discrete probability
+        distributions with dependence trees", IEEE Transactions on Information
+        Theory, IT-14 (3): 462–467
+
+    [2] Friedman N, Geiger D and Goldszmidt M (1997). Bayesian network classifiers.
+        Machine Learning 29: 131–163
+    """
+
+    def __init__(self, data, root_node=None, n_jobs=-1, **kwargs):
+        if root_node is not None and root_node not in data.columns:
+            raise ValueError(f"Root node: {root_node} not found in data columns.")
+
+        self.data = data
+        self.root_node = root_node
+        self.n_jobs = n_jobs
+
+        super(TreeSearch, self).__init__(data, **kwargs)
+
+    def estimate(
+        self,
+        estimator_type="chow-liu",
+        class_node=None,
+        edge_weights_fn="mutual_info",
+        show_progress=True,
+    ):
+        """
+        Estimate the `DAG` structure that fits best to the given data set without
+        parametrization.
+
+        Parameters
+        ----------
+        estimator_type: str (chow-liu | tan)
+            The algorithm to use for estimating the DAG.
+
+        class_node: string, int or any hashable python object. (optional)
+            Needed only if estimator_type = 'tan'. In the estimated DAG, there would be
+            edges from class_node to each of the feature variables.
+
+        edge_weights_fn: str or function (default: mutual info)
+            Method to use for computing edge weights. By default, Mutual Info Score is
+            used.
+
+        show_progress: boolean
+            If True, shows a progress bar for the running algorithm.
+
+        Returns
+        -------
+        Estimated Model: pgmpy.base.DAG
+            The estimated model structure.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import pandas as pd
+        >>> import networkx as nx
+        >>> import matplotlib.pyplot as plt
+        >>> from pgmpy.estimators import TreeSearch
+        >>> values = pd.DataFrame(np.random.randint(low=0, high=2, size=(1000, 5)),
+        ...                       columns=['A', 'B', 'C', 'D', 'E'])
+        >>> est = TreeSearch(values, root_node='B')
+        >>> model = est.estimate(estimator_type='chow-liu')
+        >>> nx.draw_circular(model, with_labels=True, arrowsize=20, arrowstyle='fancy',
+        ...                  alpha=0.3)
+        >>> plt.show()
+        >>> est = TreeSearch(values)
+        >>> model = est.estimate(estimator_type='chow-liu')
+        >>> nx.draw_circular(model, with_labels=True, arrowsize=20, arrowstyle='fancy',
+        ...                  alpha=0.3)
+        >>> plt.show()
+        >>> est = TreeSearch(values, root_node='B')
+        >>> model = est.estimate(estimator_type='tan', class_node='A')
+        >>> nx.draw_circular(model, with_labels=True, arrowsize=20, arrowstyle='fancy',
+        ...                  alpha=0.3)
+        >>> plt.show()
+        >>> est = TreeSearch(values)
+        >>> model = est.estimate(estimator_type='tan')
+        >>> nx.draw_circular(model, with_labels=True, arrowsize=20, arrowstyle='fancy',
+        ...                  alpha=0.3)
+        >>> plt.show()
+        """
+        # Step 1. Argument checks
+        # Step 1.1: Only chow-liu and tan allowed as estimator type.
+        if estimator_type not in {"chow-liu", "tan"}:
+            raise ValueError(
+                f"Invalid estimator_type. Expected either chow-liu or tan. Got: {estimator_type}"
+            )
+
+        # Step 1.2: If estimator_type=tan, class_node must be specified
+        if estimator_type == "tan" and class_node is None:
+            raise ValueError(
+                f"class_node argument must be specified for estimator_type='tan'"
+            )
+        if estimator_type == "tan" and class_node not in self.data.columns:
+            raise ValueError(f"Class node: {class_node} not found in data columns")
+
+        # Step 1.3: If root_node isn't specified, get the node with the highest score.
+        weights_computed = False
+        if self.root_node is None:
+            weights = TreeSearch._get_weights(
+                self.data, edge_weights_fn, self.n_jobs, show_progress
+            )
+            weights_computed = True
+            sum_weights = weights.sum(axis=0)
+            maxw_idx = np.argsort(sum_weights)[::-1]
+            self.root_node = self.data.columns[maxw_idx[0]]
+
+        # Step 2. Compute all edge weights.
+        if estimator_type == "chow-liu":
+            if not weights_computed:
+                weights = TreeSearch._get_weights(
+                    self.data, edge_weights_fn, self.n_jobs, show_progress
+                )
+        else:
+            weights = TreeSearch._get_conditional_weights(
+                self.data, class_node, edge_weights_fn, self.n_jobs, show_progress
+            )
+
+        # Step 3: If estimator_type = "chow-liu", estimate the DAG and return.
+        if estimator_type == "chow-liu":
+            return TreeSearch._create_tree_and_dag(
+                weights, self.data.columns, self.root_node
+            )
+
+        # Step 4: If estimator_type = "tan":
+        elif estimator_type == "tan":
+            # Step 4.1: Checks root_node != class_node
+            if self.root_node == class_node:
+                raise ValueError(
+                    f"Root node: {self.root_node} and class node: {class_node} are identical"
+                )
+
+            # Step 4.2: Construct chow-liu DAG on {data.columns - class_node}
+            class_node_idx = np.where(self.data.columns == class_node)[0][0]
+            weights = np.delete(weights, class_node_idx, axis=0)
+            weights = np.delete(weights, class_node_idx, axis=1)
+            reduced_columns = np.delete(self.data.columns, class_node_idx)
+            D = TreeSearch._create_tree_and_dag(
+                weights, reduced_columns, self.root_node
+            )
+
+            # Step 4.3: Add edges from class_node to all other nodes.
+            D.add_edges_from([(class_node, node) for node in reduced_columns])
+            return D
+
+    @staticmethod
+    def _get_weights(
+        data, edge_weights_fn="mutual_info", n_jobs=-1, show_progress=True
+    ):
+        """
+        Helper function to Chow-Liu algorithm for estimating tree structure from given data. Refer to
+        pgmpy.estimators.TreeSearch for more details. This function returns the edge weights matrix.
+
+        Parameters
+        ----------
+        data: pandas.DataFrame object
+            dataframe object where each column represents one variable.
+
+        edge_weights_fn: str or function (default: mutual_info)
+            Method to use for computing edge weights. Options are:
+                1. 'mutual_info': Mutual Information Score.
+                2. 'adjusted_mutual_info': Adjusted Mutual Information Score.
+                3. 'normalized_mutual_info': Normalized Mutual Information Score.
+                4. function(array[n_samples,], array[n_samples,]): Custom function.
+
+        n_jobs: int (default: -1)
+            Number of jobs to run in parallel. `-1` means use all processors.
+
+        show_progress: boolean
+            If True, shows a progress bar for the running algorithm.
+
+        Returns
+        -------
+        weights: numpy 2D array, shape = (n_columns, n_columns)
+            symmetric matrix where each element represents an edge weight.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import pandas as pd
+        >>> from pgmpy.estimators import TreeSearch
+        >>> values = pd.DataFrame(np.random.randint(low=0, high=2, size=(1000, 5)),
+        ...                       columns=['A', 'B', 'C', 'D', 'E'])
+        >>> est = TreeSearch(values, root_node='B')
+        >>> model = est.estimate(estimator_type='chow-liu')
+        """
+        # Step 0: Check for edge weight computation method
+        if edge_weights_fn == "mutual_info":
+            edge_weights_fn = mutual_info_score
+        elif edge_weights_fn == "adjusted_mutual_info":
+            edge_weights_fn = adjusted_mutual_info_score
+        elif edge_weights_fn == "normalized_mutual_info":
+            edge_weights_fn = normalized_mutual_info_score
+        elif not callable(edge_weights_fn):
+            raise ValueError(
+                f"edge_weights_fn should either be 'mutual_info', 'adjusted_mutual_info', "
+                f"'normalized_mutual_info'or a function of form fun(array, array). Got: f{edge_weights_fn}"
+            )
+
+        # Step 1: Compute edge weights for a fully connected graph.
+        n_vars = len(data.columns)
+        pbar = combinations(data.columns, 2)
+        if show_progress and config.SHOW_PROGRESS:
+            pbar = tqdm(pbar, total=(n_vars * (n_vars - 1) / 2), desc="Building tree")
+
+        vals = Parallel(n_jobs=n_jobs)(
+            delayed(edge_weights_fn)(data.loc[:, u], data.loc[:, v]) for u, v in pbar
+        )
+        weights = np.zeros((n_vars, n_vars))
+        indices = np.triu_indices(n_vars, k=1)
+        weights[indices] = vals
+        weights.T[indices] = vals
+
+        return weights
+
+    @staticmethod
+    def _get_conditional_weights(
+        data, class_node, edge_weights_fn="mutual_info", n_jobs=-1, show_progress=True
+    ):
+        """
+        Helper function to TAN (Tree Augmented Naive Bayes) algorithm for
+        estimating tree structure from given data. Refer to
+        pgmpy.estimators.TreeSearch for more details. This function returns the
+        edge weights matrix.
+
+        Parameters
+        ----------
+        data: pandas.DataFrame object
+            dataframe object where each column represents one variable.
+
+        class_node: str
+            The class node for TAN. The edge weight is computed as I(X, Y | class_node).
+
+        edge_weights_fn: str or function (default: mutual_info)
+            Method to use for computing edge weights. Options are:
+                1. 'mutual_info': Mutual Information Score.
+                2. 'adjusted_mutual_info': Adjusted Mutual Information Score.
+                3. 'normalized_mutual_info': Normalized Mutual Information Score.
+                4. function(array[n_samples,], array[n_samples,]): Custom function.
+
+        n_jobs: int (default: -1)
+            Number of jobs to run in parallel. `-1` means use all processors.
+
+        show_progress: boolean
+            If True, shows a progress bar for the running algorithm.
+
+        Returns
+        -------
+        weights: numpy 2D array, shape = (n_columns, n_columns)
+            symmetric matrix where each element represents an edge weight.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import pandas as pd
+        >>> from pgmpy.estimators import TreeSearch
+        >>> values = pd.DataFrame(np.random.randint(low=0, high=2, size=(1000, 5)),
+        ...                       columns=['A', 'B', 'C', 'D', 'E'])
+        >>> est = TreeSearch(values, root_node='B')
+        >>> model = est.estimate(estimator_type='tan')
+        """
+        # Step 0: Check for edge weight computation method
+        if edge_weights_fn == "mutual_info":
+            edge_weights_fn = mutual_info_score
+        elif edge_weights_fn == "adjusted_mutual_info":
+            edge_weights_fn = adjusted_mutual_info_score
+        elif edge_weights_fn == "normalized_mutual_info":
+            edge_weights_fn = normalized_mutual_info_score
+        elif not callable(edge_weights_fn):
+            raise ValueError(
+                f"edge_weights_fn should either be 'mutual_info', 'adjusted_mutual_info', "
+                f"'normalized_mutual_info'or a function of form fun(array, array). Got: f{edge_weights_fn}"
+            )
+
+        # Step 1: Compute edge weights for a fully connected graph.
+        n_vars = len(data.columns)
+        pbar = combinations(data.columns, 2)
+        if show_progress and config.SHOW_PROGRESS:
+            pbar = tqdm(pbar, total=(n_vars * (n_vars - 1) / 2), desc="Building tree")
+
+        def _conditional_edge_weights_fn(u, v):
+            """
+            Computes the conditional edge weight of variable index u and v conditioned on class_node
+            """
+            cond_marginal = data.loc[:, class_node].value_counts() / data.shape[0]
+            cond_edge_weight = 0
+            for index, marg_prob in cond_marginal.items():
+                df_cond_subset = data[data.loc[:, class_node] == index]
+                cond_edge_weight += marg_prob * edge_weights_fn(
+                    df_cond_subset.loc[:, u], df_cond_subset.loc[:, v]
+                )
+            return cond_edge_weight
+
+        vals = Parallel(n_jobs=n_jobs)(
+            delayed(_conditional_edge_weights_fn)(u, v) for u, v in pbar
+        )
+        weights = np.zeros((n_vars, n_vars))
+        indices = np.triu_indices(n_vars, k=1)
+        weights[indices] = vals
+        weights.T[indices] = vals
+
+        return weights
+
+    @staticmethod
+    def _create_tree_and_dag(weights, columns, root_node):
+        """
+        Helper function to Chow-Liu algorithm for estimating tree structure from given data. Refer to
+        pgmpy.estimators.TreeSearch for more details. This function returns the DAG based on the edge weights matrix.
+
+        Parameters
+        ----------
+        weights: numpy 2D array, shape = (n_columns, n_columns)
+            symmetric matrix where each element represents an edge weight.
+
+        columns: list or array
+            Names of the columns (& rows) of the weights matrix.
+
+        root_node: str, int, or any hashable python object.
+            The root node of the tree structure.
+
+        Returns
+        -------
+        model: pgmpy.base.DAG
+            The estimated model structure.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import pandas as pd
+        >>> from pgmpy.estimators import TreeSearch
+        >>> values = pd.DataFrame(np.random.randint(low=0, high=2, size=(1000, 5)),
+        ...                       columns=['A', 'B', 'C', 'D', 'E'])
+        >>> est = TreeSearch(values, root_node='B')
+        >>> model = est.estimate(estimator_type='chow-liu')
+        """
+        # Step 2: Compute the maximum spanning tree using the weights.
+        T = nx.maximum_spanning_tree(
+            nx.from_pandas_adjacency(
+                pd.DataFrame(weights, index=columns, columns=columns),
+                create_using=nx.Graph,
+            )
+        )
+
+        # Step 3: Create DAG by directing edges away from root node and return
+        D = nx.bfs_tree(T, root_node)
+        return DAG(D)

testbed/pgmpy__pgmpy/pgmpy/estimators/__init__.py

@@ -0,0 +1,62 @@
+from pgmpy.estimators.base import BaseEstimator, ParameterEstimator, StructureEstimator
+from pgmpy.estimators.MLE import MaximumLikelihoodEstimator
+from pgmpy.estimators.BayesianEstimator import BayesianEstimator
+from pgmpy.estimators.StructureScore import (
+    StructureScore,
+    K2,
+    BDeu,
+    BDs,
+    BIC,
+    BICGauss,
+    BICCondGauss,
+    AIC,
+    AICGauss,
+    AICCondGauss,
+    LogLikelihoodGauss,
+    LogLikelihoodCondGauss,
+)
+from pgmpy.estimators.ExhaustiveSearch import ExhaustiveSearch
+from pgmpy.estimators.HillClimbSearch import HillClimbSearch
+from pgmpy.estimators.TreeSearch import TreeSearch
+from pgmpy.estimators.SEMEstimator import SEMEstimator, IVEstimator
+from pgmpy.estimators.ScoreCache import ScoreCache
+from pgmpy.estimators.MmhcEstimator import MmhcEstimator
+from pgmpy.estimators.EM import ExpectationMaximization
+from pgmpy.estimators.PC import PC
+from pgmpy.estimators.base import MarginalEstimator
+from pgmpy.estimators.MirrorDescentEstimator import MirrorDescentEstimator
+from pgmpy.estimators.expert import ExpertInLoop
+from pgmpy.estimators.GES import GES
+
+__all__ = [
+    "BaseEstimator",
+    "ParameterEstimator",
+    "MaximumLikelihoodEstimator",
+    "BayesianEstimator",
+    "StructureEstimator",
+    "ExhaustiveSearch",
+    "HillClimbSearch",
+    "TreeSearch",
+    "StructureScore",
+    "K2",
+    "BDeu",
+    "BDs",
+    "BIC",
+    "BICGauss",
+    "AIC",
+    "AICGauss",
+    "ScoreCache",
+    "SEMEstimator",
+    "IVEstimator",
+    "MmhcEstimator",
+    "PC",
+    "ExpertInLoop",
+    "ExpectationMaximization",
+    "MarginalEstimator",
+    "MirrorDescentEstimator",
+    "GES",
+    "LogLikelihoodGauss",
+    "LogLikelihoodCondGauss",
+    "AICCondGauss",
+    "BICCondGauss",
+]

testbed/pgmpy__pgmpy/pgmpy/estimators/base.py

@@ -0,0 +1,432 @@
+#!/usr/bin/env python
+
+from collections import defaultdict
+
+import numpy as np
+import pandas as pd
+
+from pgmpy.factors import FactorDict
+from pgmpy.factors.discrete import DiscreteFactor
+from pgmpy.inference.ExactInference import BeliefPropagation
+from pgmpy.utils import preprocess_data
+
+
+class BaseEstimator(object):
+    """
+    Base class for estimators in pgmpy; `ParameterEstimator`,
+    `StructureEstimator` and `StructureScore` derive from this class.
+
+    Parameters
+    ----------
+    data: pandas DataFrame object
+        object where each column represents one variable.
+        (If some values in the data are missing the data cells should be set to `numpy.nan`.
+        Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+    state_names: dict (optional)
+        A dict indicating, for each variable, the discrete set of states (or values)
+        that the variable can take. If unspecified, the observed values in the data set
+        are taken to be the only possible states.
+    """
+
+    def __init__(self, data=None, state_names=None):
+        if data is None:
+            self.data = None
+            self.dtypes = None
+        else:
+            self.data, self.dtypes = preprocess_data(data)
+
+        # data can be None in the case when learning structure from
+        # independence conditions. Look into PC.py.
+        if self.data is not None:
+            self.variables = list(data.columns.values)
+
+            if not isinstance(state_names, dict):
+                self.state_names = {
+                    var: self._collect_state_names(var) for var in self.variables
+                }
+            else:
+                self.state_names = dict()
+                for var in self.variables:
+                    if var in state_names:
+                        if not set(self._collect_state_names(var)) <= set(
+                            state_names[var]
+                        ):
+                            raise ValueError(
+                                f"Data contains unexpected states for variable: {var}."
+                            )
+                        self.state_names[var] = state_names[var]
+                    else:
+                        self.state_names[var] = self._collect_state_names(var)
+
+    def _collect_state_names(self, variable):
+        "Return a list of states that the variable takes in the data."
+        states = sorted(list(self.data.loc[:, variable].dropna().unique()))
+        return states
+
+    def state_counts(
+        self,
+        variable,
+        parents=[],
+        weighted=False,
+        reindex=True,
+    ):
+        """
+        Return counts how often each state of 'variable' occurred in the data.
+        If a list of parents is provided, counting is done conditionally
+        for each state configuration of the parents.
+
+        Parameters
+        ----------
+        variable: string
+            Name of the variable for which the state count is to be done.
+
+        parents: list
+            Optional list of variable parents, if conditional counting is desired.
+            Order of parents in list is reflected in the returned DataFrame
+
+        weighted: bool
+            If True, data must have a `_weight` column specifying the weight of the
+            datapoint (row). If False, each datapoint has a weight of `1`.
+
+        reindex: bool
+            If True, returns a data frame with all possible parents state combinations
+            as the columns. If False, drops the state combinations which are not
+            present in the data.
+
+        Returns
+        -------
+        state_counts: pandas.DataFrame
+            Table with state counts for 'variable'
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> from pgmpy.estimators import BaseEstimator
+        >>> data = pd.DataFrame(data={'A': ['a1', 'a1', 'a2'],
+                                      'B': ['b1', 'b2', 'b1'],
+                                      'C': ['c1', 'c1', 'c2']})
+        >>> estimator = BaseEstimator(data)
+        >>> estimator.state_counts('A')
+            A
+        a1  2
+        a2  1
+        >>> estimator.state_counts('C', parents=['A', 'B'])
+        A  a1      a2
+        B  b1  b2  b1  b2
+        C
+        c1  1   1   0   0
+        c2  0   0   1   0
+        >>> estimator.state_counts('C', parents=['A'])
+        A    a1   a2
+        C
+        c1  2.0  0.0
+        c2  0.0  1.0
+        """
+        parents = list(parents)
+
+        if weighted and ("_weight" not in self.data.columns):
+            raise ValueError("data must contain a `_weight` column if weighted=True")
+
+        if not parents:
+            # count how often each state of 'variable' occurred
+            if weighted:
+                state_count_data = self.data.groupby([variable], observed=True)[
+                    "_weight"
+                ].sum()
+            else:
+                state_count_data = self.data.loc[:, variable].value_counts()
+
+            state_counts = (
+                state_count_data.reindex(self.state_names[variable])
+                .fillna(0)
+                .to_frame()
+            )
+
+        else:
+            parents_states = [self.state_names[parent] for parent in parents]
+            # count how often each state of 'variable' occurred, conditional on parents' states
+            if weighted:
+                state_count_data = (
+                    self.data.groupby([variable] + parents, observed=True)["_weight"]
+                    .sum()
+                    .unstack(parents)
+                )
+
+            else:
+                state_count_data = (
+                    self.data.groupby([variable] + parents, observed=True)
+                    .size()
+                    .unstack(parents)
+                )
+
+            if not isinstance(state_count_data.columns, pd.MultiIndex):
+                state_count_data.columns = pd.MultiIndex.from_arrays(
+                    [state_count_data.columns]
+                )
+
+            if reindex:
+                # reindex rows & columns to sort them and to add missing ones
+                # missing row    = some state of 'variable' did not occur in data
+                # missing column = some state configuration of current 'variable's parents
+                #                  did not occur in data
+                row_index = self.state_names[variable]
+                column_index = pd.MultiIndex.from_product(parents_states, names=parents)
+                state_counts = state_count_data.reindex(
+                    index=row_index, columns=column_index
+                ).fillna(0)
+            else:
+                state_counts = state_count_data.fillna(0)
+
+        return state_counts
+
+
+class ParameterEstimator(BaseEstimator):
+    """
+    Base class for parameter estimators in pgmpy.
+
+    Parameters
+    ----------
+    model: pgmpy.models.BayesianNetwork or pgmpy.models.MarkovNetwork model
+        for which parameter estimation is to be done.
+
+    data: pandas DataFrame object
+        dataframe object with column names identical to the variable names of the model.
+        (If some values in the data are missing the data cells should be set to `numpy.nan`.
+        Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+    state_names: dict (optional)
+        A dict indicating, for each variable, the discrete set of states (or values)
+        that the variable can take. If unspecified, the observed values in the data set
+        are taken to be the only possible states.
+    """
+
+    def __init__(self, model, data, **kwargs):
+        """
+        Base class for parameter estimators in pgmpy.
+
+        Parameters
+        ----------
+        model: pgmpy.models.BayesianNetwork or pgmpy.models.MarkovNetwork model
+            for which parameter estimation is to be done.
+
+        data: pandas DataFrame object
+            dataframe object with column names identical to the variable names of the model.
+            (If some values in the data are missing the data cells should be set to `numpy.nan`.
+            Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+        state_names: dict (optional)
+            A dict indicating, for each variable, the discrete set of states (or values)
+            that the variable can take. If unspecified, the observed values in the data set
+            are taken to be the only possible states.
+
+        complete_samples_only: bool (optional, default `True`)
+            Specifies how to deal with missing data, if present. If set to `True` all rows
+            that contain `np.Nan` somewhere are ignored. If `False` then, for each variable,
+            every row where neither the variable nor its parents are `np.nan` is used.
+            This sets the behavior of the `state_count`-method.
+        """
+        self.model = model
+
+        super(ParameterEstimator, self).__init__(data, **kwargs)
+
+    def state_counts(self, variable, weighted=False, **kwargs):
+        """
+        Return counts how often each state of 'variable' occurred in the data.
+        If the variable has parents, counting is done conditionally
+        for each state configuration of the parents.
+
+        Parameters
+        ----------
+        variable: string
+            Name of the variable for which the state count is to be done.
+
+        Returns
+        -------
+        state_counts: pandas.DataFrame
+            Table with state counts for 'variable'
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> from pgmpy.models import BayesianNetwork
+        >>> from pgmpy.estimators import ParameterEstimator
+        >>> model = BayesianNetwork([('A', 'C'), ('B', 'C')])
+        >>> data = pd.DataFrame(data={'A': ['a1', 'a1', 'a2'],
+                                      'B': ['b1', 'b2', 'b1'],
+                                      'C': ['c1', 'c1', 'c2']})
+        >>> estimator = ParameterEstimator(model, data)
+        >>> estimator.state_counts('A')
+            A
+        a1  2
+        a2  1
+        >>> estimator.state_counts('C')
+        A  a1      a2
+        B  b1  b2  b1  b2
+        C
+        c1  1   1   0   0
+        c2  0   0   1   0
+        """
+
+        parents = sorted(self.model.get_parents(variable))
+        return super(ParameterEstimator, self).state_counts(
+            variable, parents=parents, weighted=weighted, **kwargs
+        )
+
+
+class StructureEstimator(BaseEstimator):
+    """
+    Base class for structure estimators in pgmpy.
+
+    Parameters
+    ----------
+    data: pandas DataFrame object
+        dataframe object where each column represents one variable.
+        (If some values in the data are missing the data cells should be set to `numpy.nan`.
+        Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+    state_names: dict (optional)
+        A dict indicating, for each variable, the discrete set of states (or values)
+        that the variable can take. If unspecified, the observed values in the data set
+        are taken to be the only possible states.
+    """
+
+    def __init__(self, data=None, independencies=None, **kwargs):
+        self.independencies = independencies
+        if self.independencies is not None:
+            self.variables = self.independencies.get_all_variables()
+
+        super(StructureEstimator, self).__init__(data=data, **kwargs)
+
+    def estimate(self):
+        pass
+
+
+class MarginalEstimator(BaseEstimator):
+    """
+    Base class for marginal estimators in pgmpy.
+
+    Parameters
+    ----------
+    model: MarkovNetwork | FactorGraph | JunctionTree
+        A model to optimize, using Belief Propagation and an estimation method.
+
+    data: pandas DataFrame object
+        dataframe object where each column represents one variable.
+        (If some values in the data are missing the data cells should be set to `numpy.nan`.
+        Note that pandas converts each column containing `numpy.nan`s to dtype `float`.)
+
+    state_names: dict (optional)
+        A dict indicating, for each variable, the discrete set of states (or values)
+        that the variable can take. If unspecified, the observed values in the data set
+        are taken to be the only possible states.
+    """
+
+    def __init__(self, model, data, **kwargs):
+        super().__init__(data, **kwargs)
+        self.belief_propagation = BeliefPropagation(model=model)
+        self.theta = None
+
+    @staticmethod
+    def _clique_to_marginal(marginals, clique_nodes):
+        """
+        Construct a minimal mapping from cliques to marginals.
+
+        Parameters
+        ----------
+        marginals: FactorDict
+            A mapping from cliques to factors.
+
+        clique_nodes: List[Tuple[str, ...]]
+            Cliques that exist within a different FactorDict.
+
+        Returns
+        -------
+        clique_to_marginal: A mapping from clique to a list of marginals
+        such that each clique is a super set of the marginals it is associated with.
+        """
+        clique_to_marginal = defaultdict(lambda: [])
+        for marginal_clique, marginal in marginals.items():
+            for clique in clique_nodes:
+                if set(marginal_clique) <= set(clique):
+                    clique_to_marginal[clique].append(marginal)
+                    break
+            else:
+                raise ValueError(
+                    "Could not find a corresponding clique for"
+                    + f" marginal: {marginal_clique}"
+                    + f" out of cliques: {clique_nodes}"
+                )
+        return clique_to_marginal
+
+    def _marginal_loss(self, marginals, clique_to_marginal, metric):
+        """
+        Compute the loss and gradient for a given dictionary of clique beliefs.
+
+        Parameters
+        ----------
+        marginals: FactorDict
+            A mapping from a clique to an observed marginal represented by a `DiscreteFactor`.
+
+        clique_to_marginal: Dict[Tuple[str, ...], List[DiscreteFactor]]
+            A mapping from a Junction Tree's clique to a list of corresponding marginals
+            such that a clique is a superset of the marginal with the constraint that
+            each marginal only appears once across all cliques.
+
+        metric: str
+            One of either 'L1' or 'L2'.
+
+        Returns
+        -------
+        Loss and gradient of the loss: Tuple[float, pgmpy.factors.FactorDict.FactorDict]
+            Marginal loss and the gradients of the loss with respect to the estimated beliefs.
+        """
+        loss = 0.0
+        gradient = FactorDict({})
+
+        for clique, mu in marginals.items():
+            # Initialize a gradient for this clique as zero.
+            gradient[clique] = mu.identity_factor() * 0
+
+            # Iterate over all marginals involving this clique.
+            for y in clique_to_marginal[clique]:
+                # Step 1: Marginalize the clique to the size of `y`.
+                projection_variables = list(set(mu.scope()) - set(y.scope()))
+                mu2 = mu.marginalize(
+                    variables=projection_variables,
+                    inplace=False,
+                )
+
+                if not isinstance(mu2, DiscreteFactor):
+                    raise TypeError(f"Expecting a DiscreteFactor but found {type(mu2)}")
+
+                # Step 2: Compute the difference between the `mu2` and `y`.
+                diff_factor = mu2 + (y * -1)
+
+                if not diff_factor:
+                    raise ValueError("An error occured when calculating the gradient.")
+
+                diff = diff_factor.values.flatten()
+
+                # Step 3: Compute the loss and gradient based upon the metric.
+                if metric == "L1":
+                    loss += abs(diff).sum()
+                    grad = diff.sign() if hasattr(diff, "sign") else np.sign(diff)
+                elif metric == "L2":
+                    loss += 0.5 * (diff @ diff)
+                    grad = diff
+                else:
+                    raise ValueError("Metric must be one of L1 or L2.")
+
+                # Step 4: Update the gradient from this marginal.
+                gradient[clique] += DiscreteFactor(
+                    variables=mu2.scope(),
+                    cardinality=mu2.cardinality,
+                    values=grad,
+                    state_names=mu2.state_names,
+                )
+
+        return loss, gradient
+
+    def estimate(self):
+        pass

testbed/pgmpy__pgmpy/pgmpy/estimators/expert.py

@@ -0,0 +1,207 @@
+import sys
+from itertools import combinations
+
+import networkx as nx
+import pandas as pd
+
+from pgmpy import config
+from pgmpy.base import DAG
+from pgmpy.estimators import StructureEstimator
+from pgmpy.estimators.CITests import pillai_trace
+from pgmpy.utils import llm_pairwise_orient, manual_pairwise_orient
+
+
+class ExpertInLoop(StructureEstimator):
+    def __init__(self, data=None, **kwargs):
+        super(ExpertInLoop, self).__init__(data=data, **kwargs)
+
+    def test_all(self, dag):
+        """
+        Runs CI tests on all possible combinations of variables in `dag`.
+
+        Parameters
+        ----------
+        dag: pgmpy.base.DAG
+            The DAG on which to run the tests.
+
+        Returns
+        -------
+        pd.DataFrame: The results with p-values and effect sizes of all the tests.
+        """
+        cis = []
+        for u, v in combinations(list(dag.nodes()), 2):
+            u_parents = set(dag.get_parents(u))
+            v_parents = set(dag.get_parents(v))
+
+            if v in u_parents:
+                u_parents -= set([v])
+                edge_present = True
+            elif u in v_parents:
+                v_parents -= set([u])
+                edge_present = True
+            else:
+                edge_present = False
+
+            cond_set = list(set(u_parents).union(v_parents))
+            effect, p_value = pillai_trace(
+                X=u, Y=v, Z=cond_set, data=self.data, boolean=False
+            )
+            cis.append([u, v, cond_set, edge_present, effect, p_value])
+
+        return pd.DataFrame(
+            cis, columns=["u", "v", "z", "edge_present", "effect", "p_val"]
+        )
+
+    def estimate(
+        self,
+        pval_threshold=0.05,
+        effect_size_threshold=0.05,
+        use_llm=True,
+        llm_model="gemini/gemini-1.5-flash",
+        variable_descriptions=None,
+        show_progress=True,
+        **kwargs,
+    ):
+        """
+        Estimates a DAG from the data by utilizing expert knowledge.
+
+        The method iteratively adds and removes edges between variables
+        (similar to Greedy Equivalence Search algorithm) based on a score
+        metric that improves the model's fit to the data the most. The score
+        metric used is based on conditional independence testing. When adding
+        an edge to the model, the method asks for expert knowledge to decide
+        the orientation of the edge. Alternatively, an LLM can used to decide
+        the orientation of the edge.
+
+        Parameters
+        ----------
+        pval_threshold: float
+            The p-value threshold to use for the test to determine whether
+            there is a significant association between the variables or not.
+
+        effect_size_threshold: float
+            The effect size threshold to use to suggest a new edge. If the
+            conditional effect size between two variables is greater than the
+            threshold, the algorithm would suggest to add an edge between them.
+            And if the effect size for an edge is less than the threshold,
+            would suggest to remove the edge.
+
+        use_llm: bool
+            Whether to use a Large Language Model for edge orientation. If
+            False, prompts the user to specify the direction between the edges.
+
+        llm_model: str (default: gemini/gemini-1.5-flash)
+            The LLM model to use. Please refer to litellm documentation (https://docs.litellm.ai/docs/providers)
+            for available model options. Default is gemini-1.5-flash
+
+        variable_descriptions: dict
+            A dict of the form {var: description} giving a text description of
+            each variable in the model.
+
+        show_progress: bool (default: True)
+            If True, prints info of the running status.
+
+        kwargs: kwargs
+            Any additional parameters to pass to litellm.completion method.
+            Please refer documentation at: https://docs.litellm.ai/docs/completion/input#input-params-1
+
+        Returns
+        -------
+        pgmpy.base.DAG: A DAG representing the learned causal structure.
+
+        Examples
+        --------
+        >>> from pgmpy.utils import get_example_model
+        >>> from pgmpy.estimators import ExpertInLoop
+        >>> model = get_example_model('cancer')
+        >>> df = model.simulate(int(1e3))
+        >>> variable_descriptions = {
+        ...     "Smoker": "A binary variable representing whether a person smokes or not.",
+        ...     "Cancer": "A binary variable representing whether a person has cancer. ",
+        ...     "Xray": "A binary variable representing the result of an X-ray test.",
+        ...     "Pollution": "A binary variable representing whether the person is in a high-pollution area or not."
+        ...     "Dyspnoea": "A binary variable representing whether a person has shortness of breath. "}
+        >>> dag = ExpertInLoop(df).estimate(
+        ...                 effect_size_threshold=0.0001,
+        ...                 use_llm=True,
+        ...                 variable_descriptions=variable_descriptions)
+        >>> dag.edges()
+        OutEdgeView([('Smoker', 'Cancer'), ('Cancer', 'Xray'), ('Cancer', 'Dyspnoea'), ('Pollution', 'Cancer')])
+        """
+        # Step 0: Create a new DAG on all the variables with no edge.
+        nodes = list(self.data.columns)
+        dag = DAG()
+        dag.add_nodes_from(nodes)
+
+        blacklisted_edges = []
+        while True:
+            # Step 1: Compute effects and p-values between every combination of variables.
+            all_effects = self.test_all(dag)
+
+            # Step 2: Remove any edges between variables that are not sufficiently associated.
+            edge_effects = all_effects[all_effects.edge_present == True]
+            edge_effects = edge_effects[
+                (edge_effects.effect < effect_size_threshold)
+                & (edge_effects.p_val > pval_threshold)
+            ]
+            remove_edges = list(edge_effects.loc[:, ("u", "v")].to_records(index=False))
+            for edge in remove_edges:
+                dag.remove_edge(edge[0], edge[1])
+
+            # Step 3: Add edge between variables which have significant association.
+            nonedge_effects = all_effects[all_effects.edge_present == False]
+            nonedge_effects = nonedge_effects[
+                (nonedge_effects.effect >= effect_size_threshold)
+                & (nonedge_effects.p_val <= pval_threshold)
+            ]
+
+            # Step 3.2: Else determine the edge direction and add it if not in blacklisted_edges.
+            if len(blacklisted_edges) > 0:
+                blacklisted_edges_us = [edge[0] for edge in blacklisted_edges]
+                blacklisted_edges_vs = [edge[1] for edge in blacklisted_edges]
+                nonedge_effects = nonedge_effects.loc[
+                    ~(
+                        (
+                            nonedge_effects.u.isin(blacklisted_edges_us)
+                            & nonedge_effects.v.isin(blacklisted_edges_vs)
+                        )
+                        | (
+                            nonedge_effects.u.isin(blacklisted_edges_vs)
+                            & nonedge_effects.v.isin(blacklisted_edges_us)
+                        )
+                    ),
+                    :,
+                ]
+
+            # Step 3.1: Exit loop if all correlations in data are explained by the model.
+            if (edge_effects.shape[0] == 0) and (nonedge_effects.shape[0] == 0):
+                break
+
+            selected_edge = nonedge_effects.iloc[nonedge_effects.effect.argmax()]
+            if use_llm:
+                edge_direction = llm_pairwise_orient(
+                    selected_edge.u,
+                    selected_edge.v,
+                    variable_descriptions,
+                    llm_model=llm_model,
+                    **kwargs,
+                )
+
+                if config.SHOW_PROGRESS and show_progress:
+                    sys.stdout.write(
+                        f"\rQueried for edge orientation between {selected_edge.u} and {selected_edge.v}. Got: {edge_direction[0]} -> {edge_direction[1]}"
+                    )
+                    sys.stdout.flush()
+
+            else:
+                edge_direction = manual_pairwise_orient(
+                    selected_edge.u, selected_edge.v
+                )
+
+            # Step 3.3: Blacklist the edge if it creates a cycle, else add it to the DAG.
+            if nx.has_path(dag, edge_direction[1], edge_direction[0]):
+                blacklisted_edges.append(edge_direction)
+            else:
+                dag.add_edges_from([edge_direction])
+
+        return dag

testbed/pgmpy__pgmpy/pgmpy/extern/__init__.py

@@ -0,0 +1,3 @@
+from .tabulate import tabulate
+
+__all__ = ["tabulate"]

testbed/pgmpy__pgmpy/pgmpy/extern/tabulate.py

@@ -0,0 +1,970 @@
+# -*- coding: utf-8 -*-
+
+# LICENSE INFORMATION
+#
+# Copyright (c) 2011-2013 Sergey Astanin
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+#  "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+#     The above copyright notice and this permission notice shall be
+#     included in all copies or substantial portions of the Software.
+#
+#     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#     LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#     OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""Pretty-print tabular data."""
+
+from __future__ import print_function
+from __future__ import unicode_literals
+from collections import namedtuple
+from platform import python_version_tuple
+import re
+
+
+if python_version_tuple()[0] < "3":
+    from itertools import izip_longest
+    from functools import partial
+
+    _none_type = type(None)
+    _int_type = int
+    _float_type = float
+    _text_type = unicode
+    _binary_type = str
+else:
+    from itertools import zip_longest as izip_longest
+    from functools import reduce, partial
+
+    _none_type = type(None)
+    _int_type = int
+    _float_type = float
+    _text_type = str
+    _binary_type = bytes
+
+
+__all__ = ["tabulate", "tabulate_formats", "simple_separated_format"]
+__version__ = "0.7.3"
+
+
+Line = namedtuple("Line", ["begin", "hline", "sep", "end"])
+
+
+DataRow = namedtuple("DataRow", ["begin", "sep", "end"])
+
+
+# A table structure is supposed to be:
+#
+#     --- lineabove ---------
+#         headerrow
+#     --- linebelowheader ---
+#         datarow
+#     --- linebewteenrows ---
+#     ... (more datarows) ...
+#     --- linebewteenrows ---
+#         last datarow
+#     --- linebelow ---------
+#
+# TableFormat's line* elements can be
+#
+#   - either None, if the element is not used,
+#   - or a Line tuple,
+#   - or a function: [col_widths], [col_alignments] -> string.
+#
+# TableFormat's *row elements can be
+#
+#   - either None, if the element is not used,
+#   - or a DataRow tuple,
+#   - or a function: [cell_values], [col_widths], [col_alignments] -> string.
+#
+# padding (an integer) is the amount of white space around data values.
+#
+# with_header_hide:
+#
+#   - either None, to display all table elements unconditionally,
+#   - or a list of elements not to be displayed if the table has column headers.
+#
+TableFormat = namedtuple(
+    "TableFormat",
+    [
+        "lineabove",
+        "linebelowheader",
+        "linebetweenrows",
+        "linebelow",
+        "headerrow",
+        "datarow",
+        "padding",
+        "with_header_hide",
+    ],
+)
+
+
+def _pipe_segment_with_colons(align, colwidth):
+    """Return a segment of a horizontal line with optional colons which
+    indicate column's alignment (as in `pipe` output format)."""
+    w = colwidth
+    if align in ["right", "decimal"]:
+        return ("-" * (w - 1)) + ":"
+    elif align == "center":
+        return ":" + ("-" * (w - 2)) + ":"
+    elif align == "left":
+        return ":" + ("-" * (w - 1))
+    else:
+        return "-" * w
+
+
+def _pipe_line_with_colons(colwidths, colaligns):
+    """Return a horizontal line with optional colons to indicate column's
+    alignment (as in `pipe` output format)."""
+    segments = [_pipe_segment_with_colons(a, w) for a, w in zip(colaligns, colwidths)]
+    return "|" + "|".join(segments) + "|"
+
+
+def _mediawiki_row_with_attrs(separator, cell_values, colwidths, colaligns):
+    alignment = {
+        "left": "",
+        "right": 'align="right"| ',
+        "center": 'align="center"| ',
+        "decimal": 'align="right"| ',
+    }
+    # hard-coded padding _around_ align attribute and value together
+    # rather than padding parameter which affects only the value
+    values_with_attrs = [
+        " " + alignment.get(a, "") + c + " " for c, a in zip(cell_values, colaligns)
+    ]
+    colsep = separator * 2
+    return (separator + colsep.join(values_with_attrs)).rstrip()
+
+
+def _latex_line_begin_tabular(colwidths, colaligns):
+    alignment = {"left": "l", "right": "r", "center": "c", "decimal": "r"}
+    tabular_columns_fmt = "".join([alignment.get(a, "l") for a in colaligns])
+    return "\\begin{tabular}{" + tabular_columns_fmt + "}\n\hline"
+
+
+_table_formats = {
+    "simple": TableFormat(
+        lineabove=Line("", "-", "  ", ""),
+        linebelowheader=Line("", "-", "  ", ""),
+        linebetweenrows=None,
+        linebelow=Line("", "-", "  ", ""),
+        headerrow=DataRow("", "  ", ""),
+        datarow=DataRow("", "  ", ""),
+        padding=0,
+        with_header_hide=["lineabove", "linebelow"],
+    ),
+    "plain": TableFormat(
+        lineabove=None,
+        linebelowheader=None,
+        linebetweenrows=None,
+        linebelow=None,
+        headerrow=DataRow("", "  ", ""),
+        datarow=DataRow("", "  ", ""),
+        padding=0,
+        with_header_hide=None,
+    ),
+    "grid": TableFormat(
+        lineabove=Line("+", "-", "+", "+"),
+        linebelowheader=Line("+", "=", "+", "+"),
+        linebetweenrows=Line("+", "-", "+", "+"),
+        linebelow=Line("+", "-", "+", "+"),
+        headerrow=DataRow("|", "|", "|"),
+        datarow=DataRow("|", "|", "|"),
+        padding=1,
+        with_header_hide=None,
+    ),
+    "pipe": TableFormat(
+        lineabove=_pipe_line_with_colons,
+        linebelowheader=_pipe_line_with_colons,
+        linebetweenrows=None,
+        linebelow=None,
+        headerrow=DataRow("|", "|", "|"),
+        datarow=DataRow("|", "|", "|"),
+        padding=1,
+        with_header_hide=["lineabove"],
+    ),
+    "orgtbl": TableFormat(
+        lineabove=None,
+        linebelowheader=Line("|", "-", "+", "|"),
+        linebetweenrows=None,
+        linebelow=None,
+        headerrow=DataRow("|", "|", "|"),
+        datarow=DataRow("|", "|", "|"),
+        padding=1,
+        with_header_hide=None,
+    ),
+    "rst": TableFormat(
+        lineabove=Line("", "=", "  ", ""),
+        linebelowheader=Line("", "=", "  ", ""),
+        linebetweenrows=None,
+        linebelow=Line("", "=", "  ", ""),
+        headerrow=DataRow("", "  ", ""),
+        datarow=DataRow("", "  ", ""),
+        padding=0,
+        with_header_hide=None,
+    ),
+    "mediawiki": TableFormat(
+        lineabove=Line(
+            '{| class="wikitable" style="text-align: left;"',
+            "",
+            "",
+            "\n|+ <!-- caption -->\n|-",
+        ),
+        linebelowheader=Line("|-", "", "", ""),
+        linebetweenrows=Line("|-", "", "", ""),
+        linebelow=Line("|}", "", "", ""),
+        headerrow=partial(_mediawiki_row_with_attrs, "!"),
+        datarow=partial(_mediawiki_row_with_attrs, "|"),
+        padding=0,
+        with_header_hide=None,
+    ),
+    "latex": TableFormat(
+        lineabove=_latex_line_begin_tabular,
+        linebelowheader=Line("\\hline", "", "", ""),
+        linebetweenrows=None,
+        linebelow=Line("\\hline\n\\end{tabular}", "", "", ""),
+        headerrow=DataRow("", "&", "\\\\"),
+        datarow=DataRow("", "&", "\\\\"),
+        padding=1,
+        with_header_hide=None,
+    ),
+    "tsv": TableFormat(
+        lineabove=None,
+        linebelowheader=None,
+        linebetweenrows=None,
+        linebelow=None,
+        headerrow=DataRow("", "\t", ""),
+        datarow=DataRow("", "\t", ""),
+        padding=0,
+        with_header_hide=None,
+    ),
+}
+
+
+tabulate_formats = list(sorted(_table_formats.keys()))
+
+
+_invisible_codes = re.compile("\x1b\[\d*m")  # ANSI color codes
+_invisible_codes_bytes = re.compile(b"\x1b\[\d*m")  # ANSI color codes
+
+
+def simple_separated_format(separator):
+    r"""Construct a simple TableFormat with columns separated by a separator.
+
+    >>> tsv = simple_separated_format("\t")
+    >>> tabulate([["foo", 1], ["spam", 23]], tablefmt=tsv) == 'foo \t 1\nspam\t23'
+    True
+
+    """
+    return TableFormat(
+        None,
+        None,
+        None,
+        None,
+        headerrow=DataRow("", separator, ""),
+        datarow=DataRow("", separator, ""),
+        padding=0,
+        with_header_hide=None,
+    )
+
+
+def _isconvertible(conv, string):
+    try:
+        n = conv(string)
+        return True
+    except ValueError:
+        return False
+
+
+def _isnumber(string):
+    """
+    >>> _isnumber("123.45")
+    True
+    >>> _isnumber("123")
+    True
+    >>> _isnumber("spam")
+    False
+    """
+    return _isconvertible(float, string)
+
+
+def _isint(string):
+    """
+    >>> _isint("123")
+    True
+    >>> _isint("123.45")
+    False
+    """
+    return (
+        type(string) is int
+        or (isinstance(string, _binary_type) or isinstance(string, _text_type))
+        and _isconvertible(int, string)
+    )
+
+
+def _type(string, has_invisible=True):
+    """The least generic type (type(None), int, float, str, unicode).
+
+    >>> _type(None) is type(None)
+    True
+    >>> _type("foo") is type("")
+    True
+    >>> _type("1") is type(1)
+    True
+    >>> _type('\x1b[31m42\x1b[0m') is type(42)
+    True
+    >>> _type('\x1b[31m42\x1b[0m') is type(42)
+    True
+
+    """
+
+    if has_invisible and (
+        isinstance(string, _text_type) or isinstance(string, _binary_type)
+    ):
+        string = _strip_invisible(string)
+
+    if string is None:
+        return _none_type
+    elif hasattr(string, "isoformat"):  # datetime.datetime, date, and time
+        return _text_type
+    elif _isint(string):
+        return int
+    elif _isnumber(string):
+        return float
+    elif isinstance(string, _binary_type):
+        return _binary_type
+    else:
+        return _text_type
+
+
+def _afterpoint(string):
+    """Symbols after a decimal point, -1 if the string lacks the decimal point.
+
+    >>> _afterpoint("123.45")
+    2
+    >>> _afterpoint("1001")
+    -1
+    >>> _afterpoint("eggs")
+    -1
+    >>> _afterpoint("123e45")
+    2
+
+    """
+    if _isnumber(string):
+        if _isint(string):
+            return -1
+        else:
+            pos = string.rfind(".")
+            pos = string.lower().rfind("e") if pos < 0 else pos
+            if pos >= 0:
+                return len(string) - pos - 1
+            else:
+                return -1  # no point
+    else:
+        return -1  # not a number
+
+
+def _padleft(width, s, has_invisible=True):
+    """Flush right.
+
+    >>> _padleft(6, '\u044f\u0439\u0446\u0430') == '  \u044f\u0439\u0446\u0430'
+    True
+
+    """
+    iwidth = width + len(s) - len(_strip_invisible(s)) if has_invisible else width
+    fmt = "{0:>%ds}" % iwidth
+    return fmt.format(s)
+
+
+def _padright(width, s, has_invisible=True):
+    """Flush left.
+
+    >>> _padright(6, '\u044f\u0439\u0446\u0430') == '\u044f\u0439\u0446\u0430  '
+    True
+
+    """
+    iwidth = width + len(s) - len(_strip_invisible(s)) if has_invisible else width
+    fmt = "{0:<%ds}" % iwidth
+    return fmt.format(s)
+
+
+def _padboth(width, s, has_invisible=True):
+    """Center string.
+
+    >>> _padboth(6, '\u044f\u0439\u0446\u0430') == ' \u044f\u0439\u0446\u0430 '
+    True
+
+    """
+    iwidth = width + len(s) - len(_strip_invisible(s)) if has_invisible else width
+    fmt = "{0:^%ds}" % iwidth
+    return fmt.format(s)
+
+
+def _strip_invisible(s):
+    "Remove invisible ANSI color codes."
+    if isinstance(s, _text_type):
+        return re.sub(_invisible_codes, "", s)
+    else:  # a bytestring
+        return re.sub(_invisible_codes_bytes, "", s)
+
+
+def _visible_width(s):
+    """Visible width of a printed string. ANSI color codes are removed.
+
+    >>> _visible_width('\x1b[31mhello\x1b[0m'), _visible_width("world")
+    (5, 5)
+
+    """
+    if isinstance(s, _text_type) or isinstance(s, _binary_type):
+        return len(_strip_invisible(s))
+    else:
+        return len(_text_type(s))
+
+
+def _align_column(strings, alignment, minwidth=0, has_invisible=True):
+    """[string] -> [padded_string]
+
+    >>> list(map(str,_align_column(["12.345", "-1234.5", "1.23", "1234.5", "1e+234", "1.0e234"], "decimal")))
+    ['   12.345  ', '-1234.5    ', '    1.23   ', ' 1234.5    ', '    1e+234 ', '    1.0e234']
+
+    >>> list(map(str,_align_column(['123.4', '56.7890'], None)))
+    ['123.4', '56.7890']
+
+    """
+    if alignment == "right":
+        strings = [s.strip() for s in strings]
+        padfn = _padleft
+    elif alignment == "center":
+        strings = [s.strip() for s in strings]
+        padfn = _padboth
+    elif alignment == "decimal":
+        decimals = [_afterpoint(s) for s in strings]
+        maxdecimals = max(decimals)
+        strings = [s + (maxdecimals - decs) * " " for s, decs in zip(strings, decimals)]
+        padfn = _padleft
+    elif not alignment:
+        return strings
+    else:
+        strings = [s.strip() for s in strings]
+        padfn = _padright
+
+    if has_invisible:
+        width_fn = _visible_width
+    else:
+        width_fn = len
+
+    maxwidth = max(max(map(width_fn, strings)), minwidth)
+    padded_strings = [padfn(maxwidth, s, has_invisible) for s in strings]
+    return padded_strings
+
+
+def _more_generic(type1, type2):
+    types = {_none_type: 0, int: 1, float: 2, _binary_type: 3, _text_type: 4}
+    invtypes = {4: _text_type, 3: _binary_type, 2: float, 1: int, 0: _none_type}
+    moregeneric = max(types.get(type1, 4), types.get(type2, 4))
+    return invtypes[moregeneric]
+
+
+def _column_type(strings, has_invisible=True):
+    """The least generic type all column values are convertible to.
+
+    >>> _column_type(["1", "2"]) is _int_type
+    True
+    >>> _column_type(["1", "2.3"]) is _float_type
+    True
+    >>> _column_type(["1", "2.3", "four"]) is _text_type
+    True
+    >>> _column_type(["four", '\u043f\u044f\u0442\u044c']) is _text_type
+    True
+    >>> _column_type([None, "brux"]) is _text_type
+    True
+    >>> _column_type([1, 2, None]) is _int_type
+    True
+    >>> import datetime as dt
+    >>> _column_type([dt.datetime(1991,2,19), dt.time(17,35)]) is _text_type
+    True
+
+    """
+    types = [_type(s, has_invisible) for s in strings]
+    return reduce(_more_generic, types, int)
+
+
+def _format(val, valtype, floatfmt, missingval=""):
+    r"""Format a value accoding to its type.
+
+    Unicode is supported:
+
+    >>> hrow = ['\u0431\u0443\u043a\u0432\u0430', '\u0446\u0438\u0444\u0440\u0430']
+    >>> tbl = [['\u0430\u0437', 2], ['\u0431\u0443\u043a\u0438', 4]]
+    >>> good_result = '\u0431\u0443\u043a\u0432\u0430      \u0446\u0438\u0444\u0440\u0430\n-------  -------\n\u0430\u0437             2\n\u0431\u0443\u043a\u0438           4'
+    >>> tabulate(tbl, headers=hrow) == good_result
+    True
+
+    """
+    if val is None:
+        return missingval
+
+    if valtype in [int, _text_type]:
+        return "{0}".format(val)
+    elif valtype is _binary_type:
+        try:
+            return _text_type(val, "ascii")
+        except TypeError:
+            return _text_type(val)
+    elif valtype is float:
+        return format(float(val), floatfmt)
+    else:
+        return "{0}".format(val)
+
+
+def _align_header(header, alignment, width):
+    if alignment == "left":
+        return _padright(width, header)
+    elif alignment == "center":
+        return _padboth(width, header)
+    elif not alignment:
+        return "{0}".format(header)
+    else:
+        return _padleft(width, header)
+
+
+def _normalize_tabular_data(tabular_data, headers):
+    """Transform a supported data type to a list of lists, and a list of headers.
+
+    Supported tabular data types:
+
+    * list-of-lists or another iterable of iterables
+
+    * list of named tuples (usually used with headers="keys")
+
+    * list of dicts (usually used with headers="keys")
+
+    * list of OrderedDicts (usually used with headers="keys")
+
+    * 2D NumPy arrays
+
+    * NumPy record arrays (usually used with headers="keys")
+
+    * dict of iterables (usually used with headers="keys")
+
+    * pandas.DataFrame (usually used with headers="keys")
+
+    The first row can be used as headers if headers="firstrow",
+    column indices can be used as headers if headers="keys".
+
+    """
+
+    if hasattr(tabular_data, "keys") and hasattr(tabular_data, "values"):
+        # dict-like and pandas.DataFrame?
+        if hasattr(tabular_data.values, "__call__"):
+            # likely a conventional dict
+            keys = tabular_data.keys()
+            rows = list(
+                izip_longest(*tabular_data.values())
+            )  # columns have to be transposed
+        elif hasattr(tabular_data, "index"):
+            # values is a property, has .index => it's likely a pandas.DataFrame (pandas 0.11.0)
+            keys = tabular_data.keys()
+            vals = tabular_data.values  # values matrix doesn't need to be transposed
+            names = tabular_data.index
+            rows = [[v] + list(row) for v, row in zip(names, vals)]
+        else:
+            raise ValueError("tabular data doesn't appear to be a dict or a DataFrame")
+
+        if headers == "keys":
+            headers = list(map(_text_type, keys))  # headers should be strings
+
+    else:  # it's a usual an iterable of iterables, or a NumPy array
+        rows = list(tabular_data)
+
+        if (
+            headers == "keys"
+            and hasattr(tabular_data, "dtype")
+            and getattr(tabular_data.dtype, "names")
+        ):
+            # numpy record array
+            headers = tabular_data.dtype.names
+        elif (
+            headers == "keys"
+            and len(rows) > 0
+            and isinstance(rows[0], tuple)
+            and hasattr(rows[0], "_fields")
+        ):
+            # namedtuple
+            headers = list(map(_text_type, rows[0]._fields))
+        elif len(rows) > 0 and isinstance(rows[0], dict):
+            # dict or OrderedDict
+            uniq_keys = set()  # implements hashed lookup
+            keys = []  # storage for set
+            if headers == "firstrow":
+                firstdict = rows[0] if len(rows) > 0 else {}
+                keys.extend(firstdict.keys())
+                uniq_keys.update(keys)
+                rows = rows[1:]
+            for row in rows:
+                for k in row.keys():
+                    # Save unique items in input order
+                    if k not in uniq_keys:
+                        keys.append(k)
+                        uniq_keys.add(k)
+            if headers == "keys":
+                headers = keys
+            elif headers == "firstrow" and len(rows) > 0:
+                headers = [firstdict.get(k, k) for k in keys]
+                headers = list(map(_text_type, headers))
+            rows = [[row.get(k) for k in keys] for row in rows]
+        elif headers == "keys" and len(rows) > 0:
+            # keys are column indices
+            headers = list(map(_text_type, range(len(rows[0]))))
+
+    # take headers from the first row if necessary
+    if headers == "firstrow" and len(rows) > 0:
+        headers = list(map(_text_type, rows[0]))  # headers should be strings
+        rows = rows[1:]
+
+    headers = list(map(_text_type, headers))
+    rows = list(map(list, rows))
+
+    # pad with empty headers for initial columns if necessary
+    if headers and len(rows) > 0:
+        nhs = len(headers)
+        ncols = len(rows[0])
+        if nhs < ncols:
+            headers = [""] * (ncols - nhs) + headers
+
+    return rows, headers
+
+
+def tabulate(
+    tabular_data,
+    headers=[],
+    tablefmt="simple",
+    floatfmt="g",
+    numalign="decimal",
+    stralign="left",
+    missingval="",
+):
+    """Format a fixed width table for pretty printing.
+
+    >>> print(tabulate([[1, 2.34], [-56, "8.999"], ["2", "10001"]]))
+    ---  ---------
+      1      2.34
+    -56      8.999
+      2  10001
+    ---  ---------
+
+    The first required argument (`tabular_data`) can be a
+    list-of-lists (or another iterable of iterables), a list of named
+    tuples, a dictionary of iterables, an iterable of dictionaries,
+    a two-dimensional NumPy array, NumPy record array, or a Pandas'
+    dataframe.
+
+
+    Table headers
+    -------------
+
+    To print nice column headers, supply the second argument (`headers`):
+
+      - `headers` can be an explicit list of column headers
+      - if `headers="firstrow"`, then the first row of data is used
+      - if `headers="keys"`, then dictionary keys or column indices are used
+
+    Otherwise, a headerless table is produced.
+
+    If the number of headers is less than the number of columns, they
+    are supposed to be names of the last columns. This is consistent
+    with the plain-text format of R and Pandas' dataframes.
+
+    >>> print(tabulate([["sex","age"],["Alice","F",24],["Bob","M",19]],
+    ...       headers="firstrow"))
+           sex      age
+    -----  -----  -----
+    Alice  F         24
+    Bob    M         19
+
+
+    Column alignment
+    ----------------
+
+    `tabulate` tries to detect column types automatically, and aligns
+    the values properly. By default, it aligns decimal points of the
+    numbers (or flushes integer numbers to the right), and flushes
+    everything else to the left. Possible column alignments
+    (`numalign`, `stralign`) are: "right", "center", "left", "decimal"
+    (only for `numalign`), and None (to disable alignment).
+
+
+    Table formats
+    -------------
+
+    `floatfmt` is a format specification used for columns which
+    contain numeric data with a decimal point.
+
+    `None` values are replaced with a `missingval` string:
+
+    >>> print(tabulate([["spam", 1, None],
+    ...                 ["eggs", 42, 3.14],
+    ...                 ["other", None, 2.7]], missingval="?"))
+    -----  --  ----
+    spam    1  ?
+    eggs   42  3.14
+    other   ?  2.7
+    -----  --  ----
+
+    Various plain-text table formats (`tablefmt`) are supported:
+    'plain', 'simple', 'grid', 'pipe', 'orgtbl', 'rst', 'mediawiki',
+    and 'latex'. Variable `tabulate_formats` contains the list of
+    currently supported formats.
+
+    "plain" format doesn't use any pseudographics to draw tables,
+    it separates columns with a double space:
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
+    ...                 ["strings", "numbers"], "plain"))
+    strings      numbers
+    spam         41.9999
+    eggs        451
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="plain"))
+    spam   41.9999
+    eggs  451
+
+    "simple" format is like Pandoc simple_tables:
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
+    ...                 ["strings", "numbers"], "simple"))
+    strings      numbers
+    ---------  ---------
+    spam         41.9999
+    eggs        451
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="simple"))
+    ----  --------
+    spam   41.9999
+    eggs  451
+    ----  --------
+
+    "grid" is similar to tables produced by Emacs table.el package or
+    Pandoc grid_tables:
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
+    ...                ["strings", "numbers"], "grid"))
+    +-----------+-----------+
+    | strings   |   numbers |
+    +===========+===========+
+    | spam      |   41.9999 |
+    +-----------+-----------+
+    | eggs      |  451      |
+    +-----------+-----------+
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="grid"))
+    +------+----------+
+    | spam |  41.9999 |
+    +------+----------+
+    | eggs | 451      |
+    +------+----------+
+
+    "pipe" is like tables in PHP Markdown Extra extension or Pandoc
+    pipe_tables:
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
+    ...                ["strings", "numbers"], "pipe"))
+    | strings   |   numbers |
+    |:----------|----------:|
+    | spam      |   41.9999 |
+    | eggs      |  451      |
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="pipe"))
+    |:-----|---------:|
+    | spam |  41.9999 |
+    | eggs | 451      |
+
+    "orgtbl" is like tables in Emacs org-mode and orgtbl-mode. They
+    are slightly different from "pipe" format by not using colons to
+    define column alignment, and using a "+" sign to indicate line
+    intersections:
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
+    ...                ["strings", "numbers"], "orgtbl"))
+    | strings   |   numbers |
+    |-----------+-----------|
+    | spam      |   41.9999 |
+    | eggs      |  451      |
+
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="orgtbl"))
+    | spam |  41.9999 |
+    | eggs | 451      |
+
+    "rst" is like a simple table format from reStructuredText; please
+    note that reStructuredText accepts also "grid" tables:
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]],
+    ...                ["strings", "numbers"], "rst"))
+    =========  =========
+    strings      numbers
+    =========  =========
+    spam         41.9999
+    eggs        451
+    =========  =========
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="rst"))
+    ====  ========
+    spam   41.9999
+    eggs  451
+    ====  ========
+
+    "mediawiki" produces a table markup used in Wikipedia and on other
+    MediaWiki-based sites:
+
+    >>> print(tabulate([["strings", "numbers"], ["spam", 41.9999], ["eggs", "451.0"]],
+    ...                headers="firstrow", tablefmt="mediawiki"))
+    {| class="wikitable" style="text-align: left;"
+    |+ <!-- caption -->
+    |-
+    ! strings   !! align="right"|   numbers
+    |-
+    | spam      || align="right"|   41.9999
+    |-
+    | eggs      || align="right"|  451
+    |}
+
+    "latex" produces a tabular environment of LaTeX document markup:
+
+    >>> print(tabulate([["spam", 41.9999], ["eggs", "451.0"]], tablefmt="latex"))
+    \\begin{tabular}{lr}
+    \\hline
+     spam &  41.9999 \\\\
+     eggs & 451      \\\\
+    \\hline
+    \\end{tabular}
+
+    """
+
+    list_of_lists, headers = _normalize_tabular_data(tabular_data, headers)
+
+    # optimization: look for ANSI control codes once,
+    # enable smart width functions only if a control code is found
+    plain_text = "\n".join(
+        ["\t".join(map(_text_type, headers))]
+        + ["\t".join(map(_text_type, row)) for row in list_of_lists]
+    )
+    has_invisible = re.search(_invisible_codes, plain_text)
+    if has_invisible:
+        width_fn = _visible_width
+    else:
+        width_fn = len
+
+    # format rows and columns, convert numeric values to strings
+    cols = list(zip(*list_of_lists))
+    coltypes = list(map(_column_type, cols))
+    cols = [
+        [_format(v, ct, floatfmt, missingval) for v in c]
+        for c, ct in zip(cols, coltypes)
+    ]
+
+    # align columns
+    aligns = [numalign if ct in [int, float] else stralign for ct in coltypes]
+    minwidths = [width_fn(h) + 2 for h in headers] if headers else [0] * len(cols)
+    cols = [
+        _align_column(c, a, minw, has_invisible)
+        for c, a, minw in zip(cols, aligns, minwidths)
+    ]
+
+    if headers:
+        # align headers and add headers
+        minwidths = [max(minw, width_fn(c[0])) for minw, c in zip(minwidths, cols)]
+        headers = [
+            _align_header(h, a, minw) for h, a, minw in zip(headers, aligns, minwidths)
+        ]
+        rows = list(zip(*cols))
+    else:
+        minwidths = [width_fn(c[0]) for c in cols]
+        rows = list(zip(*cols))
+
+    if not isinstance(tablefmt, TableFormat):
+        tablefmt = _table_formats.get(tablefmt, _table_formats["simple"])
+
+    return _format_table(tablefmt, headers, rows, minwidths, aligns)
+
+
+def _build_simple_row(padded_cells, rowfmt):
+    "Format row according to DataRow format without padding."
+    begin, sep, end = rowfmt
+    return (begin + sep.join(padded_cells) + end).rstrip()
+
+
+def _build_row(padded_cells, colwidths, colaligns, rowfmt):
+    "Return a string which represents a row of data cells."
+    if not rowfmt:
+        return None
+    if hasattr(rowfmt, "__call__"):
+        return rowfmt(padded_cells, colwidths, colaligns)
+    else:
+        return _build_simple_row(padded_cells, rowfmt)
+
+
+def _build_line(colwidths, colaligns, linefmt):
+    "Return a string which represents a horizontal line."
+    if not linefmt:
+        return None
+    if hasattr(linefmt, "__call__"):
+        return linefmt(colwidths, colaligns)
+    else:
+        begin, fill, sep, end = linefmt
+        cells = [fill * w for w in colwidths]
+        return _build_simple_row(cells, (begin, sep, end))
+
+
+def _pad_row(cells, padding):
+    if cells:
+        pad = " " * padding
+        padded_cells = [pad + cell + pad for cell in cells]
+        return padded_cells
+    else:
+        return cells
+
+
+def _format_table(fmt, headers, rows, colwidths, colaligns):
+    """Produce a plain-text representation of the table."""
+    lines = []
+    hidden = fmt.with_header_hide if (headers and fmt.with_header_hide) else []
+    pad = fmt.padding
+    headerrow = fmt.headerrow
+
+    padded_widths = [(w + 2 * pad) for w in colwidths]
+    padded_headers = _pad_row(headers, pad)
+    padded_rows = [_pad_row(row, pad) for row in rows]
+
+    if fmt.lineabove and "lineabove" not in hidden:
+        lines.append(_build_line(padded_widths, colaligns, fmt.lineabove))
+
+    if padded_headers:
+        lines.append(_build_row(padded_headers, padded_widths, colaligns, headerrow))
+        if fmt.linebelowheader and "linebelowheader" not in hidden:
+            lines.append(_build_line(padded_widths, colaligns, fmt.linebelowheader))
+
+    if padded_rows and fmt.linebetweenrows and "linebetweenrows" not in hidden:
+        # initial rows with a line below
+        for row in padded_rows[:-1]:
+            lines.append(_build_row(row, padded_widths, colaligns, fmt.datarow))
+            lines.append(_build_line(padded_widths, colaligns, fmt.linebetweenrows))
+        # the last row without a line below
+        lines.append(_build_row(padded_rows[-1], padded_widths, colaligns, fmt.datarow))
+    else:
+        for row in padded_rows:
+            lines.append(_build_row(row, padded_widths, colaligns, fmt.datarow))
+
+    if fmt.linebelow and "linebelow" not in hidden:
+        lines.append(_build_line(padded_widths, colaligns, fmt.linebelow))
+
+    return "\n".join(lines)

testbed/pgmpy__pgmpy/pgmpy/factors/FactorDict.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+from numbers import Number
+
+import numpy as np
+from sklearn.preprocessing import OrdinalEncoder
+
+from pgmpy.factors.base import factor_product
+from pgmpy.factors.discrete import DiscreteFactor
+
+
+class FactorDict(dict):
+    @classmethod
+    def from_dataframe(cls, df, marginals):
+        """Create a `FactorDict` from a given set of marginals.
+
+        Parameters
+        ----------
+        df: pandas DataFrame object
+
+        marginals: List[Tuple[str]]
+            List of Tuples containing the names of the marginals.
+
+        Returns
+        -------
+        Factor dictionary: FactorDict
+            FactorDict with each marginal's Factor representing the empirical
+                frequency of the marginal from the dataset.
+        """
+        if df.isnull().values.any():
+            raise ValueError("df cannot contain None or np.nan values.")
+
+        factor_dict = cls({})
+        for marginal in marginals:
+            # Subset of columns arranged in a lexographical ordering.
+            _df = df.loc[:, list(marginal)].sort_values(list(marginal))
+            cardinality = list(_df.nunique())
+            # Since we have sorted the columns, this encoding will
+            # also be sorted lexographically.
+            encoded = OrdinalEncoder().fit_transform(_df)
+            factor_dict[marginal] = DiscreteFactor(
+                variables=marginal,
+                cardinality=cardinality,
+                values=np.histogramdd(sample=encoded, bins=cardinality)[0].flatten(),
+                state_names={
+                    column: sorted(_df[column].unique().tolist()) for column in marginal
+                },
+            )
+        return factor_dict
+
+    def get_factors(self):
+        return set(self.values())
+
+    def __mul__(self, const):
+        return FactorDict({clique: const * self[clique] for clique in self})
+
+    def __rmul__(self, const):
+        return self.__mul__(const)
+
+    def __add__(self, other):
+        return FactorDict(
+            {clique: self[clique] + other for clique in self}
+            if isinstance(other, Number)
+            else {clique: self[clique] + other[clique] for clique in self}
+        )
+
+    def __sub__(self, other):
+        return self + -1 * other
+
+    def dot(self, other):
+        return sum((self[clique] * other[clique]).values.sum() for clique in self)
+
+    def product(self):
+        return factor_product(*self.get_factors())

testbed/pgmpy__pgmpy/pgmpy/factors/FactorSet.py

@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+
+from functools import reduce
+
+from pgmpy.factors.base import BaseFactor
+
+
+class FactorSet(object):
+    r"""
+    Base class of *DiscreteFactor Sets*.
+
+    A factor set provides a compact representation of  higher dimensional factor
+    :math:`\phi_1\cdot\phi_2\cdots\phi_n`
+
+    For example the factor set corresponding to factor :math:`\phi_1\cdot\phi_2` would be the union of the factors
+    :math:`\phi_1` and :math:`\phi_2` i.e. factor set :math:`\vec\phi = \phi_1 \cup \phi_2`.
+    """
+
+    def __init__(self, *factors_list):
+        """
+        Initialize the factor set class.
+
+        Parameters
+        ----------
+        factors_list: Factor1, Factor2, ....
+            All the factors whose product is represented by the factor set
+
+        Examples
+        --------
+        >>> from pgmpy.factors import FactorSet
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+        >>> factor_set = FactorSet(phi1, phi2)
+        >>> factor_set
+        <pgmpy.factors.FactorSet.FactorSet at 0x7f8e32af6d50>
+        >>> print(factor_set)
+        set([<DiscreteFactor representing phi(x1:2, x2:3, x3:2) at 0x7f8e32b4c2d0>,
+             <DiscreteFactor representing phi(x3:2, x4:2, x1:2) at 0x7f8e32b4c710>])
+        """
+        if not all(isinstance(phi, BaseFactor) for phi in factors_list):
+            raise TypeError("Input parameters must be child classes of BaseFactor")
+        self.factors = set([factor.copy() for factor in factors_list])
+
+    def add_factors(self, *factors):
+        """
+        Adds factors to the factor set.
+
+        Parameters
+        ----------
+        factors: Factor1, Factor2, ...., Factorn
+            factors to be added into the factor set
+
+        Examples
+        --------
+        >>> from pgmpy.factors import FactorSet
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+        >>> factor_set1 = FactorSet(phi1, phi2)
+        >>> phi3 = DiscreteFactor(['x5', 'x6', 'x7'], [2, 2, 2], range(8))
+        >>> phi4 = DiscreteFactor(['x5', 'x7', 'x8'], [2, 2, 2], range(8))
+        >>> factor_set1.add_factors(phi3, phi4)
+        >>> print(factor_set1)
+        set([<DiscreteFactor representing phi(x1:2, x2:3, x3:2) at 0x7f8e32b4ca10>,
+             <DiscreteFactor representing phi(x5:2, x7:2, x8:2) at 0x7f8e4c393690>,
+             <DiscreteFactor representing phi(x5:2, x6:2, x7:2) at 0x7f8e32b4c750>,
+             <DiscreteFactor representing phi(x3:2, x4:2, x1:2) at 0x7f8e32b4cb50>])
+        """
+        self.factors.update(factors)
+
+    def remove_factors(self, *factors):
+        """
+        Removes factors from the factor set.
+
+        Parameters
+        ----------
+        factors: Factor1, Factor2, ...., Factorn
+            factors to be removed from the factor set
+
+        Examples
+        --------
+        >>> from pgmpy.factors import FactorSet
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+        >>> factor_set1 = FactorSet(phi1, phi2)
+        >>> phi3 = DiscreteFactor(['x5', 'x6', 'x7'], [2, 2, 2], range(8))
+        >>> factor_set1.add_factors(phi3)
+        >>> print(factor_set1)
+        set([<DiscreteFactor representing phi(x1:2, x2:3, x3:2) at 0x7f8e32b5b050>,
+             <DiscreteFactor representing phi(x5:2, x6:2, x7:2) at 0x7f8e32b5b250>,
+             <DiscreteFactor representing phi(x3:2, x4:2, x1:2) at 0x7f8e32b5b150>])
+        >>> factor_set1.remove_factors(phi1, phi2)
+        >>> print(factor_set1)
+        set([<DiscreteFactor representing phi(x5:2, x6:2, x7:2) at 0x7f8e32b4cb10>])
+        """
+        for factor in factors:
+            self.factors.remove(factor)
+
+    def get_factors(self):
+        """
+        Returns all the factors present in factor set.
+
+        Examples
+        --------
+        >>> from pgmpy.factors import FactorSet
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+        >>> factor_set1 = FactorSet(phi1, phi2)
+        >>> phi3 = DiscreteFactor(['x5', 'x6', 'x7'], [2, 2, 2], range(8))
+        >>> factor_set1.add_factors(phi3)
+        >>> factor_set1.get_factors()
+        {<DiscreteFactor representing phi(x1:2, x2:3, x3:2) at 0x7f827c0a23c8>,
+         <DiscreteFactor representing phi(x3:2, x4:2, x1:2) at 0x7f827c0a2358>,
+         <DiscreteFactor representing phi(x5:2, x6:2, x7:2) at 0x7f825243f9e8>}
+        """
+        return self.factors
+
+    def product(self, factorset, inplace=True):
+        r"""
+        Return the factor sets product with the given factor sets
+
+        Suppose :math:`\vec\phi_1` and :math:`\vec\phi_2` are two factor sets then their product is a another factors
+        set :math:`\vec\phi_3 = \vec\phi_1 \cup \vec\phi_2`.
+
+        Parameters
+        ----------
+        factorsets: FactorSet1, FactorSet2, ..., FactorSetn
+            FactorSets to be multiplied
+
+        inplace: A boolean (Default value True)
+            If inplace = True , then it will modify the FactorSet object, if False, it will
+            return a new FactorSet object.
+
+        Returns
+        --------
+        If inpalce = False, will return a new FactorSet object, which is product of two factors
+
+        Examples
+        --------
+        >>> from pgmpy.factors import FactorSet
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+        >>> factor_set1 = FactorSet(phi1, phi2)
+        >>> phi3 = DiscreteFactor(['x5', 'x6', 'x7'], [2, 2, 2], range(8))
+        >>> phi4 = DiscreteFactor(['x5', 'x7', 'x8'], [2, 2, 2], range(8))
+        >>> factor_set2 = FactorSet(phi3, phi4)
+        >>> print(factor_set2)
+        set([<DiscreteFactor representing phi(x5:2, x6:2, x7:2) at 0x7f8e32b5b050>,
+             <DiscreteFactor representing phi(x5:2, x7:2, x8:2) at 0x7f8e32b5b690>])
+        >>> factor_set2.product(factor_set1)
+        >>> print(factor_set2)
+        set([<DiscreteFactor representing phi(x1:2, x2:3, x3:2) at 0x7f8e32b4c910>,
+             <DiscreteFactor representing phi(x3:2, x4:2, x1:2) at 0x7f8e32b4cc50>,
+             <DiscreteFactor representing phi(x5:2, x6:2, x7:2) at 0x7f8e32b5b050>,
+             <DiscreteFactor representing phi(x5:2, x7:2, x8:2) at 0x7f8e32b5b690>])
+        >>> factor_set2 = FactorSet(phi3, phi4)
+        >>> factor_set3 = factor_set2.product(factor_set1, inplace=False)
+        >>> print(factor_set2)
+        set([<DiscreteFactor representing phi(x5:2, x6:2, x7:2) at 0x7f8e32b5b060>,
+             <DiscreteFactor representing phi(x5:2, x7:2, x8:2) at 0x7f8e32b5b790>])
+        """
+        factor_set = self if inplace else self.copy()
+        factor_set1 = factorset.copy()
+
+        factor_set.add_factors(*factor_set1.factors)
+
+        if not inplace:
+            return factor_set
+
+    def divide(self, factorset, inplace=True):
+        r"""
+        Returns a new factor set instance after division by the factor set
+
+        Division of two factor sets :math:`\frac{\vec\phi_1}{\vec\phi_2}` basically translates to union of all the
+        factors present in :math:`\vec\phi_2` and :math:`\frac{1}{\phi_i}` of all the factors present in
+        :math:`\vec\phi_2`.
+
+        Parameters
+        ----------
+        factorset: FactorSet
+            The divisor
+
+        inplace: A boolean (Default value True)
+            If inplace = True ,then it will modify the FactorSet object, if False then will
+            return a new FactorSet object.
+
+        Returns
+        --------
+        If inplace = False, will return a new FactorSet Object which is division of
+        given factors.
+
+        Examples
+        --------
+        >>> from pgmpy.factors import FactorSet
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+        >>> factor_set1 = FactorSet(phi1, phi2)
+        >>> phi3 = DiscreteFactor(['x5', 'x6', 'x7'], [2, 2, 2], range(8))
+        >>> phi4 = DiscreteFactor(['x5', 'x7', 'x8'], [2, 2, 2], range(8))
+        >>> factor_set2 = FactorSet(phi3, phi4)
+        >>> factor_set3 = factor_set2.divide(factor_set1)
+        >>> print(factor_set3)
+        set([<DiscreteFactor representing phi(x3:2, x4:2, x1:2) at 0x7f8e32b5ba10>,
+             <DiscreteFactor representing phi(x5:2, x6:2, x7:2) at 0x7f8e32b5b650>,
+             <DiscreteFactor representing phi(x1:2, x2:3, x3:2) at 0x7f8e32b5b050>,
+             <DiscreteFactor representing phi(x5:2, x7:2, x8:2) at 0x7f8e32b5b8d0>])
+        """
+        factor_set = self if inplace else self.copy()
+        factor_set1 = factorset.copy()
+
+        factor_set.add_factors(
+            *[phi.identity_factor() / phi for phi in factor_set1.factors]
+        )
+
+        if not inplace:
+            return factor_set
+
+    def marginalize(self, variables, inplace=True):
+        """
+        Marginalizes the factors present in the factor sets with respect to the given variables.
+
+        Parameters
+        ----------
+        variables: list, array-like
+            List of the variables to be marginalized.
+
+        inplace: boolean (Default value True)
+            If inplace=True it will modify the factor set itself, would create a new factor set
+
+        Returns
+        -------
+        If inplace = False, will return a new marginalized FactorSet object.
+
+        Examples
+        --------
+        >>> from pgmpy.factors import FactorSet
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+        >>> factor_set1 = FactorSet(phi1, phi2)
+        >>> factor_set1.marginalize('x1')
+        >>> print(factor_set1)
+        set([<DiscreteFactor representing phi(x2:3, x3:2) at 0x7f8e32b4cc10>,
+             <DiscreteFactor representing phi(x3:2, x4:2) at 0x7f8e32b4cf90>])
+        """
+        if isinstance(variables, str):
+            raise TypeError("Expected list or array-like type got type str")
+
+        factor_set = self if inplace else self.copy()
+
+        factors_to_be_marginalized = set(
+            filter(lambda x: set(x.scope()).intersection(variables), factor_set.factors)
+        )
+
+        for factor in factors_to_be_marginalized:
+            variables_to_be_marginalized = list(
+                set(factor.scope()).intersection(variables)
+            )
+            if inplace:
+                factor.marginalize(variables_to_be_marginalized, inplace=True)
+            else:
+                factor_set.remove_factors(factor)
+                factor_set.add_factors(
+                    factor.marginalize(variables_to_be_marginalized, inplace=False)
+                )
+
+        if not inplace:
+            return factor_set
+
+    def __mul__(self, other):
+        return self.product(other)
+
+    def __truediv__(self, other):
+        return self.divide(other)
+
+    def __str__(self):
+        return self.factors.__str__()
+
+    def copy(self):
+        """
+        Create a copy of factor set.
+
+        Examples
+        --------
+        >>> from pgmpy.factors import FactorSet
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+        >>> factor_set = FactorSet(phi1, phi2)
+        >>> factor_set
+        <pgmpy.factors.FactorSet.FactorSet at 0x7fa68f390320>
+        >>> factor_set_copy = factor_set.copy()
+        >>> factor_set_copy
+        <pgmpy.factors.FactorSet.FactorSet at 0x7f91a0031160>
+        """
+        # No need to have copies of factors as argument because __init__ method creates copies.
+        return FactorSet(*self.factors)
+
+
+def factorset_product(*factorsets_list):
+    r"""
+    Base method used for product of factor sets.
+
+    Suppose :math:`\vec\phi_1` and :math:`\vec\phi_2` are two factor sets then their product is another factors set
+    :math:`\vec\phi_3 = \vec\phi_1 \cup \vec\phi_2`.
+
+    Parameters
+    ----------
+    factorsets_list: FactorSet1, FactorSet2, ..., FactorSetn
+        All the factor sets to be multiplied
+
+    Returns
+    -------
+    Product of factorset in factorsets_list
+
+    Examples
+    --------
+    >>> from pgmpy.factors import FactorSet
+    >>> from pgmpy.factors.discrete import DiscreteFactor
+    >>> from pgmpy.factors import factorset_product
+    >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+    >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+    >>> factor_set1 = FactorSet(phi1, phi2)
+    >>> phi3 = DiscreteFactor(['x5', 'x6', 'x7'], [2, 2, 2], range(8))
+    >>> phi4 = DiscreteFactor(['x5', 'x7', 'x8'], [2, 2, 2], range(8))
+    >>> factor_set2 = FactorSet(phi3, phi4)
+    >>> factor_set3 = factorset_product(factor_set1, factor_set2)
+    >>> print(factor_set3)
+    set([<DiscreteFactor representing phi(x1:2, x2:3, x3:2) at 0x7fb3a1933e90>,
+         <DiscreteFactor representing phi(x5:2, x7:2, x8:2) at 0x7fb3a1933f10>,
+         <DiscreteFactor representing phi(x5:2, x6:2, x7:2) at 0x7fb3a1933f90>,
+         <DiscreteFactor representing phi(x3:2, x4:2, x1:2) at 0x7fb3a1933e10>])
+
+    """
+    if not all(isinstance(factorset, FactorSet) for factorset in factorsets_list):
+        raise TypeError("Input parameters must be FactorSet instances")
+    return reduce(lambda x, y: x.product(y, inplace=False), factorsets_list)
+
+
+def factorset_divide(factorset1, factorset2):
+    r"""
+    Base method for dividing two factor sets.
+
+    Division of two factor sets :math:`\frac{\vec\phi_1}{\vec\phi_2}` basically translates to union of all the factors
+    present in :math:`\vec\phi_2` and :math:`\frac{1}{\phi_i}` of all the factors present in :math:`\vec\phi_2`.
+
+    Parameters
+    ----------
+    factorset1: FactorSet
+        The dividend
+
+    factorset2: FactorSet
+        The divisor
+
+    Returns
+    -------
+    The division of factorset1 and factorset2
+
+    Examples
+    --------
+    >>> from pgmpy.factors import FactorSet
+    >>> from pgmpy.factors.discrete import DiscreteFactor
+    >>> from pgmpy.factors import factorset_divide
+    >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+    >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+    >>> factor_set1 = FactorSet(phi1, phi2)
+    >>> phi3 = DiscreteFactor(['x5', 'x6', 'x7'], [2, 2, 2], range(8))
+    >>> phi4 = DiscreteFactor(['x5', 'x7', 'x8'], [2, 2, 2], range(8))
+    >>> factor_set2 = FactorSet(phi3, phi4)
+    >>> factor_set3 = factorset_divide(factor_set2, factor_set1)
+    >>> print(factor_set3)
+    set([<DiscreteFactor representing phi(x3:2, x4:2, x1:2) at 0x7f119ad78f90>,
+         <DiscreteFactor representing phi(x5:2, x6:2, x7:2) at 0x7f119ad78e50>,
+         <DiscreteFactor representing phi(x1:2, x2:3, x3:2) at 0x7f119ad78ed0>,
+         <DiscreteFactor representing phi(x5:2, x7:2, x8:2) at 0x7f119ad78e90>])
+
+    """
+    if not isinstance(factorset1, FactorSet) or not isinstance(factorset2, FactorSet):
+        raise TypeError("factorset1 and factorset2 must be FactorSet instances")
+    return factorset1.divide(factorset2, inplace=False)

testbed/pgmpy__pgmpy/pgmpy/factors/__init__.py

@@ -0,0 +1,13 @@
+from .base import factor_divide, factor_product, factor_sum_product
+from .FactorSet import FactorSet, factorset_divide, factorset_product
+from .FactorDict import FactorDict
+
+__all__ = [
+    "FactorSet",
+    "factorset_divide",
+    "factorset_product",
+    "factor_product",
+    "factor_divide",
+    "factor_sum_product",
+    "FactorDict",
+]

testbed/pgmpy__pgmpy/pgmpy/factors/base.py

@@ -0,0 +1,169 @@
+from abc import abstractmethod
+from functools import reduce
+from itertools import chain
+
+from opt_einsum import contract
+
+
+class BaseFactor(object):
+    """
+    Base class for Factors. Any Factor implementation should inherit this class.
+    """
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    @abstractmethod
+    def is_valid_cpd(self):
+        pass
+
+
+def factor_product(*args):
+    """
+    Returns factor product over `args`.
+
+    Parameters
+    ----------
+    args: `BaseFactor` instances.
+        factors to be multiplied
+
+    Returns
+    -------
+    BaseFactor: `BaseFactor` representing factor product over all the `BaseFactor` instances in args.
+
+    Examples
+    --------
+    >>> from pgmpy.factors.discrete import DiscreteFactor
+    >>> from pgmpy.factors import factor_product
+    >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+    >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+    >>> phi = factor_product(phi1, phi2)
+    >>> phi.variables
+    ['x1', 'x2', 'x3', 'x4']
+    >>> phi.cardinality
+    array([2, 3, 2, 2])
+    >>> phi.values
+    array([[[[ 0,  0],
+             [ 4,  6]],
+
+            [[ 0,  4],
+             [12, 18]],
+
+            [[ 0,  8],
+             [20, 30]]],
+
+
+           [[[ 6, 18],
+             [35, 49]],
+
+            [[ 8, 24],
+             [45, 63]],
+
+            [[10, 30],
+             [55, 77]]]])
+    """
+    if not all(isinstance(phi, BaseFactor) for phi in args):
+        raise TypeError("Arguments must be factors")
+    # Check if all of the arguments are of the same type
+    elif len(set(map(type, args))) != 1:
+        raise NotImplementedError(
+            "All the args are expected to be instances of the same factor class."
+        )
+
+    if len(args) == 1:
+        return args[0].copy()
+    else:
+        return reduce(lambda phi1, phi2: phi1 * phi2, args)
+
+
+def factor_sum_product(output_vars, factors):
+    """
+    For a given set of factors: `args` returns the result of $ \sum_{var \not \in output_vars} \prod \textit{args} $.
+
+    Parameters
+    ----------
+    output_vars: list, iterable
+        List of variable names on which the output factor is to be defined. Variable which are present in any of the factors
+        but not in output_vars will be marginalized out.
+
+    factors: list, iterable
+        List of DiscreteFactor objects on which to perform the sum product operation.
+
+    Returns
+    -------
+    pgmpy.factor.discrete.DiscreteFactor: A DiscreteFactor object on `output_vars`.
+
+    Examples
+    --------
+    >>> from pgmpy.factors import factor_sum_product
+    >>> from pgmpy.utils import get_example_model
+    >>> factors = [cpd.to_factor() for cpd in model.cpds]
+    >>> factor_sum_product(output_vars=['HISTORY'], factors=factors)
+    <DiscreteFactor representing phi(HISTORY:2) at 0x7f240556b970>
+    """
+    state_names = {}
+    for phi in factors:
+        state_names.update(phi.state_names)
+
+    einsum_expr = []
+    for phi in factors:
+        einsum_expr.append(phi.values)
+        einsum_expr.append(phi.variables)
+    values = contract(*einsum_expr, output_vars, optimize="greedy")
+
+    from pgmpy.factors.discrete import DiscreteFactor
+
+    return DiscreteFactor(
+        variables=output_vars,
+        cardinality=values.shape,
+        values=values,
+        state_names={var: state_names[var] for var in output_vars},
+    )
+
+
+def factor_divide(phi1, phi2):
+    """
+    Returns `DiscreteFactor` representing `phi1 / phi2`.
+
+    Parameters
+    ----------
+    phi1: Factor
+        The Dividend.
+
+    phi2: Factor
+        The Divisor.
+
+    Returns
+    -------
+    DiscreteFactor: `DiscreteFactor` representing factor division `phi1 / phi2`.
+
+    Examples
+    --------
+    >>> from pgmpy.factors.discrete import DiscreteFactor
+    >>> from pgmpy.factors import factor_product
+    >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+    >>> phi2 = DiscreteFactor(['x3', 'x1'], [2, 2], range(1, 5))
+    >>> phi = factor_divide(phi1, phi2)
+    >>> phi.variables
+    ['x1', 'x2', 'x3']
+    >>> phi.cardinality
+    array([2, 3, 2])
+    >>> phi.values
+    array([[[ 0.        ,  0.33333333],
+            [ 2.        ,  1.        ],
+            [ 4.        ,  1.66666667]],
+
+           [[ 3.        ,  1.75      ],
+            [ 4.        ,  2.25      ],
+            [ 5.        ,  2.75      ]]])
+    """
+    if not isinstance(phi1, BaseFactor) or not isinstance(phi2, BaseFactor):
+        raise TypeError("phi1 and phi2 should be factors instances")
+
+    # Check if all of the arguments are of the same type
+    elif type(phi1) != type(phi2):
+        raise NotImplementedError(
+            "All the args are expected to be instances of the same factor class."
+        )
+
+    return phi1.divide(phi2, inplace=False)

testbed/pgmpy__pgmpy/pgmpy/factors/continuous/ContinuousFactor.py

@@ -0,0 +1,461 @@
+import types
+
+import numpy as np
+import scipy.integrate as integrate
+
+from pgmpy.factors.base import BaseFactor
+from pgmpy.factors.distributions import CustomDistribution, GaussianDistribution
+
+
+class ContinuousFactor(BaseFactor):
+    """
+    Base class for factors representing various multivariate
+    representations.
+    """
+
+    def __init__(self, variables, pdf, *args, **kwargs):
+        """
+        Parameters
+        ----------
+        variables: list or array-like
+            The variables for which the distribution is defined.
+
+        pdf: function
+            The probability density function of the distribution.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from scipy.special import beta
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        # Two variable dirichlet distribution with alpha = (1,2)
+        >>> def dirichlet_pdf(x, y):
+        ...     return (np.power(x, 1) * np.power(y, 2)) / beta(x, y)
+        >>> dirichlet_factor = ContinuousFactor(['x', 'y'], dirichlet_pdf)
+        >>> dirichlet_factor.scope()
+        ['x', 'y']
+        >>> dirichlet_factor.assignment(5,6)
+        226800.0
+        >>> dirichlet_factor.cdf([(0, 0.2), (0, 0.5)])
+        8.384972114200703e-05
+        """
+        if not isinstance(variables, (list, tuple, np.ndarray)):
+            raise TypeError(
+                f"variables: Expected type list or array-like, got type {type(variables)}"
+            )
+
+        if len(set(variables)) != len(variables):
+            raise ValueError("Variable names cannot be same.")
+
+        variables = list(variables)
+
+        if isinstance(pdf, str):
+            if pdf == "gaussian":
+                self.distribution = GaussianDistribution(
+                    variables=variables,
+                    mean=kwargs["mean"],
+                    covariance=kwargs["covariance"],
+                )
+            else:
+                raise NotImplementedError(
+                    f"{pdf} distribution not supported. Please use CustomDistribution"
+                )
+
+        elif isinstance(pdf, CustomDistribution):
+            self.distribution = pdf
+
+        elif callable(pdf):
+            self.distribution = CustomDistribution(
+                variables=variables, distribution=pdf
+            )
+
+        else:
+            raise ValueError(
+                f"pdf: Expected type: str or function, Got: {type(variables)}"
+            )
+
+    @property
+    def pdf(self):
+        """
+        Returns the pdf of the ContinuousFactor.
+        """
+        return self.distribution.pdf
+
+    @property
+    def variable(self):
+        return self.scope()[0]
+
+    def cdf(self, limits):
+        """
+        Returns the value of the cumulative distribution function for a multivariate
+        distribution over the given limits.
+
+        Parameters
+        ----------
+        limits : list of tuples
+            Each tuple contains the lower and upper integration limits for each variable.
+            For example, limits for a bivariate distribution could be [(-np.inf, x1), (-np.inf, x2)].
+
+        Returns
+        -------
+        float
+            The cumulative probability within the specified limits.
+
+        Examples
+        --------
+        >>> from scipy.stats import norm, multivariate_normal
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        >>> pdf = lambda x, y: multivariate_normal.pdf([x, y], mean=[0,0], cov=[[1, 0.5], [0.5, 1]])
+        >>> factor = ContinuousFactor(['x', 'y'], pdf)
+        >>> factor.cdf([(-np.inf, 1), (-np.inf, 1)])
+        0.7452035867990542
+        """
+
+        if len(limits) != len(self.distribution.variables):
+            raise ValueError(
+                "Limits should have the same length as the number of variables."
+            )
+
+        return integrate.nquad(self.pdf, limits)[0]
+
+    def scope(self):
+        """
+        Returns the scope of the factor.
+
+        Returns
+        -------
+        list: List of variable names in the scope of the factor.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        >>> from scipy.stats import multivariate_normal
+        >>> normal_pdf = lambda x: multivariate_normal(x, [0, 0], [[1, 0], [0, 1]])
+        >>> phi = ContinuousFactor(['x1', 'x2'], normal_pdf)
+        >>> phi.scope()
+        ['x1', 'x2']
+        """
+        return self.distribution.variables
+
+    def get_evidence(self):
+        return self.scope()[1:]
+
+    def assignment(self, *args):
+        """
+        Returns a list of pdf assignments for the corresponding values.
+
+        Parameters
+        ----------
+        *args: values
+            Values whose assignment is to be computed.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        >>> from scipy.stats import multivariate_normal
+        >>> normal_pdf = lambda x1, x2: multivariate_normal.pdf((x1, x2), [0, 0], [[1, 0], [0, 1]])
+        >>> phi = ContinuousFactor(['x1', 'x2'], normal_pdf)
+        >>> phi.assignment(1, 2)
+        0.013064233284684921
+        """
+        return self.distribution.assignment(*args)
+
+    def copy(self):
+        """
+        Return a copy of the distribution.
+
+        Returns
+        -------
+        ContinuousFactor object: copy of the distribution
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from scipy.special import beta
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        # Two variable dirichlet distribution with alpha = (1,2)
+        >>> def dirichlet_pdf(x, y):
+        ...     return (np.power(x, 1) * np.power(y, 2)) / beta(x, y)
+        >>> dirichlet_factor = ContinuousFactor(['x', 'y'], dirichlet_pdf)
+        >>> dirichlet_factor.variables
+        ['x', 'y']
+        >>> copy_factor = dirichlet_factor.copy()
+        >>> copy_factor.variables
+        ['x', 'y']
+        """
+        return ContinuousFactor(self.scope(), self.distribution.copy())
+
+    def discretize(self, method, *args, **kwargs):
+        """
+        Discretizes the continuous distribution into discrete
+        probability masses using various methods.
+
+        Parameters
+        ----------
+        method : A Discretizer Class from pgmpy.discretize
+
+        *args, **kwargs:
+            The parameters to be given to the Discretizer Class.
+
+        Returns
+        -------
+        An n-D array or a DiscreteFactor object according to the discretiztion
+        method used.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from scipy.special import beta
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        >>> from pgmpy.factors.continuous import RoundingDiscretizer
+        >>> def dirichlet_pdf(x, y):
+        ...     return (np.power(x, 1) * np.power(y, 2)) / beta(x, y)
+        >>> dirichlet_factor = ContinuousFactor(['x', 'y'], dirichlet_pdf)
+        >>> dirichlet_factor.discretize(RoundingDiscretizer, low=1, high=2, cardinality=5)
+        # TODO: finish this
+        """
+        return method(self, *args, **kwargs).get_discrete_values()
+
+    def reduce(self, values, inplace=True):
+        """
+        Reduces the factor to the context of the given variable values.
+
+        Parameters
+        ----------
+        values: list, array-like
+            A list of tuples of the form (variable_name, variable_value).
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new ContinuousFactor object.
+
+        Returns
+        -------
+        ContinuousFactor or None: if inplace=True (default) returns None
+                                  if inplace=False returns a new ContinuousFactor instance.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from scipy.special import beta
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        >>> def custom_pdf(x, y, z):
+        ...     return z*(np.power(x, 1) * np.power(y, 2)) / beta(x, y)
+        >>> custom_factor = ContinuousFactor(['x', 'y', 'z'], custom_pdf)
+        >>> custom_factor.variables
+        ['x', 'y', 'z']
+        >>> custom_factor.assignment(1, 2, 3)
+        24.0
+
+        >>> custom_factor.reduce([('y', 2)])
+        >>> custom_factor.variables
+        ['x', 'z']
+        >>> custom_factor.assignment(1, 3)
+        24.0
+        """
+        phi = self if inplace else self.copy()
+
+        phi.distribution = phi.distribution.reduce(values, inplace=False)
+        if not inplace:
+            return phi
+
+    def marginalize(self, variables, inplace=True):
+        """
+        Marginalize the factor with respect to the given variables.
+
+        Parameters
+        ----------
+        variables: list, array-like
+            List of variables with respect to which factor is to be maximized.
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new ContinuousFactor instance.
+
+        Returns
+        -------
+        DiscreteFactor or None: if inplace=True (default) returns None
+                        if inplace=False returns a new ContinuousFactor instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        >>> from scipy.stats import multivariate_normal
+        >>> std_normal_pdf = lambda *x: multivariate_normal.pdf(x, [0, 0], [[1, 0], [0, 1]])
+        >>> std_normal = ContinuousFactor(['x1', 'x2'], std_normal_pdf)
+        >>> std_normal.scope()
+        ['x1', 'x2']
+        >>> std_normal.assignment([1, 1])
+        0.058549831524319168
+        >>> std_normal.marginalize(['x2'])
+        >>> std_normal.scope()
+        ['x1']
+        >>> std_normal.assignment(1)
+
+        """
+        phi = self if inplace else self.copy()
+        phi.distribution = phi.distribution.marginalize(variables, inplace=False)
+
+        if not inplace:
+            return phi
+
+    def normalize(self, inplace=True):
+        """
+        Normalizes the pdf of the continuous factor so that it integrates to
+        1 over all the variables.
+
+        Parameters
+        ----------
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new factor.
+
+        Returns
+        -------
+        ContinuousFactor or None:
+             if inplace=True (default) returns None
+             if inplace=False returns a new ContinuousFactor instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        >>> from scipy.stats import multivariate_normal
+        >>> std_normal_pdf = lambda x: 2 * multivariate_normal.pdf(x, [0, 0], [[1, 0], [0, 1]])
+        >>> std_normal = ContinuousFactor(['x1', 'x2'], std_normal_pdf)
+        >>> std_normal.assignment(1, 1)
+        0.117099663049
+        >>> std_normal.normalize()
+        >>> std_normal.assignment(1, 1)
+        0.0585498315243
+
+        """
+        phi = self if inplace else self.copy()
+        phi.distribution.normalize(inplace=True)
+
+        if not inplace:
+            return phi
+
+    def is_valid_cpd(self):
+        return self.distribution.is_valid_cpd()
+
+    def _operate(self, other, operation, inplace=True):
+        """
+        Gives the ContinuousFactor operation (product or divide) with
+        the other factor.
+
+        Parameters
+        ----------
+        other: ContinuousFactor
+            The ContinuousFactor to be multiplied.
+
+        operation: String
+            'product' for multiplication operation and 'divide' for
+            division operation.
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new factor.
+
+        Returns
+        -------
+        ContinuousFactor or None:
+                        if inplace=True (default) returns None
+                        if inplace=False returns a new `DiscreteFactor` instance.
+
+        """
+        if not isinstance(other, ContinuousFactor):
+            raise TypeError(
+                f"ContinuousFactor objects can only be multiplied ",
+                f"or divided with another ContinuousFactor object. ",
+                f"Got {type(other)}, expected: ContinuousFactor.",
+            )
+
+        phi = self if inplace else self.copy()
+        phi.distribution = phi.distribution._operate(
+            other=other.distribution, operation=operation, inplace=False
+        )
+
+        if not inplace:
+            return phi
+
+    def product(self, other, inplace=True):
+        """
+        Gives the ContinuousFactor product with the other factor.
+
+        Parameters
+        ----------
+        other: ContinuousFactor
+            The ContinuousFactor to be multiplied.
+
+        Returns
+        -------
+        ContinuousFactor or None:
+                        if inplace=True (default) returns None
+                        if inplace=False returns a new `ContinuousFactor` instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        >>> from scipy.stats import multivariate_normal
+        >>> sn_pdf1 = lambda x: multivariate_normal.pdf([x], [0], [[1]])
+        >>> sn_pdf2 = lambda x1,x2: multivariate_normal.pdf([x1, x2], [0, 0], [[1, 0], [0, 1]])
+        >>> sn1 = ContinuousFactor(['x2'], sn_pdf1)
+        >>> sn2 = ContinuousFactor(['x1', 'x2'], sn_pdf2)
+
+        >>> sn3 = sn1.product(sn2, inplace=False)
+        >>> sn3.assignment(0, 0)
+        0.063493635934240983
+
+        >>> sn3 = sn1 * sn2
+        >>> sn3.assignment(0, 0)
+        0.063493635934240983
+        """
+        return self._operate(other, "product", inplace)
+
+    def divide(self, other, inplace=True):
+        """
+        Gives the ContinuousFactor divide with the other factor.
+
+        Parameters
+        ----------
+        other: ContinuousFactor
+            The ContinuousFactor to be divided.
+
+        Returns
+        -------
+        ContinuousFactor or None:
+                        if inplace=True (default) returns None
+                        if inplace=False returns a new `ContinuousFactor` instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        >>> from scipy.stats import multivariate_normal
+        >>> sn_pdf1 = lambda x: multivariate_normal.pdf([x], [0], [[1]])
+        >>> sn_pdf2 = lambda x1,x2: multivariate_normal.pdf([x1, x2], [0, 0], [[1, 0], [0, 1]])
+        >>> sn1 = ContinuousFactor(['x2'], sn_pdf1)
+        >>> sn2 = ContinuousFactor(['x1', 'x2'], sn_pdf2)
+
+        >>> sn4 = sn2.divide(sn1, inplace=False)
+        >>> sn4.assignment(0, 0)
+        0.3989422804014327
+
+        >>> sn4 = sn2 / sn1
+        >>> sn4.assignment(0, 0)
+        0.3989422804014327
+        """
+        if set(other.scope()) - set(self.scope()):
+            raise ValueError("Scope of divisor should be a subset of dividend")
+
+        return self._operate(other, "divide", inplace)
+
+    def __mul__(self, other):
+        return self.product(other, inplace=False)
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __truediv__(self, other):
+        return self.divide(other, inplace=False)
+
+    __div__ = __truediv__

testbed/pgmpy__pgmpy/pgmpy/factors/continuous/LinearGaussianCPD.py

@@ -0,0 +1,246 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+import pandas as pd
+from scipy.stats import multivariate_normal
+
+from pgmpy.factors.base import BaseFactor
+
+
+class LinearGaussianCPD(BaseFactor):
+    r"""
+    For, X -> Y the Linear Gaussian model assumes that the mean
+    of Y is a linear function of mean of X and the variance of Y does
+    not depend on X.
+
+    For example,
+
+    .. math::
+
+      p(Y|X) = N(-2x + 0.9 ; 1)
+
+    Here, :math:`x` is the mean of the variable :math:`X`.
+
+    Let :math:`Y` be a continuous variable with continuous parents
+    :math:`X1, X2, \cdots, Xk`. We say that :math:`Y` has a linear Gaussian CPD
+    if there are parameters :math:`\beta_0, \beta_1, ..., \beta_k`
+    and :math:`\sigma_2` such that,
+
+    .. math:: p(Y |x1, x2, ..., xk) = \mathcal{N}(\beta_0 + x1*\beta_1 + ......... + xk*\beta_k ; \sigma_2)
+
+    In vector notation,
+
+    .. math:: p(Y |x) = \mathcal{N}(\beta_0 + \boldmath{β}.T * \boldmath{x} ; \sigma_2)
+
+    References
+    ----------
+    .. [1] https://cedar.buffalo.edu/~srihari/CSE574/Chap8/Ch8-PGM-GaussianBNs/8.5%20GaussianBNs.pdf
+    """
+
+    def __init__(
+        self, variable, evidence_mean, evidence_variance, evidence=[], beta=None
+    ):
+        """
+        Parameters
+        ----------
+
+        variable: any hashable python object
+            The variable whose CPD is defined.
+
+        evidence_mean: list (array-like)
+            Mean vector (numpy array) of the joint distribution, X
+
+        evidence_variance: int, float
+            The variance of the multivariate gaussian, X = ['x1', 'x2', ..., 'xn']
+
+        evidence: iterable of any hashable python objects
+            An iterable of the parents of the variable. None if there are no parents.
+
+        beta (optional): iterable of int or float
+            An iterable representing the coefficient vector of the linear equation.
+            The first term represents the constant term in the linear equation.
+
+        Examples
+        --------
+
+        # For P(Y| X1, X2, X3) = N(-2x1 + 3x2 + 7x3 + 0.2; 9.6)
+
+        >>> cpd = LinearGaussianCPD('Y',  [0.2, -2, 3, 7], 9.6, ['X1', 'X2', 'X3'])
+        >>> cpd.variable
+        'Y'
+        >>> cpd.evidence
+        ['x1', 'x2', 'x3']
+        >>> cpd.beta_vector
+        [0.2, -2, 3, 7]
+
+        """
+        self.variable = variable
+        self.mean = np.array(evidence_mean)
+        self.variance = evidence_variance
+        self.evidence = evidence
+        self.sigma_yx = None
+
+        self.variables = [variable] + evidence
+        super(LinearGaussianCPD, self).__init__(
+            self.variables, pdf="gaussian", mean=self.mean, covariance=self.variance
+        )
+
+    def sum_of_product(self, xi, xj):
+        prod_xixj = xi * xj
+        return np.sum(prod_xixj)
+
+    def maximum_likelihood_estimator(self, data, states):
+        """
+        Fit using MLE method.
+
+        Parameters
+        ----------
+        data: pandas.DataFrame or 2D array
+            Dataframe of values containing samples from the conditional distribution, (Y|X)
+            and corresponding X values.
+
+        states: All the input states that are jointly gaussian.
+
+        Returns
+        -------
+        beta, variance (tuple): Returns estimated betas and the variance.
+        """
+        x_df = pd.DataFrame(data, columns=states)
+        x_len = len(self.evidence)
+
+        sym_coefs = []
+        for i in range(0, x_len):
+            sym_coefs.append("b" + str(i + 1) + "_coef")
+
+        sum_x = x_df.sum()
+        x = [sum_x["(Y|X)"]]
+        coef_matrix = pd.DataFrame(columns=sym_coefs)
+
+        # First we compute just the coefficients of beta_1 to beta_N.
+        # Later we compute beta_0 and append it.
+        for i in range(0, x_len):
+            x.append(self.sum_of_product(x_df["(Y|X)"], x_df[self.evidence[i]]))
+            for j in range(0, x_len):
+                coef_matrix.loc[i, sym_coefs[j]] = self.sum_of_product(
+                    x_df[self.evidence[i]], x_df[self.evidence[j]]
+                )
+
+        coef_matrix.insert(0, "b0_coef", sum_x[self.evidence].values)
+        row_1 = np.append([len(x_df)], sum_x[self.evidence].values)
+        coef_matrix.loc[-1] = row_1
+        coef_matrix.index = coef_matrix.index + 1  # shifting index
+        coef_matrix.sort_index(inplace=True)
+
+        beta_coef_matrix = np.matrix(coef_matrix.values, dtype="float")
+        coef_inv = np.linalg.inv(beta_coef_matrix)
+        beta_est = np.array(np.matmul(coef_inv, np.transpose(x)))
+        self.beta = beta_est[0]
+
+        sigma_est = 0
+        x_len_df = len(x_df)
+        for i in range(0, x_len):
+            for j in range(0, x_len):
+                sigma_est += (
+                    self.beta[i + 1]
+                    * self.beta[j + 1]
+                    * (
+                        self.sum_of_product(
+                            x_df[self.evidence[i]], x_df[self.evidence[j]]
+                        )
+                        / x_len_df
+                        - np.mean(x_df[self.evidence[i]])
+                        * np.mean(x_df[self.evidence[j]])
+                    )
+                )
+
+        sigma_est = np.sqrt(
+            self.sum_of_product(x_df["(Y|X)"], x_df["(Y|X)"]) / x_len_df
+            - np.mean(x_df["(Y|X)"]) * np.mean(x_df["(Y|X)"])
+            - sigma_est
+        )
+        self.sigma_yx = sigma_est
+        return self.beta, self.sigma_yx
+
+    def fit(self, data, states, estimator=None, **kwargs):
+        """
+        Determine βs from data
+
+        Parameters
+        ----------
+        data: pandas.DataFrame
+            Dataframe containing samples from the conditional distribution, p(Y|X)
+            estimator: 'MLE' or 'MAP'
+        """
+        if estimator == "MLE":
+            mean, variance = self.maximum_likelihood_estimator(data, states)
+        elif estimator == "MAP":
+            raise NotImplementedError(
+                "fit method has not been implemented using Maximum A-Priori (MAP)"
+            )
+
+        return mean, variance
+
+    @property
+    def pdf(self):
+        def _pdf(*args):
+            # The first element of args is the value of the variable on which CPD is defined
+            # and the rest of the elements give the mean values of the parent
+            # variables.
+            mean = (
+                sum([arg * coeff for (arg, coeff) in zip(args[1:], self.mean)])
+                + self.mean[0]
+            )
+            return multivariate_normal.pdf(
+                args[0], np.array(mean), np.array([[self.variance]])
+            )
+
+        return _pdf
+
+    def copy(self):
+        """
+        Returns a copy of the distribution.
+
+        Returns
+        -------
+        LinearGaussianCPD: copy of the distribution
+
+        Examples
+        --------
+        >>> from pgmpy.factors.continuous import LinearGaussianCPD
+        >>> cpd = LinearGaussianCPD('Y',  [0.2, -2, 3, 7], 9.6, ['X1', 'X2', 'X3'])
+        >>> copy_cpd = cpd.copy()
+        >>> copy_cpd.variable
+        'Y'
+        >>> copy_cpd.evidence
+        ['X1', 'X2', 'X3']
+        """
+        copy_cpd = LinearGaussianCPD(
+            self.variable, self.beta, self.variance, list(self.evidence)
+        )
+
+        return copy_cpd
+
+    def __str__(self):
+        mean = self.mean.round(3)
+        variance = round(self.variance, 3)
+        if self.evidence and list(self.mean):
+            # P(Y| X1, X2, X3) = N(-2*X1_mu + 3*X2_mu + 7*X3_mu; 0.2)
+            rep_str = "P({node} | {parents}) = N({mu} + {b_0}; {sigma})".format(
+                node=str(self.variable),
+                parents=", ".join([str(var) for var in self.evidence]),
+                mu=" + ".join(
+                    [
+                        f"{coeff}*{parent}"
+                        for coeff, parent in zip(mean[1:], self.evidence)
+                    ]
+                ),
+                b_0=str(mean[0]),
+                sigma=str(variance),
+            )
+        else:
+            # P(X) = N(1, 4)
+            rep_str = f"P({str(self.variable)}) = N({str(mean[0])}; {str(variance)})"
+        return rep_str
+
+    def __repr__(self):
+        str_repr = self.__str__()
+        return f"<LinearGaussianCPD: {str_repr} at {hex(id(self))}"

testbed/pgmpy__pgmpy/pgmpy/factors/continuous/__init__.py

@@ -0,0 +1,12 @@
+from pgmpy.factors.distributions.CanonicalDistribution import CanonicalDistribution
+from .ContinuousFactor import ContinuousFactor
+from .LinearGaussianCPD import LinearGaussianCPD
+from .discretize import BaseDiscretizer, RoundingDiscretizer, UnbiasedDiscretizer
+
+__all__ = [
+    "CanonicalDistribution",
+    "ContinuousFactor",
+    "LinearGaussianCPD" "BaseDiscretizer",
+    "RoundingDiscretizer",
+    "UnbiasedDiscretizer",
+]

testbed/pgmpy__pgmpy/pgmpy/factors/continuous/discretize.py

@@ -0,0 +1,255 @@
+from abc import ABC, abstractmethod
+
+import numpy as np
+from scipy import integrate
+
+
+class BaseDiscretizer(ABC):
+    """
+    Base class for the discretizer classes in pgmpy. The discretizer
+    classes are used to discretize a continuous random variable
+    distribution into discrete probability masses.
+
+    Parameters
+    ----------
+    factor: A ContinuousFactor object
+        the continuous node or factor representing the distribution
+        to be discretized.
+
+    low, high: float
+        the range over which the function will be discretized.
+
+    cardinality: int
+        the number of states required in the discretized output.
+
+    Examples
+    --------
+    >>> from scipy.stats import norm
+    >>> from pgmpy.factors.continuous import ContinuousFactor, BaseDiscretizer
+    >>> normal = ContinuousFactor(['x'],norm(0, 1).pdf)
+    >>> class ChildDiscretizer(BaseDiscretizer):
+    ...     def get_discrete_values(self):
+    ...         pass
+    >>> discretizer = ChildDiscretizer(normal, -3, 3, 10)
+    >>> discretizer.factor
+    <pgmpy.factors.continuous.ContinuousFactor.ContinuousFactor object at 0x1316f4da0>
+    >>> discretizer.cardinality
+    10
+    >>> discretizer.get_labels()
+    ['x=-3.0', 'x=-2.4', 'x=-1.8', 'x=-1.2', 'x=-0.6', 'x=0.0', 'x=0.6', 'x=1.2', 'x=1.8', 'x=2.4']
+
+    """
+
+    def __init__(self, factor, low, high, cardinality):
+        self.factor = factor
+        self.low = low
+        self.high = high
+        self.cardinality = cardinality
+
+    @abstractmethod
+    def get_discrete_values(self):
+        """
+        This method implements the algorithm to discretize the given
+        continuous distribution.
+
+        It must be implemented by all the subclasses of BaseDiscretizer.
+
+        Returns
+        -------
+        A list of discrete values or a DiscreteFactor object.
+        """
+        pass
+
+    def get_labels(self):
+        """
+        Returns a list of strings representing the values about
+        which the discretization method calculates the probability
+        masses.
+
+        Default value is the points -
+        [low, low+step, low+2*step, ......... , high-step]
+        unless the method is overridden by a subclass.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.continuous import ContinuousFactor
+        >>> from pgmpy.discretize import BaseDiscretizer
+        >>> class ChildDiscretizer(BaseDiscretizer):
+        ...     def get_discrete_values(self):
+        ...         pass
+        >>> from scipy.stats import norm
+        >>> node = ContinuousFactor(['x'],norm(0).pdf)
+        >>> child = ChildDiscretizer(node, -5, 5, 20)
+        >>> chld.get_labels()
+        ['x=-5.0', 'x=-4.5', 'x=-4.0', 'x=-3.5', 'x=-3.0', 'x=-2.5',
+         'x=-2.0', 'x=-1.5', 'x=-1.0', 'x=-0.5', 'x=0.0', 'x=0.5', 'x=1.0',
+         'x=1.5', 'x=2.0', 'x=2.5', 'x=3.0', 'x=3.5', 'x=4.0', 'x=4.5']
+
+        """
+        step = (self.high - self.low) / self.cardinality
+        labels = [
+            f"x={str(i)}" for i in np.round(np.arange(self.low, self.high, step), 3)
+        ]
+        return labels
+
+
+class RoundingDiscretizer(BaseDiscretizer):
+    """
+    This class uses the rounding method for discretizing the
+    given continuous distribution.
+
+    For the rounding method,
+
+    The probability mass is,
+    cdf(x+step/2)-cdf(x), for x = low
+
+    cdf(x+step/2)-cdf(x-step/2), for low < x <= high
+
+    where, cdf is the cumulative density function of the distribution
+    and step = (high-low)/cardinality.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from pgmpy.factors.continuous import ContinuousFactor,RoundingDiscretizer
+    >>> std_normal_pdf = lambda x : np.exp(-x*x/2) / (np.sqrt(2*np.pi))
+    >>> std_normal = ContinuousFactor(['x'],std_normal_pdf)
+    >>> std_normal.discretize(RoundingDiscretizer, low=-3, high=3,
+    ...                       cardinality=12)
+    [0.001629865203424451, 0.009244709419989363, 0.027834684208773178,
+     0.065590616803038182, 0.120977578710013, 0.17466632194020804,
+     0.19741265136584729, 0.17466632194020937, 0.12097757871001302,
+     0.065590616803036905, 0.027834684208772664, 0.0092447094199902269]
+    """
+
+    def get_discrete_values(self):
+        step = (self.high - self.low) / self.cardinality
+
+        # for x=[low]
+        discrete_values = [
+            self.factor.cdf([(-np.inf, self.low + step / 2)])
+            - self.factor.cdf([(-np.inf, self.low)])
+        ]
+
+        # for x=[low+step, low+2*step, ........., high-step]
+        points = np.linspace(self.low + step, self.high - step, self.cardinality - 1)
+        discrete_values.extend(
+            [
+                self.factor.cdf([(-np.inf, i + step / 2)])
+                - self.factor.cdf([(-np.inf, i - step / 2)])
+                for i in points
+            ]
+        )
+
+        return discrete_values
+
+
+class UnbiasedDiscretizer(BaseDiscretizer):
+    """
+    This class uses the unbiased method for discretizing the
+    given continuous distribution.
+
+    The unbiased method for discretization is the matching of the
+    first moment method. It involves calculating the first order
+    limited moment of the distribution which is done by the _lim_moment
+    method.
+
+    For this method,
+
+    The probability mass is,
+    (E(x) - E(x + step))/step + 1 - cdf(x), for x = low
+
+    (2 * E(x) - E(x - step) - E(x + step))/step, for low < x < high
+
+    (E(x) - E(x - step))/step - 1 + cdf(x), for x = high
+
+    where, E(x) is the first limiting moment of the distribution
+    about the point x, cdf is the cumulative density function
+    and step = (high-low)/cardinality.
+
+    References
+    ----------
+    Klugman, S. A., Panjer, H. H. and Willmot, G. E.,
+    Loss Models, From Data to Decisions, Fourth Edition,
+    Wiley, section 9.6.5.2 (Method of local moment matching) and
+    exercise 9.41.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from pgmpy.factors.continuous import ContinuousFactor,UnbiasedDiscretizer
+    # exponential distribution with rate = 2
+    >>> exp_pdf = lambda x: 2*np.exp(-2*x) if x>=0 else 0
+    >>> exp_node = ContinuousFactor(['x'],exp_pdf)
+    >>> exp_node.discretize(UnbiasedDiscretizer, low=0, high=5, cardinality=10)
+    [0.39627368905806137, 0.4049838434034298, 0.13331784003148325,
+     0.043887287876647259, 0.014447413395300212, 0.0047559685431339703,
+     0.0015656350182896128, 0.00051540201980112557, 0.00016965346326140994,
+     3.7867260839208328e-05]
+
+    """
+
+    def get_discrete_values(self):
+        lev = self._lim_moment
+        step = (self.high - self.low) / (self.cardinality - 1)
+
+        # for x=[low]
+        discrete_values = [
+            (lev(self.low) - lev(self.low + step)) / step
+            + 1
+            - self.factor.cdf([(-np.inf, self.low)])
+        ]
+
+        # for x=[low+step, low+2*step, ........., high-step]
+        points = np.linspace(self.low + step, self.high - step, self.cardinality - 2)
+        discrete_values.extend(
+            [(2 * lev(i) - lev(i - step) - lev(i + step)) / step for i in points]
+        )
+
+        # for x=[high]
+        discrete_values.append(
+            (lev(self.high) - lev(self.high - step)) / step
+            - 1
+            + self.factor.cdf([(-np.inf, self.high)])
+        )
+
+        return discrete_values
+
+    def _lim_moment(self, u, order=1):
+        """
+        This method calculates the kth order limiting moment of
+        the distribution. It is given by -
+
+        E(u) = Integral (-inf to u) [ (x^k)*pdf(x) dx ] + (u^k)(1-cdf(u))
+
+        where, pdf is the probability density function and cdf is the
+        cumulative density function of the distribution.
+
+        Reference
+        ---------
+        Klugman, S. A., Panjer, H. H. and Willmot, G. E.,
+        Loss Models, From Data to Decisions, Fourth Edition,
+        Wiley, definition 3.5 and equation 3.8.
+
+        Parameters
+        ----------
+        u: float
+            The point at which the moment is to be calculated.
+
+        order: int
+            The order of the moment, default is first order.
+        """
+
+        def fun(x):
+            return np.power(x, order) * self.factor.pdf(x)
+
+        return integrate.quad(fun, -np.inf, u)[0] + np.power(u, order) * (
+            1 - self.factor.cdf([(-np.inf, u)])
+        )
+
+    def get_labels(self):
+        labels = list(
+            f"x={str(i)}"
+            for i in np.round(np.linspace(self.low, self.high, self.cardinality), 3)
+        )
+        return labels

testbed/pgmpy__pgmpy/pgmpy/factors/discrete/CPD.py

@@ -0,0 +1,677 @@
+#!/usr/bin/env python3
+"""Contains the different formats of CPDs used in PGM"""
+import csv
+import numbers
+from itertools import chain, product
+from shutil import get_terminal_size
+from warnings import warn
+
+import numpy as np
+import torch
+
+from pgmpy import config
+from pgmpy.extern import tabulate
+from pgmpy.factors.discrete import DiscreteFactor
+from pgmpy.utils import compat_fns
+
+
+class TabularCPD(DiscreteFactor):
+    """
+    Defines the conditional probability distribution table (CPD table)
+
+    Parameters
+    ----------
+    variable: int, string (any hashable python object)
+        The variable whose CPD is defined.
+
+    variable_card: integer
+        Cardinality/no. of states of `variable`
+
+    values: 2D array, 2D list or 2D tuple
+        Values for the CPD table. Please refer the example for the
+        exact format needed.
+
+    evidence: array-like
+        List of variables in evidences(if any) w.r.t. which CPD is defined.
+
+    evidence_card: array-like
+        cardinality/no. of states of variables in `evidence`(if any)
+
+    Examples
+    --------
+    For a distribution of P(grade|diff, intel)
+
+    +---------+-------------------------+------------------------+
+    |diff:    |          easy           |         hard           |
+    +---------+------+--------+---------+------+--------+--------+
+    |aptitude:| low  | medium |  high   | low  | medium |  high  |
+    +---------+------+--------+---------+------+--------+--------+
+    |gradeA   | 0.1  | 0.1    |   0.1   |  0.1 |  0.1   |   0.1  |
+    +---------+------+--------+---------+------+--------+--------+
+    |gradeB   | 0.1  | 0.1    |   0.1   |  0.1 |  0.1   |   0.1  |
+    +---------+------+--------+---------+------+--------+--------+
+    |gradeC   | 0.8  | 0.8    |   0.8   |  0.8 |  0.8   |   0.8  |
+    +---------+------+--------+---------+------+--------+--------+
+
+    values should be
+    [[0.1,0.1,0.1,0.1,0.1,0.1],
+    [0.1,0.1,0.1,0.1,0.1,0.1],
+    [0.8,0.8,0.8,0.8,0.8,0.8]]
+
+    >>> cpd = TabularCPD('grade',3,[[0.1,0.1,0.1,0.1,0.1,0.1],
+    ...                             [0.1,0.1,0.1,0.1,0.1,0.1],
+    ...                             [0.8,0.8,0.8,0.8,0.8,0.8]],
+    ...                             evidence=['diff', 'intel'], evidence_card=[2,3])
+    >>> print(cpd)
+    +---------+---------+---------+---------+---------+---------+---------+
+    | diff    | diff_0  | diff_0  | diff_0  | diff_1  | diff_1  | diff_1  |
+    +---------+---------+---------+---------+---------+---------+---------+
+    | intel   | intel_0 | intel_1 | intel_2 | intel_0 | intel_1 | intel_2 |
+    +---------+---------+---------+---------+---------+---------+---------+
+    | grade_0 | 0.1     | 0.1     | 0.1     | 0.1     | 0.1     | 0.1     |
+    +---------+---------+---------+---------+---------+---------+---------+
+    | grade_1 | 0.1     | 0.1     | 0.1     | 0.1     | 0.1     | 0.1     |
+    +---------+---------+---------+---------+---------+---------+---------+
+    | grade_2 | 0.8     | 0.8     | 0.8     | 0.8     | 0.8     | 0.8     |
+    +---------+---------+---------+---------+---------+---------+---------+
+    >>> cpd.values
+    array([[[ 0.1,  0.1,  0.1],
+            [ 0.1,  0.1,  0.1]],
+           [[ 0.1,  0.1,  0.1],
+            [ 0.1,  0.1,  0.1]],
+           [[ 0.8,  0.8,  0.8],
+            [ 0.8,  0.8,  0.8]]])
+    >>> cpd.variables
+    ['grade', 'diff', 'intel']
+    >>> cpd.cardinality
+    array([3, 2, 3])
+    >>> cpd.variable
+    'grade'
+    >>> cpd.variable_card
+    3
+    """
+
+    def __init__(
+        self,
+        variable,
+        variable_card,
+        values,
+        evidence=None,
+        evidence_card=None,
+        state_names={},
+    ):
+        self.variable = variable
+        self.variable_card = None
+
+        variables = [variable]
+
+        if not isinstance(variable_card, numbers.Integral):
+            raise TypeError("Event cardinality must be an integer")
+        self.variable_card = variable_card
+
+        cardinality = [variable_card]
+        if evidence_card is not None:
+            if isinstance(evidence_card, numbers.Real):
+                raise TypeError("Evidence card must be a list of numbers")
+            cardinality.extend(evidence_card)
+
+        if evidence is not None:
+            if isinstance(evidence, str):
+                raise TypeError("Evidence must be list, tuple or array of strings.")
+            variables.extend(evidence)
+            if not len(evidence_card) == len(evidence):
+                raise ValueError(
+                    "Length of evidence_card doesn't match length of evidence"
+                )
+
+        if config.BACKEND == "numpy":
+            values = np.array(values, dtype=config.get_dtype())
+        else:
+            values = (
+                torch.Tensor(values).type(config.get_dtype()).to(config.get_device())
+            )
+
+        if values.ndim != 2:
+            raise TypeError("Values must be a 2D list/array")
+
+        if evidence is None:
+            expected_cpd_shape = (variable_card, 1)
+        else:
+            expected_cpd_shape = (variable_card, np.prod(evidence_card))
+        if values.shape != expected_cpd_shape:
+            raise ValueError(
+                f"values must be of shape {expected_cpd_shape}. Got shape: {values.shape}"
+            )
+
+        if not isinstance(state_names, dict):
+            raise ValueError(
+                f"state_names must be of type dict. Got {type(state_names)}"
+            )
+
+        super(TabularCPD, self).__init__(
+            variables, cardinality, values.flatten(), state_names=state_names
+        )
+
+    def __repr__(self):
+        var_str = f"<TabularCPD representing P({self.variable}:{self.variable_card}"
+
+        evidence = self.variables[1:]
+        evidence_card = self.cardinality[1:]
+        if evidence:
+            evidence_str = " | " + ", ".join(
+                [f"{var}:{card}" for var, card in zip(evidence, evidence_card)]
+            )
+        else:
+            evidence_str = ""
+
+        return var_str + evidence_str + f") at {hex(id(self))}>"
+
+    def get_values(self):
+        """
+        Returns the values of the CPD as a 2-D array. The order of the
+        parents is the same as provided in evidence.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import TabularCPD
+        >>> cpd = TabularCPD('grade', 3, [[0.1, 0.1],
+        ...                               [0.1, 0.1],
+        ...                               [0.8, 0.8]],
+        ...                  evidence='evi1', evidence_card=2)
+        >>> cpd.get_values()
+        array([[ 0.1,  0.1],
+               [ 0.1,  0.1],
+               [ 0.8,  0.8]])
+        """
+        if self.variable in self.variables:
+            return self.values.reshape(
+                tuple([self.cardinality[0], np.prod(self.cardinality[1:])])
+            )
+        else:
+            return self.values.reshape(tuple([np.prod(self.cardinality), 1]))
+
+    def __str__(self):
+        return self._make_table_str(tablefmt="grid")
+
+    def _str(self, phi_or_p="p", tablefmt="fancy_grid"):
+        return super(self, TabularCPD)._str(phi_or_p, tablefmt)
+
+    def _make_table_str(
+        self, tablefmt="fancy_grid", print_state_names=True, return_list=False
+    ):
+        headers_list = []
+
+        # Build column headers
+        evidence = self.variables[1:]
+        evidence_card = self.cardinality[1:]
+        if evidence:
+            col_indexes = np.array(list(product(*[range(i) for i in evidence_card])))
+            if self.state_names and print_state_names:
+                for i in range(len(evidence_card)):
+                    column_header = [str(evidence[i])] + [
+                        "{var}({state})".format(
+                            var=evidence[i], state=self.state_names[evidence[i]][d]
+                        )
+                        for d in col_indexes.T[i]
+                    ]
+                    headers_list.append(column_header)
+            else:
+                for i in range(len(evidence_card)):
+                    column_header = [str(evidence[i])] + [
+                        f"{evidence[i]}_{d}" for d in col_indexes.T[i]
+                    ]
+                    headers_list.append(column_header)
+
+        # Build row headers
+        if self.state_names and print_state_names:
+            variable_array = [
+                [
+                    "{var}({state})".format(
+                        var=self.variable, state=self.state_names[self.variable][i]
+                    )
+                    for i in range(self.variable_card)
+                ]
+            ]
+        else:
+            variable_array = [
+                [f"{self.variable}_{i}" for i in range(self.variable_card)]
+            ]
+        # Stack with data
+        labeled_rows = np.hstack(
+            (np.array(variable_array).T, compat_fns.to_numpy(self.get_values()))
+        ).tolist()
+
+        if return_list:
+            return headers_list + labeled_rows
+
+        # No support for multi-headers in tabulate
+        cdf_str = tabulate(headers_list + labeled_rows, tablefmt=tablefmt)
+
+        cdf_str = self._truncate_strtable(cdf_str)
+
+        return cdf_str
+
+    def _truncate_strtable(self, cdf_str):
+        terminal_width, terminal_height = get_terminal_size()
+
+        list_rows_str = cdf_str.split("\n")
+
+        table_width, table_height = len(list_rows_str[0]), len(list_rows_str)
+
+        colstr_i = np.array(
+            [pos for pos, char in enumerate(list_rows_str[0]) if char == "+"]
+        )
+
+        if table_width > terminal_width:
+            half_width = terminal_width // 2 - 3
+
+            left_i = colstr_i[colstr_i < half_width][-1]
+            right_i = colstr_i[(table_width - colstr_i) < half_width][0]
+
+            new_cdf_str = []
+            for temp_row_str in list_rows_str:
+                left = temp_row_str[: left_i + 1]
+                right = temp_row_str[right_i:]
+                if temp_row_str[left_i] == "+":
+                    joiner = "-----"
+                else:
+                    joiner = " ... "
+                new_cdf_str.append(left + joiner + right)
+
+            cdf_str = "\n".join(new_cdf_str)
+
+        # TODO: vertical limiter
+        # if table_height > terminal_height:
+        #     half_height = terminal_height // 2
+
+        return cdf_str
+
+    def to_csv(self, filename):
+        """
+        Exports the CPD to a CSV file.
+
+        Examples
+        --------
+        >>> from pgmpy.utils import get_example_model
+        >>> model = get_example_model("alarm")
+        >>> cpd = model.get_cpds("SAO2")
+        >>> cpd.to_csv(filename="sao2.cs")
+        """
+        with open(filename, "w") as f:
+            writer = csv.writer(f)
+            writer.writerows(self._make_table_str(tablefmt="grid", return_list=True))
+
+    def copy(self):
+        """
+        Returns a copy of the `TabularCPD` object.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import TabularCPD
+        >>> cpd = TabularCPD('grade', 2,
+        ...                  [[0.7, 0.6, 0.6, 0.2],[0.3, 0.4, 0.4, 0.8]],
+        ...                  ['intel', 'diff'], [2, 2])
+        >>> copy = cpd.copy()
+        >>> copy.variable
+        'grade'
+        >>> copy.variable_card
+        2
+        >>> copy.evidence
+        ['intel', 'diff']
+        >>> copy.values
+        array([[[ 0.7,  0.6],
+                [ 0.6,  0.2]],
+               [[ 0.3,  0.4],
+                [ 0.4,  0.8]]])
+        """
+        evidence = self.variables[1:] if len(self.variables) > 1 else None
+        evidence_card = self.cardinality[1:] if len(self.variables) > 1 else None
+        return TabularCPD(
+            self.variable,
+            self.variable_card,
+            compat_fns.copy(self.get_values()),
+            evidence,
+            evidence_card,
+            state_names=self.state_names.copy(),
+        )
+
+    def normalize(self, inplace=True):
+        """
+        Normalizes the cpd table. The method modifies each column of values such
+        that it sums to 1 without changing the proportion between states.
+
+        Parameters
+        ----------
+        inplace: boolean
+            If inplace=True it will modify the CPD itself, else would return
+            a new CPD
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import TabularCPD
+        >>> cpd_table = TabularCPD('grade', 2,
+        ...                        [[0.7, 0.2, 0.6, 0.2],[0.4, 0.4, 0.4, 0.8]],
+        ...                        ['intel', 'diff'], [2, 2])
+        >>> cpd_table.normalize()
+        >>> cpd_table.get_values()
+        array([[ 0.63636364,  0.33333333,  0.6       ,  0.2       ],
+               [ 0.36363636,  0.66666667,  0.4       ,  0.8       ]])
+        """
+        tabular_cpd = self if inplace else self.copy()
+        cpd = tabular_cpd.get_values()
+        tabular_cpd.values = (cpd / cpd.sum(axis=0)).reshape(
+            tuple(tabular_cpd.cardinality)
+        )
+        if not inplace:
+            return tabular_cpd
+
+    def marginalize(self, variables, inplace=True):
+        """
+        Modifies the CPD table with marginalized values. Marginalization refers to
+        summing out variables, hence that variable would no longer appear in the
+        CPD.
+
+        Parameters
+        ----------
+        variables: list, array-like
+            list of variable to be marginalized
+
+        inplace: boolean
+            If inplace=True it will modify the CPD itself, else would return
+            a new CPD
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import TabularCPD
+        >>> cpd_table = TabularCPD('grade', 2,
+        ...                        [[0.7, 0.6, 0.6, 0.2],[0.3, 0.4, 0.4, 0.8]],
+        ...                        ['intel', 'diff'], [2, 2])
+        >>> cpd_table.marginalize(['diff'])
+        >>> cpd_table.get_values()
+        array([[ 0.65,  0.4 ],
+               [ 0.35,  0.6 ]])
+        """
+        if self.variable in variables:
+            raise ValueError(
+                "Marginalization not allowed on the variable on which CPD is defined"
+            )
+
+        tabular_cpd = self if inplace else self.copy()
+
+        super(TabularCPD, tabular_cpd).marginalize(variables)
+        tabular_cpd.normalize()
+
+        if not inplace:
+            return tabular_cpd
+
+    def reduce(self, values, inplace=True, show_warnings=True):
+        """
+        Reduces the cpd table to the context of given variable values. Reduce fixes the
+        state of given variable to specified value. The reduced variables will no longer
+        appear in the CPD.
+
+        Parameters
+        ----------
+        values: list, array-like
+            A list of tuples of the form (variable_name, variable_state).
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new factor.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import TabularCPD
+        >>> cpd_table = TabularCPD('grade', 2,
+        ...                        [[0.7, 0.6, 0.6, 0.2],[0.3, 0.4, 0.4, 0.8]],
+        ...                        ['intel', 'diff'], [2, 2])
+        >>> cpd_table.reduce([('diff', 0)])
+        >>> cpd_table.get_values()
+        array([[ 0.7,  0.6],
+               [ 0.3,  0.4]])
+        """
+        if self.variable in (value[0] for value in values):
+            raise ValueError(
+                "Reduce not allowed on the variable on which CPD is defined"
+            )
+
+        tabular_cpd = self if inplace else self.copy()
+
+        super(TabularCPD, tabular_cpd).reduce(values, show_warnings=show_warnings)
+        tabular_cpd.normalize()
+
+        if not inplace:
+            return tabular_cpd
+
+    def to_factor(self):
+        """
+        Returns an equivalent factor with the same variables, cardinality, values as that of the CPD.
+        Since factor doesn't distinguish between conditional and non-conditional distributions,
+        evidence information will be lost.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import TabularCPD
+        >>> cpd = TabularCPD('grade', 3, [[0.1, 0.1],
+        ...                               [0.1, 0.1],
+        ...                               [0.8, 0.8]],
+        ...                  evidence='evi1', evidence_card=2)
+        >>> factor = cpd.to_factor()
+        >>> factor
+        <DiscreteFactor representing phi(grade:3, evi1:2) at 0x7f847a4f2d68>
+        """
+        factor = DiscreteFactor.__new__(DiscreteFactor)
+        factor.variables = self.variables.copy()
+        factor.cardinality = self.cardinality.copy()
+        factor.values = compat_fns.copy(self.values)
+        factor.state_names = self.state_names.copy()
+        factor.name_to_no = self.name_to_no.copy()
+        factor.no_to_name = self.no_to_name.copy()
+        return factor
+
+    def reorder_parents(self, new_order, inplace=True):
+        """
+        Returns a new cpd table according to provided parent/evidence order.
+
+        Parameters
+        ----------
+        new_order: list
+            list of new ordering of variables
+
+        inplace: boolean
+            If inplace == True it will modify the CPD itself
+            otherwise new value will be returned without affecting old values
+
+        Examples
+        --------
+
+        Consider a CPD P(grade| diff, intel)
+
+        >>> cpd = TabularCPD('grade',3,[[0.1,0.1,0.0,0.4,0.2,0.1],
+        ...                             [0.3,0.2,0.1,0.4,0.3,0.2],
+        ...                             [0.6,0.7,0.9,0.2,0.5,0.7]],
+        ...                  evidence=['diff', 'intel'], evidence_card=[2,3])
+        >>> print(cpd)
+        +----------+----------+----------+----------+----------+----------+----------+
+        | diff     | diff(0)  | diff(0)  | diff(0)  | diff(1)  | diff(1)  | diff(1)  |
+        +----------+----------+----------+----------+----------+----------+----------+
+        | intel    | intel(0) | intel(1) | intel(2) | intel(0) | intel(1) | intel(2) |
+        +----------+----------+----------+----------+----------+----------+----------+
+        | grade(0) | 0.1      | 0.1      | 0.0      | 0.4      | 0.2      | 0.1      |
+        +----------+----------+----------+----------+----------+----------+----------+
+        | grade(1) | 0.3      | 0.2      | 0.1      | 0.4      | 0.3      | 0.2      |
+        +----------+----------+----------+----------+----------+----------+----------+
+        | grade(2) | 0.6      | 0.7      | 0.9      | 0.2      | 0.5      | 0.7      |
+        +----------+----------+----------+----------+----------+----------+----------+
+        >>> cpd.values
+        array([[[ 0.1,  0.1,  0. ],
+                [ 0.4,  0.2,  0.1]],
+               [[ 0.3,  0.2,  0.1],
+                [ 0.4,  0.3,  0.2]],
+               [[ 0.6,  0.7,  0.9],
+                [ 0.2,  0.5,  0.7]]])
+        >>> cpd.variables
+        ['grade', 'diff', 'intel']
+        >>> cpd.cardinality
+        array([3, 2, 3])
+        >>> cpd.variable
+        'grade'
+        >>> cpd.variable_card
+        3
+        >>> cpd.reorder_parents(['intel', 'diff'])
+        array([[0.1, 0.4, 0.1, 0.2, 0. , 0.1],
+               [0.3, 0.4, 0.2, 0.3, 0.1, 0.2],
+               [0.6, 0.2, 0.7, 0.5, 0.9, 0.7]])
+        >>> print(cpd)
+        +----------+----------+----------+----------+----------+----------+----------+
+        | intel    | intel(0) | intel(0) | intel(1) | intel(1) | intel(2) | intel(2) |
+        +----------+----------+----------+----------+----------+----------+----------+
+        | diff     | diff(0)  | diff(1)  | diff(0)  | diff(1)  | diff(0)  | diff(1)  |
+        +----------+----------+----------+----------+----------+----------+----------+
+        | grade(0) | 0.1      | 0.4      | 0.1      | 0.2      | 0.0      | 0.1      |
+        +----------+----------+----------+----------+----------+----------+----------+
+        | grade(1) | 0.3      | 0.4      | 0.2      | 0.3      | 0.1      | 0.2      |
+        +----------+----------+----------+----------+----------+----------+----------+
+        | grade(2) | 0.6      | 0.2      | 0.7      | 0.5      | 0.9      | 0.7      |
+        +----------+----------+----------+----------+----------+----------+----------+
+        >>> cpd.values
+        array([[[0.1, 0.4],
+                [0.1, 0.2],
+                [0. , 0.1]],
+               [[0.3, 0.4],
+                [0.2, 0.3],
+                [0.1, 0.2]],
+               [[0.6, 0.2],
+                [0.7, 0.5],
+                [0.9, 0.7]]])
+        >>> cpd.variables
+        ['grade', 'intel', 'diff']
+        >>> cpd.cardinality
+        array([3, 3, 2])
+        >>> cpd.variable
+        'grade'
+        >>> cpd.variable_card
+        3
+        """
+        if (
+            len(self.variables) <= 1
+            or (set(new_order) - set(self.variables))
+            or (set(self.variables[1:]) - set(new_order))
+        ):
+            raise ValueError("New order either has missing or extra arguments")
+        else:
+            if new_order != self.variables[1:]:
+                evidence = self.variables[1:]
+                evidence_card = self.cardinality[1:]
+                card_map = dict(zip(evidence, evidence_card))
+                old_pos_map = dict(zip(evidence, range(len(evidence))))
+                trans_ord = [0] + [(old_pos_map[letter] + 1) for letter in new_order]
+                new_values = compat_fns.transpose(self.values, tuple(trans_ord))
+
+                if inplace:
+                    variables = [self.variables[0]] + new_order
+                    cardinality = [self.variable_card] + [
+                        card_map[var] for var in new_order
+                    ]
+                    super(TabularCPD, self).__init__(
+                        variables, cardinality, new_values.flatten()
+                    )
+                    return self.get_values()
+                else:
+                    return new_values.reshape(
+                        tuple(
+                            [
+                                self.cardinality[0],
+                                np.prod([card_map[var] for var in new_order]),
+                            ]
+                        )
+                    )
+            else:
+                warn("Same ordering provided as current")
+                return self.get_values()
+
+    def get_evidence(self):
+        """
+        Returns the evidence variables of the CPD.
+        """
+        return self.variables[:0:-1]
+
+    @staticmethod
+    def get_random(
+        variable, evidence=None, cardinality=None, state_names={}, seed=None
+    ):
+        """
+        Generates a TabularCPD instance with random values on `variable` with
+        parents/evidence `evidence` with cardinality/number of states as given
+        in `cardinality`.
+
+        Parameters
+        ----------
+        variable: str, int or any hashable python object.
+            The variable on which to define the TabularCPD.
+
+        evidence: list, array-like
+            A list of variable names which are the parents/evidence of `variable`.
+
+        cardinality: dict (default: None)
+            A dict of the form {var_name: card} specifying the number of states/
+            cardinality of each of the variables. If None, assigns each variable
+            2 states.
+
+        state_names: dict (default: {})
+            A dict of the form {var_name: list of states} to specify the state names
+            for the variables in the CPD. If state_names=None, integral state names
+            starting from 0 is assigned.
+
+        Returns
+        -------
+        Random CPD: pgmpy.factors.discrete.TabularCPD
+            A TabularCPD object on `variable` with `evidence` as evidence with random values.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import TabularCPD
+        >>> TabularCPD(variable='A', evidence=['C', 'D'],
+        ...            cardinality={'A': 3, 'B': 2, 'C': 4})
+        <TabularCPD representing P(A:3 | C:4, B:2) at 0x7f95e22b8040>
+        >>> TabularCPD(variable='A', evidence=['C', 'D'],
+        ...            cardinality={'A': 2, 'B': 2, 'C': 2},
+        ...            state_names={'A': ['a1', 'a2'],
+        ...                         'B': ['b1', 'b2'],
+        ...                         'C': ['c1', 'c2']})
+        """
+        generator = np.random.default_rng(seed=seed)
+
+        if evidence is None:
+            evidence = []
+
+        if cardinality is None:
+            cardinality = {var: 2 for var in chain([variable], evidence)}
+        else:
+            for var in chain([variable], evidence):
+                if var not in cardinality.keys():
+                    raise ValueError(f"Cardinality for variable: {var} not specified.")
+
+        if len(evidence) == 0:
+            values = generator.random((cardinality[variable], 1))
+            values = values / np.sum(values, axis=0)
+            node_cpd = TabularCPD(
+                variable=variable,
+                variable_card=cardinality[variable],
+                values=values,
+                state_names=state_names,
+            )
+        else:
+            parent_card = [cardinality[var] for var in evidence]
+            values = generator.random((cardinality[variable], np.prod(parent_card)))
+            values = values / np.sum(values, axis=0)
+            node_cpd = TabularCPD(
+                variable=variable,
+                variable_card=cardinality[variable],
+                values=values,
+                evidence=evidence,
+                evidence_card=parent_card,
+                state_names=state_names,
+            )
+
+        return node_cpd

testbed/pgmpy__pgmpy/pgmpy/factors/discrete/DiscreteFactor.py

@@ -0,0 +1,1043 @@
+from collections import namedtuple
+from itertools import product
+
+import numpy as np
+import pandas as pd
+import torch
+
+from pgmpy import config
+from pgmpy.extern import tabulate
+from pgmpy.factors.base import BaseFactor
+from pgmpy.global_vars import logger
+from pgmpy.utils import StateNameMixin, compat_fns
+
+State = namedtuple("State", ["var", "state"])
+
+
+class DiscreteFactor(BaseFactor, StateNameMixin):
+    """
+    Initialize a `DiscreteFactor` class.
+
+    Defined above, we have the following mapping from variable
+    assignments to the index of the row vector in the value field:
+
+    +-----+-----+-----+-------------------+
+    |  x1 |  x2 |  x3 |    phi(x1, x2, x3)|
+    +-----+-----+-----+-------------------+
+    | x1_0| x2_0| x3_0|     phi.value(0)  |
+    +-----+-----+-----+-------------------+
+    | x1_0| x2_0| x3_1|     phi.value(1)  |
+    +-----+-----+-----+-------------------+
+    | x1_0| x2_1| x3_0|     phi.value(2)  |
+    +-----+-----+-----+-------------------+
+    | x1_0| x2_1| x3_1|     phi.value(3)  |
+    +-----+-----+-----+-------------------+
+    | x1_1| x2_0| x3_0|     phi.value(4)  |
+    +-----+-----+-----+-------------------+
+    | x1_1| x2_0| x3_1|     phi.value(5)  |
+    +-----+-----+-----+-------------------+
+    | x1_1| x2_1| x3_0|     phi.value(6)  |
+    +-----+-----+-----+-------------------+
+    | x1_1| x2_1| x3_1|     phi.value(7)  |
+    +-----+-----+-----+-------------------+
+
+    Parameters
+    ----------
+    variables: list, array-like
+        List of variables on which the factor is to be defined i.e. scope of the factor.
+
+    cardinality: list, array_like
+        List of cardinalities/no.of states of each variable. `cardinality`
+        array must have a value corresponding to each variable in
+        `variables`.
+
+    values: list, array_like
+        List of values of factor.
+        A DiscreteFactor's values are stored in a row vector in the value
+        using an ordering such that the left-most variables as defined in
+        `variables` cycle through their values the fastest. Please refer
+        to examples for usage examples.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from pgmpy.factors.discrete import DiscreteFactor
+    >>> phi = DiscreteFactor(['x1', 'x2', 'x3'], [2, 2, 2], np.ones(8))
+    >>> phi
+    <DiscreteFactor representing phi(x1:2, x2:2, x3:2) at 0x7f8188fcaa90>
+    >>> print(phi)
+    +------+------+------+-----------------+
+    | x1   | x2   | x3   |   phi(x1,x2,x3) |
+    |------+------+------+-----------------|
+    | x1_0 | x2_0 | x3_0 |          1.0000 |
+    | x1_0 | x2_0 | x3_1 |          1.0000 |
+    | x1_0 | x2_1 | x3_0 |          1.0000 |
+    | x1_0 | x2_1 | x3_1 |          1.0000 |
+    | x1_1 | x2_0 | x3_0 |          1.0000 |
+    | x1_1 | x2_0 | x3_1 |          1.0000 |
+    | x1_1 | x2_1 | x3_0 |          1.0000 |
+    | x1_1 | x2_1 | x3_1 |          1.0000 |
+    +------+------+------+-----------------+
+    """
+
+    def __init__(self, variables, cardinality, values, state_names={}):
+        if isinstance(variables, str):
+            raise TypeError("Variables: Expected type list or array like, got string")
+
+        if config.BACKEND == "numpy":
+            values = np.array(values, dtype=config.get_dtype())
+        else:
+            values = (
+                torch.Tensor(values).type(config.get_dtype()).to(config.get_device())
+            )
+
+        if len(cardinality) != len(variables):
+            raise ValueError(
+                "Number of elements in cardinality must be equal to number of variables"
+            )
+
+        if compat_fns.size(values) != np.prod(cardinality):
+            raise ValueError(f"Values array must be of size: {np.prod(cardinality)}")
+
+        if len(set(variables)) != len(variables):
+            raise ValueError("Variable names cannot be same")
+
+        if not isinstance(state_names, dict):
+            raise ValueError(
+                f"state_names must be of type dict. Got {type(state_names)}."
+            )
+
+        self.variables = list(variables)
+        self.cardinality = np.array(cardinality, dtype=int)
+        self.values = values.reshape(tuple(self.cardinality))
+
+        # Set the state names
+        super(DiscreteFactor, self).store_state_names(
+            variables, cardinality, state_names
+        )
+
+    def scope(self):
+        """
+        Returns the scope of the factor i.e. the variables on which the factor is defined.
+
+        Returns
+        -------
+        Scope of the factor: list
+            List of variables on which the factor is defined.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], np.ones(12))
+        >>> phi.scope()
+        ['x1', 'x2', 'x3']
+        """
+        return self.variables
+
+    def get_cardinality(self, variables):
+        """
+        Returns the cardinality/no.of states of each variable in `variables`.
+
+        Parameters
+        ----------
+        variables: list, array-like
+                A list of variable names.
+
+        Returns
+        -------
+        Cardinality of variables: dict
+            Dictionary of the form {variable: variable_cardinality}
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi.get_cardinality(['x1'])
+        {'x1': 2}
+        >>> phi.get_cardinality(['x1', 'x2'])
+        {'x1': 2, 'x2': 3}
+        """
+        if isinstance(variables, str):
+            raise TypeError("variables: Expected type list or array-like, got type str")
+
+        if not all([var in self.variables for var in variables]):
+            raise ValueError("Variable not in scope")
+
+        return {var: self.cardinality[self.variables.index(var)] for var in variables}
+
+    def get_value(self, **kwargs):
+        """
+        Returns the value of the given variable states. Assumes that the arguments
+        specified are state names, and falls back to considering it as state no if
+        can't find the state name.
+
+        Parameters
+        ----------
+        kwargs: named arguments of the form variable=state_name
+            Spcifies the state of each of the variable for which to get
+            the value.
+
+        Returns
+        -------
+        value of kwargs: float
+            The value of specified states.
+
+        Examples
+        --------
+        >>> from pgmpy.utils import get_example_model
+        >>> model = get_example_model("asia")
+        >>> phi = model.get_cpds("either").to_factor()
+        >>> phi.get_value(lung="yes", tub="no", either="yes")
+        1.0
+        """
+        for variable in kwargs.keys():
+            if variable not in self.variables:
+                raise ValueError(f"Factor doesn't have the variable: {variable}")
+
+        index = []
+        for var in self.variables:
+            if var not in kwargs.keys():
+                raise ValueError(f"Variable: {var} not found in arguments")
+            else:
+                try:
+                    index.append(self.name_to_no[var][kwargs[var]])
+                except KeyError:
+                    logger.info(f"Using {var} state as number instead of name.")
+                    index.append(kwargs[var])
+        return self.values[tuple(index)]
+
+    def set_value(self, value, **kwargs):
+        """
+        Sets the probability value of the given variable states.
+
+        Parameters
+        ----------
+        value: float
+            The value for the specified state.
+
+        kwargs: named arguments of the form variable=state_name
+            Spcifies the state of each of the variable for which to get
+            the probability value.
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        >>> from pgmpy.utils import get_example_model
+        >>> model = get_example_model("asia")
+        >>> phi = model.get_cpds("either").to_factor()
+        >>> phi.set_value(value=0.1, lung="yes", tub="no", either="yes")
+        >>> phi.get_value(lung='yes', tub='no', either='yes')
+        0.1
+        """
+        if not isinstance(value, (float, int)):
+            raise ValueError(f"value must be float. Got: {type(value)}.")
+
+        for variable in kwargs.keys():
+            if variable not in self.variables:
+                raise ValueError(f"Factor doesn't have the variable: {variable}")
+
+        index = []
+        for var in self.variables:
+            if var not in kwargs.keys():
+                raise ValueError(f"Variable: {var} not found in arguments")
+            elif isinstance(kwargs[var], str):
+                index.append(self.name_to_no[var][kwargs[var]])
+            else:
+                logger.info(f"Using {var} state as number instead of name.")
+                index.append(kwargs[var])
+
+        self.values[tuple(index)] = value
+
+    def assignment(self, index):
+        """
+        Returns a list of assignments (variable and state) for the corresponding index.
+
+        Parameters
+        ----------
+        index: list, array-like
+            List of indices whose assignment is to be computed
+
+        Returns
+        -------
+        Full assignments: list
+            Returns a list of full assignments of all the variables of the factor.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi = DiscreteFactor(['diff', 'intel'], [2, 2], np.ones(4))
+        >>> phi.assignment([1, 2])
+        [[('diff', 0), ('intel', 1)], [('diff', 1), ('intel', 0)]]
+        """
+        if config.get_backend() == "numpy":
+            index = np.array(index)
+        else:
+            if (len(index) == 1) and (isinstance(index[0], torch.Tensor)):
+                index = index[0][None]
+            else:
+                index = torch.tensor(index, dtype=torch.int, device=config.get_device())
+
+        max_possible_index = np.prod(self.cardinality) - 1
+        if not all(i <= max_possible_index for i in index):
+            raise IndexError("Index greater than max possible index")
+
+        assignments = compat_fns.get_compute_backend().zeros(
+            (len(index), len(self.scope())), dtype=int
+        )
+        rev_card = self.cardinality[::-1]
+        for i, card in enumerate(rev_card):
+            assignments[:, i] = index % card
+            index = index // card
+
+        assignments = compat_fns.flip(assignments, axis=(1,))
+
+        return [
+            [
+                (key, self.get_state_names(key, int(val)))
+                for key, val in zip(self.variables, values)
+            ]
+            for values in assignments
+        ]
+
+    def identity_factor(self):
+        """
+        Returns the identity factor.
+
+        Def: The identity factor of a factor has the same scope and cardinality as the original factor,
+             but the values for all the assignments is 1. When the identity factor is multiplied with
+             the factor it returns the factor itself.
+
+        Returns
+        -------
+        Identity factor: pgmpy.factors.discrete.DiscreteFactor.
+            Returns a factor with all values set to 1.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi_identity = phi.identity_factor()
+        >>> phi_identity.variables
+        ['x1', 'x2', 'x3']
+        >>> phi_identity.values
+        array([[[ 1.,  1.],
+                [ 1.,  1.],
+                [ 1.,  1.]],
+               [[ 1.,  1.],
+                [ 1.,  1.],
+                [ 1.,  1.]]])
+        """
+        return DiscreteFactor(
+            variables=self.variables,
+            cardinality=self.cardinality,
+            values=compat_fns.ones(compat_fns.size(self.values)),
+            state_names=self.state_names,
+        )
+
+    def marginalize(self, variables, inplace=True):
+        """
+        Modifies the factor with marginalized values.
+
+        Parameters
+        ----------
+        variables: list, array-like
+            List of variables over which to marginalize.
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new factor.
+
+        Returns
+        -------
+        Marginalized factor: pgmpy.factors.discrete.DiscreteFactor or None
+        If inplace=True (default) returns None else returns a new `DiscreteFactor` instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi.marginalize(['x1', 'x3'])
+        >>> phi.values
+        array([14., 22., 30.])
+        >>> phi.variables
+        ['x2']
+        """
+
+        if isinstance(variables, str):
+            raise TypeError("variables: Expected type list or array-like, got type str")
+
+        phi = self if inplace else self.copy()
+
+        for var in variables:
+            if var not in phi.variables:
+                raise ValueError(f"{var} not in scope.")
+
+        var_indexes = [phi.variables.index(var) for var in variables]
+
+        index_to_keep = sorted(set(range(len(self.variables))) - set(var_indexes))
+        n_variables = len(self.variables)
+        phi.variables = [phi.variables[index] for index in index_to_keep]
+        phi.cardinality = phi.cardinality[index_to_keep]
+        phi.del_state_names(variables)
+
+        phi.values = compat_fns.einsum(phi.values, range(n_variables), index_to_keep)
+
+        if not inplace:
+            return phi
+
+    def maximize(self, variables, inplace=True):
+        """
+        Maximizes the factor with respect to `variables`.
+
+        Parameters
+        ----------
+        variables: list, array-like
+            List of variables with respect to which factor is to be maximized
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new factor.
+
+        Returns
+        -------
+        Maximized factor: pgmpy.factors.discrete.DiscreteFactor or None
+            If inplace=True (default) returns None else inplace=False returns a
+            new `DiscreteFactor` instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi = DiscreteFactor(['x1', 'x2', 'x3'], [3, 2, 2], [0.25, 0.35, 0.08, 0.16, 0.05, 0.07,
+        ...                                              0.00, 0.00, 0.15, 0.21, 0.09, 0.18])
+        >>> phi.variables
+        ['x1', 'x2', 'x3']
+        >>> phi.maximize(['x2'])
+        >>> phi.variables
+        ['x1', 'x3']
+        >>> phi.cardinality
+        array([3, 2])
+        >>> phi.values
+        array([[ 0.25,  0.35],
+               [ 0.05,  0.07],
+               [ 0.15,  0.21]])
+        """
+        if isinstance(variables, str):
+            raise TypeError("variables: Expected type list or array-like, got type str")
+
+        phi = self if inplace else self.copy()
+
+        for var in variables:
+            if var not in phi.variables:
+                raise ValueError(f"{var} not in scope.")
+
+        var_indexes = [phi.variables.index(var) for var in variables]
+
+        index_to_keep = sorted(set(range(len(self.variables))) - set(var_indexes))
+        phi.variables = [phi.variables[index] for index in index_to_keep]
+        phi.cardinality = phi.cardinality[index_to_keep]
+        phi.del_state_names(variables)
+        phi.values = compat_fns.max(phi.values, axis=tuple(var_indexes))
+
+        if not inplace:
+            return phi
+
+    def normalize(self, inplace=True):
+        """
+        Normalizes the values of factor so that they sum to 1.
+
+        Parameters
+        ----------
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new factor
+
+        Returns
+        -------
+        Normalized factor: pgmpy.factors.discrete.DiscreteFactor or None
+            If inplace=True (default) returns None else returns a new `DiscreteFactor` instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi.values
+        array([[[ 0.,  1.],
+                [ 2.,  3.],
+                [ 4.,  5.]],
+               [[ 6.,  7.],
+                [ 8.,  9.],
+                [10., 11.]]])
+        >>> phi.normalize()
+        >>> phi.variables
+        ['x1', 'x2', 'x3']
+        >>> phi.cardinality
+        array([2, 3, 2])
+        >>> phi.values
+        array([[[ 0.        ,  0.01515152],
+                [ 0.03030303,  0.04545455],
+                [ 0.06060606,  0.07575758]],
+               [[ 0.09090909,  0.10606061],
+                [ 0.12121212,  0.13636364],
+                [ 0.15151515,  0.16666667]]])
+        """
+        phi = self if inplace else self.copy()
+
+        phi.values = phi.values / (phi.values.sum())
+
+        if not inplace:
+            return phi
+
+    def reduce(self, values, inplace=True, show_warnings=True):
+        """
+        Reduces the factor to the context of given variable values. The variables which
+        are reduced would be removed from the factor.
+
+        Parameters
+        ----------
+        values: list, array-like
+            A list of tuples of the form (variable_name, variable_state).
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new factor.
+
+        show_warnings: boolean
+            Whether to show warning when state name not found.
+
+        Returns
+        -------
+        Reduced factor: pgmpy.factors.discrete.DiscreteFactor or None
+            If inplace=True (default) returns None else returns a new `DiscreteFactor` instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi.reduce([('x1', 0), ('x2', 0)])
+        >>> phi.variables
+        ['x3']
+        >>> phi.cardinality
+        array([2])
+        >>> phi.values
+        array([0., 1.])
+        """
+        # Check if values is an array
+        if isinstance(values, str):
+            raise TypeError("values: Expected type list or array-like, got type str")
+
+        if not all([isinstance(state_tuple, tuple) for state_tuple in values]):
+            raise TypeError(
+                "values: Expected type list of tuples, get type {type}", type(values[0])
+            )
+
+        # Check if all variables in values are in the factor
+        for var, _ in values:
+            if var not in self.variables:
+                raise ValueError(f"The variable: {var} is not in the factor")
+
+        phi = self if inplace else self.copy()
+
+        # Convert the state names to state number. If state name not found treat them as
+        # state numbers.
+        try:
+            values = [
+                (var, self.get_state_no(var, state_name)) for var, state_name in values
+            ]
+        except KeyError:
+            if show_warnings:
+                logger.warning(
+                    "Found unknown state name. Trying to switch to using all state names as state numbers"
+                )
+
+        var_index_to_del = []
+        slice_ = [slice(None)] * len(self.variables)
+        for var, state in values:
+            var_index = phi.variables.index(var)
+            slice_[var_index] = state
+            var_index_to_del.append(var_index)
+
+        var_index_to_keep = sorted(
+            set(range(len(phi.variables))) - set(var_index_to_del)
+        )
+        # set difference is not guaranteed to maintain ordering
+        phi.variables = [phi.variables[index] for index in var_index_to_keep]
+        phi.cardinality = phi.cardinality[var_index_to_keep]
+        phi.del_state_names([var for var, _ in values])
+
+        phi.values = phi.values[tuple(slice_)]
+
+        if not inplace:
+            return phi
+
+    def sum(self, phi1, inplace=True):
+        """
+        DiscreteFactor sum with `phi1`.
+
+        Parameters
+        ----------
+        phi1: float or `DiscreteFactor` instance.
+            If float, the value is added to each value in the factor.
+            DiscreteFactor to be added.
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new factor.
+
+        Returns
+        -------
+        Summed factor: pgmpy.factors.discrete.DiscreteFactor or None
+            If inplace=True (default) returns None else returns a new `DiscreteFactor` instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+        >>> phi1.sum(phi2, inplace=True)
+        >>> phi1.variables
+        ['x1', 'x2', 'x3', 'x4']
+        >>> phi1.cardinality
+        array([2, 3, 2, 2])
+        >>> phi1.values
+        array([[[[ 0.,  2.],
+                 [ 5.,  7.]],
+                [[ 2.,  4.],
+                 [ 7.,  9.]],
+                [[ 4.,  6.],
+                 [ 9., 11.]]],
+               [[[ 7., 9.],
+                 [12., 14.]],
+                [[ 9., 11.],
+                 [14., 16.]],
+                [[11., 13.],
+                 [16., 18.]]]])
+        """
+        phi = self if inplace else self.copy()
+        if isinstance(phi1, (int, float)):
+            phi.values += phi1
+        else:
+            phi1 = phi1.copy()
+
+            # modifying phi to add new variables
+            extra_vars = set(phi1.variables) - set(phi.variables)
+            if extra_vars:
+                slice_ = [slice(None)] * len(phi.variables)
+                slice_.extend([np.newaxis] * len(extra_vars))
+                phi.values = phi.values[tuple(slice_)]
+
+                phi.variables.extend(extra_vars)
+
+                new_var_card = phi1.get_cardinality(extra_vars)
+                phi.cardinality = np.append(
+                    phi.cardinality, [new_var_card[var] for var in extra_vars]
+                )
+                phi.add_state_names(phi1)
+
+            # modifying phi1 to add new variables
+            extra_vars = set(phi.variables) - set(phi1.variables)
+            if extra_vars:
+                slice_ = [slice(None)] * len(phi1.variables)
+                slice_.extend([np.newaxis] * len(extra_vars))
+                phi1.values = phi1.values[tuple(slice_)]
+
+                phi1.variables.extend(extra_vars)
+                # No need to modify cardinality as we don't need it.
+
+            # rearranging the axes of phi1 to match phi
+            for axis in range(phi.values.ndim):
+                exchange_index = phi1.variables.index(phi.variables[axis])
+                phi1.variables[axis], phi1.variables[exchange_index] = (
+                    phi1.variables[exchange_index],
+                    phi1.variables[axis],
+                )
+                phi1.values = phi1.values.swapaxes(axis, exchange_index)
+
+            phi.values = phi.values + phi1.values
+
+        if not inplace:
+            return phi
+
+    def product(self, phi1, inplace=True):
+        """
+        DiscreteFactor product with `phi1`.
+
+        Parameters
+        ----------
+        phi1: float or `DiscreteFactor` instance
+            If float, all the values are multiplied with `phi1`.
+            else if `DiscreteFactor` instance, mutliply based on matching rows.
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new factor.
+
+        Returns
+        -------
+        Multiplied factor: pgmpy.factors.discrete.DiscreteFactor or None
+            If inplace=True (default) returns None else returns a new `DiscreteFactor` instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x4', 'x1'], [2, 2, 2], range(8))
+        >>> phi1.product(phi2, inplace=True)
+        >>> phi1.variables
+        ['x1', 'x2', 'x3', 'x4']
+        >>> phi1.cardinality
+        array([2, 3, 2, 2])
+        >>> phi1.values
+        array([[[[ 0,  0],
+                 [ 4,  6]],
+                [[ 0,  4],
+                 [12, 18]],
+                [[ 0,  8],
+                 [20, 30]]],
+               [[[ 6, 18],
+                 [35, 49]],
+                [[ 8, 24],
+                 [45, 63]],
+                [[10, 30],
+                 [55, 77]]]]
+        """
+        phi = self if inplace else self.copy()
+        if isinstance(phi1, (int, float)):
+            phi.values *= phi1
+        else:
+            # Compute the new values
+            new_variables = list(set(phi.variables).union(phi1.variables))
+            var_to_int = {var: index for index, var in enumerate(new_variables)}
+            phi.values = compat_fns.einsum(
+                phi.values,
+                [var_to_int[var] for var in phi.variables],
+                phi1.values,
+                [var_to_int[var] for var in phi1.variables],
+                range(len(new_variables)),
+            )
+
+            # Compute the new cardinality array
+            phi_card = {var: card for var, card in zip(phi.variables, phi.cardinality)}
+            phi1_card = {
+                var: card for var, card in zip(phi1.variables, phi1.cardinality)
+            }
+            phi_card.update(phi1_card)
+            phi.cardinality = np.array([phi_card[var] for var in new_variables])
+
+            # Set the new variables and state names
+            phi.variables = new_variables
+            phi.add_state_names(phi1)
+
+        if not inplace:
+            return phi
+
+    def divide(self, phi1, inplace=True):
+        """
+        DiscreteFactor division by `phi1`.
+
+        Parameters
+        ----------
+        phi1 : `DiscreteFactor` instance
+            The denominator for division.
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new factor.
+
+        Returns
+        -------
+        Divided factor: pgmpy.factors.discrete.DiscreteFactor or None
+            If inplace=True (default) returns None else returns a new `DiscreteFactor` instance.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi2 = DiscreteFactor(['x3', 'x1'], [2, 2], range(1, 5))
+        >>> phi1.divide(phi2)
+        >>> phi1.variables
+        ['x1', 'x2', 'x3']
+        >>> phi1.cardinality
+        array([2, 3, 2])
+        >>> phi1.values
+        array([[[ 0.        ,  0.33333333],
+                [ 2.        ,  1.        ],
+                [ 4.        ,  1.66666667]],
+               [[ 3.        ,  1.75      ],
+                [ 4.        ,  2.25      ],
+                [ 5.        ,  2.75      ]]])
+        """
+        phi = self if inplace else self.copy()
+        phi1 = phi1.copy()
+
+        if set(phi1.variables) - set(phi.variables):
+            raise ValueError("Scope of divisor should be a subset of dividend")
+
+        # Adding extra variables in phi1.
+        extra_vars = set(phi.variables) - set(phi1.variables)
+        if extra_vars:
+            slice_ = [slice(None)] * len(phi1.variables)
+            slice_.extend([np.newaxis] * len(extra_vars))
+            phi1.values = phi1.values[tuple(slice_)]
+
+            phi1.variables.extend(extra_vars)
+
+        # Rearranging the axes of phi1 to match phi
+        for axis in range(phi.values.ndim):
+            exchange_index = phi1.variables.index(phi.variables[axis])
+            phi1.variables[axis], phi1.variables[exchange_index] = (
+                phi1.variables[exchange_index],
+                phi1.variables[axis],
+            )
+            phi1.values = phi1.values.swapaxes(axis, exchange_index)
+
+        phi.values = phi.values / phi1.values
+
+        # If factor division 0/0 = 0 but is undefined for x/0. In pgmpy we are using
+        # np.inf to represent x/0 cases.
+        phi.values[config.get_compute_backend().isnan(phi.values)] = 0
+
+        if not inplace:
+            return phi
+
+    def sample(self, n, seed=None):
+        """
+        Normalizes the factor and samples state combinations from it.
+
+        Parameters
+        ----------
+        n: int
+            Number of samples to generate.
+
+        seed: int (default: None)
+            The seed value for the random number generator.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi1 = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 2], range(12))
+        >>> phi1.sample(5)
+            x1  x2  x3
+        0    1   0   0
+        1    0   2   0
+        2    1   2   0
+        3    1   1   1
+        4    1   1   1
+        """
+        phi = self.normalize(inplace=False)
+        p = phi.values.ravel()
+
+        # TODO: Fix this to make it work natively in torch.
+        p = compat_fns.to_numpy(p)
+
+        rng = np.random.default_rng(seed=seed)
+        indexes = rng.choice(range(len(p)), size=n, p=p)
+        samples = []
+        index_to_state = {}
+        for index in indexes:
+            if index in index_to_state:
+                samples.append(index_to_state[index])
+            else:
+                assignment = self.assignment([index])[0]
+                samples.append(assignment)
+                index_to_state[index] = assignment
+
+        return pd.DataFrame([{k: v for k, v in s} for s in samples])
+
+    def copy(self):
+        """
+        Returns a copy of the factor.
+
+        Returns
+        -------
+        Copy of self: pgmpy.factors.discrete.DiscreteFactor
+            A copy of the original discrete factor.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.discrete import DiscreteFactor
+        >>> phi = DiscreteFactor(['x1', 'x2', 'x3'], [2, 3, 3], np.arange(18))
+        >>> phi_copy = phi.copy()
+        >>> phi_copy.variables
+        ['x1', 'x2', 'x3']
+        >>> phi_copy.cardinality
+        array([2, 3, 3])
+        >>> phi_copy.values
+        array([[[ 0,  1,  2],
+                [ 3,  4,  5],
+                [ 6,  7,  8]],
+               [[ 9, 10, 11],
+                [12, 13, 14],
+                [15, 16, 17]]])
+        """
+        copy = DiscreteFactor.__new__(self.__class__)
+        copy.variables = [*self.variables]
+        copy.cardinality = np.array(self.cardinality)
+        copy.values = compat_fns.copy(self.values)
+        copy.state_names = self.state_names.copy()
+        copy.no_to_name = self.no_to_name.copy()
+        copy.name_to_no = self.name_to_no.copy()
+        return copy
+
+    def is_valid_cpd(self):
+        """
+        Checks if the factor's values can be used for a valid CPD.
+        """
+        return config.get_compute_backend().allclose(
+            self.to_factor()
+            .marginalize(self.scope()[:1], inplace=False)
+            .values.flatten(),
+            compat_fns.ones(np.prod(self.cardinality[:0:-1])),
+            atol=0.01,
+        )
+
+    def __str__(self):
+        return self._str(phi_or_p="phi", tablefmt="grid")
+
+    def _str(self, phi_or_p="phi", tablefmt="grid", print_state_names=True):
+        """
+        Generate the string from `__str__` method.
+
+        Parameters
+        ----------
+        phi_or_p: 'phi' | 'p'
+                'phi': When used for Factors.
+                  'p': When used for CPDs.
+        print_state_names: boolean
+                If True, the user defined state names are displayed.
+        """
+        string_header = list(map(str, self.scope()))
+        string_header.append(f"{phi_or_p}({','.join(string_header)})")
+
+        value_index = 0
+        factor_table = []
+        for prob in product(*[range(card) for card in self.cardinality]):
+            if self.state_names and print_state_names:
+                prob_list = [
+                    "{var}({state})".format(
+                        var=list(self.variables)[i],
+                        state=self.state_names[list(self.variables)[i]][prob[i]],
+                    )
+                    for i in range(len(self.variables))
+                ]
+            else:
+                prob_list = [
+                    f"{list(self.variables)[i]}_{prob[i]}"
+                    for i in range(len(self.variables))
+                ]
+
+            prob_list.append(self.values.ravel()[value_index])
+            factor_table.append(prob_list)
+            value_index += 1
+
+        return tabulate(
+            factor_table, headers=string_header, tablefmt=tablefmt, floatfmt=".4f"
+        )
+
+    def __repr__(self):
+        var_card = ", ".join(
+            [f"{var}:{card}" for var, card in zip(self.variables, self.cardinality)]
+        )
+        return f"<DiscreteFactor representing phi({var_card}) at {hex(id(self))}>"
+
+    def __mul__(self, other):
+        return self.product(other, inplace=False)
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __add__(self, other):
+        return self.sum(other, inplace=False)
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __truediv__(self, other):
+        return self.divide(other, inplace=False)
+
+    __div__ = __truediv__
+
+    def __eq__(self, other, atol=1e-08):
+        """
+        Method for checking if two factors are equal.
+
+        Parameters
+        ----------
+        atol: float
+            The maximum allowed difference in values to be considered equal.
+        """
+        if not (isinstance(self, DiscreteFactor) and isinstance(other, DiscreteFactor)):
+            return False
+
+        elif set(self.scope()) != set(other.scope()):
+            return False
+
+        else:
+            # Change the axis so that the variables are in the same order.
+            phi = other.copy()
+            if self.variables != phi.variables:
+                for axis in range(self.values.ndim):
+                    exchange_index = phi.variables.index(self.variables[axis])
+                    phi.variables[axis], phi.variables[exchange_index] = (
+                        phi.variables[exchange_index],
+                        phi.variables[axis],
+                    )
+                    phi.cardinality[axis], phi.cardinality[exchange_index] = (
+                        phi.cardinality[exchange_index],
+                        phi.cardinality[axis],
+                    )
+                    phi.values = phi.values.swapaxes(axis, exchange_index)
+
+            # Check the state names order and match them
+            for axis, var in enumerate(self.variables):
+                if set(self.state_names[var]) != set(phi.state_names[var]):
+                    return False
+                elif self.state_names[var] != phi.state_names[var]:
+                    ref_index = []
+                    for state_name in self.state_names[var]:
+                        ref_index.append(phi.state_names[var].index(state_name))
+
+                    slice_ = [slice(None)] * len(self.variables)
+                    slice_[axis] = ref_index
+                    phi.values = phi.values[tuple(slice_)]
+
+            if phi.values.shape != self.values.shape:
+                return False
+            elif not config.get_compute_backend().allclose(
+                phi.values, self.values, atol=atol
+            ):
+                return False
+            elif not all(self.cardinality == phi.cardinality):
+                return False
+            else:
+                return True
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        variable_hashes = [hash(variable) for variable in self.variables]
+        sorted_var_hashes = sorted(variable_hashes)
+        state_names_hash = hash(frozenset(self.state_names))
+        phi = self.copy()
+        for axis in range(phi.values.ndim):
+            exchange_index = variable_hashes.index(sorted_var_hashes[axis])
+            variable_hashes[axis], variable_hashes[exchange_index] = (
+                variable_hashes[exchange_index],
+                variable_hashes[axis],
+            )
+            phi.cardinality[axis], phi.cardinality[exchange_index] = (
+                phi.cardinality[exchange_index],
+                phi.cardinality[axis],
+            )
+            phi.values = phi.values.swapaxes(axis, exchange_index)
+        return hash(
+            str(sorted_var_hashes)
+            + str(hash(compat_fns.tobytes(phi.values)))
+            + str(hash(compat_fns.tobytes(phi.cardinality)))
+            + str(state_names_hash)
+        )

testbed/pgmpy__pgmpy/pgmpy/factors/discrete/JointProbabilityDistribution.py

@@ -0,0 +1,404 @@
+import itertools
+from functools import reduce
+from operator import mul
+
+import numpy as np
+
+from pgmpy.factors.discrete import DiscreteFactor
+from pgmpy.independencies import Independencies
+
+
+class JointProbabilityDistribution(DiscreteFactor):
+    """
+    Base class for Joint Probability Distribution
+    """
+
+    def __init__(self, variables, cardinality, values):
+        """
+        Initialize a Joint Probability Distribution class.
+
+        Defined above, we have the following mapping from variable
+        assignments to the index of the row vector in the value field:
+
+        +-----+-----+-----+-------------------------+
+        |  x1 |  x2 |  x3 |    P(x1, x2, x2)        |
+        +-----+-----+-----+-------------------------+
+        | x1_0| x2_0| x3_0|    P(x1_0, x2_0, x3_0)  |
+        +-----+-----+-----+-------------------------+
+        | x1_1| x2_0| x3_0|    P(x1_1, x2_0, x3_0)  |
+        +-----+-----+-----+-------------------------+
+        | x1_0| x2_1| x3_0|    P(x1_0, x2_1, x3_0)  |
+        +-----+-----+-----+-------------------------+
+        | x1_1| x2_1| x3_0|    P(x1_1, x2_1, x3_0)  |
+        +-----+-----+-----+-------------------------+
+        | x1_0| x2_0| x3_1|    P(x1_0, x2_0, x3_1)  |
+        +-----+-----+-----+-------------------------+
+        | x1_1| x2_0| x3_1|    P(x1_1, x2_0, x3_1)  |
+        +-----+-----+-----+-------------------------+
+        | x1_0| x2_1| x3_1|    P(x1_0, x2_1, x3_1)  |
+        +-----+-----+-----+-------------------------+
+        | x1_1| x2_1| x3_1|    P(x1_1, x2_1, x3_1)  |
+        +-----+-----+-----+-------------------------+
+
+        Parameters
+        ----------
+        variables: list
+            List of scope of Joint Probability Distribution.
+        cardinality: list, array_like
+            List of cardinality of each variable
+        value: list, array_like
+            List or array of values of factor.
+            A Joint Probability Distribution's values are stored in a row
+            vector in the value using an ordering such that the left-most
+            variables as defined in the variable field cycle through their
+            values the fastest.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.discrete import JointProbabilityDistribution
+        >>> prob = JointProbabilityDistribution(['x1', 'x2', 'x3'], [2, 2, 2], np.ones(8)/8)
+        >>> print(prob)
+        x1    x2    x3      P(x1,x2,x3)
+        ----  ----  ----  -------------
+        x1_0  x2_0  x3_0         0.1250
+        x1_0  x2_0  x3_1         0.1250
+        x1_0  x2_1  x3_0         0.1250
+        x1_0  x2_1  x3_1         0.1250
+        x1_1  x2_0  x3_0         0.1250
+        x1_1  x2_0  x3_1         0.1250
+        x1_1  x2_1  x3_0         0.1250
+        x1_1  x2_1  x3_1         0.1250
+        """
+        if np.isclose(np.sum(values), 1):
+            super(JointProbabilityDistribution, self).__init__(
+                variables, cardinality, values
+            )
+        else:
+            raise ValueError("The probability values doesn't sum to 1.")
+
+    def __repr__(self):
+        var_card = ", ".join(
+            [f"{var}:{card}" for var, card in zip(self.variables, self.cardinality)]
+        )
+        return f"<Joint Distribution representing P({var_card}) at {hex(id(self))}>"
+
+    def __str__(self):
+        return self._str(phi_or_p="P")
+
+    def marginal_distribution(self, variables, inplace=True):
+        """
+        Returns the marginal distribution over variables.
+
+        Parameters
+        ----------
+        variables: string, list, tuple, set, dict
+                Variable or list of variables over which marginal distribution needs
+                to be calculated
+        inplace: Boolean (default True)
+                If False return a new instance of JointProbabilityDistribution
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.discrete import JointProbabilityDistribution
+        >>> values = np.random.rand(12)
+        >>> prob = JointProbabilityDistribution(['x1', 'x2', 'x3'], [2, 3, 2], values/np.sum(values))
+        >>> prob.marginal_distribution(['x1', 'x2'])
+        >>> print(prob)
+        x1    x2      P(x1,x2)
+        ----  ----  ----------
+        x1_0  x2_0      0.1502
+        x1_0  x2_1      0.1626
+        x1_0  x2_2      0.1197
+        x1_1  x2_0      0.2339
+        x1_1  x2_1      0.1996
+        x1_1  x2_2      0.1340
+        """
+        return self.marginalize(
+            list(
+                set(list(self.variables))
+                - set(
+                    variables
+                    if isinstance(variables, (list, set, dict, tuple))
+                    else [variables]
+                )
+            ),
+            inplace=inplace,
+        )
+
+    def check_independence(
+        self, event1, event2, event3=None, condition_random_variable=False
+    ):
+        """
+        Check if the Joint Probability Distribution satisfies the given independence condition.
+
+        Parameters
+        ----------
+        event1: list
+            random variable whose independence is to be checked.
+        event2: list
+            random variable from which event1 is independent.
+        values: 2D array or list like or 1D array or list like
+            A 2D list of tuples of the form (variable_name, variable_state).
+            A 1D list or array-like to condition over randome variables (condition_random_variable must be True)
+            The values on which to condition the Joint Probability Distribution.
+        condition_random_variable: Boolean (Default false)
+            If true and event3 is not None than will check independence condition over random variable.
+
+        For random variables say X, Y, Z to check if X is independent of Y given Z.
+        event1 should be either X or Y.
+        event2 should be either Y or X.
+        event3 should Z.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.discrete import JointProbabilityDistribution as JPD
+        >>> prob = JPD(['I','D','G'],[2,2,3],
+                       [0.126,0.168,0.126,0.009,0.045,0.126,0.252,0.0224,0.0056,0.06,0.036,0.024])
+        >>> prob.check_independence(['I'], ['D'])
+        True
+        >>> prob.check_independence(['I'], ['D'], [('G', 1)])  # Conditioning over G_1
+        False
+        >>> # Conditioning over random variable G
+        >>> prob.check_independence(['I'], ['D'], ('G',), condition_random_variable=True)
+        False
+        """
+        JPD = self.copy()
+        if isinstance(event1, str):
+            raise TypeError("Event 1 should be a list or array-like structure")
+
+        if isinstance(event2, str):
+            raise TypeError("Event 2 should be a list or array-like structure")
+
+        if event3:
+            if isinstance(event3, str):
+                raise TypeError("Event 3 cannot of type string")
+
+            elif condition_random_variable:
+                if not all(isinstance(var, str) for var in event3):
+                    raise TypeError("event3 should be a 1d list of strings")
+                event3 = list(event3)
+                # Using the definition of conditional independence
+                # If P(X,Y|Z) = P(X|Z)*P(Y|Z)
+                # This can be expanded to P(X,Y,Z)*P(Z) == P(X,Z)*P(Y,Z)
+                phi_z = JPD.marginal_distribution(event3, inplace=False).to_factor()
+                for variable_pair in itertools.product(event1, event2):
+                    phi_xyz = JPD.marginal_distribution(
+                        event3 + list(variable_pair), inplace=False
+                    ).to_factor()
+                    phi_xz = JPD.marginal_distribution(
+                        event3 + [variable_pair[0]], inplace=False
+                    ).to_factor()
+                    phi_yz = JPD.marginal_distribution(
+                        event3 + [variable_pair[1]], inplace=False
+                    ).to_factor()
+                    if phi_xyz * phi_z != phi_xz * phi_yz:
+                        return False
+                return True
+            else:
+                JPD.conditional_distribution(event3)
+
+        for variable_pair in itertools.product(event1, event2):
+            if JPD.marginal_distribution(
+                variable_pair, inplace=False
+            ) != JPD.marginal_distribution(
+                variable_pair[0], inplace=False
+            ) * JPD.marginal_distribution(
+                variable_pair[1], inplace=False
+            ):
+                return False
+        return True
+
+    def get_independencies(self, condition=None):
+        """
+        Returns the independent variables in the joint probability distribution.
+        Returns marginally independent variables if condition=None.
+        Returns conditionally independent variables if condition!=None
+
+        Parameters
+        ----------
+        condition: array_like
+                Random Variable on which to condition the Joint Probability Distribution.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.discrete import JointProbabilityDistribution
+        >>> prob = JointProbabilityDistribution(['x1', 'x2', 'x3'], [2, 3, 2], np.ones(12)/12)
+        >>> prob.get_independencies()
+        (x1 \u27C2 x2)
+        (x1 \u27C2 x3)
+        (x2 \u27C2 x3)
+        """
+        JPD = self.copy()
+        if condition:
+            JPD.conditional_distribution(condition)
+        independencies = Independencies()
+        for variable_pair in itertools.combinations(list(JPD.variables), 2):
+            if JPD.marginal_distribution(
+                variable_pair, inplace=False
+            ) == JPD.marginal_distribution(
+                variable_pair[0], inplace=False
+            ) * JPD.marginal_distribution(
+                variable_pair[1], inplace=False
+            ):
+                independencies.add_assertions(variable_pair)
+        return independencies
+
+    def conditional_distribution(self, values, inplace=True):
+        """
+        Returns Conditional Probability Distribution after setting values to 1.
+
+        Parameters
+        ----------
+        values: list or array_like
+            A list of tuples of the form (variable_name, variable_state).
+            The values on which to condition the Joint Probability Distribution.
+        inplace: Boolean (default True)
+            If False returns a new instance of JointProbabilityDistribution
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.discrete import JointProbabilityDistribution
+        >>> prob = JointProbabilityDistribution(['x1', 'x2', 'x3'], [2, 2, 2], np.ones(8)/8)
+        >>> prob.conditional_distribution([('x1', 1)])
+        >>> print(prob)
+        x2    x3      P(x2,x3)
+        ----  ----  ----------
+        x2_0  x3_0      0.2500
+        x2_0  x3_1      0.2500
+        x2_1  x3_0      0.2500
+        x2_1  x3_1      0.2500
+        """
+        JPD = self if inplace else self.copy()
+        JPD.reduce(values)
+        JPD.normalize()
+        if not inplace:
+            return JPD
+
+    def copy(self):
+        """
+        Returns A copy of JointProbabilityDistribution object
+
+        Examples
+        ---------
+        >>> import numpy as np
+        >>> from pgmpy.factors.discrete import JointProbabilityDistribution
+        >>> prob = JointProbabilityDistribution(['x1', 'x2', 'x3'], [2, 3, 2], np.ones(12)/12)
+        >>> prob_copy = prob.copy()
+        >>> prob_copy.values == prob.values
+        True
+        >>> prob_copy.variables == prob.variables
+        True
+        >>> prob_copy.variables[1] = 'y'
+        >>> prob_copy.variables == prob.variables
+        False
+        """
+        return JointProbabilityDistribution(self.scope(), self.cardinality, self.values)
+
+    def minimal_imap(self, order):
+        """
+        Returns a Bayesian Model which is minimal IMap of the Joint Probability Distribution
+        considering the order of the variables.
+
+        Parameters
+        ----------
+        order: array-like
+            The order of the random variables.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.discrete import JointProbabilityDistribution
+        >>> prob = JointProbabilityDistribution(['x1', 'x2', 'x3'], [2, 3, 2], np.ones(12)/12)
+        >>> bayesian_model = prob.minimal_imap(order=['x2', 'x1', 'x3'])
+        >>> bayesian_model
+        <pgmpy.models.models.models at 0x7fd7440a9320>
+        >>> bayesian_model.edges()
+        [('x1', 'x3'), ('x2', 'x3')]
+        """
+        from pgmpy.models import BayesianNetwork
+
+        def get_subsets(u):
+            for r in range(len(u) + 1):
+                for i in itertools.combinations(u, r):
+                    yield i
+
+        G = BayesianNetwork()
+        for variable_index in range(len(order)):
+            u = order[:variable_index]
+            for subset in get_subsets(u):
+                if len(subset) < len(u) and self.check_independence(
+                    [order[variable_index]], set(u) - set(subset), subset, True
+                ):
+                    G.add_edges_from(
+                        [(variable, order[variable_index]) for variable in subset]
+                    )
+        return G
+
+    def is_imap(self, model):
+        """
+        Checks whether the given BayesianNetwork is Imap of JointProbabilityDistribution
+
+        Parameters
+        ----------
+        model : An instance of BayesianNetwork Class, for which you want to
+            check the Imap
+
+        Returns
+        -------
+        Is IMAP: bool
+            True if given Bayesian Network is Imap for Joint Probability Distribution False otherwise
+
+        Examples
+        --------
+        >>> from pgmpy.models import BayesianNetwork
+        >>> from pgmpy.factors.discrete import TabularCPD
+        >>> from pgmpy.factors.discrete import JointProbabilityDistribution
+        >>> bm = BayesianNetwork([('diff', 'grade'), ('intel', 'grade')])
+        >>> diff_cpd = TabularCPD('diff', 2, [[0.2], [0.8]])
+        >>> intel_cpd = TabularCPD('intel', 3, [[0.5], [0.3], [0.2]])
+        >>> grade_cpd = TabularCPD('grade', 3,
+        ...                        [[0.1,0.1,0.1,0.1,0.1,0.1],
+        ...                         [0.1,0.1,0.1,0.1,0.1,0.1],
+        ...                         [0.8,0.8,0.8,0.8,0.8,0.8]],
+        ...                        evidence=['diff', 'intel'],
+        ...                        evidence_card=[2, 3])
+        >>> bm.add_cpds(diff_cpd, intel_cpd, grade_cpd)
+        >>> val = [0.01, 0.01, 0.08, 0.006, 0.006, 0.048, 0.004, 0.004, 0.032,
+        ...        0.04, 0.04, 0.32, 0.024, 0.024, 0.192, 0.016, 0.016, 0.128]
+        >>> JPD = JointProbabilityDistribution(['diff', 'intel', 'grade'], [2, 3, 3], val)
+        >>> JPD.is_imap(bm)
+        True
+        """
+        from pgmpy.models import BayesianNetwork
+
+        if not isinstance(model, BayesianNetwork):
+            raise TypeError("model must be an instance of BayesianNetwork")
+        factors = [cpd.to_factor() for cpd in model.get_cpds()]
+        factor_prod = reduce(mul, factors)
+        JPD_fact = DiscreteFactor(self.variables, self.cardinality, self.values)
+        if JPD_fact == factor_prod:
+            return True
+        else:
+            return False
+
+    def to_factor(self):
+        """
+        Returns JointProbabilityDistribution as a DiscreteFactor object
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.discrete import JointProbabilityDistribution
+        >>> prob = JointProbabilityDistribution(['x1', 'x2', 'x3'], [2, 3, 2], np.ones(12)/12)
+        >>> phi = prob.to_factor()
+        >>> type(phi)
+        pgmpy.factors.DiscreteFactor.DiscreteFactor
+        """
+        return DiscreteFactor(self.variables, self.cardinality, self.values)
+
+    def pmap(self):
+        pass

testbed/pgmpy__pgmpy/pgmpy/factors/discrete/__init__.py

@@ -0,0 +1,5 @@
+from .DiscreteFactor import DiscreteFactor, State
+from .CPD import TabularCPD
+from .JointProbabilityDistribution import JointProbabilityDistribution
+
+__all__ = ["TabularCPD", "State", "DiscreteFactor"]

testbed/pgmpy__pgmpy/pgmpy/factors/distributions/CanonicalDistribution.py

@@ -0,0 +1,614 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+
+from pgmpy.factors.distributions import BaseDistribution
+from pgmpy.factors.distributions import GaussianDistribution
+
+
+class CanonicalDistribution(BaseDistribution):
+    """
+    The intermediate factors in a Gaussian network can be described
+    compactly using a simple parametric representation called the
+    canonical form. This representation is closed under the basic
+    operations used in inference: factor product, factor division,
+    factor reduction, and marginalization. Thus, we define this
+    CanonicalDistribution class that allows the inference process to be
+    performed on joint Gaussian networks.
+
+    A canonical form C (X; K,h,g) is defined as
+
+    C (X; K,h,g) = exp( ((-1/2) * X.T * K * X) + (h.T * X) + g)
+
+    References
+    ----------
+    Probabilistic Graphical Models, Principles and Techniques,
+    Daphne Koller and Nir Friedman, Section 14.2, Chapter 14.
+
+    """
+
+    def __init__(self, variables, K, h, g):
+        """
+        Parameters
+        ----------
+        variables: list or array-like
+        The variables for wich the distribution is defined.
+
+        K: n x n, 2-d array-like
+
+        h : n x 1, array-like
+
+        g : int, float
+
+        pdf: function
+        The probability density function of the distribution.
+
+        The terms K, h and g are defined parameters for canonical
+        factors representation.
+
+        Examples
+        --------
+        >>> from pgmpy.factors.continuous import CanonicalDistribution
+        >>> phi = CanonicalDistribution(['X', 'Y'], np.array([[1, -1], [-1, 1]]),
+                                  np.array([[1], [-1]]), -3)
+        >>> phi.variables
+        ['X', 'Y']
+
+        >>> phi.K
+        array([[1, -1],
+               [-1, 1]])
+
+        >>> phi.h
+        array([[1],
+               [-1]])
+
+        >>> phi.g
+        -3
+
+        """
+        no_of_var = len(variables)
+
+        if len(h) != no_of_var:
+            raise ValueError(
+                "Length of h parameter vector must be equal to "
+                "the number of variables."
+            )
+
+        self.variables = variables
+        self.h = np.asarray(np.reshape(h, (no_of_var, 1)), dtype=float)
+        self.g = g
+        self.K = np.asarray(K, dtype=float)
+
+        if self.K.shape != (no_of_var, no_of_var):
+            raise ValueError(
+                f"The K matrix should be a square matrix with order equal to the number of variables. Got: {self.K.shape}, Expected: {(no_of_var, no_of_var)}"
+            )
+
+    @property
+    def pdf(self):
+        def fun(*args):
+            x = np.array(args)
+            return np.exp(
+                self.g + np.dot(x, self.h)[0] - 0.5 * np.dot(x.T, np.dot(self.K, x))
+            )
+
+        return fun
+
+    def assignment(self, *x):
+        """
+        Returns the probability value of the PDF at the given parameter values.
+        Parameters
+        ----------
+        *x: values of all variables of this distribution,
+            collective defining a point at which the probability value is to be computed.
+        Returns
+        -------
+        float: The probability value at the point.
+        Examples
+        --------
+        >>> from pgmpy.factors.distributions import GaussianDistribution
+        >>> dist = GaussianDistribution(variables=['x1', 'x2'],
+        ...                             mean=[[0], [0]],
+        ...                             cov=[[1, 0], [0, 1]])
+        >>> dist.assignment(0, 0)
+        0.15915494309189535
+        """
+        return self.pdf(*x)
+
+    def copy(self):
+        """
+        Makes a copy of the factor.
+
+        Returns
+        -------
+        CanonicalDistribution object: Copy of the factor
+
+        Examples
+        --------
+        >>> from pgmpy.factors.continuous import CanonicalDistribution
+        >>> phi = CanonicalDistribution(['X', 'Y'], np.array([[1, -1], [-1, 1]]),
+                                  np.array([[1], [-1]]), -3)
+        >>> phi.variables
+        ['X', 'Y']
+
+        >>> phi.K
+        array([[1, -1],
+               [-1, 1]])
+
+        >>> phi.h
+        array([[1],
+               [-1]])
+
+        >>> phi.g
+        -3
+
+        >>> phi2 = phi.copy()
+
+        >>> phi2.variables
+        ['X', 'Y']
+
+        >>> phi2.K
+        array([[1, -1],
+               [-1, 1]])
+
+        >>> phi2.h
+        array([[1],
+               [-1]])
+
+        >>> phi2.g
+        -3
+
+        """
+        copy_factor = CanonicalDistribution(
+            self.variables, self.K.copy(), self.h.copy(), self.g
+        )
+
+        return copy_factor
+
+    def to_joint_gaussian(self):
+        """
+        Return an equivalent Joint Gaussian Distribution.
+
+        Examples
+        --------
+
+        >>> import numpy as np
+        >>> from pgmpy.factors.continuous import CanonicalDistribution
+        >>> phi = CanonicalDistribution(['x1', 'x2'], np.array([[3, -2], [-2, 4]]),
+                                  np.array([[5], [-1]]), 1)
+        >>> jgd = phi.to_joint_gaussian()
+        >>> jgd.variables
+        ['x1', 'x2']
+        >>> jgd.covariance
+        array([[ 0.5  ,  0.25 ],
+               [ 0.25 ,  0.375]])
+        >>> jgd.mean
+        array([[ 2.25 ],
+               [ 0.875]])
+
+        """
+        covariance = np.linalg.inv(self.K)
+        mean = np.dot(covariance, self.h)
+
+        return GaussianDistribution(self.variables, mean, covariance)
+
+    def reduce(self, values, inplace=True):
+        """
+        Reduces the distribution to the context of the given variable values.
+
+        Let C(X,Y ; K, h, g) be some canonical form over X,Y where,
+
+        k = [[K_XX, K_XY],        ;       h = [[h_X],
+             [K_YX, K_YY]]                     [h_Y]]
+
+        The formula for the obtained conditional distribution for setting
+        Y = y is given by,
+
+        .. math:: K' = K_{XX}
+        .. math:: h' = h_X - K_{XY} * y
+        .. math:: g' = g + {h^T}_Y * y - 0.5 * y^T * K_{YY} * y
+
+
+        Parameters
+        ----------
+        values: list, array-like
+            A list of tuples of the form (variable name, variable value).
+
+        inplace: boolean
+            If inplace=True it will modify the factor itself, else would return
+            a new CanonicalFactor object.
+
+        Returns
+        -------
+        CanonicalDistribution or None:
+                if inplace=True (default) returns None
+                if inplace=False returns a new CanonicalDistribution instance.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.continuous import CanonicalDistribution
+        >>> phi = CanonicalDistribution(['X1', 'X2', 'X3'],
+        ...                       np.array([[1, -1, 0], [-1, 4, -2], [0, -2, 4]]),
+        ...                       np.array([[1], [4], [-1]]), -2)
+        >>> phi.variables
+        ['X1', 'X2', 'X3']
+
+        >>> phi.K
+        array([[ 1., -1.],
+               [-1.,  3.]])
+
+        >>> phi.h
+        array([[ 1. ],
+               [ 3.5]])
+
+        >>> phi.g
+        -2
+
+        >>> phi.reduce([('X3', 0.25)])
+
+        >>> phi.variables
+        ['X1', 'X2']
+
+        >>> phi.K
+        array([[ 1, -1],
+               [-1,  4]])
+
+        >>> phi.h
+        array([[ 1. ],
+               [ 4.5]])
+
+        >>> phi.g
+        -2.375
+        """
+        if not isinstance(values, (list, tuple, np.ndarray)):
+            raise TypeError(
+                f"variables: Expected type list or array-like, got type {type(values)}"
+            )
+
+        if not all([var in self.variables for var, value in values]):
+            raise ValueError("Variable not in scope.")
+
+        phi = self if inplace else self.copy()
+
+        var_to_reduce = [var for var, value in values]
+
+        # index_to_keep -> j vector
+        index_to_keep = [
+            self.variables.index(var)
+            for var in self.variables
+            if var not in var_to_reduce
+        ]
+        # index_to_reduce -> i vector
+        index_to_reduce = [self.variables.index(var) for var in var_to_reduce]
+
+        K_i_i = self.K[np.ix_(index_to_keep, index_to_keep)]
+        K_i_j = self.K[np.ix_(index_to_keep, index_to_reduce)]
+        K_j_j = self.K[np.ix_(index_to_reduce, index_to_reduce)]
+        h_i = self.h[index_to_keep]
+        h_j = self.h[index_to_reduce]
+
+        # The values for the reduced variables.
+        y = np.array([value for var, value in values]).reshape(len(index_to_reduce), 1)
+
+        phi.variables = [self.variables[index] for index in index_to_keep]
+        phi.K = K_i_i
+        phi.h = h_i - np.dot(K_i_j, y)
+        phi.g = (
+            self.g
+            + (np.dot(h_j.T, y) - (0.5 * np.linalg.multi_dot([y.T, K_j_j, y])))[0][0]
+        )
+
+        if not inplace:
+            return phi
+
+    def marginalize(self, variables, inplace=True):
+        """
+        Modifies the factor with marginalized values.
+
+        Let C(X,Y ; K, h, g) be some canonical form over X,Y where,
+
+        k = [[K_XX, K_XY],        ;       h = [[h_X],
+             [K_YX, K_YY]]                     [h_Y]]
+
+        In this case, the result of the integration operation is a canonical
+        from C (K', h', g') given by,
+
+        .. math:: K' = K_{XX} - K_{XY} * {K^{-1}}_{YY} * K_YX
+        .. math:: h' = h_X - K_{XY} * {K^{-1}}_{YY} * h_Y
+        .. math:: g' = g + 0.5 * (|Y| * log(2*pi) - log(|K_{YY}|) + {h^T}_Y * K_{YY} * h_Y)
+
+        Parameters
+        ----------
+
+        variables: list or array-like
+                List of variables over which to marginalize.
+
+        inplace: boolean
+                If inplace=True it will modify the distribution itself,
+                else would return a new distribution.
+
+        Returns
+        -------
+        CanonicalDistribution or None :
+                if inplace=True (default) returns None
+                if inplace=False return a new CanonicalDistribution instance
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.continuous import CanonicalDistribution
+        >>> phi = CanonicalDistribution(['X1', 'X2', 'X3'],
+        ...                       np.array([[1, -1, 0], [-1, 4, -2], [0, -2, 4]]),
+        ...                       np.array([[1], [4], [-1]]), -2)
+        >>> phi.K
+        array([[ 1, -1,  0],
+                [-1,  4, -2],
+                [ 0, -2,  4]])
+
+        >>> phi.h
+        array([[ 1],
+                [ 4],
+                [-1]])
+
+        >>> phi.g
+        -2
+
+        >>> phi.marginalize(['X3'])
+
+        >>> phi.K
+        array([[ 1., -1.],
+                [-1.,  3.]])
+
+        >>> phi.h
+        array([[ 1. ],
+                [ 3.5]])
+
+        >>> phi.g
+        0.22579135
+        """
+        if not isinstance(variables, (list, tuple, np.ndarray)):
+            raise TypeError(
+                f"variables: Expected type list or array-like, got type {type(variables)}"
+            )
+
+        if not all([var in self.variables for var in variables]):
+            raise ValueError("Variable not in scope.")
+
+        phi = self if inplace else self.copy()
+
+        # index_to_keep -> i vector
+        index_to_keep = [
+            self.variables.index(var) for var in self.variables if var not in variables
+        ]
+        # index_to_marginalize -> j vector
+        index_to_marginalize = [self.variables.index(var) for var in variables]
+
+        K_i_i = self.K[np.ix_(index_to_keep, index_to_keep)]
+        K_i_j = self.K[np.ix_(index_to_keep, index_to_marginalize)]
+        K_j_i = self.K[np.ix_(index_to_marginalize, index_to_keep)]
+        K_j_j = self.K[np.ix_(index_to_marginalize, index_to_marginalize)]
+        K_j_j_inv = np.linalg.inv(K_j_j)
+        h_i = self.h[index_to_keep]
+        h_j = self.h[index_to_marginalize]
+
+        phi.variables = [self.variables[index] for index in index_to_keep]
+
+        phi.K = K_i_i - np.linalg.multi_dot([K_i_j, K_j_j_inv, K_j_i])
+        phi.h = h_i - np.linalg.multi_dot([K_i_j, K_j_j_inv, h_j])
+        phi.g = (
+            self.g
+            + 0.5
+            * (
+                len(variables) * np.log(2 * np.pi)
+                - np.log(abs(np.linalg.det(K_j_j)))
+                + np.linalg.multi_dot([h_j.T, K_j_j, h_j])
+            )[0][0]
+        )
+
+        if not inplace:
+            return phi
+
+    def _operate(self, other, operation, inplace=True):
+        """
+        Gives the CanonicalDistribution operation (product or divide) with
+        the other factor.
+
+        The product of two canonical factors over the same scope
+        X is simply:
+
+        C(K1, h1, g1) * C(K2, h2, g2) = C(K1+K2, h1+h2, g1+g2)
+
+        The division of canonical forms is defined analogously:
+
+        C(K1, h1, g1) / C(K2, h2, g2) = C(K1-K2, h1-h2, g1- g2)
+
+        When we have two canonical factors over different scopes X and Y,
+        we simply extend the scope of both to make their scopes match and
+        then perform the operation of the above equation. The extension of
+        the scope is performed by simply adding zero entries to both the K
+        matrices and the h vectors.
+
+        Parameters
+        ----------
+        other: CanonicalFactor
+            The CanonicalDistribution to be multiplied.
+
+        operation: String
+            'product' for multiplication operation and
+            'divide' for division operation.
+
+        Returns
+        -------
+        CanonicalDistribution or None:
+                        if inplace=True (default) returns None
+                        if inplace=False returns a new CanonicalDistribution instance.
+
+        Example
+        -------
+        >>> import numpy as np
+        >>> from pgmpy.factors.continuous import CanonicalDistribution
+        >>> phi1 = CanonicalDistribution(['x1', 'x2', 'x3'],
+                                   np.array([[1, -1, 0], [-1, 4, -2], [0, -2, 4]]),
+                                   np.array([[1], [4], [-1]]), -2)
+        >>> phi2 = CanonicalDistribution(['x1', 'x2'], np.array([[3, -2], [-2, 4]]),
+                                   np.array([[5], [-1]]), 1)
+
+        >>> phi3 = phi1 * phi2
+        >>> phi3.K
+        array([[ 4., -3.,  0.],
+               [-3.,  8., -2.],
+               [ 0., -2.,  4.]])
+        >>> phi3.h
+        array([ 6.,  3., -1.])
+        >>> phi3.g
+        -1
+
+        >>> phi4 = phi1 / phi2
+        >>> phi4.K
+        array([[-2.,  1.,  0.],
+               [ 1.,  0., -2.],
+               [ 0., -2.,  4.]])
+        >>> phi4.h
+        array([-4.,  5., -1.])
+        >>> phi4.g
+        -3
+
+        """
+        if not isinstance(other, CanonicalDistribution):
+            raise TypeError(
+                f"CanonicalDistribution object can only be multiplied or divided with an another CanonicalDistribution object. Got {type(other)}, expected CanonicalDistribution."
+            )
+
+        phi = self if inplace else self.copy()
+
+        all_vars = self.variables + [
+            var for var in other.variables if var not in self.variables
+        ]
+        no_of_var = len(all_vars)
+
+        self_var_index = [all_vars.index(var) for var in self.variables]
+        other_var_index = [all_vars.index(var) for var in other.variables]
+
+        def _extend_K_scope(K, index):
+            ext_K = np.zeros([no_of_var, no_of_var])
+            ext_K[np.ix_(index, index)] = K
+            return ext_K
+
+        def _extend_h_scope(h, index):
+            ext_h = np.zeros(no_of_var).reshape(no_of_var, 1)
+            ext_h[index] = h
+            return ext_h
+
+        phi.variables = all_vars
+
+        if operation == "product":
+            phi.K = _extend_K_scope(self.K, self_var_index) + _extend_K_scope(
+                other.K, other_var_index
+            )
+            phi.h = _extend_h_scope(self.h, self_var_index) + _extend_h_scope(
+                other.h, other_var_index
+            )
+            phi.g = self.g + other.g
+
+        else:
+            phi.K = _extend_K_scope(self.K, self_var_index) - _extend_K_scope(
+                other.K, other_var_index
+            )
+            phi.h = _extend_h_scope(self.h, self_var_index) - _extend_h_scope(
+                other.h, other_var_index
+            )
+            phi.g = self.g - other.g
+
+        if not inplace:
+            return phi
+
+    def product(self, other, inplace=True):
+        """
+        Returns the product of two gaussian distributions.
+
+        Parameters
+        ----------
+        other: CanonicalFactor
+            The GaussianDistribution to be multiplied.
+
+        inplace: boolean
+            If True, modifies the distribution itself, otherwise returns a new
+            CanonicalDistribution object.
+
+        Returns
+        -------
+        CanonicalDistribution or None:
+                    if inplace=True (default) returns None.
+                    if inplace=False returns a new CanonicalDistribution instance.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.distributions import GaussianDistribution as GD
+        >>> dis1 = GD(['x1', 'x2', 'x3'], np.array([[1], [-3], [4]]),
+        ...            np.array([[4, 2, -2], [2, 5, -5], [-2, -5, 8]]))
+        >>> dis2 = GD(['x3', 'x4'], [1, 2], [[2, 3], [5, 6]])
+        >>> dis3 = dis1.product(dis2, inplace=False)
+        >>> dis3.covariance
+        array([[ 3.6,  1. , -0.4, -0.6],
+               [ 1. ,  2.5, -1. , -1.5],
+               [-0.4, -1. ,  1.6,  2.4],
+               [-1. , -2.5,  4. ,  4.5]])
+        >>> dis3.mean
+        array([[ 1.6],
+               [-1.5],
+               [ 1.6],
+               [ 3.5]])
+        """
+        return self._operate(other, operation="product", inplace=inplace)
+
+    def divide(self, other, inplace=True):
+        """
+        Returns the division of two gaussian distributions.
+
+        Parameters
+        ----------
+        other: GaussianDistribution
+            The GaussianDistribution to be divided.
+
+        inplace: boolean
+            If True, modifies the distribution itself, otherwise returns a new
+            GaussianDistribution object.
+
+        Returns
+        -------
+        CanonicalDistribution or None:
+                    if inplace=True (default) returns None.
+                    if inplace=False returns a new CanonicalDistribution instance.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from pgmpy.factors.distributions import GaussianDistribution as GD
+        >>> dis1 = GD(['x1', 'x2', 'x3'], np.array([[1], [-3], [4]]),
+        ...            np.array([[4, 2, -2], [2, 5, -5], [-2, -5, 8]]))
+        >>> dis2 = GD(['x3', 'x4'], [1, 2], [[2, 3], [5, 6]])
+        >>> dis3 = dis1.divide(dis2, inplace=False)
+        >>> dis3.covariance
+        array([[ 3.6,  1. , -0.4, -0.6],
+               [ 1. ,  2.5, -1. , -1.5],
+               [-0.4, -1. ,  1.6,  2.4],
+               [-1. , -2.5,  4. ,  4.5]])
+        >>> dis3.mean
+        array([[ 1.6],
+               [-1.5],
+               [ 1.6],
+               [ 3.5]])
+        """
+        return self._operate(other, operation="divide", inplace=inplace)
+
+    def __mul__(self, other):
+        return self.product(other, inplace=False)
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __truediv__(self, other):
+        return self.divide(other, inplace=False)
+
+    __div__ = __truediv__