fit!(mc::Machine, input::DataFrame, output::Vector)

Generic trait to be overloaded by different subtypes of Machine. Multiple dispatch for fit!.

fit_transform!(mc::Machine, input::DataFrame, output::Vector)

Dynamic dispatch that calls in sequence fit! and transform! functions.

transform!(mc::Machine, input::DataFrame)

Generic trait to be overloaded by different subtypes of Machine. Multiple dispatch for transform!.

Baseline(
   default_args = Dict(
       :name => "baseline",
      :output => :class,
      :strat => mode
   )
)

Baseline model that returns the mode during classification.

Baseline(name::String,opt...)

Helper function

Identity(args=Dict())

Returns the input as output.

Identity(name::String,opt...)

Helper function

fit!(idy::Identity,x::DataFrame,y::Vector)

Does nothing.

fit!(bsl::Baseline,x::DataFrame,y::Vector)

Get the mode of the training data.

transform!(idy::Identity,x::DataFrame)

Return the input as output.

transform!(bsl::Baseline,x::DataFrame)

Return the mode in classification.

Imputer(
   Dict(
      # Imputation strategy.
      # Statistic that takes a vector such as mean or median.
      :strategy => mean
   )
)

Imputes NaN values from Float64 features.

Implements fit! and transform.

OneHotEncoder(Dict(
   # Nominal columns
   :nominal_columns => Int[],

   # Nominal column values map. Key is column index, value is list of
   # possible values for that column.
   :nominal_column_values_map => Dict{Int,Any}()
))

Transforms myinstances with nominal features into one-hot form and coerces the instance matrix to be of element type Float64.

Implements fit! and transform.

Wrapper(
   default_args = Dict(
      :name => "ohe-wrapper",
      # Transformer to call.
      :transformer => OneHotEncoder(),
      # Transformer args.
      :transformer_args => Dict()
   )
)

Wraps around a transformer.

Implements fit! and transform.

createtransformer(prototype::Transformer, args=Dict())

Create transformer

• prototype: prototype transformer to base new transformer on
• options: additional options to override prototype's options

Returns: new transformer.

ComboPipeline(machs::Vector{T}) where {T<:Machine}

Feature union pipeline which iteratively calls fit_transform of each element and concatenate their output into one dataframe.

Implements fit! and transform!.

Pipeline(machs::Vector{<:Machine},args::Dict=Dict())

Linear pipeline which iteratively calls and passes the result of fit_transform to the succeeding elements in the pipeline.

Implements fit! and transform!.

Pipeline(machs::Vararg{Machine})

Helper function for Pipeline structure.

Pipeline(machs::Vector{<:Machine},args::Dict=Dict())

Helper function for Pipeline structure.

NARemover(
  Dict(
    :name => "nadetect",
    :acceptance => 0.10 # tolerable NAs percentage
  )
)

Removes columns with NAs greater than acceptance rate. This assumes that it processes columns of features. The output column should not be part of input to avoid it being excluded if it fails the acceptance critera.

Implements fit! and transform!.

NARemover(acceptance::Float64)

Helper function for NARemover.

fit!(nad::NARemover,features::DataFrame,labels::Vector=[])

Checks and exit of df is empty

Arguments

• nad::NARemover: custom type
• features::DataFrame: input
• labels::Vector=[]:

transform!(nad::NARemover,nfeatures::DataFrame)

Removes columns with NAs greater than acceptance rate.

Arguments

• nad::NARemover: custom type
• nfeatures::DataFrame: input

crossvalidate(pl::Machine,X::DataFrame,Y::Vector,pfunc::Function,kfolds=10)

Run K-fold crossvalidation where:

• pfunc is a performance metric
• X and Y are input and target

Adaboost(
  Dict(
    :output => :class,
    :num_iterations => 7
  )
)

Adaboosted decision tree stumps. See DecisionTree.jl's documentation

Hyperparameters:

• :num_iterations => 7 (number of iterations of AdaBoost)

Implements fit!, transform!

PrunedTree(
  Dict(
    :purity_threshold => 1.0,
    :max_depth => -1,
    :min_samples_leaf => 1,
    :min_samples_split => 2,
    :min_purity_increase => 0.0
  )
)

Decision tree classifier. See DecisionTree.jl's documentation

Hyperparmeters:

