Limit the range of parameter values or define input value distributions ?

[bernddude]

Hello is there a way to constrain the range of the allowed values the fit function allows for the gcm.ml functions ?
For example is there a way to bound the values to positive values b/c it is understood that negative values would not make any sense ?

[bloebp]

Hi,
if you mean to limit the range of the output of the models, then unfortunately not. In this case, you would need to define a custom model (see for example https://www.pywhy.org/dowhy/v0.9.1/user_guide/gcm_based_inference/customizing_model_assignment.html). However, one thing to keep in mind: If you use an additive noise model (ANM), then it has the form Y = f(X) + N, where the f would be your gcm.ml model. Without additionally constraints on the causal mechanism or the N, it could still happen that you, e.g., get a negative value, even if f doesn't produce any (because N can be negative). In this case, you would need the define a customized ConditionalStochasticModel. The ConditionalStochasticModel represents the general form Y = g(X, N) and here, you would need to make sure that the values are in a certain range.

It might not necessarily be an accurate representation, but you could just create an ANM model that clips the values:

from typing import Optional

import numpy as np

from dowhy.gcm import AdditiveNoiseModel, PredictionModel, StochasticModel
from dowhy.gcm.ml import create_linear_regressor


class ClippedANM(AdditiveNoiseModel):

    def __init__(self,
                 prediction_model: PredictionModel,
                 noise_model: Optional[StochasticModel] = None) -> None:
        super(ClippedANM, self).__init__(
            prediction_model=prediction_model, noise_model=noise_model
        )

        self._min_value = None
        self._max_value = None

    def fit(self, X: np.ndarray, Y: np.ndarray) -> None:
        super(ClippedANM, self).fit(X, Y)

        self._min_value = np.min(Y)
        self._max_value = np.max(Y)

    def draw_samples(self, parent_samples: np.ndarray) -> np.ndarray:
        return self._clip_values(super(ClippedANM, self).draw_samples(parent_samples))

    def evaluate(self, parent_samples: np.ndarray, noise_samples: np.ndarray) -> np.ndarray:
        return self._clip_values(super(ClippedANM, self).evaluate(parent_samples, noise_samples))

    def _clip_values(self, samples: np.ndarray) -> np.ndarray:
        samples[samples < self._min_value] = self._min_value
        samples[samples > self._max_value] = self._max_value

        return samples

You can then use this one instead of the AdditiveNoiseModel. Again, note that this might not necessarily be a good representation, since you have a higher density at the clipping values here than in the training data. But maybe it is a good starting point for modifications.

[bernddude]

Thx a lot Patrick, that is very much the information i was looking for. Thank you so much for the detailed explanation i will definitely give this a try and provide some feedback on how this worked out. Intuitively i suspect that if i just clip the values it might create some 'artifacts' , however maybe there is something with the noise distribution i can try ?
I did also notice that it does make a considerable difference how the input values are scaled.
Thank you once again , Bernd

[bernddude]

Hello Patrick, i just wanted to provide some additional feedback on your suggestion. I tested your suggestion with some data sets and extended the idea a little bit more by optimizing the bounds and the noise distribution.
This provided significantly better results for both the model fit, the sampling of generative data and the causal results

thx again bernd

[bloebp]

Great to hear! Do you mind sharing the solution you ended up with? Might be helpful for others as well or we can even consider adding it to the library.

[bernddude]

I am happy to do that. Please give me a few days (i might have to work on it this weekend). I'll have to create some synthetic example cases since i can't use the raw data are subject to confidential agreements. However i can make some generalized or conceptual cases which capture the same information.
The general observation i am making is that in particular the counterfactual calculation provide much closer results to what i know the results should look like. Specifically in the prior situation the counterfactual calculations created a lot of artifacts in the sense of outcomes which are not possible. That is of cause 'my fault' , in the sense that i didn't help the model to capture the correct dependencies. In a way i think of this very similar to being able to choose better prior in a Bayesian model ?

[bloebp]

Sounds interesting! Yea really curious to see an example use case. And no need to rush :)