Merge branch 'main' into use-level-names-for-categories

Author: EssamWisam

src/encoders/frequency_encoding/frequency_encoding.jl

@@ -24,11 +24,15 @@ function frequency_encoder_fit(
     ignore::Bool = true,
     ordered_factor::Bool = false,
     normalize::Bool = false,
+    output_type::Type = Float32,
 )
     # 1. Define feature mapper
     function feature_mapper(col, name)
         frequency_map = (!normalize) ? countmap(col) : proportionmap(col)
-        statistic_given_feat_val = Dict{Any, Real}(level=>frequency_map[level] for level in levels(col))
+        feat_levels = levels(col)
+        statistic_given_feat_val = Dict{eltype(feat_levels), output_type}(
+            level => frequency_map[level] for level in feat_levels
+        )
         return statistic_given_feat_val
     end
 

src/encoders/frequency_encoding/interface_mlj.jl

@@ -6,6 +6,7 @@ mutable struct FrequencyEncoder{AS <: AbstractVector{Symbol}} <: Unsupervised
     ignore::Bool
     ordered_factor::Bool
     normalize::Bool
+    output_type::Type
 end;
 
 # 2. Constructor
@@ -14,8 +15,9 @@ function FrequencyEncoder(;
     ignore = true,
     ordered_factor = false,
     normalize = false,
+    output_type = Float32,
 )
-    return FrequencyEncoder(features, ignore, ordered_factor, normalize)
+    return FrequencyEncoder(features, ignore, ordered_factor, normalize, output_type)
 end;
 
 
@@ -32,6 +34,7 @@ function MMI.fit(transformer::FrequencyEncoder, verbosity::Int, X)
         ignore = transformer.ignore,
         ordered_factor = transformer.ordered_factor,
         normalize = transformer.normalize,
+        output_type = transformer.output_type,
     )
     fitresult = generic_cache[:statistic_given_feat_val]
 
@@ -96,6 +99,7 @@ Train the machine using `fit!(mach, rows=...)`.
 - `ignore=true`: Whether to exclude or include the features given in `features`
 - `ordered_factor=false`: Whether to encode `OrderedFactor` or ignore them
 - `normalize=false`: Whether to use normalized frequencies that sum to 1 over category values or to use raw counts.
+- `output_type=Float32`: The type of the output values. The default is `Float32`, but you can set it to `Float64` or any other type that can hold the frequency values.
 
 # Operations
 

src/encoders/missingness_encoding/missingness_encoding.jl

