Probabilistic Model Zoo¶
In this section, we present the code for implementing some models in Inferpy. The corresponding code in Edward can be found in the Inferpy vs Edward section.
Bayesian Linear Regression¶
Graphically, a (Bayesian) linear regression can be defined as follows,
The InferPy code for this model is shown below,
import edward as ed
import inferpy as inf
from inferpy.models import Normal
import numpy as np
d, N = 5, 20000
# model definition
with inf.ProbModel() as m:
#define the weights
w0 = Normal(0,1)
w = Normal(0, 1, dim=d)
# define the generative model
with inf.replicate(size=N):
x = Normal(0, 1, observed=True, dim=d)
y = Normal(w0 + inf.dot(x,w), 1.0, observed=True)
# toy data generation
x_train = inf.models.Normal(loc=10, scale=5, dim=d).sample(N)
y_train = np.matmul(x_train, np.array([10,10,0.1,0.5,2]).reshape((d,1))) \
+ inf.models.Normal(loc=0, scale=5, dim=1).sample(N)
data = {x.name: x_train, y.name: y_train}
# compile and fit the model with training data
m.compile()
m.fit(data)
print(m.posterior([w, w0]))
Bayesian Logistic Regression¶
Graphically, a (Bayesian) logistic regression can be defined as follows,
The InferPy code for this model is shown below,
import edward as ed
import inferpy as inf
from inferpy.models import Normal, Bernoulli, Categorical
d, N = 10, 500
# model definition
with inf.ProbModel() as m:
#define the weights
w0 = Normal(0,1)
w = Normal(0, 1, dim=d)
# define the generative model
with inf.replicate(size=N):
x = Normal(0, 1, observed=True, dim=d)
y = Bernoulli(logits=w0+inf.dot(x, w), observed=True)
# toy data generation
x_train = Normal(loc=0, scale=1, dim=d).sample(N)
y_train = Bernoulli(probs=0.4).sample(N)
data = {x.name: x_train, y.name: y_train}
# compile and fit the model with training data
m.compile()
m.fit(data)
print(m.posterior([w, w0]))
Bayesian Multinomial Logistic Regression¶
Graphically, a (Bayesian) multinomial logistic regression can be defined as follows,
The InferPy code for this model is shown below,
import edward as ed
import inferpy as inf
from inferpy.models import Normal, Bernoulli, Categorical
import numpy as np
d, N = 10, 500
#number of classes
K = 3
# model definition
with inf.ProbModel() as m:
#define the weights
w0 = Normal(0,1, dim=K)
with inf.replicate(size=K):
w = Normal(0, 1, dim=d)
# define the generative model
with inf.replicate(size=N):
x = Normal(0, 1, observed=True, dim=d)
y = Bernoulli(logits = w0 + inf.matmul(x, w, transpose_b=True), observed=True)
# toy data generation
x_train = Normal(loc=0, scale=1, dim=d).sample(N)
y_train = Bernoulli(probs=np.random.rand(K)).sample(N)
data = {x.name: x_train, y.name: y_train}
# compile and fit the model with training data
m.compile()
m.fit(data)
print(m.posterior([w, w0]))
Mixture of Gaussians¶
Graphically, a Mixture of Gaussians can be defined as follows,
The InferPy code for this model is shown below,
import edward as ed
import inferpy as inf
import numpy as np
import tensorflow as tf
K, d, N, T = 3, 4, 1000, 5000
# toy data generation
x_train = np.vstack([inf.models.Normal(loc=0, scale=1, dim=d).sample(300),
inf.models.Normal(loc=10, scale=1, dim=d).sample(700)])
######## Inferpy ##########
# model definition
with inf.ProbModel() as m:
# prior distributions
with inf.replicate(size=K):
mu = inf.models.Normal(loc=0, scale=1, dim=d)
sigma = inf.models.InverseGamma(concentration=1, rate=1, dim=d,)
p = inf.models.Dirichlet(np.ones(K)/K)
# define the generative model
with inf.replicate(size=N):
z = inf.models.Categorical(probs = p)
x = inf.models.Normal(mu[z], sigma[z],observed=True, dim=d)
# compile and fit the model with training data
data = {x: x_train}
m.compile(infMethod="MCMC")
m.fit(data)
# print the posterior
print(m.posterior(mu))
Linear Factor Model (PCA)¶
- A linear factor model allows to perform principal component analysis (PCA). Graphically,
- it can be defined as follows,
The InferPy code for this model is shown below,
import edward as ed
import inferpy as inf
K, d, N = 5, 10, 200
# model definition
with inf.ProbModel() as m:
#define the weights
with inf.replicate(size=K):
w = inf.models.Normal(0, 1, dim=d)
# define the generative model
with inf.replicate(size=N):
z = inf.models.Normal(0, 1, dim=K)
x = inf.models.Normal(inf.matmul(z,w),
1.0, observed=True, dim=d)
# toy data generation
x_train = inf.models.Normal(loc=0, scale=1., dim=d).sample(N)
data = {x.name: x_train}
# compile and fit the model with training data
m.compile()
m.fit(data)
#extract the hidden representation from a set of observations
hidden_encoding = m.posterior(z)
PCA with ARD Prior (PCA)¶
Similarly to the previous model, the PCA with ARD Prior can be graphically defined as follows,
Its code in InferPy is shown below,
import edward as ed
import inferpy as inf
from inferpy.models import Normal, InverseGamma
K, d, N = 5, 10, 200
# model definition
with inf.ProbModel() as m:
#define the weights
with inf.replicate(size=K):
w = Normal(0, 1, dim=d)
sigma = InverseGamma(1.0,1.0)
# define the generative model
with inf.replicate(size=N):
z = Normal(0, 1, dim=K)
x = Normal(inf.matmul(z,w),
sigma, observed=True, dim=d)
# toy data generation
x_train = Normal(loc=0, scale=1., dim=d).sample(N)
data = {x.name: x_train}
# compile and fit the model with training data
m.compile()
m.fit(data)
#extract the hidden representation from a set of observations
hidden_encoding = m.posterior(z)