Struct AutoDml 

pub struct AutoDml { /* private fields */ }

Auto-DML estimator of θ = E[m(W; γ)].

ml_g learns γ(D, X) = E[Y | D, X] on W = (D, X) (the treatment in the first column), the Riesz learner (default RieszLasso) learns α from the functional, and the score is

ψ = m(W; γ̂) + α̂(W)·(Y − γ̂(W)) − θ,

cross-fitted like every other model. Each treatment in the data gets the same functional applied to it (other treatments act as covariates). Sensitivity analysis uses σ² = E[(Y − γ)²] and ν² = E[2m(W; α) − α²].

use dml_core::{AutoDml, AverageDerivative, DmlData, Ols, ShiftEffect};
use ndarray::{Array1, Array2};

let n = 400;
let x = Array2::from_shape_fn((n, 1), |(i, _)| ((i * 7) % 11) as f64 / 5.0);
let d: Array1<f64> = (0..n).map(|i| x[[i, 0]] + ((i * 13) % 7) as f64 / 3.0).collect();
let y: Array1<f64> = (0..n).map(|i| 0.5 * d[i] + x[[i, 0]].sin() + ((i * 17) % 5) as f64 / 4.0).collect();
let data = DmlData::new(y, d, x)?;

// Average derivative E[∂γ/∂D]; here γ is linear in D with slope 0.5.
let fit = AutoDml::new(Ols::new(), AverageDerivative::new()).fit(&data)?;
assert!((fit.coef()[0] - 0.5).abs() < 0.1);

// Effect of raising every treatment by one unit.
let shift = AutoDml::new(Ols::new(), ShiftEffect::new(1.0)).fit(&data)?;
assert!((shift.coef()[0] - fit.coef()[0]).abs() < 1e-6);

Implementations

impl AutoDml

pub fn new( ml_g: impl Regressor + 'static, functional: impl LinearFunctional + 'static, ) -> Self

pub fn from_boxed( ml_g: Box<dyn Regressor>, functional: Box<dyn LinearFunctional>, ) -> Self

Like AutoDml::new for boxed trait objects.

pub fn riesz(self, riesz: impl RieszLearner + 'static) -> Self

Learner for the Riesz representer (default RieszLasso::default).

pub fn riesz_boxed(self, riesz: Box<dyn RieszLearner>) -> Self

pub fn n_folds(self, n_folds: usize) -> Self

Number of cross-fitting folds (default 5).

pub fn n_rep(self, n_rep: usize) -> Self

Number of independent sample splits (default 1). Estimates are aggregated across repetitions by the median, as in DoubleML.

pub fn seed(self, seed: u64) -> Self

Seed for the sample splits (default 0).

pub fn fit(&self, data: &DmlData) -> Result<DmlFit>

Draw seeded sample splits and fit. With clustered data (DmlData::with_clusters) whole clusters are assigned to folds and standard errors are cluster-robust.

pub fn fit_with_cluster_folds( &self, data: &DmlData, splits: &[Vec<ClusterFold>], ) -> Result<DmlFit>

Fit clustered data with explicit cluster folds, one Vec<ClusterFold> per repetition.

pub fn sensitivity_benchmark( &self, data: &DmlData, long: &DmlFit, benchmarking_set: &[usize], ) -> Result<SensitivityBenchmark>

Sensitivity benchmark for the covariate columns benchmarking_set: refits this model without them (with the same sample splitting, so long must come from fit with the current settings) and compares it with long.

pub fn fit_with_folds( &self, data: &DmlData, splits: &[Vec<Fold>], ) -> Result<DmlFit>

Fit with caller-supplied splits, one Vec<Fold> per repetition (e.g. to reproduce another implementation exactly).

Trait Implementations

impl LinearScoreModel for AutoDml

fn name(&self) -> String

Label for summaries, e.g. "PLR (partialling out)".

fn estimate_score( &self, input: &ScoreInput<'_>, folds: &[Fold], ) -> Result<ScoreEstimate>

Cross-fit the nuisances on folds and return the score elements.

fn validate(&self, _data: &DmlData) -> Result<()>

Reject data the model cannot handle (called once before fitting).

fn strata(&self, _data: &DmlData) -> Option<Vec<usize>>

Strata for the default sample splits (e.g. treatment levels), so each fold holds about the same share of every stratum. None (the default) draws plain K-fold splits.