@@ -30,7 +30,7 @@ function missingness_encoder_fit(
     features::AbstractVector{Symbol} = Symbol[];
     ignore::Bool = true,
     ordered_factor::Bool = false,
-    label_for_missing::Dict{<:Type, <:Any} = Dict(    
+    label_for_missing::Dict{<:Type, <:Any} = Dict(
         AbstractString => "missing",
         Char => 'm',
     ),
@@ -40,8 +40,8 @@ function missingness_encoder_fit(
 
     # 1. Define feature mapper
     function feature_mapper(col, name)
-        col_type = nonmissingtype(eltype(col)).parameters[1]
-        feat_levels = levels(col; skipmissing=true)
+        feat_levels = levels(col; skipmissing = true)
+        col_type = nonmissingtype(eltype(feat_levels))
 
         # Ensure column type is valid (can't test because never occurs)
         # Converting array elements to strings before wrapping in a `CategoricalArray`, as...
@@ -58,7 +58,7 @@ function missingness_encoder_fit(
 
         # Check no collision between keys(label_for_missing) and feat_levels
         for value in values(label_for_missing)
-            if !ismissing(value) 
+            if !ismissing(value)
                 if value in feat_levels
                     throw(ArgumentError(COLLISION_NEW_VAL_ME(value)))
                 end
@@ -73,7 +73,7 @@ function missingness_encoder_fit(
                 break
             end
         end
-        
+
         # Nonmissing levels remain as is
         label_for_missing_given_feature = Dict{Missing, col_type}()
 
@@ -91,7 +91,8 @@ function missingness_encoder_fit(
 
     # 2. Pass it to generic_fit
     label_for_missing_given_feature, encoded_features = generic_fit(
-        X, features; ignore = ignore, ordered_factor = ordered_factor, feature_mapper = feature_mapper,
+        X, features; ignore = ignore, ordered_factor = ordered_factor,
+        feature_mapper = feature_mapper,
     )
     cache = Dict(
         :label_for_missing_given_feature => label_for_missing_given_feature,
@@ -117,6 +118,11 @@ Apply a fitted missingness encoder to a table given the output of `missingness_e
 """
 function missingness_encoder_transform(X, cache::Dict)
     label_for_missing_given_feature = cache[:label_for_missing_given_feature]
-    return generic_transform(X, label_for_missing_given_feature; ignore_unknown = true)
+    return generic_transform(
+        X,
+        label_for_missing_given_feature;
+        ignore_unknown = true,
+        ensure_categorical = true,
+    )
 end
 

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
+    output_type::Type
 end;
 
 # 2. Constructor
 function OrdinalEncoder(;
     features = Symbol[],
     ignore = true,
     ordered_factor = false,
+    output_type = Float32,
 )
-    return OrdinalEncoder(features, ignore, ordered_factor)
+    return OrdinalEncoder(features, ignore, ordered_factor, output_type)
 end;
 
 
@@ -29,6 +31,7 @@ function MMI.fit(transformer::OrdinalEncoder, verbosity::Int, X)
         transformer.features;
         ignore = transformer.ignore,
         ordered_factor = transformer.ordered_factor,
+        output_type = transformer.output_type,
     )
     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
+- `output_type`: 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,
+    output_type::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), output_type}(value => index for (index, value) in enumerate(feat_levels))
         return index_given_feat_val
     end
 

src/encoders/target_encoding/target_encoding.jl

@@ -166,8 +166,9 @@ function target_encoder_fit(
 
     # 3. Define function to compute the new value(s) for each level given a column
     function feature_mapper(col, name)
+        feat_levels = levels(col)
         y_stat_given_feat_level_for_col =
-            Dict{Any, Union{AbstractFloat, AbstractVector{<:AbstractFloat}}}()
+            Dict{eltype(feat_levels), Any}()
         for level in levels(col)
             # Get the targets of an example that belong to this level
             targets_for_level = y[col.==level]

src/generic.jl

@@ -130,6 +130,7 @@ function generic_transform(
     ignore_unknown = false,
     use_levelnames = false,
     custom_levels = nothing,
+    ensure_categorical = false,
 )
     feat_names = Tables.schema(X).names
     new_feat_names = Symbol[]
@@ -153,7 +154,12 @@ function generic_transform(
 
             if single_feat
                 level2scalar = mapping_per_feat_level[feat_name]
-                new_col = !isempty(level2scalar) ? recode(col, level2scalar...) : col
+                if ensure_categorical
+                    new_col = !isempty(level2scalar) ? recode(col, level2scalar...) : col
+                else 
+                    new_col = !isempty(level2scalar) ? unwrap.(recode(col, level2scalar...)) : col
+                end
+               
                 push!(new_cols, new_col)
                 push!(new_feat_names, feat_name)
             else

src/transformers/cardinality_reducer/cardinality_reducer.jl

@@ -35,20 +35,20 @@ function cardinality_reducer_fit(
     features::AbstractVector{Symbol} = Symbol[];
     ignore::Bool = true,
     ordered_factor::Bool = false,
-    min_frequency::Real = 3,                        
-    label_for_infrequent::Dict{<:Type, <:Any} = Dict(    
+    min_frequency::Real = 3,
+    label_for_infrequent::Dict{<:Type, <:Any} = Dict(
         AbstractString => "Other",
         Char => 'O',
     ),
-)   
+)
     supportedtypes_list = [Char, AbstractString, Number]
     supportedtypes = Union{supportedtypes_list...}
 
     # 1. Define feature mapper
     function feature_mapper(col, name)
         val_to_freq = (min_frequency isa AbstractFloat) ? proportionmap(col) : countmap(col)
-        col_type = eltype(col).parameters[1]
         feat_levels = levels(col)
+        col_type = eltype(feat_levels)
 
         # Ensure column type is valid (can't test because never occurs)
         # Converting array elements to strings before wrapping in a `CategoricalArray`, as...
@@ -88,7 +88,11 @@ function cardinality_reducer_fit(
                     elseif elgrandtype == Number
                         new_cat_given_col_val[level] = minimum(feat_levels) - 1
                     else
-                        throw(ArgumentError(UNSPECIFIED_COL_TYPE(col_type, label_for_infrequent)))
+                        throw(
+                            ArgumentError(
+                                UNSPECIFIED_COL_TYPE(col_type, label_for_infrequent),
+                            ),
+                        )
                     end
                 end
             end
@@ -98,7 +102,8 @@ function cardinality_reducer_fit(
 
     # 2. Pass it to generic_fit
     new_cat_given_col_val, encoded_features = generic_fit(
-        X, features; ignore = ignore, ordered_factor = ordered_factor, feature_mapper = feature_mapper,
+        X, features; ignore = ignore, ordered_factor = ordered_factor,
+        feature_mapper = feature_mapper,
     )
     cache = Dict(
         :new_cat_given_col_val => new_cat_given_col_val,
@@ -125,5 +130,5 @@ Apply a fitted cardinality reducer to a table given the output of `cardinality_r
 """
 function cardinality_reducer_transform(X, cache::Dict)
     new_cat_given_col_val = cache[:new_cat_given_col_val]
-    return generic_transform(X, new_cat_given_col_val; ignore_unknown = true)
+    return generic_transform(X, new_cat_given_col_val; ignore_unknown = true, ensure_categorical = true)
 end

test/encoders/contrast_encoder.jl

@@ -51,9 +51,7 @@ end
     cache = contrast_encoder_fit(X, [:name]; ignore=false, mode = :dummy)
     k = length(levels(X.name))
     contrast_matrix = get_dummy_contrast(k)
-    print()
     for (i, level) in enumerate(levels(X.name))
-        println(cache[:vector_given_value_given_feature])
         @test cache[:vector_given_value_given_feature][:name][level] == contrast_matrix[i, :]
     end
 end
@@ -289,4 +287,40 @@ end
 
     # Test report
     @test report(mach) == (encoded_features = generic_cache[:encoded_features],)
+end
+
+
+@testset "Test Contrast Encoder Output Types" begin
+    X = (
+        name   = categorical(["Ben", "John", "Mary", "John"]),
+        height = [1.85, 1.67, 1.5, 1.67],
+        favnum = categorical([7, 5, 10, 1]),
+        age    = [23, 23, 14, 23],
+    )
+
+    methods =  [:contrast, :dummy, :sum, :backward_diff, :helmert, :hypothesis]
+    matrix_func = [buildrandomcontrast, nothing, nothing, nothing, nothing, buildrandomhypothesis]
+    
+    for (i, method) in enumerate(methods)
+        encoder = ContrastEncoder(
+            features = [:name, :favnum],
+            ignore = false,
+            mode = method,
+            buildmatrix=matrix_func[i]
+        )
+        mach = fit!(machine(encoder, X))
+        Xnew = MMI.transform(mach, X)
+
+        # Test Consistency with Types
+        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 scitypes for previously Count feature
+        last_type, last_sctype = ts[end], scs[end]
+        @test last_type <: Integer && isconcretetype(last_type)
+        @test last_sctype <: Count
+    end
 end

test/encoders/frequency_encoder.jl

@@ -9,7 +9,8 @@ using MLJTransforms: frequency_encoder_fit, frequency_encoder_transform
     for norm in normalize
         result = frequency_encoder_fit(X; normalize = norm)[:statistic_given_feat_val]
         enc =
-            (col, level) -> ((norm) ? sum(col .== level) / length(col) : sum(col .== level))
+            (col, level) ->
+                Float32((norm) ? sum(col .== level) / length(col) : sum(col .== level))
         true_output = Dict{Symbol, Dict{Any, Any}}(
             :F => Dict(
                 "m" => enc(F_col, "m"),
@@ -44,7 +45,7 @@ end
         X_tr = frequency_encoder_transform(X, cache)
         enc =
             (col, level) ->
-                ((norm) ? sum(X[col] .== level) / length(X[col]) : sum(X[col] .== level))
+                Float32((norm) ? sum(X[col] .== level) / length(X[col]) : sum(X[col] .== level))
 
         target = (
             A = [enc(:A, X[:A][i]) for i in 1:10],
@@ -81,4 +82,42 @@ end
         # Test report
         @test report(mach) == (encoded_features = generic_cache[:encoded_features],)
     end
-end
+end
+
+@testset "Test Frequency Encoding Output 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 => Continuous,
+        :C => Multiclass,
+        :D => Multiclass,
+        :E => OrderedFactor,
+    )
+
+    # Check scitype coercions:
+    schema(X)
+
+    encoder = FrequencyEncoder(ordered_factor = false, normalize = false)
+    mach = fit!(machine(encoder, X))
+    Xnew = MMI.transform(mach, X)
+
+
+    scs = schema(Xnew).scitypes
+    ts  = schema(Xnew).types
+    # Check scitypes correctness
+    @test all(scs[1:end-1] .== Continuous)
+    @test all(t -> (t <: AbstractFloat) && isconcretetype(t), ts[1:end-1])
+    # Ordinal column should be intact
+    @test scs[end] === schema(X).scitypes[end]
+    @test ts[end] == schema(X).types[end]
+end