dump local, private, classes method if favour of CategoricalArrays.levels

Author: ablaom

src/backends.jl

@@ -31,8 +31,8 @@ If [`Sage`](@ref)`(multitarget=..., code_type=...)` has been implemented, then
 `observations.target` has an integer element type controlled by `code_type`, and we
 additionally have:
 
-- `observations.classes`: A categorical vector of the ordered target classes, as actually
-  seen in the user-supplied target, with the full pool of classes available by applying
+- `observations.classes`: A categorical vector of the ordered target levels, as actually
+  seen in the user-supplied target, with the full pool of levels available by applying
   `Categorical.levels` to the result. The corresponding integer codes will be
   `sort(unique(observations.target))`.
 

src/saffron.jl

@@ -150,7 +150,7 @@ function finalize(x, names, y, int)  # here `int` is `levelcode` or `refcode` fu
         CategoricalArrays.CategoricalArray,
         SubArray{<:Any, <:Any, <:CategoricalArrays.CategoricalArray},
     } || throw(ERR_EXPECTED_CATEGORICAL)
-    l = LearnDataFrontEnds.classes(y)
+    l = CategoricalArrays.levels(y)
     u = unique(y)
     mask = map(in(u), l)
     _classes_seen = l[mask]

src/tools.jl

@@ -112,56 +112,6 @@ function decompose(X, v, _targets::NTuple)
     return swapdims(A, v), collect(names), swapdims(B, v)
 end
 
-"""
-    classes(x)
-
-*Private method.*
-
-Return, as a `CategoricalVector`, all the categorical elements with
-the same pool as `CategoricalValue` `x` (including `x`), with an
-ordering consistent with the pool. Note that `x in classes(x)` is
-always true.
-
-Not to be confused with `levels(x.pool)`. See the example below.
-
-Also, overloaded for `x` a `CategoricalArray`, `CategoricalPool`, and for views of
-`CategoricalArray`.
-
-    julia>  v = categorical(['c', 'b', 'c', 'a'])
-    4-element CategoricalArrays.CategoricalArray{Char,1,UInt32}:
-     'c'
-     'b'
-     'c'
-     'a'
-
-    julia> levels(v)
-    3-element Array{Char,1}:
-     'a'
-     'b'
-     'c'
-
-    julia> x = v[4]
-    CategoricalArrays.CategoricalValue{Char,UInt32} 'a'
-
-    julia> classes(x)
-    3-element CategoricalArrays.CategoricalArray{Char,1,UInt32}:
-     'a'
-     'b'
-     'c'
-
-    julia> levels(x.pool)
-    3-element Array{Char,1}:
-     'a'
-     'b'
-     'c'
-
-"""
-classes(p::CategoricalArrays.CategoricalPool) = [p[i] for i in 1:length(p)]
-classes(x::CategoricalArrays.CategoricalValue) = classes(CategoricalArrays.pool(x))
-classes(v::CategoricalArrays.CategoricalArray) = classes(CategoricalArrays.pool(v))
-classes(v::SubArray{<:Any, <:Any, <:CategoricalArrays.CategoricalArray}) = classes(parent(v))
-
-
 struct CategoricalDecoder{V,R}
     classes::CategoricalArrays.CategoricalVector{
         V,
@@ -193,7 +143,7 @@ pool as `x`.
 *Warning:* There is no guarantee that `levelcode.(d.(u)) == u` will always holds.
 
 """
-decoder(x) = CategoricalDecoder(classes(x))
+decoder(x) = CategoricalDecoder(CategoricalArrays.levels(x))
 
 (d::CategoricalDecoder{V,R})(i::Integer) where {V,R} =
     CategoricalArrays.CategoricalValue{V,R}(d.classes[i])

test/backends.jl

@@ -7,7 +7,7 @@ import CategoricalArrays
     y = [3, 2, 1]
     names = [:x1, :x2]
     ycat = CategoricalArrays.categorical(y)
-    c = LearnDataFrontEnds.classes(ycat)
+    c = CategoricalArrays.levels(ycat)
     d = LearnDataFrontEnds.decoder(ycat)
     mime =  MIME"text/plain"()
 

test/tools.jl

@@ -8,8 +8,9 @@ import LearnDataFrontEnds: DoView, DontView, Multitarget, Unitarget
 using CategoricalArrays
 using Random
 using StableRNGs
-import LearnDataFrontEnds: classes,  decoder
+import LearnDataFrontEnds: decoder
 
+# developers, use this to work locally:
 # include("_some_learners.jl")
 
 @testset "decompose" begin
@@ -79,17 +80,6 @@ end
 
 rng = StableRNGs.StableRNG(123)
 
-@testset "classes" begin
-    v = categorical(collect("asqfasqffqsaaaa"), ordered=true)
-    @test classes(v[1]) == levels(v)
-    @test classes(v) == levels(v)
-    levels!(v, reverse(levels(v)))
-    @test classes(v[1]) == levels(v)
-    @test classes(v) == levels(v)
-    vsub = view(v, 1:2)
-    @test classes(vsub) == classes(v)
-end
-
 const int = CategoricalArrays.refcode
 
 @testset "decoder" begin
@@ -123,7 +113,7 @@ const int = CategoricalArrays.refcode
     e = decoder(y)
     @test e.(int.(W)) == W
 
-    @test int.(classes(y)) == 1:length(classes(x))
+    @test int.(levels(y)) == 1:length(levels(x))
 
     v = categorical(['a', 'b', 'c'], ordered=true)
 end