dump fit_observation_scitype in favour of fit_scitype

Author: ablaom

docs/src/traits.md

@@ -28,7 +28,7 @@ In the examples column of the table below, `Continuous` is a name owned the pack
 | [`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.fit_observation_scitype`](@ref)`(learner)`    | upper bound on `scitype(observation)` for `observation` in `data` ensuring `fit(learner, data)` works                  | `Union{}`                                             | `Tuple{AbstractVector{Continuous}, Continuous}`                |
+| [`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`                                                         |
 
@@ -105,7 +105,7 @@ LearnAPI.nonlearners
 LearnAPI.human_name
 LearnAPI.data_interface
 LearnAPI.iteration_parameter
-LearnAPI.fit_observation_scitype
+LearnAPI.fit_scitype
 LearnAPI.target_observation_scitype
 LearnAPI.is_static
 ```

src/traits.jl

@@ -416,16 +416,33 @@ Implement if algorithm is iterative. Returns a symbol or `nothing`.
 """
 iteration_parameter(::Any) = nothing
 
+# """
+#     LearnAPI.fit_observation_scitype(learner)
+
+# Return an upper bound `S` on the scitype of individual observations guaranteed to work
+# when calling `fit`: if `observations = obs(learner, data)` and
+# `ScientificTypes.scitype(collect(o)) <:S` for each `o` in `observations`, then the call
+# `fit(learner, data)` is supported.
+
+# $DOC_EXPLAIN_EACHOBS
+
+# See also [`LearnAPI.target_observation_scitype`](@ref).
+
+# # New implementations
+
+# Optional. The fallback return value is `Union{}`.
+
+# """
+# fit_observation_scitype(::Any) = Union{}
 
 """
-    LearnAPI.fit_observation_scitype(learner)
+    LearnAPI.fit_scitype(learner)
 
-Return an upper bound `S` on the scitype of individual observations guaranteed to work
-when calling `fit`: if `observations = obs(learner, data)` and
-`ScientificTypes.scitype(collect(o)) <:S` for each `o` in `observations`, then the call
-`fit(learner, data)` is supported.
+Return an upper bound `S` on the `scitype` (scientific type) of `data` for which the call
+[`fit(learner, data)`](@ref) is supported. Specifically, if `ScientificTypes.scitype(data)
+<: S` then the call is guaranteed to succeed. If not, the call may or may not succeed.
 
-$DOC_EXPLAIN_EACHOBS
+See ScientificTypes.jl documentation for more on the `scitype` function.
 
 See also [`LearnAPI.target_observation_scitype`](@ref).
 
@@ -434,21 +451,25 @@ See also [`LearnAPI.target_observation_scitype`](@ref).
 Optional. The fallback return value is `Union{}`.
 
 """
-fit_observation_scitype(::Any) = Union{}
+fit_scitype(::Any) = Union{}
 
 """
     LearnAPI.target_observation_scitype(learner)
 
-Return an upper bound `S` on the scitype of each observation of an applicable target
-variable. Specifically, both of the following is always true:
+Return an upper bound `S` on the `scitype` (scientific type) of each observation of any
+target variable associated with the learner. See LearnAPI.jl documentation for the meaning
+of "target variable".  See ScientificTypes.jl documentation for an explanation of the
+`scitype` function, which it provides.
+
+Specifically, both of the following is always true:
 
 - If `:(LearnAPI.target) in LearnAPI.functions(learner)` (i.e., `fit` consumes target
   variables) then "target" means anything returned by [`LearnAPI.target(learner,
   observations)`](@ref), where `observations = `[`LearnAPI.obs(learner, data)`](@ref) and
-  `data` is an admissible argument in the call [`fit(learner, data)`](@ref).
+  `data` is a supported argument in the call [`fit(learner, data)`](@ref).
 
-- `S` will always be an upper bound on the scitype of (point) observations that could be
-  conceivably extracted from the output of [`predict`](@ref).
+- `S` is an upper bound on the `scitype` of (point) observations that might normally be
+  extracted from the output of [`predict`](@ref).
 
 To illustate the second property, suppose we have
 
@@ -458,9 +479,9 @@ ŷ = predict(model, Sampleable(), data_new)
 ```
 
 Then each individual sample generated by each "observation" of `ŷ` (a vector of sampleable
-objects, say) will be bound in scitype by `S`.
+objects, say) will be bound in `scitype` by `S`.
 
-See also See also [`LearnAPI.fit_observation_scitype`](@ref).
+See also See also [`LearnAPI.fit_scitype`](@ref).
 
 # New implementations
 

test/traits.jl

@@ -43,7 +43,7 @@ small = SmallLearner()
 @test LearnAPI.human_name(small) == "small learner"
 @test isnothing(LearnAPI.iteration_parameter(small))
 @test LearnAPI.data_interface(small) == LearnAPI.RandomAccess()
-@test !(6 isa LearnAPI.fit_observation_scitype(small))
+@test !(6 isa LearnAPI.fit_scitype(small))
 @test 6 isa LearnAPI.target_observation_scitype(small)
 @test !LearnAPI.is_static(small)