MLJ.jl is the umbrella entry point and coordination layer for the MLJ machine-learning ecosystem in Julia. The repository's own source is a thin facade module (`src/MLJ.jl`) that re-exports the public API from satellite packages — MLJBase, MLJModels, MLJTuning, MLJEnsembles, MLJIteration, and StatisticalMeasures — plus a small amount of scitype-related code. The actual implementations of fit/predict/transform, learning networks, tuning, ensembling, model composition, and evaluation live primarily in those dependencies. This repo is therefore best understood as the distribution, documentation, integration-testing, and governance hub for the larger MLJ framework rather than a standalone implementation of ML algorithms. In production, users enter through `using MLJ`, load concrete models via `@load`, wrap data and models in `machine(...)`, and drive the system with `fit!`, `predict`, `transform`, `evaluate`, `TunedModel`, `IteratedModel`, `Pipeline`, and related APIs. The system is designed around scientific types and the Tables.jl interface, allowing tabular data to flow uniformly into 200+ models across Julia and other languages, including scikit-learn interop. It supports complex composite workflows: linear pipelines, learning networks/DAGs, target transformations, homogeneous ensembles, stacking, hyperparameter optimization, and performance evaluation. The repository also contains an extensive documentation site, runnable examples, a JOSS paper, and a registry-driven integration test suite. Maintenance is active: the latest commit is recent, CI runs on GitHub Actions, dependabot is configured, and release automation via TagBot is present. Some documentation artifacts show age — for example, the synthetic-data notebook records Julia 1.4.2 — and a few APIs are explicitly experimental, but the core package remains current with the Julia ecosystem and demonstrates disciplined package management across a large dependency graph.
auto-sklearn is an automated machine learning library offering a scikit-learn-compatible interface for classification and regression. It performs hyperparameter optimization via Bayesian optimization (SMAC), integrates meta-learning to warm-start the search from prior runs, and builds ensembles using Caruana's ensemble selection. The codebase is modular: pipeline components (classifiers, regressors, preprocessors) are defined with ConfigSpace and can be extended via a third-party component system. Parallel execution uses dask, and custom metrics, cross-validation splitters, and early stopping are supported. The repository also contains a substantial research component—precomputed meta-features and algorithm run data stored in ARFF format—and scripts for reproducing experiments. The architecture is well-tested with a comprehensive test suite, though some dependencies are pinned to older versions and there is moderate technical drift.
HyperView is a CLI-driven toolkit for downloading TradingView market data, backtesting Python trading strategies with TradingView-parity fill assumptions, and optimizing parameters via Bayesian search (Optuna). The system is organized as a monolith with subcommands: download-data, backtest, hyperopt, pine-optimize, pine-batch-optimize, list-data, list-strategies. It features a pluggable strategy framework with auto-discovery, 20+ TA-Lib indicator wrappers, a backtester that simulates intrabar SL/TP paths, and a two-stage Pine input optimizer that exports optimized Pine scripts with injected best parameters. The codebase is well-structured with dataclasses, type hints, and a rich CLI output using the `rich` library. It includes unit tests for the Pine optimization pipeline and CLI parser. The repository is primarily an application, though it contains data engineering patterns in its downloader and caching layers.
Made With ML is an educational data science project that implements an end-to-end ML pipeline for classifying GitHub repositories into categories (NLP, computer vision, MLOps, other) based on their titles and descriptions. The core data lineage flows from raw CSV datasets (dataset.csv, holdout.csv) through text cleaning, tokenization via SciBERT, and stratified splitting into train/val/test sets, followed by distributed training with PyTorch and Ray Train, hyperparameter tuning via HyperOpt, evaluation with slice-based metrics using Snorkel, and serving through a FastAPI/Ray Serve deployment. The project demonstrates MLOps patterns including MLflow experiment tracking, data validation with Great Expectations, behavioral model testing, and CI/CD via GitHub Actions with Anyscale for cloud execution. The codebase is well-structured with clear separation of concerns across data.py, train.py, tune.py, evaluate.py, predict.py, serve.py, models.py, and utils.py. It includes comprehensive tests at the code, data, and model levels. However, the project shows signs of staleness with pinned dependencies from 2023 (Ray 2.7.0, transformers 4.28.1, torch 2.0.0) that have known security vulnerabilities and compatibility issues with current Python versions. The data pipeline components—particularly the CustomPreprocessor, stratified splitting, and text cleaning—are genuinely reusable patterns. The evaluation framework with slice-based metrics and behavioral tests (invariance, directional expectations, minimum functionality) represents solid ML engineering practice. The deployment configuration is tightly coupled to Anyscale's proprietary platform, limiting portability.
This is a mature Python library for global optimization of expensive black-box functions using Bayesian optimization. It provides the `BayesianOptimization` class that iteratively fits a Gaussian process regressor (via scikit-learn) to observed function evaluations and uses an acquisition function (Upper Confidence Bound, Expected Improvement, Probability of Improvement, or combined) to propose the next point to evaluate. The library supports constrained optimization, domain reduction, mixed continuous/integer/categorical parameters, asynchronous/parallel optimization, and state persistence. Its architecture is modular: acquisition functions are organized in a strategy pattern, parameters are polymorphic with a base class for custom types, constraints are modeled with separate GPs, and domain reduction is implemented as a transformer. The core algorithm is well-tested and documented, with examples ranging from toy functions to hyperparameter tuning. It is not a research notebook collection or data pipeline; it is a production-grade library intended for integration into optimization workflows.
AutoKeras is an automated machine learning (AutoML) library built on Keras 3, designed to make deep learning accessible to non-experts. It provides high-level task-specific APIs (e.g., ImageClassifier, TextClassifier, StructuredDataClassifier) that automate neural architecture search and hyperparameter tuning. The core architecture uses a modular block-based system—blocks (e.g., DenseBlock, ConvBlock, ResNetBlock) are composed into a graph via a functional API, and a tuner (Greedy, Bayesian, Hyperband, Random) searches for the best model. The library includes a data preprocessing pipeline (Pipeline, HyperPipeline), adapters for input/output conversion, and serialization for model persistence. While primarily an application library, it also contains research-oriented components like benchmark experiments and tuner implementations, reflecting its academic origins. Key entry points are the AutoModel class and task classes, which expose fit/predict/evaluate workflows similar to Keras.
Renate is a Python library for continual learning that provides implementations of various algorithms (Experience Replay, DER, Super-ER, etc.) to mitigate catastrophic forgetting when updating neural networks on sequential data. It features a modular architecture separating models, data handling, update strategies, memory buffers, and drift detection, enabling users to customize continual learning pipelines. The framework supports local execution and cloud deployment via Amazon SageMaker, includes hyperparameter optimization through Syne Tune, and offers benchmarking tools for evaluating continual learning methods across diverse datasets and scenarios. Key reusable components include a memory buffer system with reservoir and class-balancing strategies, Maximum Mean Discrepancy (MMD) based drift detectors for monitoring data distribution shifts, and a composable loss component system for constructing complex continual learning objectives. The library integrates with PyTorch Lightning for training and provides abstract base classes for models and data modules to facilitate extension. Although the project is explicitly archived and no longer maintained, the codebase demonstrates solid engineering practices with well-defined interfaces and decoupled components. It has been tested on vision and NLP benchmarks (CIFAR, CLEAR, DomainNet, Hugging Face datasets) and includes synthetic scenario generators for controlled experimentation. The archival status indicates that users should expect no further updates or security patches, but the core functionality remains usable for continual learning research and applications.