replace MLUtils wiith MLCore

Author: ablaom

README.md

@@ -26,7 +26,7 @@ Here `learner` specifies the configuration the algorithm (the hyperparameters) w
 
 ## Related packages
 
-- [MLCore.jl](https://github.com/JuliaML/MLCore.jl) ([docs](https://juliaml.github.io/MLUtils.jl/stable/api/#Core-API))
+- [MLCore.jl](https://github.com/JuliaML/MLCore.jl) ([docs](https://juliaml.github.io/MLCore.jl/stable/api/#Core-API))
 
 - [LearnTestAPI.jl](https://github.com/JuliaAI/LearnTestAPI.jl): Package to test implementations of LearnAPI.jl (but documented here)
 

docs/Project.toml

@@ -3,7 +3,7 @@ Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 DocumenterInterLinks = "d12716ef-a0f6-4df4-a9f1-a5a34e75c656"
 LearnAPI = "92ad9a40-7767-427a-9ee6-6e577f1266cb"
 LearnTestAPI = "3111ed91-c4f2-40e7-bb19-7f6c618409b8"
-MLUtils = "f1d291b0-491e-4a28-83b9-f70985020b54"
+MLCore = "c2834f40-e789-41da-a90e-33b280584a8c"
 ScientificTypesBase = "30f210dd-8aff-4c5f-94ba-8e64358c1161"
 Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 

docs/src/anatomy_of_an_implementation.md

@@ -334,7 +334,7 @@ assumptions about data from those made above.
 
 - If the `data` object consumed by `fit`, `predict`, or `transform` is not not a suitable
   table¹, array³, tuple of tables and arrays, or some other object implementing the
-  [MLUtils.jl](https://juliaml.github.io/MLUtils.jl/dev/) `getobs`/`numobs` interface,
+  [MLCore.jl](https://juliaml.github.io/MLCore.jl/dev/) `getobs`/`numobs` interface,
   then an implementation must: (i) overload [`obs`](@ref) to articulate how provided data
   can be transformed into a form that does support this interface, as illustrated below
   under [Providing a separate data front end](@ref) below; or (ii) overload the trait
@@ -419,7 +419,7 @@ The [`obs`](@ref) methods exist to:
     how it works.
 
 In the typical case, where [`LearnAPI.data_interface`](@ref) is not overloaded, the
-alternative data representations must implement the MLUtils.jl `getobs/numobs` interface
+alternative data representations must implement the MLCore.jl `getobs/numobs` interface
 for observation subsampling, which is generally all a user or meta-algorithm will need,
 before passing the data on to `fit`/`predict`, as you would the original data.
 
@@ -436,14 +436,14 @@ one enables the following alternative:
 observations = obs(learner, data) # preprocessed training data
 
 # optional subsampling:
-observations = MLUtils.getobs(observations, train_indices)
+observations = MLCore.getobs(observations, train_indices)
 
 model = fit(learner, observations)
 
 newobservations = obs(model, newdata)
 
 # optional subsampling:
-newobservations = MLUtils.getobs(observations, test_indices)
+newobservations = MLCore.getobs(observations, test_indices)
 
 predict(model, newobservations)
 ```
@@ -568,15 +568,15 @@ LearnAPI.target(learner::Ridge, data) = LearnAPI.target(learner, obs(learner, da
   are generally different.
 
 - We need the adjoint operator, `'`, because the last dimension in arrays is the
-  observation dimension, according to the MLUtils.jl convention. Remember, `Xnew` is a
+  observation dimension, according to the MLCore.jl convention. Remember, `Xnew` is a
   table here.
 
 Since LearnAPI.jl provides fallbacks for `obs` that simply return the unadulterated data
 argument, overloading `obs` is optional. This is provided data in publicized
 `fit`/`predict` signatures already consists only of objects implement the
 [`LearnAPI.RandomAccess`](@ref) interface (most tables¹, arrays³, and tuples thereof).
 
-To opt out of supporting the MLUtils.jl interface altogether, an implementation must
+To opt out of supporting the MLCore.jl interface altogether, an implementation must
 overload the trait, [`LearnAPI.data_interface(learner)`](@ref). See [Data
 interfaces](@ref data_interfaces) for details.
 
@@ -593,15 +593,15 @@ LearnAPI.fit(learner::Ridge, X, y; kwargs...)  = fit(learner, (X, y); kwargs...)
 ## [Demonstration of an advanced `obs` workflow](@id advanced_demo)
 
 We now can train and predict using internal data representations, resampled using the
-generic MLUtils.jl interface:
+generic MLCore.jl interface:
 
 ```@example anatomy2
-import MLUtils
+import MLCore
 learner = Ridge()
 observations_for_fit = obs(learner, (X, y))
-model = fit(learner, MLUtils.getobs(observations_for_fit, train))
+model = fit(learner, MLCore.getobs(observations_for_fit, train))
 observations_for_predict = obs(model, X)
-ẑ = predict(model, MLUtils.getobs(observations_for_predict, test))
+ẑ = predict(model, MLCore.getobs(observations_for_predict, test))
 ```
 
 ```julia
@@ -616,7 +616,7 @@ obs_workflows).
 ¹ In LearnAPI.jl a *table* is any object `X` implementing the
 [Tables.jl](https://tables.juliadata.org/dev/) interface, additionally satisfying
 `Tables.istable(X) == true` and implementing `DataAPI.nrow` (and whence
-`MLUtils.numobs`). Tables that are also (unnamed) tuples are disallowed.
+`MLCore.numobs`). Tables that are also (unnamed) tuples are disallowed.
 
 ² An implementation can provide further accessor functions, if necessary, but
 like the native ones, they must be included in the [`LearnAPI.functions`](@ref)

docs/src/index.md

@@ -92,12 +92,13 @@ unless the algorithm explicitly opts out. Moreover, the `fit` and `predict` meth
 also be able to consume these alternative data representations, for performance benefits
 in some situations.
 
-The fallback data interface is the [MLUtils.jl](https://github.com/JuliaML/MLUtils.jl)
-`getobs/numobs` interface, here tagged as [`LearnAPI.RandomAccess()`](@ref), and if the
-input consumed by the algorithm already implements that interface (tables, arrays, etc.)
-then overloading `obs` is completely optional. Plain iteration interfaces, with or without
-knowledge of the number of observations, can also be specified, to support, e.g., data
-loaders reading images from disk.
+The fallback data interface is the [MLCore.jl](https://github.com/JuliaML/MLCore.jl)
+`getobs/numobs` interface (previously provided by MLUtils.jl) here tagged as
+[`LearnAPI.RandomAccess()`](@ref). However, if the input consumed by the algorithm already
+implements that interface (tables, arrays, etc.)  then overloading `obs` is completely
+optional. Plain iteration interfaces, with or without knowledge of the number of
+observations, can also be specified, to support, e.g., data loaders reading images from
+disk.
 
 Some canned data front ends (implementations of [`obs`](@ref)) are provided by the
 [LearnDataFrontEnds.jl](https://juliaai.github.io/LearnDataFrontEnds.jl/stable/) package.

docs/src/obs.md

@@ -26,26 +26,26 @@ observations = obs(learner, data)
 
 then, assuming the typical case that `LearnAPI.data_interface(learner) ==
 LearnAPI.RandomAccess()`, `observations` implements the
-[MLUtils.jl](https://juliaml.github.io/MLUtils.jl/dev/) `getobs`/`numobs` interface, for
+[MLCore.jl](https://juliaml.github.io/MLCore.jl/dev/) `getobs`/`numobs` interface, for
 grabbing and counting observations. Moreover, we can pass `observations` to `fit` in place
-of the original data, or first resample it using `MLUtils.getobs`:
+of the original data, or first resample it using `MLCore.getobs`:
 
 ```julia
 # equivalent to `model = fit(learner, data)`
 model = fit(learner, observations)
 
 # with resampling:
-resampled_observations = MLUtils.getobs(observations, 1:10)
+resampled_observations = MLCore.getobs(observations, 1:10)
 model = fit(learner, resampled_observations)
 ```
 
 In some implementations, the alternative pattern above can be used to avoid repeating
 unnecessary internal data preprocessing, or inefficient resampling.  For example, here's
-how a user might call `obs` and `MLUtils.getobs` to perform efficient cross-validation:
+how a user might call `obs` and `MLCore.getobs` to perform efficient cross-validation:
 
 ```julia
 using LearnAPI
-import MLUtils
+import MLCore
 
 learner = <some supervised learner>
 
@@ -61,7 +61,7 @@ never_trained = true
 scores = map(train_test_folds) do (train, test)
 
     # train using model-specific representation of data:
-    fitobs_subset = MLUtils.getobs(fitobs, train)
+    fitobs_subset = MLCore.getobs(fitobs, train)
     model = fit(learner, fitobs_subset)
 
     # predict on the fold complement:
@@ -70,7 +70,7 @@ scores = map(train_test_folds) do (train, test)
         global predictobs = obs(model, X)
         global never_trained = false
     end
-    predictobs_subset = MLUtils.getobs(predictobs, test)
+    predictobs_subset = MLCore.getobs(predictobs, test)
     ŷ = predict(model, Point(), predictobs_subset)
 
     y = LearnAPI.target(learner, data)

docs/src/predict_transform.md

@@ -52,8 +52,8 @@ transform(learner, data) # `fit` implied
 
 ```julia
 fitobs = obs(learner, (X, y)) # learner-specific repr. of data
-model = fit(learner, MLUtils.getobs(fitobs, 1:100))
-predictobs = obs(model, MLUtils.getobs(X, 101:150))
+model = fit(learner, MLCore.getobs(fitobs, 1:100))
+predictobs = obs(model, MLCore.getobs(X, 101:150))
 ŷ = predict(model, Point(), predictobs)
 ```
 

docs/src/reference.md

@@ -21,13 +21,13 @@ individual observations.
 A `DataFrame` instance, from [DataFrames.jl](https://dataframes.juliadata.org/stable/), is
 an example of data, the observations being the rows. Typically, data provided to
 LearnAPI.jl algorithms, will implement the
-[MLUtils.jl](https://juliaml.github.io/MLUtils.jl/stable) `getobs/numobs` interface for
+[MLCore.jl](https://juliaml.github.io/MLCore.jl/stable) `getobs/numobs` interface for
 accessing individual observations, but implementations can opt out of this requirement;
 see [`obs`](@ref) and [`LearnAPI.data_interface`](@ref) for details.
 
 !!! note
 
-	In the MLUtils.jl
+	In the MLCore.jl
 	convention, observations in tables are the rows but observations in a matrix are the
 	columns.
 

docs/src/traits.md

@@ -27,7 +27,7 @@ In the examples column of the table below, `Continuous` is a name owned the pack
 | [`LearnAPI.nonlearners`](@ref)`(learner)`                | properties *not* corresponding to other learners                                                                       | all properties                                        | `(:K, :leafsize, :metric,)`                                    |
 | [`LearnAPI.human_name`](@ref)`(learner)`                 | human name for the learner; should be a noun                                                                           | type name with spaces                                 | "elastic net regressor"                                        |
 | [`LearnAPI.iteration_parameter`](@ref)`(learner)`        | symbolic name of an iteration parameter                                                                                | `nothing`                                             | :epochs                                                        |
-| [`LearnAPI.data_interface`](@ref)`(learner)`             | Interface implemented by objects returned by [`obs`](@ref)                                                             | `Base.HasLength()` (supports `MLUtils.getobs/numobs`) | `Base.SizeUnknown()` (supports `iterate`)                      |
+| [`LearnAPI.data_interface`](@ref)`(learner)`             | Interface implemented by objects returned by [`obs`](@ref)                                                             | `Base.HasLength()` (supports `MLCore.getobs/numobs`) | `Base.SizeUnknown()` (supports `iterate`)                      |
 | [`LearnAPI.fit_scitype`](@ref)`(learner)`                | upper bound on `scitype(data)` ensuring `fit(learner, data)` works                                                     | `Union{}`                                             | `Tuple{AbstractVector{Continuous}, Continuous}`                |
 | [`LearnAPI.target_observation_scitype`](@ref)`(learner)` | upper bound on the scitype of each observation of the targget                                                          | `Any`                                                 | `Continuous`                                                   |
 | [`LearnAPI.is_static`](@ref)`(learner)`                  | `true` if `fit` consumes no data                                                                                       | `false`                                               | `true`                                                         |

src/accessor_functions.jl

@@ -319,7 +319,7 @@ Here's a sample workflow for some such `learner`, with training data, `(X, y)`,
 is the training target, here assumed to be a vector.
 
 ```julia
-import MLUtils.getobs
+import MLCore.getobs
 model = fit(learner, (X, y))
 yhat = LearnAPI.predictions(model)
 test_indices = LearnAPI.out_of_sample_indices(model)

src/obs.jl

@@ -25,15 +25,15 @@ model = fit(learner, data_train)
 ŷ = predict(model, Point(), X[101:150])
 ```
 
-Alternative workflow using `obs` and the MLUtils.jl method `getobs` to carry out
+Alternative workflow using `obs` and the MLCore.jl method `getobs` to carry out
 subsampling (assumes `LearnAPI.data_interface(learner) == RandomAccess()`):
 
 ```julia
-import MLUtils
+import MLCore
 fit_observations = obs(learner, data)
-model = fit(learner, MLUtils.getobs(fit_observations, 1:100))
+model = fit(learner, MLCore.getobs(fit_observations, 1:100))
 predict_observations = obs(model, X)
-ẑ = predict(model, Point(), MLUtils.getobs(predict_observations, 101:150))
+ẑ = predict(model, Point(), MLCore.getobs(predict_observations, 101:150))
 @assert ẑ == ŷ
 ```
 
@@ -54,7 +54,7 @@ alternatives with the same output, whenever `observations = obs(model, data)`.
 
 If `LearnAPI.data_interface(learner) == RandomAccess()` (the default), then `fit`,
 `predict` and `transform` must additionally accept `obs` output that has been *subsampled*
-using `MLUtils.getobs`, with the obvious interpretation applying to the outcomes of such
+using `MLCore.getobs`, with the obvious interpretation applying to the outcomes of such
 calls (e.g., if *all* observations are subsampled, then outcomes should be the same as if
 using the original data).