Update code to Julia 0.6 and remove definitions that are no longer

needed.

Remove Compat dependency since it is no longer used

Author: andreasnoack

REQUIRE

@@ -1,3 +1,2 @@
 julia 0.5
 ScikitLearnBase 0.0.4
-Compat 0.18.0

src/DecisionTree.jl

@@ -2,8 +2,6 @@ __precompile__()
 
 module DecisionTree
 
-using Compat
-
 import Base: length, convert, promote_rule, show, start, next, done
 
 export Leaf, Node, Ensemble, print_tree, depth, build_stump, build_tree,
@@ -24,14 +22,7 @@ export DecisionTreeClassifier, DecisionTreeRegressor, RandomForestClassifier,
 #####################################
 ##### Compatilibity Corrections #####
 
-const Range1 = Range
 _int(x) = map(y->round(Integer, y), x)
-float(x) = map(Float64, x)
-
-_squeeze(m::Matrix, i::Int) = squeeze(m, i)
-_squeeze(v::Vector, i::Int) = v
-neg(arr) = map(!, arr)
-
 
 ###########################
 ########## Types ##########
@@ -50,7 +41,7 @@ immutable Node
     right::Union{Leaf,Node}
 end
 
-@compat const LeafOrNode = Union{Leaf,Node}
+const LeafOrNode = Union{Leaf,Node}
 
 immutable Ensemble
     trees::Vector{Node}

src/classification.jl

@@ -23,10 +23,10 @@ end
 # and returns a Matrix containing the resulting vectors, stacked vertically
 function stack_function_results(row_fun::Function, X::Matrix)
     N = size(X, 1)
-    N_cols = length(row_fun(_squeeze(X[1,:],1))) # gets the number of columns
+    N_cols = length(row_fun(X[1, :])) # gets the number of columns
     out = Array{Float64}(N, N_cols)
     for i in 1:N
-        out[i, :] = row_fun(_squeeze(X[i,:],1))
+        out[i, :] = row_fun(X[i, :])
     end
     return out
 end
@@ -94,7 +94,7 @@ function _split_neg_z1_loss(labels::Vector, features::Matrix, weights::Vector)
         domain_i = sort(unique(features[:,i]))
         for thresh in domain_i[2:end]
             cur_split = features[:,i] .< thresh
-            value = _neg_z1_loss(labels[cur_split], weights[cur_split]) + _neg_z1_loss(labels[neg(cur_split)], weights[neg(cur_split)])
+            value = _neg_z1_loss(labels[cur_split], weights[cur_split]) + _neg_z1_loss(labels[(!).(cur_split)], weights[(!).(cur_split)])
             if value > best_val
                 best_val = value
                 best = (i, thresh)
@@ -114,7 +114,7 @@ function build_stump(labels::Vector, features::Matrix, weights=[0];
     split = features[:,id] .< thresh
     return Node(id, thresh,
                 Leaf(majority_vote(labels[split]), labels[split]),
-                Leaf(majority_vote(labels[neg(split)]), labels[neg(split)]))
+                Leaf(majority_vote(labels[(!).(split)]), labels[(!).(split)]))
 end
 
 function build_tree(labels::Vector, features::Matrix, nsubfeatures=0, maxdepth=-1; rng=Base.GLOBAL_RNG)
