More refactoring

Author: juliohm

src/interface.jl

@@ -3,10 +3,10 @@
 # ------------------------------------------------------------------
 
 """
-    StatsLearnModel(model, invars, outvars)
+    StatsLearnModel(model, features, targets)
 
-Wrap a (possibly external) `model` with selectors of
-input variables `invars` and output variables `outvars`.
+Wrap a (possibly external) `model` with selectors
+of `features` and `targets`.
 
 ## Examples
 
@@ -17,11 +17,11 @@ StatsLearnModel(DecisionTreeClassifier(), 1:3, "target")
 """
 struct StatsLearnModel{M,I<:ColumnSelector,O<:ColumnSelector}
   model::M
-  invars::I
-  outvars::O
+  feats::I
+  targs::O
 end
 
-StatsLearnModel(model, invars, outvars) = StatsLearnModel(model, selector(invars), selector(outvars))
+StatsLearnModel(model, feats, targs) = StatsLearnModel(model, selector(feats), selector(targs))
 
 """
     fit(model, input, output)
@@ -34,8 +34,8 @@ function fit end
 
 function Base.show(io::IO, model::StatsLearnModel{M}) where {M}
   println(io, "StatsLearnModel{$(nameof(M))}")
-  println(io, "├─ features: $(model.invars)")
-  print(io, "└─ targets: $(model.outvars)")
+  println(io, "├─ features: $(model.feats)")
+  print(io, "└─ targets: $(model.targs)")
 end
 
 """

src/learn.jl

@@ -3,11 +3,10 @@
 # ------------------------------------------------------------------
 
 """
-    Learn(train, model, invars => outvars)
+    Learn(train, model, features => targets)
 
 Fits the statistical learning `model` to `train` table,
-using the selectors of input variables `invars` and
-output variables `outvars`.
+using the selectors of `features` and `targets`.
 
 # Examples
 
@@ -21,10 +20,10 @@ Learn(train, model, r"[abc]" => ["d", "e"])
 """
 struct Learn{M<:FittedStatsLearnModel} <: StatelessFeatureTransform
   model::M
-  invars::Vector{Symbol}
+  feats::Vector{Symbol}
 end
 
-Learn(train, model, (invars, outvars)::Pair) = Learn(train, StatsLearnModel(model, invars, outvars))
+Learn(train, model, (feats, targs)::Pair) = Learn(train, StatsLearnModel(model, feats, targs))
 
 function Learn(train, lmodel::StatsLearnModel)
   if !Tables.istable(train)
@@ -33,22 +32,22 @@ function Learn(train, lmodel::StatsLearnModel)
 
   cols = Tables.columns(train)
   names = Tables.columnnames(cols)
-  invars = lmodel.invars(names)
-  outvars = lmodel.outvars(names)
+  feats = lmodel.feats(names)
+  targs = lmodel.targs(names)
 
-  input = (; (var => Tables.getcolumn(cols, var) for var in invars)...)
-  output = (; (var => Tables.getcolumn(cols, var) for var in outvars)...)
+  input = (; (var => Tables.getcolumn(cols, var) for var in feats)...)
+  output = (; (var => Tables.getcolumn(cols, var) for var in targs)...)
 
   fmodel = fit(lmodel.model, input, output)
 
-  Learn(fmodel, invars)
+  Learn(fmodel, feats)
 end
 
 isrevertible(::Type{<:Learn}) = false
 
 function applyfeat(transform::Learn, feat, prep)
   model = transform.model
-  vars = transform.invars
+  vars = transform.feats
 
   cols = Tables.columns(feat)
   pairs = (var => Tables.getcolumn(cols, var) for var in vars)

test/runtests.jl

@@ -27,12 +27,12 @@ const SLM = StatsLearnModels
   @testset "StatsLearnModel" begin
     # accessor functions
     model = DecisionTreeClassifier()
-    invars = selector([:a, :b])
-    outvars = selector(:c)
-    lmodel = SLM.StatsLearnModel(model, invars, outvars)
+    feats = selector([:a, :b])
+    targs = selector(:c)
+    lmodel = SLM.StatsLearnModel(model, feats, targs)
     @test lmodel.model === model
-    @test lmodel.invars === invars
-    @test lmodel.outvars === outvars
+    @test lmodel.feats === feats
+    @test lmodel.targs === targs
     # show
     lmodel = SLM.StatsLearnModel(DecisionTreeClassifier(), [:a, :b], :c)
     @test sprint(show, lmodel) == """
@@ -106,17 +106,17 @@ const SLM = StatsLearnModels
   @testset "Learn" begin
     Random.seed!(123)
     outvar = :target
-    invars = setdiff(propertynames(iris), [outvar])
-    outvars = outvar
+    feats = setdiff(propertynames(iris), [outvar])
+    targs = outvar
     model = DecisionTreeClassifier()
-    transform = Learn(iris[train, :], model, invars => outvars)
+    transform = Learn(iris[train, :], model, feats => targs)
     @test !isrevertible(transform)
     pred = transform(iris[test, :])
     accuracy = count(pred.target .== iris.target[test]) / length(test)
     @test accuracy > 0.9
 
     # throws
     # training data is not a table
-    @test_throws ArgumentError Learn(nothing, model, invars => outvars)
+    @test_throws ArgumentError Learn(nothing, model, feats => targs)
   end
 end