[PYTHON] pgmpy: Essai de réseau de bassins discrets jusqu'à l'inférence

Déclencheur

Intéressé par le méta-apprentissage, les réseaux de neurones graphiques, l'utilisation des structures de connaissances, y compris l'utilisation en tant que connaissances préalables, et le stockage des connaissances. Parallèlement, je cherchais une bibliothèque pour implémenter facilement un réseau Basian. Puisque pgmpy avait l'air bien, j'enregistrerai le flux général.

pgmpy：pgmpy is a python library for working with Probabilistic Graphical Models. https://pgmpy.org/

référence

Implémentation d'un réseau Basian avec des données Titanic https://qiita.com/YuyaOmori/items/e051f0360d1f9562620b

Réseau Basian: de l'introduction à l'application à la modélisation humaine https://staff.aist.go.jp/y.motomura/paper/BSJ0403.pdf

environnement

Windows10 Python3.7 Anaconda pgmpy==0.1.9

Installation

pip install pgmpy==0.1.9

Si c'est nonGPU sans pytorch

conda install pytorch torchvision cpuonly -c pytorch

Les données

Utilisez les données suivantes

python

import pandas as pd
df = pd.DataFrame()
df['t'] = [1, 1, 1, 1, 0, 0, 1, 1, 1, 2, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2]
df['a'] = [2, 2, 2, 2, 1, 1, 1, 1, 2, 1, 1, 2, 0, 0, 0, 1, 1, 2, 2, 2]
df['h'] = [0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]

Courir

Définition de la structure du modèle

python

from pgmpy.models import BayesianModel
model = BayesianModel([('t','h'),('a','h')])

Le graphe est un graphe de non-circulation dirigé de t → h et a → h.

Créer et vérifier le CPD dans le modèle

python

model.fit(df) #Les conditions sont omises. Portez une attention particulière au surajustement par défaut

print(model.get_cpds('t'))
print(model.get_cpds('a'))
print(model.get_cpds('h'))

production

+------+-----+
| t(0) | 0.2 |
+------+-----+
| t(1) | 0.5 |
+------+-----+
| t(2) | 0.3 |
+------+-----+
+------+------+
| a(0) | 0.15 |
+------+------+
| a(1) | 0.4  |
+------+------+
| a(2) | 0.45 |
+------+------+
+------+------+--------------------+------+------+------+------+------+------+------+
| a    | a(0) | a(0)               | a(0) | a(1) | a(1) | a(1) | a(2) | a(2) | a(2) |
+------+------+--------------------+------+------+------+------+------+------+------+
| t    | t(0) | t(1)               | t(2) | t(0) | t(1) | t(2) | t(0) | t(1) | t(2) |
+------+------+--------------------+------+------+------+------+------+------+------+
| h(0) | 0.5  | 0.3333333333333333 | 0.5  | 1.0  | 0.0  | 0.0  | 1.0  | 0.6  | 0.0  |
+------+------+--------------------+------+------+------+------+------+------+------+
| h(1) | 0.5  | 0.6666666666666666 | 0.5  | 0.0  | 1.0  | 1.0  | 0.0  | 0.4  | 1.0  |
+------+------+--------------------+------+------+------+------+------+------+------+

Inférence 1

python

from pgmpy.inference import VariableElimination
ve = VariableElimination(model)

#t=1,h=Qu'est-ce que quand 1 est défini?
print(ve.map_query(variables=['a'], evidence={'t':1, 'h':1}))

production

{'a': 1}

Inférence 2

python

#t=0,1,Quand il est 2, un,h Chaque valeur estimée? Quoi?
for i in [0,1,2]:
    print(ve.query(variables=['a', 'h'], evidence={'t':i}))

production

+------+------+------------+
| a    | h    |   phi(a,h) |
+======+======+============+
| a(0) | h(0) |     0.0750 |
+------+------+------------+
| a(0) | h(1) |     0.0750 |
+------+------+------------+
| a(1) | h(0) |     0.4000 |
+------+------+------------+
| a(1) | h(1) |     0.0000 |
+------+------+------------+
| a(2) | h(0) |     0.4500 |
+------+------+------------+
| a(2) | h(1) |     0.0000 |
+------+------+------------+

