Merge pull request #33 from alan-turing-institute/dev

For a 0.1.3 release

Author: ablaom

Project.toml

@@ -1,7 +1,7 @@
 name = "NearestNeighborModels"
 uuid = "636a865e-7cf4-491e-846c-de09b730eb36"
 authors = ["Anthony D. Blaom <anthony.blaom@gmail.com>", "Sebastian Vollmer <s.vollmer.4@warwick.ac.uk>", "Thibaut Lienart <thibaut.lienart@gmail.com>", "Okon Samuel <okonsamuel50@gmail.com>"]
-version = "0.1.2"
+version = "0.1.3"
 
 [deps]
 Distances = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7"

src/models.jl

@@ -29,7 +29,7 @@ function dict_preds(::Val{:columnaccess}, func, target_table, idxsvec, weights)
     dict_table = Dict(
         nm => func(weights, Tables.getcolumn(cols, nm), idxsvec) for nm in colnames
     )
-    return dict_table  
+    return dict_table
 end
 
 function dict_preds(::Val{:noncolumnaccess}, func, target_table, idxsvec, weights)
@@ -62,7 +62,7 @@ end
 function ntuple_preds(::Val{:noncolumnaccess}, func, target_table, idxsvec, weights)
     cols = Tables.columntable(target_table)
     colnames = Tables.columnnames(cols)
-    column_table = NamedTuple{colnames}( 
+    column_table = NamedTuple{colnames}(
         func(weights, Tables.getcolumn(col, nm), idxsvec) for nm in colnames
     )
     return column_table
@@ -152,37 +152,37 @@ end
 function _predict_knnclassifier(weights, y, idxsvec)
     # `classes` and `classes_seen` has an ordering consistent with the pool of y
     classes = @inbounds MMI.classes(y[1])
-    classes_seen = filter(in(unique(y)), classes) 
+    classes_seen = filter(in(unique(y)), classes)
     nclasses = length(classes)
     nc = length(classes_seen) # Number of classes seen in `y`.
-    
-    # `labels` and `integers_seen` assigns ranks {1, 2, ..., nclasses}, to the 
+
+    # `labels` and `integers_seen` assigns ranks {1, 2, ..., nclasses}, to the
     # `CategoricalValue`'s in `y` according the ordering given by the pool of `y`.
-    # In the case of `integers_seen` the ranks happen to sorted with the lower ranks 
+    # In the case of `integers_seen` the ranks happen to sorted with the lower ranks
     # comming first and the higher rank coming last.
     # In both cases some ranks may be absent because some categorical values in `classes`
-    # may be absent from `y` (in the case of `labels`) and `classes_seen` 
+    # may be absent from `y` (in the case of `labels`) and `classes_seen`
     # (in the case of `integers_seen`).
     labels = MMI.int(y)
     integers_seen = MMI.int(classes_seen)
-    
+
     # Recode `integers_seen` to be in {1,..., nc}
     # same as nc == nclasses || replace!(labels, (integers_seen .=> 1:nc)...)
     nc == nclasses || _replace!(labels, integers_seen, 1:nc)
     nsamples = length(idxsvec)
     probs = zeros(eltype(weights), nsamples, nc)
-    
+
     @inbounds for i in eachindex(idxsvec)
         idxs = idxsvec[i]
         idxs_labels = @view(labels[idxs])
         @simd for j in eachindex(idxs_labels)
-             @inbounds probs[i, idxs_labels[j]] += weights[i, j] 
+             @inbounds probs[i, idxs_labels[j]] += weights[i, j]
         end
-    end  
+    end
     return MMI.UnivariateFinite(classes_seen, scale(probs, dims=2))
 end
- 
-function MMI.predict(m::KNNClassifier, fitresult, X) 
+
+function MMI.predict(m::KNNClassifier, fitresult, X)
     err_if_given_invalid_K(m.K)
     Xmatrix = transpose(MMI.matrix(X))
     check_onebased_indexing("prediction input", Xmatrix)
@@ -233,12 +233,12 @@ function _predict_knnreg(weights, y, idxs_matrix)
     return preds
 end
 function MMI.predict(m::KNNRegressor, fitresult, X)
-    err_if_given_invalid_K(m.K)    
+    err_if_given_invalid_K(m.K)
     #Xmatrix = MMI.matrix(X, transpose=true) # NOTE: copies the data
     Xmatrix = transpose(MMI.matrix(X))
     check_onebased_indexing("prediction input", Xmatrix)
     predict_args = setup_predict_args(m, Xmatrix, fitresult)
-    preds = _predict_knnreg(predict_args...)
+    preds = _predict_knnreg(predict_args...) |> vec
     return preds
 end
 
@@ -301,25 +301,25 @@ function _predict_multiknnreg(weights, Ymatrix, idxs_matrix)
         );
         dims = 3
    )