• :purity_threshold => 1.0 (merge leaves having >=thresh combined purity)
• :max_depth => -1 (maximum depth of the decision tree)
• :min_samples_leaf => 1 (the minimum number of samples each leaf needs to have)
• :min_samples_split => 2 (the minimum number of samples in needed for a split)
• :min_purity_increase => 0.0 (minimum purity needed for a split)

Implements fit!, transform!

RandomForest(
  Dict(
    :output => :class,
    :num_subfeatures => 0,
    :num_trees => 10,
    :partial_sampling => 0.7,
    :max_depth => -1
  )
)

Random forest classification. See DecisionTree.jl's documentation

Hyperparmeters:

• :num_subfeatures => 0 (number of features to consider at random per split)
• :num_trees => 10 (number of trees to train)
• :partial_sampling => 0.7 (fraction of samples to train each tree on)
• :max_depth => -1 (maximum depth of the decision trees)
• :min_samples_leaf => 1 (the minimum number of samples each leaf needs to have)
• :min_samples_split => 2 (the minimum number of samples in needed for a split)
• :min_purity_increase => 0.0 (minimum purity needed for a split)

Implements fit!, transform!

fit!(adaboost::Adaboost, features::DataFrame, labels::Vector)

Optimize the hyperparameters of Adaboost instance.

fit!(tree::PrunedTree, features::DataFrame, labels::Vector)

Optimize the hyperparameters of PrunedTree instance.

fit!(forest::RandomForest, features::DataFrame, labels::Vector)

Optimize the parameters of the RandomForest instance.

transform!(adaboost::Adaboost, features::DataFrame)

Predict using the optimized hyperparameters of the trained Adaboost instance.

transform!(ptree::PrunedTree, features::DataFrame)

Predict using the optimized hyperparameters of the trained PrunedTree instance.

transform!(forest::RandomForest, features::DataFrame)

Predict using the optimized hyperparameters of the trained RandomForest instance.

BestLearner(
   Dict(
      # Output to train against
      # (:class).
      :output => :class,
      # Function to return partitions of instance indices.
      :partition_generator => (instances, labels) -> kfold(size(instances, 1), 5),
      # Function that selects the best learner by index.
      # Arg learner_partition_scores is a (learner, partition) score matrix.
      :selection_function => (learner_partition_scores) -> findmax(mean(learner_partition_scores, dims=2))[2],      
      # Score type returned by score() using respective output.
      :score_type => Real,
      # Candidate learners.
      :learners => [PrunedTree(), Adaboost(), RandomForest()],
      # Options grid for learners, to search through by BestLearner.
      # Format is [learner_1_options, learner_2_options, ...]
      # where learner_options is same as a learner's options but
      # with a list of values instead of scalar.
      :learner_options_grid => nothing
   )
)

Selects best learner from the set by performing a grid search on learners if grid option is indicated.

StackEnsemble(
   Dict(    
      # Output to train against
      # (:class).
      :output => :class,
      # Set of learners that produce feature space for stacker.
      :learners => [PrunedTree(), Adaboost(), RandomForest()],
      # Machine learner that trains on set of learners' outputs.
      :stacker => RandomForest(),
      # Proportion of training set left to train stacker itself.
      :stacker_training_proportion => 0.3,
      # Provide original features on top of learner outputs to stacker.
      :keep_original_features => false
   )
)

An ensemble where a 'stack' of learners is used for training and prediction.

VoteEnsemble(
   Dict( 
      # Output to train against
      # (:class).
      :output => :class,
      # Learners in voting committee.
      :learners => [PrunedTree(), Adaboost(), RandomForest()]
   )
)

Set of machine learners employing majority vote to decide prediction.

Implements: fit!, transform!

fit!(bls::BestLearner, instances::DataFrame, labels::Vector)

Training phase:

• obtain learners as is if grid option is not present
• generate learners if grid option is present
• foreach prototype learner, generate learners with specific options found in grid
• generate partitions
• train each learner on each partition and obtain validation output

fit!(se::StackEnsemble, instances::DataFrame, labels::Vector)

Training phase of the stack of learners.

• perform holdout to obtain indices for
• partition learner and stacker training sets
• partition training set for learners and stacker
• train all learners
• train stacker on learners' outputs
• build final model from the trained learners

fit!(ve::VoteEnsemble, instances::DataFrame, labels::Vector)

Training phase of the ensemble.

transform!(bls::BestLearner, instances::DataFrame)

Choose the best learner based on cross-validation results and use it for prediction.

transform!(se::StackEnsemble, instances::DataFrame)

