Refactor Learn transform in terms of new LabeledTable (#16)

* Add LabeledTable

* Implement Tables.jl interface for LabeledTable

* Refactor Learn transform

* Update README.md

* Add IO methods for LabeledTable

* Remove MLJ extension

* Refactor tests

* Adjust label style in IO methods

* Implement accessor methods for LabeledTable

* Refactor Learn in terms of LabeledTable api

* Bump version

* Change colors in IO methods

Author: juliohm

Project.toml

@@ -1,7 +1,7 @@
 name = "StatsLearnModels"
 uuid = "c146b59d-1589-421c-8e09-a22e554fd05c"
+version = "1.2.0"
 authors = ["Elias Carvalho <eliascarvdev@gmail.com> and contributors"]
-version = "1.1.1"
 
 [deps]
 ColumnSelectors = "9cc86067-7e36-4c61-b350-1ac9833d277f"
@@ -11,26 +11,23 @@ Distances = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
 GLM = "38e38edf-8417-5370-95a0-9cbb8c7f171a"
 NearestNeighbors = "b8a86587-4115-5ab1-83bc-aa920d37bbce"
+PrettyTables = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
+StyledStrings = "f489334b-da3d-4c2e-b8f0-e476e12c162b"
 TableTransforms = "0d432bfd-3ee1-4ac1-886a-39f05cc69a3e"
 Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 
-[weakdeps]
-MLJModelInterface = "e80e1ace-859a-464e-9ed9-23947d8ae3ea"
-
-[extensions]
-StatsLearnModelsMLJModelInterfaceExt = "MLJModelInterface"
-
 [compat]
 ColumnSelectors = "1.0"
 DataScienceTraits = "1.0"
 DecisionTree = "0.12"
 Distances = "0.10"
 Distributions = "0.25"
 GLM = "1.9"
-MLJModelInterface = "1.9"
 NearestNeighbors = "0.4"
+PrettyTables = "3.0.2"
 StatsBase = "0.33, 0.34"
+StyledStrings = "1.0"
 TableTransforms = "1.15"
 Tables = "1.11"
 julia = "1.9"

README.md

@@ -26,27 +26,22 @@ train = (feature1=rand(100), feature2=rand(100), target=rand(1:2, 100))
 test = (feature1=rand(20), feature2=rand(20))
 ```
 
-One can train a learning `model` (e.g. `RandomForestClassifier`) with
-the `train` table:
+It is possible train a learning `model` (e.g. `RandomForestClassifier`) with
+the `train` table to approximate a `:target` label and perform predictions
+with the `test` table:
 
 ```julia
 model = RandomForestClassifier()
-
-learn = Learn(train, model, ["feature1","feature2"] => "target")
-```
-
-and apply the trained `model` to the `test` table:
-
-```julia
-pred = learn(test)
+learn = Learn(label(train, :target); model)
+preds = learn(test)
 ```
 
-The package exports native Julia models from various packages
-in the ecosystem. It is also possible to use models from the
-[MLJ.jl](https://github.com/JuliaAI/MLJ.jl) stack.
+The function `label` is used to tag columns of the table with target labels,
+which can be categorical or continuous. Remaining columns are assumed to be
+predictors.
 
-The combination of TableTransforms.jl with StatsLearnModels.jl
-can be thought of as a powerful alternative to MLJ.jl.
+Please check the [models](https://github.com/JuliaML/StatsLearnModels.jl/tree/main/src/models)
+directory for documentation on available models and their parameters.
 
 [build-img]: https://img.shields.io/github/actions/workflow/status/JuliaML/StatsLearnModels.jl/CI.yml?branch=main&style=flat-square
 [build-url]: https://github.com/JuliaML/StatsLearnModels.jl/actions

ext/StatsLearnModelsMLJModelInterfaceExt.jl

@@ -4,13 +4,15 @@
 
 module StatsLearnModels
 
-using Tables
 using Distances
+using PrettyTables
+using StyledStrings
 using DataScienceTraits
 using StatsBase: mode, mean
 using ColumnSelectors: ColumnSelector, selector
 using TableTransforms: StatelessFeatureTransform
 
+import Tables
 import TableTransforms: applyfeat, isrevertible
 
 using DecisionTree: AdaBoostStumpClassifier, DecisionTreeClassifier, RandomForestClassifier
@@ -22,13 +24,20 @@ import GLM
 import DecisionTree as DT
 import NearestNeighbors as NN
 
+include("labeledtable.jl")
 include("interface.jl")
 include("models/nn.jl")
 include("models/glm.jl")
 include("models/tree.jl")
 include("learn.jl")
 
 export
+  # labeled table
+  LabeledTable,
+  predictors,
+  targets,
+  label,
+
   # NearestNeighbors.jl
   KNNClassifier,
   KNNRegressor,

src/StatsLearnModels.jl

@@ -2,47 +2,21 @@
 # Licensed under the MIT License. See LICENSE in the project root.
 # ------------------------------------------------------------------
 
-"""
-    StatsLearnModel(model, features, targets)
-
-Wrap a statistical learning `model` with selectors
-of `features` and `targets`.
-
-## Examples
-
-```julia
-StatsLearnModel(DecisionTreeClassifier(), ["x1","x2"], "y")
-StatsLearnModel(DecisionTreeClassifier(), 1:3, "target")
-```
-"""
-struct StatsLearnModel{M,F<:ColumnSelector,T<:ColumnSelector}
-  model::M
-  feats::F
-  targs::T
-end
-
-StatsLearnModel(model, feats, targs) = StatsLearnModel(model, selector(feats), selector(targs))
-
 """
     fit(model, input, output)
 
-Fit statistical learning `model` using features in `input` table
-and targets in `output` table. Returns a fitted model with all
-the necessary information for prediction with the `predict` function.
+Fit statistical learning `model` using predictors
+in `input` table and targets in `output` table.
+Returns a fitted model with all the necessary
+information for prediction with [`predict`](@ref).
 """
 function fit end
 
-function Base.show(io::IO, model::StatsLearnModel{M}) where {M}
-  println(io, "StatsLearnModel{$(nameof(M))}")
-  println(io, "├─ features: $(model.feats)")
-  print(io, "└─ targets: $(model.targs)")
-end
-
 """
     FittedStatsLearnModel(model, cache)
 
-Wrap the statistical learning `model` with the `cache`
-produced during the [`fit`](@ref) stage.
+Wrap the statistical learning `model` with the
+`cache` produced during the [`fit`](@ref) stage.
 """
 struct FittedStatsLearnModel{M,C}
   model::M
@@ -53,7 +27,9 @@ end
     predict(model::FittedStatsLearnModel, table)
 
 Predict targets using the fitted statistical
-learning `model` and a new `table` of features.
+learning `model` and a new `table` containing
+the same predictors used during the [`fit`](@ref)
+stage.
 """
 function predict end
 

src/interface.jl

@@ -0,0 +1,109 @@
+# ------------------------------------------------------------------
+# Licensed under the MIT License. See LICENSE in the project root.
+# ------------------------------------------------------------------
+
+"""
+    LabeledTable(table, names)
+
+Stores a Tables.jl `table` along with column `names` that
+identify which columns are labels for supervised learning.
+"""
+struct LabeledTable{T}
+  table::T
+  labels::Vector{Symbol}
+end
+
+function LabeledTable(table, names)
+  Tables.istable(table) || throw(ArgumentError("please provide a valid Tables.jl table"))
+  cols = Tables.columns(table)
+  vars = Tables.columnnames(cols)
+  labs = selector(names)(vars)
+  labs ⊆ vars || throw(ArgumentError("all labels must be column names in the table"))
+  vars ⊆ labs && throw(ArgumentError("there must be at least one feature column in the table"))
+  LabeledTable{typeof(table)}(table, labs)
+end
+
+# -----------------
+# TABLES INTERFACE
+# -----------------
+
+Tables.istable(::Type{<:LabeledTable}) = true
+
+Tables.rowaccess(::Type{<:LabeledTable{T}}) where {T} = Tables.rowaccess(T)
+
+Tables.columnaccess(::Type{<:LabeledTable{T}}) where {T} = Tables.columnaccess(T)
+
+Tables.rows(t::LabeledTable) = Tables.rows(t.table)
+
+Tables.columns(t::LabeledTable) = Tables.columns(t.table)
+
+Tables.columnnames(t::LabeledTable) = Tables.columnnames(t.table)
+
+# -----------------
+# ACCESSOR METHODS
+# -----------------
+
+Base.parent(t::LabeledTable) = t.table
+
+function predictors(t::LabeledTable)
+  cols = Tables.columns(t.table)
+  vars = Tables.columnnames(cols)
+  setdiff(vars, t.labels)
+end
+
+targets(t::LabeledTable) = t.labels
+
+# -----------
+# IO METHODS
+# -----------
+
+function Base.summary(io::IO, t::LabeledTable)
+  name = nameof(typeof(t))
+  nlab =  length(t.labels)
+  print(io, "$name with $nlab label(s)")
+end
+
+Base.show(io::IO, t::LabeledTable) = summary(io, t)
+
+function Base.show(io::IO, ::MIME"text/plain", t::LabeledTable)
+  pretty_table(io, t; backend=:text, _common_kwargs(t)...)
+end
+
+function Base.show(io::IO, ::MIME"text/html", t::LabeledTable)
+  pretty_table(
+    io,
+    t;
+    backend=:html,
+    _common_kwargs(t)...,
+    renderer=:show,
+    style=HtmlTableStyle(title=["font-size" => "14px"])
+  )
+end
+
+function _common_kwargs(t)
+  cols = Tables.columns(t)
+  vars = Tables.columnnames(cols)
+
+  labels = map(vars) do var
+    if var ∈ t.labels
+      styled"{(weight=bold),magenta:$var}"
+    else
+      styled"{(weight=bold),yellow:$var}"
+    end
+  end
+
+  (
+    title=summary(t),
+    column_labels=collect(labels),
+    maximum_number_of_rows=10,
+    new_line_at_end=false,
+    alignment=:c
+  )
+end
+
+"""
+    label(table, names)
+
+Creates a `LabeledTable` from `table` using `names` as label columns.
+"""
+label(table, names) = LabeledTable(table, names)