TrueTarget -> LiteralTarget

Author: ablaom

docs/src/anatomy_of_an_implementation.md

@@ -8,7 +8,7 @@
 > returning the absolute values of the linear coefficients. The ridge regressor has a
 > target variable and outputs literal predictions of the target (rather than, say,
 > probabilistic predictions); accordingly the overloaded `predict` method is dispatched on
-> the `TrueTarget` subtype of `KindOfProxy`. An **algorithm trait** declares this type as the
+> the `LiteralTarget` subtype of `KindOfProxy`. An **algorithm trait** declares this type as the
 > preferred kind of target proxy. Other traits articulate the algorithm's training data type
 > requirements and the input/output type of `predict`.
 
@@ -110,7 +110,7 @@ level API, using those traits.
 Now we need a method for predicting the target on new input features:
 
 ```@example anatomy
-function LearnAPI.predict(::MyRidge, ::LearnAPI.TrueTarget, fitted_params, Xnew)
+function LearnAPI.predict(::MyRidge, ::LearnAPI.LiteralTarget, fitted_params, Xnew)
     Xmatrix = Tables.matrix(Xnew)
     report = nothing
     return Xmatrix*fitted_params.coefficients, report
@@ -119,7 +119,7 @@ nothing # hide
 ```
 
 The second argument of `predict` is always an instance of `KindOfProxy`, and will always
-be `TrueTarget()` in this case, as only literal values of the target (rather than, say
+be `LiteralTarget()` in this case, as only literal values of the target (rather than, say
 probabilistic predictions) are being supported.
 
 In some algorithms `predict` computes something of interest in addition to the target
@@ -159,13 +159,13 @@ list). Accordingly, we are required to declare a preferred target proxy, which w
 [`LearnAPI.preferred_kind_of_proxy`](@ref):
 
 ```@example anatomy
-LearnAPI.preferred_kind_of_proxy(::Type{<:MyRidge}) = LearnAPI.TrueTarget()
+LearnAPI.preferred_kind_of_proxy(::Type{<:MyRidge}) = LearnAPI.LiteralTarget()
 nothing # hide
 ```
 Or, you can use the shorthand
 
 ```@example anatomy
-@trait MyRidge preferred_kind_of_proxy=LearnAPI.TrueTarget()
+@trait MyRidge preferred_kind_of_proxy=LearnAPI.LiteralTarget()
 nothing # hide
 ```
 
@@ -307,7 +307,7 @@ feature_importances(algorithm, fitted_params, fit_report)
 Make a prediction using new data:
 
 ```@example anatomy
-yhat, predict_report = predict(algorithm, LearnAPI.TrueTarget(), fitted_params, X[test])
+yhat, predict_report = predict(algorithm, LearnAPI.LiteralTarget(), fitted_params, X[test])
 ```
 
 Compare predictions with ground truth

docs/src/operations.md

@@ -17,7 +17,7 @@ Here's a snippet of code with a `LearnAPI.predict` call:
 ```julia
 fitted_params, state, fit_report = LearnAPI.fit(some_algorithm, 1, X, y)
 ŷ, predict_report = 
-    LearnAPI.predict(some_algorithm, LearnAPI.TrueTarget(), fitted_params, Xnew)
+    LearnAPI.predict(some_algorithm, LearnAPI.LiteralTarget(), fitted_params, Xnew)
 ```
 
 | method                             | compulsory? | fallback | requires    |
@@ -43,7 +43,7 @@ ŷ, predict_report =
 ## Predict or transform?
 
 If the algorithm has a notion of [target variable](@ref proxy), then implement a `predict`
-method for each supported kind of target proxy (`TrueTarget()`, `Distribution()`,
+method for each supported kind of target proxy (`LiteralTarget()`, `Distribution()`,
 etc). See [Target proxies](@ref) below.
 
 If an operation is to have an inverse operation, then it cannot be `predict` - use
@@ -70,7 +70,7 @@ LearnAPI.IID
 |          type                   | form of an observation                              | 
 |:-------------------------------:|:----------------------------------------------------|
 | `LearnAPI.None`                 | has no declared relationship with a target variable |
-| `LearnAPI.TrueTarget`           | same as target observations |
+| `LearnAPI.LiteralTarget`           | same as target observations |
 | `LearnAPI.Sampleable`           | object that can be sampled to obtain object of the same form as target observation |
 | `LearnAPI.Distribution`         | explicit probability density/mass function whose sample space is all possible target observations |
 | `LearnAPI.LogDistribution`      | explicit log-probability density/mass function whose sample space is possible target observations |

src/algorithm_traits.jl

@@ -98,7 +98,7 @@ LearnAPI.predict(algorithm::MyNewAlgorithmType, LearnAPI.Distribution(), Xnew) =
 Then we can declare
 
 ```julia
-@trait MyNewAlgorithmType  preferred_kind_of_proxy = LearnAPI.TrueTarget()
+@trait MyNewAlgorithmType  preferred_kind_of_proxy = LearnAPI.LiteralTarget()
 ```
 
 which is shorthand for
@@ -590,8 +590,8 @@ const DOC_PREDICT_OUTPUT(s)  =
     Overloading the trait is optional. Here's a sample implementation for a supervised
     regressor type `MyRgs` that only predicts actual values of the target:
 
-        LearnAPI.predict(alogrithm::MyRgs, ::LearnAPI.TrueTarget, data...) = ...
-        LearnAPI.predict_output_$(s)(::Type{<:MyRgs}, ::LearnAPI.TrueTarget) =
+        LearnAPI.predict(alogrithm::MyRgs, ::LearnAPI.LiteralTarget, data...) = ...
+        LearnAPI.predict_output_$(s)(::Type{<:MyRgs}, ::LearnAPI.LiteralTarget) =
             AbstractVector{ScientificTypesBase.Continuous}
 
     The fallback method returns `Any`.
@@ -617,7 +617,7 @@ const DOC_PREDICT_OUTPUT2(s) =
 
     Return a dictionary of upper bounds on the $(s) of predictions, keyed on concrete
     subtypes of [`LearnAPI.KindOfProxy`](@ref). Each of these subtypes respresents a
-    different form of target prediction (`TrueTarget`, `Distribution`, `SurvivalFunction`,
+    different form of target prediction (`LiteralTarget`, `Distribution`, `SurvivalFunction`,
     etc) possibly supported by `algorithm`, but the existence of a key does not guarantee
     that form is supported.
 

src/operations.jl

@@ -25,7 +25,7 @@ as observations) or a proxy for these, for the specified `algorithm` having lear
 parameters `fitted_params` (first object returned by [`LearnAPI.fit`](@ref)`(algorithm,
 ...)`).  $DOC_NEW_DATA
 
-Where available, use `kind_of_proxy=TrueTarget()` for ordinary target predictions, and
+Where available, use `kind_of_proxy=LiteralTarget()` for ordinary target predictions, and
 `kind_of_proxy=Distribution()` for PDF/PMF predictions. Always available is
 `kind_of_proxy=`LearnAPI.preferred_kind_of_proxy(algorithm)`.
 
@@ -157,7 +157,7 @@ See also [`LearnAPI.KindOfProxy`](@ref).
 """
 abstract type IID <: KindOfProxy end
 
-struct TrueTarget <: IID end
+struct LiteralTarget <: IID end
 struct Sampleable <: IID end
 struct Distribution <: IID end
 struct LogDistribution <: IID end