+------+------+------------+
| h    | a    |   phi(h,a) |
+======+======+============+
| h(0) | a(0) |     0.0500 |
+------+------+------------+
| h(0) | a(1) |     0.0000 |
+------+------+------------+
| h(0) | a(2) |     0.2700 |
+------+------+------------+
| h(1) | a(0) |     0.1000 |
+------+------+------------+
| h(1) | a(1) |     0.4000 |
+------+------+------------+
| h(1) | a(2) |     0.1800 |
+------+------+------------+

+------+------+------------+
| a    | h    |   phi(a,h) |
+======+======+============+
| a(0) | h(0) |     0.0750 |
+------+------+------------+
| a(0) | h(1) |     0.0750 |
+------+------+------------+
| a(1) | h(0) |     0.0000 |
+------+------+------------+
| a(1) | h(1) |     0.4000 |
+------+------+------------+
| a(2) | h(0) |     0.0000 |
+------+------+------------+
| a(2) | h(1) |     0.4500 |
+------+------+------------+

Supplément

--model.fit (df) peut être divisé, par exemple: Notez qu'il peut être plus facile à manipuler s'il est divisé.

python

#Partie création CPD
from pgmpy.estimators import BayesianEstimator
estimator = BayesianEstimator(model, df)
cpd_ta = estimator.estimate_cpd('t', prior_type='dirichlet', pseudo_counts=[[0],[0],[0]])
cpd_aa = estimator.estimate_cpd('a', prior_type='dirichlet', pseudo_counts=[[0],[0],[0]])
cpd_h = estimator.estimate_cpd('h', prior_type='dirichlet', pseudo_counts=[[0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0]])

#Partie d'entrée CPD
model.add_cpds(cpd_ta, cpd_aa, cpd_h) 

• Si vous souhaitez créer un CPD de manière arbitraire, par exemple:

python

from pgmpy.factors.discrete import TabularCPD
cpd_h = TabularCPD(variable='h', variable_card=2,
                        values=[[1, 0.3, 0.5, 1, 0, 0, 1, 0.6, 0],
                                [0, 0.7, 0.5, 0, 1, 1, 0, 0.4, 1]],
                        evidence=['t', 'a'],
                        evidence_card=[3, 3])

• L'apprentissage structurel est omis.

--Il semble qu'il existe également une fonction comme l'arbre de jonction qui prend en charge la multiplication des connexions. Vérifier tout ce que nous pouvons faire.

――Il semble qu'il existe également une méthode appelée réseau dynamique de bassin qui considère le système temporel.

• [Relay series] Mon nœud de recommandation - Le célèbre détective "nœud de Bayes" qui trouve des relations cachées démêle la structure causale entre les variables https://www.ibm.com/blogs/solutions/jp-ja/spssmodeler-push-node-18/ Essayé avec l'ensemble de données d'iris pour référence. J'avais des problèmes car l'une des fonctionnalités n'apparaissait pas dans l'apprentissage structurel, mais il n'y avait aucun problème avec les autres.

• Je veux mettre l'accent sur l'extraction de pièces individuelles. Ensuite, procédez comme suit. Bayes hiérarchiques (de "The World of Bayes Modeling") https://recruit.cct-inc.co.jp/tecblog/machine-learning/hierarchical-bayesian/ PyMC3. Nécessite Theano, qui ne fonctionne qu'avec python 3.6 ou moins.

• En attente de PyMC4 　https://github.com/pymc-devs/pymc4/tree/1c5e23825271fc2ff0c701b9224573212f56a534
• Expérience d'inférence bayésienne avec Python: introduction à MCMC avec PyMC 　https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers J'ai touché PyMC2, mais j'ai presque oublié. Est-il temps de changer?

--NumPyro a une baie hiérarchique. Le pyro à base de PyTorch est presque le même. https://pyro.ai/numpyro/bayesian_hierarchical_linear_regression.html#2.-Modelling:-Bayesian-Hierarchical-Linear-Regression-with-Partial-Pooling https://qiita.com/takeajioka/items/ab299d75efa184eb1432