@@ -131,7 +131,7 @@ function build_tree(labels::Vector, features::Matrix, nsubfeatures=0, maxdepth=-
     id, thresh = S
     split = features[:,id] .< thresh
     labels_left = labels[split]
-    labels_right = labels[neg(split)]
+    labels_right = labels[(!).(split)]
     pure_left = all(labels_left .== labels_left[1])
     pure_right = all(labels_right .== labels_right[1])
     if pure_right && pure_left
@@ -141,7 +141,7 @@ function build_tree(labels::Vector, features::Matrix, nsubfeatures=0, maxdepth=-
     elseif pure_left
         return Node(id, thresh,
                     Leaf(labels_left[1], labels_left),
-                    build_tree(labels_right,features[neg(split),:], nsubfeatures,
+                    build_tree(labels_right,features[(!).(split),:], nsubfeatures,
                                max(maxdepth-1, -1); rng=rng))
     elseif pure_right
         return Node(id, thresh,
@@ -152,7 +152,7 @@ function build_tree(labels::Vector, features::Matrix, nsubfeatures=0, maxdepth=-
         return Node(id, thresh,
                     build_tree(labels_left,features[split,:], nsubfeatures,
                                max(maxdepth-1, -1); rng=rng),
-                    build_tree(labels_right,features[neg(split),:], nsubfeatures,
+                    build_tree(labels_right,features[(!).(split),:], nsubfeatures,
                                max(maxdepth-1, -1); rng=rng))
     end
 end
@@ -202,10 +202,10 @@ function apply_tree(tree::LeafOrNode, features::Matrix)
     N = size(features,1)
     predictions = Array{Any}(N)
     for i in 1:N
-        predictions[i] = apply_tree(tree, _squeeze(features[i,:],1))
+        predictions[i] = apply_tree(tree, features[i, :])
     end
     if typeof(predictions[1]) <: Float64
-        return float(predictions)
+        return Float64.(predictions)
     else
         return predictions
     end
@@ -252,7 +252,7 @@ function apply_forest(forest::Ensemble, features::Vector)
     ntrees = length(forest)
     votes = Array{Any}(ntrees)
     for i in 1:ntrees
-        votes[i] = apply_tree(forest.trees[i],features)
+        votes[i] = apply_tree(forest.trees[i], features)
     end
     if typeof(votes[1]) <: Float64
         return mean(votes)
@@ -265,10 +265,10 @@ function apply_forest(forest::Ensemble, features::Matrix)
     N = size(features,1)
     predictions = Array{Any}(N)
     for i in 1:N
-        predictions[i] = apply_forest(forest, _squeeze(features[i,:],1))
+        predictions[i] = apply_forest(forest, features[i, :])
     end
     if typeof(predictions[1]) <: Float64
-        return float(predictions)
+        return Float64.(predictions)
     else
         return predictions
     end
@@ -302,7 +302,7 @@ function build_adaboost_stumps(labels::Vector, features::Matrix, niterations::In
         err = _weighted_error(labels, predictions, weights)
         new_coeff = 0.5 * log((1.0 + err) / (1.0 - err))
         matches = labels .== predictions
-        weights[neg(matches)] *= exp(new_coeff)
+        weights[(!).(matches)] *= exp(new_coeff)
         weights[matches] *= exp(-new_coeff)
         weights /= sum(weights)
         push!(coeffs, new_coeff)
@@ -336,7 +336,7 @@ function apply_adaboost_stumps(stumps::Ensemble, coeffs::Vector{Float64}, featur
     N = size(features,1)
     predictions = Array{Any}(N)
     for i in 1:N
-        predictions[i] = apply_adaboost_stumps(stumps, coeffs, _squeeze(features[i,:],1))
+        predictions[i] = apply_adaboost_stumps(stumps, coeffs, features[i,:])
     end
     return predictions
 end

src/measures.jl

@@ -16,23 +16,23 @@ function show(io::IO, cm::ConfusionMatrix)
     show(io, cm.kappa)
 end
 
-function _hist_add!{T}(counts::Dict{T,Int}, labels::Vector{T}, region::Range1{Int})
+function _hist_add!{T}(counts::Dict{T,Int}, labels::Vector{T}, region::UnitRange{Int})
     for i in region
         lbl = labels[i]
         counts[lbl] = get(counts, lbl, 0) + 1
     end
     return counts
 end
 
-function _hist_sub!{T}(counts::Dict{T,Int}, labels::Vector{T}, region::Range1{Int})
+function _hist_sub!{T}(counts::Dict{T,Int}, labels::Vector{T}, region::UnitRange{Int})
     for i in region
         lbl = labels[i]
         counts[lbl] -= 1
     end
     return counts
 end
 
-function _hist_shift!{T}(counts_from::Dict{T,Int}, counts_to::Dict{T,Int}, labels::Vector{T}, region::Range1{Int})
+function _hist_shift!{T}(counts_from::Dict{T,Int}, counts_to::Dict{T,Int}, labels::Vector{T}, region::UnitRange{Int})
     for i in region
         lbl = labels[i]
         counts_from[lbl] -= 1
@@ -41,7 +41,7 @@ function _hist_shift!{T}(counts_from::Dict{T,Int}, counts_to::Dict{T,Int}, label
     return nothing
 end
 
-_hist{T}(labels::Vector{T}, region::Range1{Int} = 1:endof(labels)) = 
+_hist{T}(labels::Vector{T}, region::UnitRange{Int} = 1:endof(labels)) = 
     _hist_add!(Dict{T,Int}(), labels, region)
 
 function _set_entropy{T}(counts::Dict{T,Int}, N::Int)
@@ -136,7 +136,7 @@ function _nfoldCV(classifier::Symbol, labels, features, args...)
     for i in 1:nfolds
         test_inds = falses(N)
         test_inds[(i - 1) * ntest + 1 : i * ntest] = true
-        train_inds = neg(test_inds)
+        train_inds = (!).(test_inds)
         test_features = features[inds[test_inds],:]
         test_labels = labels[inds[test_inds]]
         train_features = features[inds[train_inds],:]
@@ -201,7 +201,7 @@ function _nfoldCV{T<:Float64, U<:Real}(regressor::Symbol, labels::Vector{T}, fea
     for i in 1:nfolds
         test_inds = falses(N)
         test_inds[(i - 1) * ntest + 1 : i * ntest] = true
-        train_inds = neg(test_inds)
+        train_inds = (!).(test_inds)
         test_features = features[inds[test_inds],:]
         test_labels = labels[inds[test_inds]]
         train_features = features[inds[train_inds],:]

src/regression.jl

@@ -97,7 +97,7 @@ function build_stump{T<:Float64, U<:Real}(labels::Vector{T}, features::Matrix{U}
     split = features[:,id] .< thresh
     return Node(id, thresh,
                 Leaf(mean(labels[split]), labels[split]),
-                Leaf(mean(labels[neg(split)]), labels[neg(split)]))
+                Leaf(mean(labels[(!).(split)]), labels[(!).(split)]))
 end
 
 function build_tree{T<:Float64, U<:Real}(labels::Vector{T}, features::Matrix{U}, maxlabels=5, nsubfeatures=0, maxdepth=-1; rng=Base.GLOBAL_RNG)
@@ -115,7 +115,7 @@ function build_tree{T<:Float64, U<:Real}(labels::Vector{T}, features::Matrix{U},
     split = features[:,id] .< thresh
     return Node(id, thresh,
                 build_tree(labels[split], features[split,:], maxlabels, nsubfeatures, max(maxdepth-1, -1); rng=rng),
-                build_tree(labels[neg(split)], features[neg(split),:], maxlabels, nsubfeatures, max(maxdepth-1, -1); rng=rng))
+                build_tree(labels[(!).(split)], features[(!).(split),:], maxlabels, nsubfeatures, max(maxdepth-1, -1); rng=rng))
 end
 
 function build_forest{T<:Float64, U<:Real}(labels::Vector{T}, features::Matrix{U}, nsubfeatures::Integer, ntrees::Integer, maxlabels=5, partialsampling=0.7, maxdepth=-1; rng=Base.GLOBAL_RNG)

test/classification_hetero.jl

@@ -3,30 +3,30 @@
 using Base.Test
 using DecisionTree
 
-m, n = 10^2, 5;
+m, n = 10^2, 5
 
-tf = [trues(Int(m/2)) falses(Int(m/2))];
-inds = randperm(m);
-labels = string.(tf[inds]);
+tf = [trues(Int(m/2)) falses(Int(m/2))]
+inds = randperm(m)
+labels = string.(tf[inds])
 
-features = Array{Any}(m, n);
-features[:,:] = randn(m, n);
-features[:,2] = string.(tf[randperm(m)]);
-features[:,3] = round(Int, features[:,3]);
-features[:,4] = tf[inds];
+features = Array{Any}(m, n)
+features[:,:] = randn(m, n)
+features[:,2] = string.(tf[randperm(m)])
+features[:,3] = map(t -> round(Int, t), features[:,3]) # can just become round.(Int, features[:,3]) when Julia 0.5 support is dropped
+features[:,4] = tf[inds]
 
-model = build_tree(labels, features);
-preds = apply_tree(model, features);
-cm = confusion_matrix(labels, preds);
+model = build_tree(labels, features)
+preds = apply_tree(model, features)
+cm = confusion_matrix(labels, preds)
 @test cm.accuracy > 0.7
 
-model = build_forest(labels, features,2,3);
-preds = apply_forest(model, features);
-cm = confusion_matrix(labels, preds);
+model = build_forest(labels, features,2,3)
+preds = apply_forest(model, features)
+cm = confusion_matrix(labels, preds)
 @test cm.accuracy > 0.7
 
-model, coeffs = build_adaboost_stumps(labels, features, 7);
-preds = apply_adaboost_stumps(model, coeffs, features);
-cm = confusion_matrix(labels, preds);
+model, coeffs = build_adaboost_stumps(labels, features, 7)
+preds = apply_adaboost_stumps(model, coeffs, features)
+cm = confusion_matrix(labels, preds)
 @test cm.accuracy > 0.7