DoubleML: Neyman-Orthogonal Causal Estimation Wrapped Around scikit-learn
DoubleML - Double Machine Learning in Python
At a glance
- What is it?
- DoubleML implements the double/debiased machine learning framework of Chernozhukov et al. (2018) in Python, letting you plug arbitrary scikit-learn learners into four causal model classes and still get valid confidence intervals. The judgement: it is a narrow, well-scoped tool for treatment-effect estimation, not a general AutoML or prediction library.
- Who is it for?
- Adopt DoubleML if you already have a treatment/outcome dataset and a causal question that maps onto one of the four supported model classes, because the package gives you orthogonal score estimation and inference without you writing the cross-fitting machinery. Do not adopt it if you need a method outside PLR, PLIV, IRM or IIVM, or if you cannot state a defensible identification assumption for your data.
- Can I use it commercially?
- Yes. BSD-3-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 29 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The estimation problem DoubleML was built to remove
Plug a flexible machine learning model into a naive two-step treatment-effect estimate and you get bias. The learner fits the outcome and the treatment too well, absorbs part of the effect you are trying to measure, and the resulting estimate converges slower than the square root of the sample size. DoubleML exists to break that dependency. It implements the double/debiased machine learning framework of Chernozhukov et al. (2018), which the README cites directly, and its purpose is to let you use machine learners for nuisance functions while keeping the target parameter estimate root-n consistent and its confidence intervals usable. The audience is narrow and specific: econometricians, applied statisticians and data scientists who have a treatment variable, an outcome, and a causal question, and who want inference rather than a prediction score. If your goal is forecasting, this package is the wrong shape entirely.
Four model classes and the abstract base that carries the rest
The README lists exactly four supported models: partially linear regression (PLR), partially linear IV regression (PLIV), interactive regression (IRM) and interactive IV regression (IIVM), exposed as the classes DoubleMLPLR, DoubleMLPLIV, DoubleMLIRM and DoubleMLIIVM. Everything else lives in an abstract base class named DoubleML. That split matters when you read the source: the base class holds the estimation loop, the resampling, and the inference methods, while each subclass supplies a Neyman orthogonal score function that is linear in the target parameter. The README states that the base class provides fit, bootstrap, confint, p_adjust and tune. So the extension path is defined: a new model class needs a score function of that linear form, and the README also notes that alternative score functions can be supplied as callables and alternative resampling schemes can be substituted. The package is built on top of scikit-learn, which is where the nuisance learners come from.
Cross-fitting, orthogonal scores and where the learners plug in
The mechanism visible in the material is this: you name machine learners for the nuisance functions, DoubleML estimates those nuisance functions, and then it evaluates a Neyman orthogonal score function to produce the estimate of the target parameter. Orthogonality is the property that makes the estimate insensitive to small errors in the nuisance estimates, which is what allows a flexible learner to be used without the bias described above. The README describes the implementation as flexible along four axes: the machine learners for the nuisance functions, the resampling schemes, the double machine learning algorithm, and the Neyman orthogonal score functions. Because the learners are scikit-learn objects, the practical constraint is their interface. A learner that does not expose the prediction method a given model class needs cannot be dropped in, and the documentation is the place to confirm which interface each class expects. The README does not enumerate those interface requirements itself.
Installing it and running a first fit
The README gives two install routes. From PyPI: pip install -U DoubleML. From source: git clone git@github.com:DoubleML/doubleml-for-py.git, then cd doubleml-for-py, then pip install --editable . For development the README recommends uv and shows git clone, cd doubleml-for-py, uv sync --extra rdd, which sets up the environment including the dev dependency group. The stated runtime dependencies are Python, scikit-learn, numpy, scipy, pandas, statsmodels and joblib. The README badges list Python 3.10, 3.11, 3.12 and 3.13. Once installed, the workflow implied by the base class is: construct a model class with your data and learners, call fit, then call confint or p_adjust for inference, and bootstrap or tune when you need resampling or hyperparameter search. Note that the README does not print a full worked example, so the concrete constructor signatures have to come from the documentation site rather than this file.
Where DoubleML stops being the right tool
The four model classes are the boundary. If your causal structure is not a partially linear or interactive regression, with or without an instrument, the package does not cover it out of the box, and the extension route requires you to write a score function that is linear in the target parameter. That is a real mathematical obligation, not a configuration change. The second limitation is identification, which no software can supply. DoubleML estimates the parameter you specify under the assumptions you implicitly accept; if the instrument is weak or the treatment is not as good as randomly assigned conditional on the covariates you pass, the confidence intervals will be narrow and wrong. The package cannot detect that for you. Third, the README does not describe built-in diagnostics for nuisance-fit quality or overlap, so sensitivity analysis is something you assemble yourself. Finally, because nuisance estimation is delegated to scikit-learn, compute cost scales with the learners you choose and the resampling scheme you configure, not with anything DoubleML controls.
How this differs from EconML
EconML, Microsoft's causal machine learning library, covers a broader set of estimators, including metalearners, doubly robust learners and orthogonal forests, and it also offers heterogeneity-oriented tooling for estimating conditional treatment effects. DoubleML takes the opposite stance: it implements one framework, the Chernozhukov et al. (2018) double/debiased machine learning approach, and stays inside it. The practical difference is what you get for the constraint. DoubleML's object model is small and uniform, four model classes over one abstract base, and the README states that the R twin was developed alongside the Python package on top of mlr3. If your analysis is a partially linear or interactive regression with inference and you want the score-function machinery handled for you, DoubleML is the more direct fit. If you need a metalearner or a heterogeneous-effect estimator that is not one of those four classes, EconML is the place to look, and you accept a wider API surface in exchange.
Releases, licence and what maintenance actually costs you
The release history in the supplied material shows 0.11.4 on 2026-08-10, 0.11.3 on 2026-05-22 and 0.11.2 on 2026-01-19, with the last repository push on 2026-08-18. That is a steady minor-version cadence, and pre-1.0 versioning means minor releases can carry interface changes. The README names two maintainers, @PhilippBach and @SvenKlaassen, and points bugs at the GitHub issue tracker. The package is BSD-3-Clause, a permissive licence that generally allows commercial and closed-source use with the copyright notice and disclaimer retained; that is a general description of the licence text, not legal advice, and you should read the LICENSE file and your own counsel's view before relying on it. Upgrade cost is mostly the usual one: pin your DoubleML version, re-run your estimation scripts after a bump, and check the release notes, because the score-function and resampling extension points described in the README are exactly the areas where a minor release can shift behaviour.
Editorial conclusion
Adopt DoubleML if you already have a treatment/outcome dataset and a causal question that maps onto one of the four supported model classes, because the package gives you orthogonal score estimation and inference without you writing the cross-fitting machinery. Do not adopt it if you need a method outside PLR, PLIV, IRM or IIVM, or if you cannot state a defensible identification assumption for your data. Before committing, check that your scikit-learn learner exposes the predict or predict_proba interface the chosen model class expects, and read the score-function section of the documentation for that class to confirm your nuisance specification is admissible.
Community notes