AutoMLPipeline.jl
A package that makes it trivial to create and evaluate machine learning pipeline architectures.
Install / Use
/learn @IBM/AutoMLPipeline.jlREADME
AutoMLPipeline
<div align="center">| Documentation | Build Status | Help | | :-----------------------------------------------------------------------: | :-------------------------------------------------------------------------------: | :-------------------------------------------------------: | | [![][docs-dev-img]][docs-dev-url] [![][docs-stable-img]][docs-stable-url] | [![][test-img]][test-url] [![][gha-img]][gha-url] [![][codecov-img]][codecov-url] | [![][slack-img]][slack-url] [![][gitter-img]][gitter-url] |
</div>Star History
AutoMLPipeline (AMLP) is a package that makes it trivial to create complex ML pipeline structures using simple expressions. It leverages on the built-in macro programming features of Julia to symbolically process, manipulate pipeline expressions, and makes it easy to discover optimal structures for machine learning regression and classification.
To illustrate, here is a pipeline expression
and evaluation of a typical machine learning
workflow that extracts numerical features (numf)
for ica (Independent Component Analysis)
and pca (Principal Component Analysis)
transformations, respectively, concatenated with
the hot-bit encoding (ohe) of categorical
features (catf) of a given data for rf (Random Forest) modeling:
model = (catf |> ohe) + (numf |> pca) + (numf |> ica) |> rf
fit!(model,Xtrain,Ytrain)
prediction = transform!(model,Xtest)
score(:accuracy,prediction,Ytest)
crossvalidate(model,X,Y,"balanced_accuracy_score")
Just take note that + has higher priority than |> so if you
are not sure, enclose the operations inside parentheses.
### these two expressions are the same
a |> b + c; a |> (b + c)
### these two expressions are the same
a + b |> c; (a + b) |> c
Please read this AutoMLPipeline Paper for benchmark comparisons.
Recorded Video/Conference Presentations:
- 2024 JuliaCon (End-to-End AI with Julia, K0s, and Argo Workflow)
- 2023 JuliaCon (Wrapping Up Offline RL as Part of AutoMLPipeline Workflow)
- 2022 JuliaCon (Distributed AutoML Pipeline Search in PC/RasPi K8s Cluster)
- 2021 JuliaCon (Finding an Effective Strategy for AutoML Pipeline Optimization)
- 2021 PyData Ireland Meetup (Symbolic ML Pipeline Expression and Benchmarking)
- 2020 JuliaCon (AutoMLPipeline: A ToolBox for Building ML Pipelines)
Related Video/Conference Presentations:
- 2021 JuliaCon (Lale in Julia: A package for semi-automated data science)
- 2019 JuliaCon (TSML: Time Series Machine Learning Pipeline)
- 2021 OpenSource Guild in IBM (Overview of HPC and Data Science in Julia Programming with AutoML)
More examples can be found in the examples folder including optimizing pipelines by multi-threading or distributed computing.
Motivations
The typical workflow in machine learning classification or prediction requires some or combination of the following preprocessing steps together with modeling:
- feature extraction (e.g. ica, pca, svd)
- feature transformation (e.g. normalization, scaling, ohe)
- feature selection (anova, correlation)
- modeling (rf, adaboost, xgboost, lm, svm, mlp)
Each step has several choices of functions to use together with their corresponding parameters. Optimizing the performance of the entire pipeline is a combinatorial search of the proper order and combination of preprocessing steps, optimization of their corresponding parameters, together with searching for the optimal model and its hyper-parameters.
Because of close dependencies among various steps, we can consider the entire process to be a pipeline optimization problem (POP). POP requires simultaneous optimization of pipeline structure and parameter adaptation of its elements. As a consequence, having an elegant way to express pipeline structure can help lessen the complexity in the management and analysis of the wide-array of choices of optimization routines.
The target of future work will be the implementations of different pipeline optimization algorithms ranging from evolutionary approaches, integer programming (discrete choices of POP elements), tree/graph search, and hyper-parameter search.
Package Features
- Symbolic pipeline API for easy expression and high-level description of complex pipeline structures and processing workflow
- Common API wrappers for ML libs including Scikitlearn, DecisionTree, etc
- Easily extensible architecture by overloading just two main interfaces: fit! and transform!
- Meta-ensembles that allow composition of ensembles of ensembles (recursively if needed) for robust prediction routines
- Categorical and numerical feature selectors for specialized preprocessing routines based on types
Installation
AutoMLPipeline is in the Julia Official package registry.
The latest release can be installed at the Julia
prompt using Julia's package management which is triggered
by pressing ] at the julia prompt:
julia> ]
pkg> update
pkg> add AutoMLPipeline
Sample Usage
Below outlines some typical way to preprocess and model any dataset.
1. Load Data, Extract Input (X) and Target (Y)
# Make sure that the input feature is a dataframe and the target output is a 1-D vector.
using AutoMLPipeline
profbdata = getprofb()
X = profbdata[:,2:end]
Y = profbdata[:,1] |> Vector;
head(x)=first(x,5)
head(profbdata)
5×7 DataFrame. Omitted printing of 1 columns
│ Row │ Home.Away │ Favorite_Points │ Underdog_Points │ Pointspread │ Favorite_Name │ Underdog_name │
│ │ String │ Int64 │ Int64 │ Float64 │ String │ String │
├─────┼───────────┼─────────────────┼─────────────────┼─────────────┼───────────────┼───────────────┤
│ 1 │ away │ 27 │ 24 │ 4.0 │ BUF │ MIA │
│ 2 │ at_home │ 17 │ 14 │ 3.0 │ CHI │ CIN │
│ 3 │ away │ 51 │ 0 │ 2.5 │ CLE │ PIT │
│ 4 │ at_home │ 28 │ 0 │ 5.5 │ NO │ DAL │
│ 5 │ at_home │ 38 │ 7 │ 5.5 │ MIN │ HOU │
2. Load Filters, Transformers, and Learners
using AutoMLPipeline
#### Decomposition
pca = skoperator("PCA")
fa = skoperator("FactorAnalysis")
ica = skoperator("FastICA")
#### Scaler
rb = skoperator("RobustScaler")
pt = skoperator("PowerTransformer")
norm = skoperator("Normalizer")
mx = skoperator("MinMaxScaler")
std = skoperator("StandardScaler")
#### categorical preprocessing
ohe = OneHotEncoder()
#### Column selector
catf = CatFeatureSelector()
numf = NumFeatureSelector()
disc = CatNumDiscriminator()
#### Learners
rf = skoperator("RandomForestClassifier")
gb = skoperator("GradientBoostingClassifier")
lsvc = skoperator("LinearSVC")
svc = skoperator("SVC")
mlp = skoperator("MLPClassifier")
ada = skoperator("AdaBoostClassifier")
sgd = skoperator("SGDClassifier")
skrf_reg = skoperator("RandomForestRegressor")
skgb_reg = skoperator("GradientBoostingRegressor")
jrf = RandomForest()
tree = PrunedTree()
vote = VoteEnsemble()
stack = StackEnsemble()
best = BestLearner()
Note: You can get a listing of available Preprocessors and Learners by invoking the function:
skoperator()
3. Filter categories and hot-encode them
pohe = catf |> ohe
tr = fit_transform!(pohe,X,Y)
head(tr)
5×56 DataFrame. Omitted printing of 47 columns
│ Row │ x1 │ x2 │ x3 │ x4 │ x5 │ x6 │ x7 │ x8 │ x9 │
│ │ Float64 │ Float64 │ Float64 │ Float64 │ Float64 │ Float64 │ Float64 │ Float64 │ Float64 │
├─────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
│ 1 │ 1.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │
│ 2 │ 0.0 │ 1.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │
│ 3 │ 0.0 │ 0.0 │ 1.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │
│ 4 │ 0.0 │ 0.0 │ 0.0 │ 1.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │
│ 5 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │ 1.0 │ 0.0 │ 0.0 │ 0.0 │ 0.0 │
4. Numerical Feature Extraction Example
4.1 Filter numeric features, compute ica and pca features, and combine both features
pdec = (numf |> pca) + (numf |> ica)
tr = fit_transform!(pdec,X,Y)
head(tr)
5×8 DataFrame
│ Row │ x1 │ x2 │ x3 │ x4
