hanalyze

🌐 English | 日本語

hanalyze is a Haskell-native statistical engineering toolkit: regression, GLMM, Bayesian inference (HMC/NUTS/Gibbs/ADVI/SMC), Gaussian processes, machine learning (SVM / gradient boosting / neural networks), survival analysis (KM / Cox / AFT / competing risks), time series (ARIMA / GARCH / state space), causal discovery (LiNGAM) and treatment-effect estimation, design of experiments (classical + custom optimal design), multi-objective optimisation, native plotting, and HTML reporting integrated under one API. Core modelling and optimisation logic is implemented in Haskell, with numerical linear algebra delegated to hmatrix/BLAS/LAPACK. No R/Stan/Python bridge required. Benchmarks (see below) show competitive accuracy with Python/R references in the tested cases. Performance varies by domain: optimisation and small-to-medium MCMC workloads are often faster in these benchmarks, while large-scale ML/GLM workloads are currently slower than sklearn.

Highlights

• Haskell-native: types catch many dtype/API mismatches; shape checks happen at runtime where needed
• Algorithms in Haskell, BLAS for numerics: hmatrix/BLAS/LAPACK powers linear algebra; no R/Stan/Python bridge
• Native plotting: 90+ documented figure types through the hgg grammar-of-graphics integration (plot-integration flag) — pure-Haskell SVG output, no browser required (see Gallery)
• HTML reporting: MathJax/Mermaid + Vega-Lite visualisations in one call; PNG/SVG export available for supported plots
• Dirty-data defence: 8 warning codes + auto-sniff (delim/header/encoding) + cleaning DSL
• Hackage dataframe: Polars-like DataFrame used directly; CSV native, Parquet/JSON support through dataframe

Gallery

Every figure below (and 90+ more across docs/) is generated straight from analysis results via the hgg integration — pure Haskell, SVG out.

Linear regression — fit + 95% CI (docs)	Bayesian MCMC dashboard — trace / density / R̂ / ESS (docs)
Gaussian process — mean + credible band (docs)	Kernel SVM (RBF) — decision boundary + support vectors (docs)
DOE prediction profiler — response vs each factor + CI (docs)	RSM response surface (3D) (docs)
DirectLiNGAM causal discovery — estimated DAG (docs)	Kaplan-Meier survival curves (docs)
Time-series forecast (docs)	k-means clusters + 95% ellipses (docs)

Capabilities

Features grouped by category. Each capability links to a usage doc and (where relevant) a theory doc. The full API reference lives in docs/api-guide/ (12 chapters).

Statistical inference (Hanalyze.Stat.*)

Regression (Hanalyze.Model.*)

Machine learning (Hanalyze.Model.* / Hanalyze.Stat.*)

Causal inference (Hanalyze.Model.LiNGAM.* / Hanalyze.Stat.Causal.*)

Bayesian (Hanalyze.MCMC.* / Hanalyze.Stat.* / Hanalyze.Model.HBM)

Optimisation (Hanalyze.Optim.*)

Design of experiments (Hanalyze.Design.*)

Visualisation (Hanalyze.Viz.*)

ModelGraph — 3 routes

There are three ways to visualise the DAG of an HBM model; pick by use case:

All three routes take the same Hanalyze.Model.HBM.ModelGraph as input. Layout quality vs dependency trade-off:

• Mermaid: lightweight, but no offline rendering
• Graphviz DOT: best layout quality, but requires the dot CLI
• hgg: intermediate quality (roughly 70-80% of graphviz dot, pure Haskell); the only option when zero dependencies are required

Code example (with hgg-analyze-bridge added as a dependency):

import qualified Hanalyze.Viz.ModelGraph    as Mermaid
import qualified Hanalyze.Viz.ModelGraphDot as Dot
import qualified Data.Text.IO               as TIO
import           Hgg.Plot.Bridge.Analyze (renderModelGraphSVG)
import           Hanalyze.Model.HBM          (buildModelGraph)

main = do
  let mg = buildModelGraph myHBM
  Mermaid.renderModelGraph "out/dag.html" "My HBM" mg            -- Route 1
  TIO.writeFile "out/dag.dot" (Dot.renderModelGraphDot mg)       -- Route 2
  renderModelGraphSVG     "out/dag.svg"  "My HBM" mg             -- Route 3

Note: for standard plots, hgg also ships native PNG (Rasterific) and PDF backends. For the ModelGraph SVG route, convert via rsvg-convert / inkscape when PNG / PDF is needed.

Data I/O (Hanalyze.DataIO.*)

Quick start

30 seconds via CLI

git clone https://github.com/frenzieddoll/hanalyze
cd hanalyze
cabal build all

# Regress sales on price + promo, write an HTML report.
hanalyze regress data/readme/sales.csv "price promo" sales --report sales.html
# β₀=185.05  β(price)=-4.37  β(promo)=+32.29  R²=0.995

