Merge branch 'main' into add-callable-and-better-errors

Author: EssamWisam

.gitignore

@@ -27,3 +27,4 @@ meh/*.ipynb
 .DS_Store
 /*.jl
 scratchpad/
+examples/test.jl

src/MLJTransforms.jl

@@ -7,7 +7,7 @@ using MLJModelInterface
 using TableOperations
 using StatsBase
 using LinearAlgebra
-
+using OrderedCollections: OrderedDict
 # Other transformers
 using Combinatorics
 import Distributions

src/encoders/contrast_encoder/contrast_encoder.jl

@@ -125,7 +125,7 @@ function contrast_encoder_fit(
             throw(ArgumentError("Mode $feat_mode is not supported."))
         end
 
-        vector_given_value_given_feature = Dict(level=>contrastmatrix[l, :] for (l, level) in enumerate(feat_levels))
+        vector_given_value_given_feature = OrderedDict(level=>contrastmatrix[l, :] for (l, level) in enumerate(feat_levels))
         return vector_given_value_given_feature
     end
 
@@ -159,5 +159,5 @@ Use a fitted contrast encoder to encode the levels of selected categorical varia
 """
 function contrast_encoder_transform(X, cache::Dict)
     vector_given_value_given_feature = cache[:vector_given_value_given_feature]
-    return generic_transform(X, vector_given_value_given_feature, single_feat = false)
+    return generic_transform(X, vector_given_value_given_feature, single_feat = false; use_levelnames = true)
 end

src/encoders/contrast_encoder/interface_mlj.jl

@@ -148,12 +148,12 @@ mach = fit!(machine(encoder, X))
 Xnew = transform(mach, X)
 
 julia > Xnew
-    (name_1 = [1.0, 0.0, 0.0, 0.0],
-    name_2 = [0.0, 1.0, 0.0, 1.0],
+    (name_John = [1.0, 0.0, 0.0, 0.0],
+    name_Mary = [0.0, 1.0, 0.0, 1.0],
     height = [1.85, 1.67, 1.5, 1.67],
-    favnum_1 = [0.0, 1.0, 0.0, -1.0],
-    favnum_2 = [2.0, -1.0, 0.0, -1.0],
-    favnum_3 = [-1.0, -1.0, 3.0, -1.0],
+    favnum_5 = [0.0, 1.0, 0.0, -1.0],
+    favnum_7 = [2.0, -1.0, 0.0, -1.0],
+    favnum_10 = [-1.0, -1.0, 3.0, -1.0],
     age = [23, 23, 14, 23],)
 ```
 

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{A <: Any} <: 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 = 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{A <: Any} <: Unsupervised
     features::A
     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 = 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/interface_mlj.jl

@@ -51,6 +51,8 @@ struct TargetEncoderResult{
     y_stat_given_feat_level::Dict{A, A}
     task::S            # "Regression", "Classification" 
     num_classes::I     # num_classes in case of classification
+    y_classes::A      # y_classes in case of classification
+    
 end
 
 
@@ -76,6 +78,7 @@ function MMI.fit(transformer::TargetEncoder, verbosity::Int, X, y)
         generic_cache[:y_stat_given_feat_level],
         generic_cache[:task],
         generic_cache[:num_classes],
+        generic_cache[:y_classes],
     )
     report = (encoded_features = generic_cache[:encoded_features],)        # report only has list of encoded features
     cache = nothing
@@ -90,6 +93,7 @@ function MMI.transform(transformer::TargetEncoder, fitresult, Xnew)
             fitresult.y_stat_given_feat_level,
         :num_classes => fitresult.num_classes,
         :task => fitresult.task,
+        :y_classes => fitresult.y_classes,
     )
     Xnew_transf = target_encoder_transform(Xnew, generic_cache)
     return Xnew_transf