-   # Normalizing the weighted labels gives us our final preds  
+   # Normalizing the weighted labels gives us our final preds
    preds = @inbounds(@view(weighted_labels[:, :, 1])) ./ _sum(weights, dims=2)
    return preds
 end
 
 function MMI.predict(m::MultitargetKNNRegressor, fitresult, X)
-    err_if_given_invalid_K(m.K)  
+    err_if_given_invalid_K(m.K)
     #Xmatrix = MMI.matrix(X, transpose=true) # NOTE: copies the data
     Xmatrix = transpose(MMI.matrix(X))
     check_onebased_indexing("prediction input", Xmatrix)
     names, args = setup_predict_args(m, Xmatrix, fitresult)
     preds = _predict_multiknnreg(args...)
-    # A matrix table was intentionally outputed. 
+    # A matrix table was intentionally outputed.
     # Users can coerce to their desired Table type.
     return MMI.table(preds, names = names)
 end
 
 ##################
-### FIT MODELS 
+### FIT MODELS
 ##################
 
 struct MultiKNNRegressorTarget{S, M<:AbstractMatrix}
@@ -339,7 +339,7 @@ end
 
 function get_target(::KNNRegressor, y)
    check_onebased_indexing("input_target", y)
-   return y 
+   return y
 end
 
 # `CategoricalArrays` and `Table(Finite)` are one-based indexed arrays and tables.
@@ -348,14 +348,14 @@ get_target(::Union{KNNClassifier, MultitargetKNNClassifier}, y) = y
 struct KNNResult{T, U, W}
     tree::T
     target::U
-    sample_weights::W    
+    sample_weights::W
 end
 
 const KNN = Union{
     KNNClassifier, KNNRegressor, MultitargetKNNRegressor, MultitargetKNNClassifier
 }
 
-function MMI.fit(m::KNN, verbosity::Int, X, y, w::Union{Nothing, Vec{<:Real}}=nothing) 
+function MMI.fit(m::KNN, verbosity::Int, X, y, w::Union{Nothing, Vec{<:Real}}=nothing)
     Xmatrix = transpose(MMI.matrix(X))
     target = get_target(m, y)
     if w !== nothing

test/models.jl

@@ -1,24 +1,23 @@
-
-@testset "KNNClassifier" begin 
+@testset "KNNClassifier" begin
     # create something rather silly: 3 massive clusters very separated
     rng = StableRNG(10)
     n, p = 50, 3
     x, w = make_x_and_w(n, p, rng=rng)
     w1 = rand(rng, n-5)
-    
+
     y1 = fill("A", n)
     y2 = fill("B", n)
     y3 = fill("C", n)
     y = categorical(vcat(y1, y2, y3))
-    
+
     # generate test data
     ntest =  5
     xtest = make_xtest(ntest, p, rng=rng)
     ytest1 = fill("A", ntest)
     ytest2 = fill("B", ntest)
     ytest3 = fill("C", ntest)
     ytest = categorical(vcat(ytest1, ytest2, ytest3))
-    
+
     # Test model fit
     knnc = KNNClassifier(weights=Inverse())
     f, _, _ = fit(knnc, 1, x, y)
@@ -27,7 +26,7 @@
     @test f2 isa KNNResult
     @test f2.sample_weights == w
     @test fitted_params(knnc, f) == (tree=f.tree,)
-    
+
     # Check predictions gotten from the model
     p = predict(knnc, f, xtest)
     p2 = predict(knnc, f2, xtest)
@@ -39,7 +38,7 @@
     @test accuracy(p2, ytest) == 1.0
 end
 
-@testset "MultitargetKNNClassifier" begin 
+@testset "MultitargetKNNClassifier" begin
     # create something rather silly: 3 massive clusters very separated
     rng = StableRNG(10)
     n, p = 50, 3