Build stacker instances and predict

transform!(ve::VoteEnsemble, instances::DataFrame)

Prediction phase of the ensemble.

CatFeatureSelector(Dict(:name => "catf"))

Automatically extract categorical columns based on inferred element types.

Implements fit! and transform!.

CatNumDiscriminator(
   Dict(
      :name => "catnumdisc",
      :maxcategories => 24
   )
)

Transform numeric columns to string (as categories) if the count of their unique elements <= maxcategories.

Implements fit! and transform!.

CatNumDiscriminator(maxcat::Int)

Helper function for CatNumDiscriminator.

FeatureSelector(
   Dict(
     :name => "featureselector",
     :columns => [col1, col2, ...]
   )
)

Returns a dataframe of the selected columns.

Implements fit! and transform!.

FeatureSelector(cols::Vararg{Int})

Helper function for FeatureSelector.

FeatureSelector(cols::Vector{Int})

Helper function for FeatureSelector.

NumFeatureSelector(Dict(:name=>"numfeatsel"))

Automatically extracts numeric features based on their inferred element types.

Implements fit! and transform!.

SKLearner(learner::String, args::Dict=Dict())

A Scikitlearn wrapper to load the different machine learning models. Invoking sklearners() will list the available learners. Please consult Scikitlearn documentation for arguments to pass.

Implements fit! and transform!.

function sklearners()

List the available scikitlearn machine learners.

SKPreprocessor(preprocessor::String,args::Dict=Dict())

A wrapper for Scikitlearn preprocessor functions. Invoking skpreprocessors() will list the acceptable and supported functions. Please check Scikitlearn documentation for arguments to pass.

Implements fit! and transform!.

crossvalidate(pl::Machine,X::DataFrame,Y::Vector,sfunc::String="balanced_accuracy_score",nfolds=10)

Runs K-fold cross-validation using balanced accuracy as the default. It support the following metrics for classification:

• "accuracy_score"
• "balancedaccuracyscore"
• "cohenkappascore"
• "jaccard_score"
• "matthews_corrcoef"
• "hamming_loss"
• "zerooneloss"
• "f1_score"
• "precision_score"
• "recall_score"

and the following metrics for regression:

• "meansquarederror"
• "meansquaredlog_error"
• "medianabsoluteerror"
• "r2_score"
• "max_error"
• "explainedvariancescore"

aggregatorclskipmissing(fn::Function)

Function to create aggregator closure with skipmissing features

createmachine(prototype::Machine, options=nothing)

Create machine

• prototype: prototype machine to base new machine on
• args: additional options to override prototype's options

Returns: new machine

find_catnum_columns(instances::DataFrame,maxuniqcat::Int=0)

Finds all categorial and numerical columns. Categorical columns are those that do not have Real type nor do all their elements correspond to Real. Also, columns with size of unique instances are less than maxuniqcat are considered categorical.

holdout(n, right_prop)

Holdout method that partitions a collection into two partitions.

• n: Size of collection to partition
• right_prop: Percentage of collection placed in right partition

Returns: two partitions of indices, left and right

infer_eltype(vector::Vector)

Returns element type of vector unless it is Any. If Any, returns the most specific type that can be inferred from the vector elements.

• vector: vector to infer element type on

Returns: inferred element type

kfold(num_instances, num_partitions)

Returns k-fold partitions.

• num_instances: total number of instances
• num_partitions: number of partitions required

Returns: training set partition.

nested_dict_merge(first::Dict, second::Dict)

Second nested dictionary is merged into first.

If a second dictionary's value as well as the first are both dictionaries, then a merge is conducted between the two inner dictionaries. Otherwise the second's value overrides the first.

• first: first nested dictionary
• second: second nested dictionary

Returns: merged nested dictionary

nested_dict_set!(dict::Dict, keys::Array{T, 1}, value) where {T}

Set value in a nested dictionary.

• dict: nested dictionary to assign value
• keys: keys to access nested dictionaries in sequence
• value: value to assign

nested_dict_to_tuples(dict::Dict)

Converts nested dictionary to list of tuples

• dict: dictionary that can have other dictionaries as values

Returns: list where elements are ([outer-key, inner-key, ...], value)

score(metric::Symbol, actual::Vector, predicted::Vector)

Score learner predictions against ground truth values.

Available metrics:

• :accuracy

• metric: metric to assess with

• actual: ground truth values

• predicted: predicted values

Returns: score of learner