✨ Fix frequency encoder output types

Author: EssamWisam

src/encoders/ordinal_encoding/interface_mlj.jl

@@ -5,15 +5,17 @@ mutable struct OrdinalEncoder{AS <: AbstractVector{Symbol}} <: Unsupervised
     features::AS
     ignore::Bool
     ordered_factor::Bool
+    op_dtype::Type
 end;
 
 # 2. Constructor
 function OrdinalEncoder(;
     features = Symbol[],
     ignore = true,
     ordered_factor = false,
+    op_dtype = Float32,
 )
-    return OrdinalEncoder(features, ignore, ordered_factor)
+    return OrdinalEncoder(features, ignore, ordered_factor, op_dtype)
 end;
 
 
@@ -29,6 +31,7 @@ function MMI.fit(transformer::OrdinalEncoder, verbosity::Int, X)
         transformer.features;
         ignore = transformer.ignore,
         ordered_factor = transformer.ordered_factor,
+        op_dtype = transformer.op_dtype,
     )
     fitresult =
         generic_cache[:index_given_feat_level]
@@ -92,6 +95,7 @@ Train the machine using `fit!(mach, rows=...)`.
 - `features=[]`: A list of names of categorical features given as symbols to exclude or include from encoding
 - `ignore=true`: Whether to exclude or includes the features given in `features`
 - `ordered_factor=false`: Whether to encode `OrderedFactor` or ignore them
+- `op_dtype`: The numerical concrete type of the encoded features. Default is `Float32`.
 
 # Operations
 

src/encoders/ordinal_encoding/ordinal_encoding.jl

@@ -10,7 +10,7 @@ Fit an encoder to encode the levels of categorical variables in a given table as
   - `features=[]`: A list of names of categorical features given as symbols to exclude or include from encoding
   - `ignore=true`: Whether to exclude or includes the features given in `features`
   - `ordered_factor=false`: Whether to encode `OrderedFactor` or ignore them
-
+  - `dtype`: The numerical concrete type of the encoded features. Default is `Float32`.
 # Returns (in a dict)
 
   - `index_given_feat_level`: Maps each level for each column in a subset of the categorical features of X into an integer.
@@ -21,12 +21,13 @@ function ordinal_encoder_fit(
     features::AbstractVector{Symbol} = Symbol[];
     ignore::Bool = true,
     ordered_factor::Bool = false,
+    op_dtype::Type = Float32,
 )
     # 1. Define feature mapper
     function feature_mapper(col, name)
         feat_levels = levels(col)
         index_given_feat_val =
-            Dict{Any, Integer}(value => index for (index, value) in enumerate(feat_levels))
+            Dict{eltype(feat_levels), op_dtype}(value => index for (index, value) in enumerate(feat_levels))
         return index_given_feat_val
     end
 

test/encoders/ordinal_encoding.jl

@@ -82,4 +82,55 @@ end
         # Test report
         @test report(mach) == (encoded_features = generic_cache[:encoded_features],)
     end
-end
+end
+
+
+@testset "Test Ordinal Encoding Types" begin
+    # Define categorical features
+    A = ["g", "b", "g", "r", "r"]
+    B = [1.0, 2.0, 3.0, 4.0, 5.0]
+    C = ["f", "f", "f", "m", "f"]
+    D = [true, false, true, false, true]
+    E = [1, 2, 3, 4, 5]
+
+    # Combine into a named tuple
+    X = (A = A, B = B, C = C, D = D, E = E)
+
+    # Coerce A, C, D to multiclass and B to continuous and E to ordinal
+    X = coerce(X,
+        :A => Multiclass,
+        :B => Multiclass,
+        :C => Multiclass,
+        :D => Continuous,
+        :E => OrderedFactor,
+    )
+
+
+    encoder = OrdinalEncoder(ordered_factor = false)
+    mach = fit!(machine(encoder, X))
+    Xnew = MMI.transform(mach, X)
+
+    scs = schema(Xnew).scitypes
+    ts  = schema(Xnew).types
+    # Check scitypes for previously continuos or categorical features
+    @test all(scs[1:end-1] .== Continuous)
+    @test all(t -> (t <: AbstractFloat) && isconcretetype(t), ts[1:end-1])
+    # Check that for last column it did not changed
+    scs[end] === schema(X).scitypes[end]
+    scs[end]
+    schema(X).scitypes[end]
+
+    ## Int32 case
+    encoder = OrdinalEncoder(ordered_factor = false, op_dtype = Int32)
+    mach = fit!(machine(encoder, X))
+    Xnew = MMI.transform(mach, X)
+    scs = schema(Xnew).scitypes
+    ts = schema(Xnew).types
+    # Check scitypes for previously categorical features
+    @test all(scs[1:end-2] .== Count)
+    @test all(t -> (t <: Integer) && isconcretetype(t), ts[1:end-2])
+    # Check rest of the types
+    scs[end-1:end]
+    @test scs[end-1:end] == schema(X).scitypes[end-1:end]
+    @test ts[end-1:end] == schema(X).types[end-1:end]
+end