@@ -53,7 +52,7 @@ end
     y1 = categorical(vcat(y11, y21, y31))
     y2 = categorical(vcat(y12, y22, y32), ordered=true)
     y = (a=y1, b=y2)
-    
+
     # generate test data
     ntest =  5
     xtest = make_xtest(ntest, p, rng=rng)
@@ -66,14 +65,14 @@ end
     ytest1 = categorical(vcat(ytest11, ytest21, ytest31))
     ytest2 = categorical(vcat(ytest12, ytest22, ytest32), ordered=true)
     ytest = (a=ytest1, b=ytest2)
-    
-    # Create two models, the first has an `output_type` of `DictTable` while the second 
+
+    # Create two models, the first has an `output_type` of `DictTable` while the second
     # has an `output_type` of `ColumnTable`
     multi_knnc = MultitargetKNNClassifier(weights=Inverse())
     multi_knnc2 = MultitargetKNNClassifier(
         weights=Inverse(), output_type=ColumnTable
     )
-    
+
     # Test model fit
     f, _, _ = fit(multi_knnc, 1, x, y)
     f2, _ , _ = fit(multi_knnc, 1, x, y, w)
@@ -83,7 +82,7 @@ end
     @test f2.sample_weights == w
     @test f4.sample_weights == w
     @test fitted_params(multi_knnc, f) == (tree=f.tree,)
-    
+
     # Check predictions gotten from the model
     p = predict(multi_knnc, f, xtest)
     p2 = predict(multi_knnc, f2, xtest)
@@ -92,13 +91,13 @@ end
     p5 = predict_mode(multi_knnc, f, xtest)
     p6 = predict_mode(multi_knnc, f2, xtest)
     p7 = predict_mode(multi_knnc2, f3, xtest)
-    p8 = predict_mode(multi_knnc2, f4, xtest)   
+    p8 = predict_mode(multi_knnc2, f4, xtest)
     for col in [:a, :b]
         @test p[col][1] isa UnivariateFinite
         @test p2[col][1] isa UnivariateFinite
         @test p3[col][1] isa UnivariateFinite
         @test p4[col][1] isa UnivariateFinite
-        
+
         @test accuracy(p5[col], ytest[col]) == 1.0
         @test accuracy(p6[col], ytest[col]) == 1.0
         @test accuracy(p7[col], ytest[col]) == 1.0
@@ -145,20 +144,21 @@ end
     y2 = fill( 2.0, n)
     y3 = fill(-2.0, n)
     y = vcat(y1, y2, y3)
-    
+
     # Test model fit
     knnr = KNNRegressor(weights=Inverse())
     f, _, _ = fit(knnr, 1, x, y)
     f2, _, _ = fit(knnr, 1, x, y, w)
     @test f2 isa KNNResult
     @test fitted_params(knnr, f) == (tree=f.tree,)
-    
+
     # Create test data
     ntest =  5
     xtest = make_xtest(ntest, p, rng=rng)
-    
+
     # Check predictions gotten from the model
     p = predict(knnr, f, xtest)
+    @test p isa AbstractVector
     p2 = predict(knnr, f2, xtest)
     @test all(p[1:ntest] .≈ 0.0)
     @test all(p[ntest+1:2*ntest] .≈ 2.0)
@@ -172,19 +172,19 @@ end
     x, w = make_x_and_w(n, p, rng=rng)
     ymat = vcat(fill( 0.0, n, 2), fill(2.0, n, 2), fill(-2.0, n, 2))
     Y = table(ymat; names = [:a, :b])
-    
+
     # Test model fit
     multi_knnr = MultitargetKNNRegressor(weights=Inverse())
     f, _ , _ = fit(multi_knnr, 1, x, Y)
     f2, _, _ = fit(multi_knnr, 1, x, Y, w)
     @test fitted_params(multi_knnr, f) == (tree=f.tree,)
     @test f2 isa KNNResult
     @test f2.sample_weights == w
-    
+
     # Create test data
     ntest = 5
     xtest = make_xtest(ntest, p, rng=rng)
-    
+
     # Check predictions gotten from the model
     pr = predict(multi_knnr, f, xtest)
     for col in [:a, :b]