data/readme/sales.csv is a 20-row demo CSV shipped with the repository (price, promo, sales). The generated sales.html includes coefficients, fit diagnostics, and an interactive prediction widget — straight from one command.

30 seconds via Haskell API

import qualified Hanalyze.Stat.Test as ST
import qualified Numeric.LinearAlgebra as LA

main = do
  let xs = LA.fromList [12, 14, 13, 15, 17, 11]
      ys = LA.fromList [18, 22, 20, 19, 25, 17]
      result = ST.tTestWelch xs ys ST.TwoSided
  print (ST.trPValue result, ST.trEffect result)
  -- (0.012, Just ("Cohen's d", -1.85))

A single import Hanalyze re-exports the core entry points (linear / GLM models, descriptive stats, tests, effect sizes, distributions, plotting helpers and CSV I/O) for quick exploration; reach for the individual Hanalyze.Model.* / Hanalyze.Stat.* modules when you need their full surface.

See docs/01-quickstart.md for a fuller introduction.

CLI

hanalyze help                     list subcommands
hanalyze regress <file> <x> <y>   LM/GLM/GP/HBM regression + HTML report
hanalyze info <file>              per-column type/statistics
hanalyze hist <file> <col>        histogram with theoretical PDF overlay
hanalyze ridge <file> ...         regularised regression (Ridge/Lasso/EN)
hanalyze kernel <file> ...        kernel regression (NW/KR/RFF), multi-D inputs
hanalyze spline <file> ...        spline regression
hanalyze multireg <file> ...      multi-output regression + interactive HTML
hanalyze melt <file> ...          long-form transform
hanalyze regrid <file> ...        time-axis grid alignment
hanalyze doe ortho <NAME> -f ...  orthogonal-array generation
hanalyze taguchi sn / analyze     Taguchi method
hanalyze clean <file> --rule ...  dirty-data cleaning

For per-command flags, run hanalyze <cmd> --help or see docs/01-quickstart.md.

Examples / demos

demo/ contains many demos (76 as of this release). Highlights:

Run: dist-newstyle/build/x86_64-linux/ghc-9.6.7/hanalyze-0.2.0.0/x/<demo-name>/build/<demo-name>/<demo-name>.

Where hanalyze fits

Rather than a complete Python/R replacement, hanalyze targets specific workflows where Haskell integration, single-binary CLI, and tight reporting add value.

Strong fit

• Haskell-native pipelines that need stats/Bayes/optim without calling out to Python
• Single-binary CLI distribution (one hanalyze binary, no Python venv)
• Dirty-CSV defence + cleaning + analysis in one workflow
• DoE / Taguchi / orthogonal arrays for manufacturing and process tuning
• HTML reports straight from the analysis (no separate templating step)
• Type-safe analysis pipelines that catch dtype/API mismatches early

Not a goal — keep using existing tools for

• Large-scale DataFrame work (pandas / polars / data.table)
• GPU deep learning (PyTorch / JAX)
• The full breadth of scikit-learn's mature model zoo
• The full Stan / PyMC MCMC diagnostics ecosystem
• The full expressive range of ggplot2

Comparison vs Python

R is included in the feature map only — no numerical bench against R has been run.

