Working with Tasks

Warning. The task API may be depreciated in the future.

In MLJ a task is a synthesis of three elements: data, an interpretation of that data, and a learning objective. Once one has a task one is ready to choose learning models.

Scientific types and the interpretation of data

Generally the columns of a table, such as a DataFrame, represents real quantities. However, the nature of a quantity is not always clear from the representation. For example, we might count phone calls using the UInt32 type but also use UInt32 to represent a categorical feature, such as the species of conifers. MLJ mitigates such ambiguity with the use of scientific types. See Getting Started) for details

Explicitly specifying scientific types during the construction of a MLJ task is the user's opportunity to articulate how the supplied data should be interpreted.

Learning objectives

In MLJ specifying a learning objective means specifying: (i) whether learning is supervised or not; (ii) whether, in the supervised case, predictions are to be probabilistic or deterministic; and (iii) what part of the data is relevant and what role is each part to play.

Sample usage

Given some data,

using RDatasets
df = dataset("boot", "channing");
first(df, 4)

4 rows × 5 columns

we can check MLJ's interpretation of that data:

schema(df)

_.table = 
┌─────────┬────────────────────────────────────────────┬───────────────┐
│ _.names │ _.types                                    │ _.scitypes    │
├─────────┼────────────────────────────────────────────┼───────────────┤
│ Sex     │ CategoricalArrays.CategoricalString{UInt8} │ Multiclass{2} │
│ Entry   │ Int32                                      │ Count         │
│ Exit    │ Int32                                      │ Count         │
│ Time    │ Int32                                      │ Count         │
│ Cens    │ Int32                                      │ Count         │
└─────────┴────────────────────────────────────────────┴───────────────┘
_.nrows = 462

We construct a task by wrapping the data in a learning objective, and coercing the data into a form MLJ will correctly interpret. (The middle three fields of df refer to ages, in months, the last is a flag.):

task = supervised(data=df,
                  target=:Exit,
                  ignore=:Time,
                  is_probabilistic=true,
                  types=Dict(:Entry=>Continuous,
                             :Exit=>Continuous,
                             :Cens=>Multiclass))
schema(task.X)

_.table = 
┌─────────┬─────────────────────────────────────────────────┬───────────────┐
│ _.names │ _.types                                         │ _.scitypes    │
├─────────┼─────────────────────────────────────────────────┼───────────────┤
│ Sex     │ CategoricalArrays.CategoricalString{UInt8}      │ Multiclass{2} │
│ Entry   │ Float64                                         │ Continuous    │
│ Cens    │ CategoricalArrays.CategoricalValue{Int32,UInt8} │ Multiclass{2} │
└─────────┴─────────────────────────────────────────────────┴───────────────┘
_.nrows = 462

Row selection and shuffling:

task[1:3].y

3-element Array{Float64,1}:
  909.0
 1128.0
  969.0

using Random
rng = MersenneTwister(1234)
shuffle!(rng, task) # rng is optional
task[1:3].y

3-element Array{Float64,1}:
 1015.0
  976.0
 1044.0

Counting rows:

nrows(task)

462

Listing the models available to complete a task:

models(task)

1-element Array{NamedTuple,1}:
 (name = ConstantRegressor, package_name = MLJModels, ... )

Choosing a model and evaluating on the task:

julia> using RDatasets

julia> iris = dataset("datasets", "iris"); # a DataFrame

julia> task = supervised(data=iris, target=:Species, is_probabilistic=true)
┌ Warning: SupervisedTask is deprecated. For model search options, see https://alan-turing-institute.github.io/MLJ.jl/dev/model_search/
└ @ MLJBase ~/.julia/packages/MLJBase/oMxBY/src/tasks.jl:103
┌ Info: 
│ is_probabilistic = true
│ input_scitype = Table{AbstractArray{Continuous,1}} 
└ target_scitype = AbstractArray{Multiclass{3},1}
SupervisedTask @ 4…03

julia> tree = @load DecisionTreeClassifier verbosity=1
import MLJModels ✔
import DecisionTree ✔
import MLJModels.DecisionTree_.DecisionTreeClassifier ✔
MLJModels.DecisionTree_.DecisionTreeClassifier(pruning_purity = 1.0,
                                               max_depth = -1,
                                               min_samples_leaf = 1,
                                               min_samples_split = 2,
                                               min_purity_increase = 0.0,
                                               n_subfeatures = 0,
                                               display_depth = 5,
                                               post_prune = false,
                                               merge_purity_threshold = 0.9,
                                               pdf_smoothing = 0.05,) @ 1…79

julia> mach = machine(tree, task)
Machine{DecisionTreeClassifier} @ 1…95

julia> evaluate!(mach, operation=predict_mode,
                 resampling=Holdout(), measure=misclassification_rate, verbosity=0)
(measure = MLJBase.MisclassificationRate[misclassification_rate],
 measurement = [0.2222222222222222],
 per_fold = Array{Float64,1}[[0.2222222222222222]],
 per_observation = Missing[missing],)

API Reference

task = supervised(data=nothing,
                  types=Dict(),
                  target=nothing,
                  ignore=Symbol[],
                  is_probabilistic=false,
                  verbosity=1)

task = supervised(X, y;
                  is_probabilistic=false,
                  verbosity=1)

X, y = task()

task = unsupervised(data=nothing, types=Dict(), ignore=Symbol[], verbosity=1)

X = task()