Also, the doc string is confusing. What is the model that is bound to the machine? (It is the output of model = EntityEmbedder(model=atomic_model).)

@ablaom I thought I could check with you quickly here before rushing into a PR. I added or modified lines surrounded with ++++

    EntityEmbedder(; model=mljflux_neural_model)

`EntityEmbedder` implements entity embeddings as in the "Entity Embeddings of Categorical Variables" paper by Cheng Guo, Felix Berkhahn.

# Training data

In MLJ (or MLJBase) bind an instance unsupervised `model` to data with
++++
    mach = machine(embed_model, X, y)
++++

Here:
++++
- `embed_model` is an instance of `EntityEmbedder`, which wraps a supervised MLJFlux model. 
  The supervised model must be one of these: `MLJFlux.NeuralNetworkClassifier`, `NeuralNetworkBinaryClassifier`,
  `MLJFlux.NeuralNetworkRegressor`,`MLJFlux.MultitargetNeuralNetworkRegressor`.
++++
- `X` is any table of input features supported by the model being wrapped. Features to be transformed must
   have element scitype `Multiclass` or `OrderedFactor`. Use `schema(X)` to 
   check scitypes. 

- `y` is the target, which can be any `AbstractVector` supported by the model being wrapped.

And here is an example I worked on to showcase the use of pipeline:

using MLJ
using CategoricalArrays
import Pkg; Pkg.add("MLJLIBSVMInterface")       # For SVC

# Setup some data
N = 200
X = (;
    Column1 = repeat(Float32[1.0, 2.0, 3.0, 4.0, 5.0], Int(N / 5)),
    Column2 = categorical(repeat(['a', 'b', 'c', 'd', 'e'], Int(N / 5))),
    Column3 = categorical(repeat(["b", "c", "d", "f", "f"], Int(N / 5)), ordered = true),
    Column4 = repeat(Float32[1.0, 2.0, 3.0, 4.0, 5.0], Int(N / 5)),
    Column5 = randn(Float32, N),
    Column6 = categorical(
        repeat(["group1", "group1", "group2", "group2", "group3"], Int(N / 5)),
    ),
)
y = categorical(repeat(["class1", "class2", "class3", "class4", "class5"], Int(N / 5)))

# Load the entity embedder, it's neural network backbone and the SVC which inherently supports
# only continuous features
EntityEmbedder = @load EntityEmbedder pkg=MLJFlux   
NeuralNetworkClassifier = @load NeuralNetworkClassifier pkg=MLJFlux
SVC = @load SVC pkg=LIBSVM              



emb = EntityEmbedder(NeuralNetworkClassifier(embedding_dims=Dict(:Column2 => 2, :Column3 => 2)))
clf = SVC(cost = 1.0)

pipeline = emb |> clf

# Construct machine
mach = machine(pipeline, X, y)

# Train model
fit!(mach)

# Predict
yhat = predict(mach, X)

# Transform data using model to encode categorical columns
machy = machine(emb, X, y)
fit!(machy)
Xnew = transform(machy, X)
Xnew

I wonder if it's optimal to have this in lieu of the previous example which I found to be better in terms of being more low-level and intuitive in not assuming any advanced knowledge of MLJ. What's your view? If we don't include the pipeline use here, I'd be happy to make this into a tutorial by using a real dataset and showing a plot (which would be in MLJTransforms docs).

Improve docs for EntityEmbedder wrapper #303

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

Improve docs for `EntityEmbedder` wrapper #303