Numbers below come from bench/results/{haskell,python}/*.csv; see bench/results/SUMMARY.md for the full table and benchmark conditions (OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1, single-thread, deterministic seeds).

See docs/comparison/python-r.md for the feature map, and bench/results/SUMMARY.md for numbers.

Benchmark highlights

Selected results from bench/results/SUMMARY.md. Each entry is a single benchmark configuration; absolute objective values depend on iteration counts, seeds, and tolerances — see the SUMMARY for full conditions. NUTS is additionally validated against posteriordb reference posteriors (see bench/posteriordb/).

• NUTS 8-schools (warmup 500, samples 1000): hanalyze 1492 ms with ESS(mu) 839 vs blackjax 530 ms / ESS 810 in this run
• Holt-Winters seasonal n=500 p=12: hanalyze 0.19 ms vs statsmodels MLE 96 ms in this run (note: hanalyze uses fixed α=0.3 closed-form; statsmodels does MLE)
• Sphere_30D/DE: hanalyze 1.0e-26 vs scipy 2.8e-5 on this benchmark
• Sphere_30D/L-BFGS: hanalyze 8.1e-40 vs scipy 2.6e-11 on this benchmark
• Rastrigin_10D/SA: hanalyze 0.0 vs scipy dual_annealing 7.8e-14 in this run
• Hartmann6/BO: hanalyze -3.07 vs skopt -2.77 in this run
• DTLZ2_3/NSGA-II: hanalyze 528 ms vs pymoo 758 ms (1.43× faster in this run)
• DE Rosenbrock_2D: hanalyze 1.2 ms vs scipy 164 ms (134× faster in this run)
• Constrained Quad2D (eq): hanalyze 0.062 ms vs scipy SLSQP 0.69 ms in this run
• regridLong on jagged long-form: hanalyze 0.99 ms vs pandas+scipy synthesis 19.4 ms in this run

Reproduce: OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 cabal run bench-{regression,kernel,optim,mo,bo,mcmc-b7,mcmc-extras,ts-extras,optim-plus,stat-util,multi-output,regrid}, then bench/python/bench_*.py (see bench/README.md).

Architecture

graph TD
  IO[DataIO.* CSV/Parquet/JSON]
  IO --> DF[Hackage dataframe]
  DF --> Models[Model.* regression/ML/Bayesian/TS/Survival]
  DF --> Stat[Stat.* tests/CV/effect/interpret]
  Models --> Optim[Optim.* optimisation]
  Models --> MCMC[MCMC.* samplers]
  Models --> Viz[Viz.* HTML/PNG/SVG]
  Stat --> Viz
  MCMC --> Viz
  Optim --> Design[Design.* DoE/Taguchi]

All modules talk to Hackage dataframe directly. The internal DataFrame.Core was retired.

Roadmap & API stability

• Stable (API expected to remain backward-compatible within minor versions): Hanalyze.DataIO.*, Hanalyze.Stat.{Test, Bootstrap, MultipleTesting, ClassMetrics, CV, Effect, Distribution}, Hanalyze.Model.{LM, GLM, Spline, Regularized, RandomForest, DecisionTree, TimeSeries, Survival, GAM}, Hanalyze.Optim.{NelderMead, LBFGS, DifferentialEvolution, CMAES, NSGA, BayesOpt, SimulatedAnnealing, ParticleSwarm}, Hanalyze.Design.*, Hanalyze.Viz.{Scatter, Bar, Histogram}.
• Experimental (API may evolve): Hanalyze.Model.HBM DSL, Hanalyze.MCMC.NUTS (mass-matrix adaptation is opt-in), Hanalyze.Stat.VI (ADVI), Hanalyze.Model.{GP, RFF, GPRobust, GLMM}, Hanalyze.Model.{SVM, GradientBoosting, NeuralNetwork}, Hanalyze.Model.LiNGAM.*, Hanalyze.Design.Custom.*, the df |-> spec fit operator (Hanalyze.Fit), the hgg integration (plot-integration flag), Hanalyze.Viz.ReportBuilder. Behaviour is benchmarked but type signatures may shift.
• Future direction: a backend-abstraction typeclass for swapping hmatrix/Massiv/Accelerate is under consideration but not on a fixed schedule. (The unified top-level re-export layer and the fit-operator API planned earlier landed in 0.2.0.0 as module Hanalyze and Hanalyze.Fit.)

Module layout

src/
  DataIO/      — CSV/JSON/Parquet IO + health checks + sniff + clean DSL + reshape (9 mods)
  Stat/        — tests/distributions/effect/CV/bootstrap/interpret/causal/MCMC diagnostics (33 mods)
  Model/       — LM/GLM/GLMM/GP/HBM/SVM/GBM/NN/Cluster/TS/Survival/LiNGAM/FDA etc. (75 mods)
  Optim/       — single-obj (NM/LBFGS/DE/CMAES/SA/PSO) + multi-obj (NSGA/BO/Pareto) (18 mods)
  Design/      — Factorial/Block/RSM/Orthogonal/Taguchi + Custom optimal design (30 mods)
  Viz/         — Vega-Lite-based visualisation + ReportBuilder (19 mods)
  MCMC/        — MH/HMC/NUTS/Gibbs/Slice/SMC + progress (9 mods)
  Math/ Data/ Plot/ + Fit/Diagnostics — numeric kernels, data helpers, hgg integration, fit operator

As of this release: 212 modules, ~1,390 test examples.

Build

cabal build all                  # library + all executables (76 demos)
cabal test                       # hspec test suite
cabal repl                       # interactive REPL

Major dependencies: hmatrix (BLAS/LAPACK), hvega (Vega-Lite), statistics, mwc-random, dataframe (Hackage Polars-like), massiv (parallel arrays), ad (auto-diff), async.

Tested on GHC 9.6.7 + cabal 3.14.2.

Running benchmarks

# 1. Generate shared test data (fixed-seed, deterministic)
cabal run bench-data-gen

# 2. Haskell side
OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 \
  cabal run bench-regression bench-kernel bench-optim bench-mo bench-bo

# 3. Python side (need bench/venv from bench/requirements.txt)
OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 \
  bench/venv/bin/python bench/python/bench_regression.py
# (similarly for kernel, optim, mo, bo)

# 4. Aggregate (Markdown table)
bench/venv/bin/python bench/aggregate.py > bench/results/SUMMARY.md

Development

• Issues / PRs: github.com/frenzieddoll/hanalyze
• Adding tests: append hspec specs in test/Spec.hs
• Adding benchmarks: place bench/haskell/Bench*.hs and matching Python script
• Coding rules: see CONTRIBUTING.md (no list-passing on hot paths, minimise unsafe*, ...)

License

BSD-3-Clause License — see LICENSE.

Author

Toshiaki Honda frenzieddoll@gmail.com