get rid of lasso.jl backend

Author: tiemvanderdeure

src/Maxnet.jl

@@ -8,7 +8,6 @@ using GLM: IdentityLink, CloglogLink, LogitLink, LogLink
 using MLJModelInterface: Continuous, Binary, Multiclass, Count
 
 export IdentityLink, CloglogLink, LogitLink, LogLink # re-export relevant links
-export LassoBackend, GLMNetBackend
 export maxnet, predict, complexity
 export LinearFeature, CategoricalFeature, QuadraticFeature, ProductFeature, ThresholdFeature, HingeFeature
 export MaxnetBinaryClassifier

src/lasso.jl

@@ -1,18 +1,5 @@
-abstract type MaxnetBackend end
-struct LassoBackend <: MaxnetBackend end
-struct GLMNetBackend <: MaxnetBackend end
-
-function fit_lasso_path(
-    backend::LassoBackend, mm, presences;
-    kw...) 
-
-    Lasso.fit(
-        Lasso.LassoPath, mm, presences, Lasso.Distributions.Binomial(); 
-        standardize = false, irls_maxiter = 1_000, kw...)
-end
-
 function fit_lasso_path(
-    backend::GLMNetBackend, mm, presences;
+    mm, presences;
     wts, penalty_factor, λ, kw...) 
 
     presence_matrix = [1 .- presences presences]
