Error in Variables with pyro


I would like to generate a simple “error in (feature) variable model”. This kind of models is required when the x and y values are subject to errors (not only the y values like in typical mean squared error minimization).

On the long run this model shall be non-linear, e.g. a Bayesian neural network.

However, I start out with a simple toy test-case where I use a simple linear Regression (which has a well known optimal solution).

In Maximum-Likelihood estimation the optimal linear model is described by an adapted loss function, see Deming Regression: Deming regression - Wikipedia


Key here is that the observed (x_i,y_i) training pairs are described as having errors themselves: (x_i,y_i)=(x_i^*+\eta_i,y_i^*+\epsilon_i)
So there is “error-free” (x_i^*, y_i^*=y_\theta(x_i^*)) associated with each training example. While the function y_\theta(x_i^*) is fitted by finding the most likely parameters \theta, finding all the optimal measurement x_i^* needs to be added to the optimization problem.

I want to create a Bayesian version of Deming regression which can then be easily generalized to nonlinear models later.

Here is what I have so far:


The problem is, that the x_i*=x_i-error\_bias_i - or equivalently the (for each sample constant but arbitrary) error_bias is not correctly fitted (it just stays at it’s initialization value) when I use the NUTs MCMC or the SVI approach with autoguide = pyro.infer.autoguide.AutoDelta(model)

Therefore, the model (as well as ordinary least squares) is not able to reproduce the optimal (Deming regression) solution, which coincides with the ground truth of the generating process):

Could you please help me to get this work with pyro? I would already be happy with solving the linear case correctly.

Later I would want to

  • optimze a non-linear model like a neural network in a later stage
  • assume that the errors in x and y may be depending on x and may be heteroscedastic (i.e. we might have varying distributions of errors in both x and y)
    If you have any furhter hints for the generalization, I would also be very happy!

Below you find my code (unfortunately, I could not upload my jupyter notebook).

import matplotlib.pyplot as plt
import torch
import copy
x1 = torch.rand(50, 1) * 0.3 - 1
x2 = torch.rand(50, 1) * 0.5 + 0.5[x1,x2])
x_no_error = torch.linspace(-5,5, steps=num).unsqueeze(1)
def f(x_no_error, noise=True):
    if noise:
        y+= 5* torch.randn_like(x_no_error)
        x+=3 * torch.randn_like(x_no_error)
    return x,y

x_test_no_error = torch.linspace(-10, 10, 401).unsqueeze(-1)

import pyro
import pyro.distributions as dist

def prediction(offset, slope, x_mu_obs):
    y_pred = offset + slope * x_mu_obs
    return y_pred

def model(x, y):
    with pyro.plate("x_data", len(x)):
        error_bias=pyro.sample("error_bias", dist.Normal(0, 2)) #only initial guess???
    x_mu_obs =  pyro.sample('x_mu_obs', dist.Normal(x_no_error_estimated, 0.1), obs=x) 
    offset = pyro.sample('offset', dist.Normal(0, 10))
    slope = pyro.sample('slope', dist.Normal(0, 10))
    y_pred = prediction(offset, slope, x_no_error_estimated) 
    y_err_var = pyro.sample('y_err_var', dist.HalfNormal(5.))
    y_obs = pyro.sample('y_mu', dist.Normal(y_pred, y_err_var), obs=y)
    return x_mu_obs, y_obs

pyro.render_model(model, model_args=(x,y), render_params=True)

import torch
from pyro.infer import MCMC, NUTS

# Convert x and y to PyTorch tensors
x = torch.tensor(x)
y = torch.tensor(y)

# Run MCMC using NUTS
nuts_kernel = NUTS(model)
mcmc = MCMC(nuts_kernel, num_samples=201, warmup_steps=200, num_chains=1), y) #fits the model to the observations

# Get posterior samples
samples = mcmc.get_samples()

# Get posterior predictive samples
predictive = pyro.infer.Predictive(model, posterior_samples=samples)
result = predictive(torch.squeeze(x),torch.squeeze(y))

y_test_pred=prediction(samples["offset"].mean(), samples["slope"].mean(), x_test)

# Plot for control

import numpy as np
from scipy.odr import ODR, Model, Data

# Define the model
def line_model(p, x):
    a, b = p
    return a*x + b

# Create the ODR object
model_deming = Model(line_model)
data = Data(x[:,0], y[:,0])
odr = ODR(data, model_deming, beta0=[1, 1])

# Perform the orthogonal regression
result =

# Print the result
print("Deming Intercept: ", result.beta[1])
print("Deming Slope: ", result.beta[0])
print("Standard deviation of the estimates: ", result.sd_beta)

from sklearn.linear_model import LinearRegression
ols_linreg_model = LinearRegression(), y[:,0]);

plt.plot(x,y, label="train data")
plt.plot(x_test,y_test_pred, label="Bayes MC test pred", color = "green") #XXX not learning deming
plt.plot(*f(x_no_error, noise=False), label="ground truth", color = "black")
plt.plot(x, ols_linreg_model.predict(x), label="OLS")
plt.plot(x_test,result.beta[1]+result.beta[0]*x_test, label="Deming", color="purple")

PS: I also had a look at what others did e.g. in pymc: Errors-in-variables model in PyMC3 - Questions - PyMC Discourse However, I need to note that their model fails to reproduce the Deming regression solution as well!