@@ -22,4 +9,3 @@ function fit_lasso_path(
 end
 
 get_coefs(path::GLMNet.GLMNetPath) = path.betas
-get_coefs(path::Lasso.LassoPath) = path.coefs

src/maxnet_function.jl

@@ -2,7 +2,7 @@
     maxnet(
         presences, predictors; 
         features, regularization_multiplier, regularization_function,
-        addsamplestobackground, weight_factor, backend, 
+        addsamplestobackground, weight_factor, 
         kw...
     )
 
@@ -21,9 +21,7 @@
 - `addsamplestobackground`: A boolean, where `true` adds the background samples to the predictors. Defaults to `true`.
 - `n_knots`: the number of knots used for Threshold and Hinge features. Defaults to 50. Ignored if there are neither Threshold nor Hinge features
 - `weight_factor`: A `Float64` value to adjust the weight of the background samples. Defaults to 100.0.
-- `backend`: Either `LassoBackend()` or `GLMNetBackend()`, to use either Lasso.jl or GLMNet.jl to fit the model.
-Lasso.jl is written in pure julia, but can be slower with large model matrices (e.g. when hinge is enabled). Defaults to `LassoBackend`.
-- `kw...`: Further arguments to be passed to `Lasso.fit` or `GLMNet.glmnet`
+- `kw...`: Further arguments to be passed to `GLMNet.glmnet`
 
 # Returns
 - `model`: A model of type `MaxnetModel`
@@ -32,7 +30,7 @@ Lasso.jl is written in pure julia, but can be slower with large model matrices (
 ```julia
 using Maxnet
 p_a, env = Maxnet.bradypus();
-bradypus_model = maxnet(p_a, env; features = "lq", backend = GLMNetBackend())
+bradypus_model = maxnet(p_a, env; features = "lq")
 
 Fit Maxnet model
 Features classes: Maxnet.AbstractFeatureClass[LinearFeature(), CategoricalFeature(), QuadraticFeature()]
@@ -49,7 +47,6 @@ function maxnet(
     regularization_function = default_regularization,
     addsamplestobackground::Bool = true, weight_factor::Float64 = 100.,
     n_knots::Int = 50,
-    backend::MaxnetBackend = LassoBackend(),
     kw...)
 
     _maxnet(
@@ -60,8 +57,7 @@ function maxnet(
         regularization_function,
         addsamplestobackground,
         weight_factor,
-        n_knots,
-        backend;
+        n_knots;
         kw...
     )
 end
@@ -90,8 +86,7 @@ function _maxnet(
     regularization_function,
     addsamplestobackground::Bool, 
     weight_factor::Float64,
-    n_knots::Int,
-    backend::MaxnetBackend;
+    n_knots::Int;
     kw...)
 
     # check if predictors is a table
@@ -137,7 +132,7 @@ function _maxnet(
     λ = lambdas(reg, presences, weights; λmax = 4, n = 200)
 
     # Fit the model
-    lassopath = fit_lasso_path(backend, mm, presences, wts = weights, penalty_factor = reg, λ = λ)
+    lassopath = fit_lasso_path(mm, presences, wts = weights, penalty_factor = reg, λ = λ)
 
     # get the coefficients out
     coefs = SparseArrays.sparse(get_coefs(lassopath)[:, end])

src/mlj_interface.jl

@@ -3,7 +3,6 @@ mutable struct MaxnetBinaryClassifier <: MMI.Probabilistic
     regularization_multiplier::Float64
     regularization_function
     weight_factor::Float64
-    backend::MaxnetBackend
     link::GLM.Link
     clamp::Bool
     kw
@@ -12,14 +11,14 @@ end
 function MaxnetBinaryClassifier(; 
     features="", 
     regularization_multiplier = 1.0, regularization_function = default_regularization, 
-    weight_factor = 100., backend = LassoBackend(), 
+    weight_factor = 100., 
     link = CloglogLink(), clamp = false,
     kw...
 )
 
     MaxnetBinaryClassifier(
         features, regularization_multiplier, regularization_function, 
-        weight_factor, backend, link, clamp, kw
+        weight_factor, link, clamp, kw
     )
 end
 
@@ -63,7 +62,6 @@ function MMI.fit(m::MaxnetBinaryClassifier, verbosity::Int, X, y)
         regularization_multiplier = m.regularization_multiplier,
         regularization_function = m.regularization_function,
         weight_factor = m.weight_factor,
-        backend = m.backend,
         m.kw...)
 
     decode = MMI.classes(y)

test/runtests.jl

@@ -17,42 +17,34 @@ env1 = map(e -> [e[1]], env) # just the first row
 end
 
 @testset "Maxnet" begin
-    # test both backends work
-    model_glmnet = Maxnet.maxnet((p_a), env; features = "lq", backend = GLMNetBackend());
-    model_lasso = Maxnet.maxnet((p_a), env; features = "lq", backend = LassoBackend());
-
-    # test both backends come up with approximately the same result
-    @test all(isapprox.(model_glmnet.coefs, model_lasso.coefs; rtol = 0.1, atol = 0.1))
-    @test Statistics.cor(model_glmnet.coefs, model_lasso.coefs) > 0.99
+    # some class combinations and keywords
+    m = Maxnet.maxnet(p_a, env; features = "lq");
+    Maxnet.maxnet(p_a, env; features = "lqp", regularization_multiplier = 2.);
+    Maxnet.maxnet(p_a, env; features = "lqh", regularization_multiplier = 5., nknots = 10);
+    Maxnet.maxnet(p_a, env; features = "lqph", weight_factor = 10.);
 
     # test the result
-    @test model_glmnet.entropy ≈ 6.114650341746531
-    @test complexity(model_glmnet) == 21
-
-    # some class combinations and keywords
-    Maxnet.maxnet(p_a, env; features = "lq", backend = LassoBackend());
-    Maxnet.maxnet(p_a, env; features = "lqp", regularization_multiplier = 2., backend = LassoBackend());
-    Maxnet.maxnet(p_a, env; features = "lqh", regularization_multiplier = 5., nknots = 10, backend = LassoBackend());
-    Maxnet.maxnet(p_a, env; features = "lqph", weight_factor = 10., backend = LassoBackend());
+    @test m.entropy ≈ 6.114650341746531
+    @test complexity(m) == 21
 
     # predictions
-    prediction = Maxnet.predict(model_lasso, env)
+    prediction = Maxnet.predict(m, env)
     @test Statistics.mean(prediction[p_a]) > Statistics.mean(prediction[.~p_a])
     @test minimum(prediction) > 0.
     @test maximum(prediction) < 1.
-    @test mean(prediction) ≈ 0.243406167194403 atol=1e-4
+    @test mean(prediction) ≈ 0.24375837576014572 atol=1e-4
 
     # check that clamping works
     # clamp shouldn't change anything in this case
-    @test prediction == Maxnet.predict(model_lasso, env; clamp = true)
+    @test prediction == Maxnet.predict(m, env; clamp = true)
 
     # predict with a crazy extrapolation
     env1_extrapolated = merge(env1, (;cld6190_ann = [100_000]))
     env1_max_cld = merge(env1, (;cld6190_ann = [maximum(env.cld6190_ann)]))
 
     # using clamp the prediction uses the highest cloud
-    @test Maxnet.predict(model_lasso, env1_extrapolated; link = IdentityLink(), clamp = true) == 
-        Maxnet.predict(model_lasso, env1_max_cld; link = IdentityLink()) 
+    @test Maxnet.predict(m, env1_extrapolated; link = IdentityLink(), clamp = true) == 
+        Maxnet.predict(m, env1_max_cld; link = IdentityLink()) 
 end
 
 @testset "MLJ" begin
@@ -63,21 +55,22 @@ end
     env_typed = MLJBase.coerce(env, cont_keys...)
 
     # make a machine
-    mach1 = machine(mn(features = "lq", backend = LassoBackend()), env_typed, categorical(p_a))
+    mach1 = machine(mn(features = "lq"), env_typed, categorical(p_a))
     fit!(mach1)
 
-    mach2 = machine(mn(features = "lqph", backend = GLMNetBackend()), env_typed, categorical(p_a))
+    mach2 = machine(mn(features = "lqph"), env_typed, categorical(p_a))
     fit!(mach2)
 
     # make the equivalent model without mlj
-    model = Maxnet.maxnet((p_a), env_typed; features = "lqph", backend = GLMNetBackend());
+    model = Maxnet.maxnet((p_a), env_typed; features = "lqph");
 
 
     # predict via MLJBase
     mljprediction = MLJBase.predict(mach2, env_typed)
     mlj_true_probability = pdf.(mljprediction, true)
 
     # test that this predicts the same as the equivalent model without mlj
+
     @test all(Maxnet.predict(model, env_typed) .≈ mlj_true_probability)
 
     @test Statistics.mean(mlj_true_probability[p_a]) > Statistics.mean(mlj_true_probability[.~p_a])