Merge pull request #71 from Eight1911/julia-0.7

resolve #66  , fix Julia 0.7 deprecation warnings

Author: bensadeghi

.DS_Store

@@ -0,0 +1,3 @@
+
+
+makefile

.gitignore

@@ -2,13 +2,12 @@ language: julia
 os:
   - linux
 julia:
-  - 0.6
   - nightly
 notifications:
   email: false
 sudo: false
 script:
   - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
-  - julia -e 'Pkg.clone(pwd()); Pkg.build("DecisionTree"); Pkg.test("DecisionTree"; coverage=true)'
+  - julia -e 'import Pkg; Pkg.clone(pwd()); Pkg.build("DecisionTree"); Pkg.test("DecisionTree"; coverage=true)'
 after_success:
-  - julia -e 'cd(Pkg.dir("DecisionTree")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'
+  - julia -e 'import Pkg; cd(Pkg.dir("DecisionTree")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'

.travis.yml

@@ -71,7 +71,7 @@ depth(leaf::Leaf) = 0
 depth(tree::Node) = 1 + max(depth(tree.left), depth(tree.right))
 
 function print_tree(leaf::Leaf, depth=-1, indent=0)
-    matches = find(leaf.values .== leaf.majority)
+    matches = findall(leaf.values .== leaf.majority)
     ratio = string(length(matches)) * "/" * string(length(leaf.values))
     println("$(leaf.majority) : $(ratio)")
 end

src/DecisionTree.jl

@@ -1,9 +1,12 @@
 # Utilities
 
+
 include("tree.jl")
+import Distributed
+import Random
 
 # Returns a dict ("Label1" => 1, "Label2" => 2, "Label3" => 3, ...)
-label_index(labels) = Dict([Pair(v => k) for (k, v) in enumerate(labels)])
+label_index(labels) = Dict(v => k for (k, v) in enumerate(labels))
 
 ## Helper function. Counts the votes.
 ## Returns a vector of probabilities (eg. [0.2, 0.6, 0.2]) which is in the same
@@ -26,7 +29,7 @@ end
 function stack_function_results(row_fun::Function, X::Matrix)
     N = size(X, 1)
     N_cols = length(row_fun(X[1, :])) # gets the number of columns
-    out = Array{Float64}(N, N_cols)
+    out = Array{Float64}(undef, N, N_cols)
     for i in 1:N
         out[i, :] = row_fun(X[i, :])
     end
@@ -53,7 +56,7 @@ function _split_neg_z1_loss(labels::Vector, features::Matrix, weights::Vector)
 end
 
 function build_stump(labels::Vector, features::Matrix, weights=[0];
-                     rng=Base.GLOBAL_RNG)
+                     rng=Random.GLOBAL_RNG)
     if weights == [0]
         return build_tree(labels, features, 0, 1)
     end
@@ -72,8 +75,8 @@ end
 
 function build_tree(labels::Vector, features::Matrix, n_subfeatures=0, max_depth=-1,
                     min_samples_leaf=1, min_samples_split=2, min_purity_increase=0.0; 
-                    rng=Base.GLOBAL_RNG)
-    rng = mk_rng(rng)::AbstractRNG
+                    rng=Random.GLOBAL_RNG)
+    rng = mk_rng(rng)::Random.AbstractRNG
     if max_depth < -1
         error("Unexpected value for max_depth: $(max_depth) (expected: max_depth >= 0, or max_depth = -1 for infinite depth)")
     end
@@ -121,7 +124,7 @@ function prune_tree(tree::LeafOrNode, purity_thresh=1.0)
         elseif N == 2    ## a stump
             all_labels = [tree.left.values; tree.right.values]
             majority = majority_vote(all_labels)
-            matches = find(all_labels .== majority)
+            matches = findall(all_labels .== majority)
             purity = length(matches) / length(all_labels)
             if purity >= purity_thresh
                 return Leaf(majority, all_labels)
@@ -156,7 +159,7 @@ end
 
 function apply_tree(tree::LeafOrNode, features::Matrix)
     N = size(features,1)
-    predictions = Array{Any}(N)
+    predictions = Array{Any}(undef, N)
     for i in 1:N
         predictions[i] = apply_tree(tree, features[i, :])
     end
@@ -191,12 +194,13 @@ end
 apply_tree_proba(tree::LeafOrNode, features::Matrix, labels) =
     stack_function_results(row->apply_tree_proba(tree, row, labels), features)
 
-function build_forest(labels::Vector, features::Matrix, n_subfeatures=0, n_trees=10, partial_sampling=0.7, max_depth=-1; rng=Base.GLOBAL_RNG)
-    rng = mk_rng(rng)::AbstractRNG
+function build_forest(labels::Vector, features::Matrix, n_subfeatures=0, n_trees=10, partial_sampling=0.7, max_depth=-1; rng=Random.GLOBAL_RNG)
+    rng = mk_rng(rng)::Random.AbstractRNG
     partial_sampling = partial_sampling > 1.0 ? 1.0 : partial_sampling
     Nlabels = length(labels)
     Nsamples = _int(partial_sampling * Nlabels)
-    forest = @parallel (vcat) for i in 1:n_trees
+
+    forest = @Distributed.distributed (vcat) for i in 1:n_trees
         inds = rand(rng, 1:Nlabels, Nsamples)
         build_tree(labels[inds], features[inds,:], n_subfeatures, max_depth;
                    rng=rng)
@@ -206,7 +210,7 @@ end
 
 function apply_forest(forest::Ensemble, features::Vector)
     n_trees = length(forest)
-    votes = Array{Any}(n_trees)
+    votes = Array{Any}(undef, n_trees)
     for i in 1:n_trees
         votes[i] = apply_tree(forest.trees[i], features)
     end
@@ -219,7 +223,7 @@ end
 
 function apply_forest(forest::Ensemble, features::Matrix)
     N = size(features,1)
-    predictions = Array{Any}(N)
+    predictions = Array{Any}(undef, N)
     for i in 1:N
         predictions[i] = apply_forest(forest, features[i, :])
     end
@@ -247,7 +251,7 @@ apply_forest_proba(forest::Ensemble, features::Matrix, labels) =
     stack_function_results(row->apply_forest_proba(forest, row, labels),
                            features)
 
-function build_adaboost_stumps(labels::Vector, features::Matrix, n_iterations::Integer; rng=Base.GLOBAL_RNG)
+function build_adaboost_stumps(labels::Vector, features::Matrix, n_iterations::Integer; rng=Random.GLOBAL_RNG)
     N = length(labels)
     weights = ones(N) / N
     stumps = Node[]
@@ -290,7 +294,7 @@ end
 
 function apply_adaboost_stumps(stumps::Ensemble, coeffs::Vector{Float64}, features::Matrix)
     N = size(features,1)
-    predictions = Array{Any}(N)
+    predictions = Array{Any}(undef, N)
     for i in 1:N
         predictions[i] = apply_adaboost_stumps(stumps, coeffs, features[i,:])
     end

src/classification/main.jl

@@ -6,6 +6,7 @@
 
 module treeclassifier
     include("../util.jl")
+    import Random
 
     export fit
 
@@ -57,7 +58,7 @@ module treeclassifier
                      ncr                 :: Array{Int64}, # ncr maintains the counts of labels on the right
                      Xf                  :: Array{T},
                      Yf                  :: Array{Int64},
-                     rng                 :: AbstractRNG) where T <: Any
+                     rng                 :: Random.AbstractRNG) where T <: Any
         region = node.region
         n_samples = length(region)
         r_start = region.start - 1
@@ -69,7 +70,7 @@ module treeclassifier
             @inbounds nc[Y[indX[i]]] += 1
         end
 
-        node.label = indmax(nc)
+        node.label = argmax(nc)
 
         if (min_samples_leaf * 2  >  n_samples
          || min_samples_split     >  n_samples
@@ -96,7 +97,6 @@ module treeclassifier
         # only sample n_features used features
         # is a hypergeometric random variable
         total_features = size(X, 2)
-
         # this is the total number of features that we expect to not
         # be one of the known constant features. since we know exactly
         # what the non constant features are, we can sample at 'non_constants_used'
@@ -127,6 +127,7 @@ module treeclassifier
             nl, nr = 0, n_samples
             lo, hi = 0, 0
             is_constant = true
+            last_f = Xf[1]
             while hi < n_samples
                 lo = hi + 1
                 curr_f = Xf[lo]
@@ -279,7 +280,7 @@ module treeclassifier
             label_dict[label_list[i]] = i
         end
 
-        _Y = Array{Int64}(length(Y))
+        _Y = Array{Int64}(undef, length(Y))
         @inbounds for i in 1:length(Y)
             _Y[i] = label_dict[Y[i]]
         end
@@ -294,7 +295,7 @@ module treeclassifier
                  min_samples_leaf    :: Int64,
                  min_samples_split   :: Int64,
                  min_purity_increase :: Float64;
-                 rng=Base.GLOBAL_RNG :: AbstractRNG) where T <: Any
+                 rng=Random.GLOBAL_RNG :: Random.AbstractRNG) where T <: Any
         n_samples, n_features = size(X)
         label_list, _Y = assign(Y)
         n_classes = Int64(length(label_list))
@@ -312,11 +313,11 @@ module treeclassifier
         end
         stack = NodeMeta[ tree.root ]
 
-        nc  = Array{Int64}(n_classes)
-        ncl = Array{Int64}(n_classes)
-        ncr = Array{Int64}(n_classes)
-        Xf  = Array{T}(n_samples)
-        Yf  = Array{Int64}(n_samples)
+        nc  = Array{Int64}(undef, n_classes)
+        ncl = Array{Int64}(undef, n_classes)
+        ncr = Array{Int64}(undef, n_classes)
+        Xf  = Array{T}(undef, n_samples)
+        Yf  = Array{Int64}(undef, n_samples)
         @inbounds while length(stack) > 0
             node = pop!(stack)
             _split!(

src/classification/tree.jl

@@ -1,3 +1,6 @@
+using LinearAlgebra
+using Random
+
 struct ConfusionMatrix
     classes::Vector
     matrix::Matrix{Int}
@@ -16,24 +19,24 @@ function show(io::IO, cm::ConfusionMatrix)
     show(io, cm.kappa)
 end
 
-function _hist_add!{T}(counts::Dict{T,Int}, labels::Vector{T}, region::UnitRange{Int})
+function _hist_add!(counts::Dict{T, Int}, labels::Vector{T}, region::UnitRange{Int}) where T
     for i in region
         lbl = labels[i]
         counts[lbl] = get(counts, lbl, 0) + 1
     end
     return counts
 end
 
-_hist{T}(labels::Vector{T}, region::UnitRange{Int} = 1:endof(labels)) = 
+_hist(labels::Vector{T}, region::UnitRange{Int} = 1:lastindex(labels)) where T = 
     _hist_add!(Dict{T,Int}(), labels, region)
 
-function _neg_z1_loss{T<:Real}(labels::Vector, weights::Vector{T})
+function _neg_z1_loss(labels::Vector, weights::Vector{T}) where T <: Real
     missmatches = labels .!= majority_vote(labels)
     loss = sum(weights[missmatches])
     return -loss
 end
 
-function _weighted_error{T<:Real}(actual::Vector, predicted::Vector, weights::Vector{T})
+function _weighted_error(actual::Vector, predicted::Vector, weights::Vector{T}) where T <: Real
     mismatches = actual .!= predicted
     err = sum(weights[mismatches]) / sum(weights)
     return err
@@ -65,15 +68,15 @@ function confusion_matrix(actual::Vector, predicted::Vector)
     classes = sort(unique([actual; predicted]))
     N = length(classes)
     for i in 1:N
-        _actual[actual .== classes[i]] = i
-        _predicted[predicted .== classes[i]] = i
+        _actual[actual .== classes[i]] .= i
+        _predicted[predicted .== classes[i]] .= i
     end
     CM = zeros(Int,N,N)
     for i in zip(_actual, _predicted)
         CM[i[1],i[2]] += 1
     end
-    accuracy = trace(CM) / sum(CM)
-    prob_chance = (sum(CM,1) * sum(CM,2))[1] / sum(CM)^2
+    accuracy = LinearAlgebra.tr(CM) / sum(CM)
+    prob_chance = (sum(CM,dims=1) * sum(CM,dims=2))[1] / sum(CM)^2
     kappa = (accuracy - prob_chance) / (1.0 - prob_chance)
     return ConfusionMatrix(classes, CM, accuracy, kappa)
 end
@@ -94,11 +97,11 @@ function _nfoldCV(classifier::Symbol, labels, features, args...)
     end
     N = length(labels)
     ntest = _int(floor(N / nfolds))
-    inds = randperm(N)
+    inds = Random.randperm(N)
     accuracy = zeros(nfolds)
     for i in 1:nfolds
         test_inds = falses(N)
-        test_inds[(i - 1) * ntest + 1 : i * ntest] = true
+        test_inds[(i - 1) * ntest + 1 : i * ntest] .= true
         train_inds = (!).(test_inds)
         test_features = features[inds[test_inds],:]
         test_labels = labels[inds[test_inds]]
@@ -144,7 +147,29 @@ function R2(actual, predicted)
     return 1.0 - ss_residual/ss_total
 end
 
-function _nfoldCV{T<:Float64}(regressor::Symbol, labels::Vector{T}, features::Matrix, args...)
+# Pearson's Correlation Coefficient
+function cor(x, y)
+    @assert(length(x) == length(y))
+    @assert(length(x) > 1)
+
+    n = length(x)
+
+    x_mean = sum(x) / n
+    y_mean = sum(y) / n
+
+    x_centered = x .- x_mean
+    y_centered = y .- y_mean
+
+    x_var = sum(x_centered .^ 2)
+    y_var = sum(y_centered .^ 2)
+
+    xy_cov = sum(x_centered .* y_centered)
+
+    return xy_cov / sqrt(x_var * y_var)
+
+end
+
+function _nfoldCV(regressor::Symbol, labels::Vector{T}, features::Matrix, args...) where T <: Float64
     nfolds = args[end]
     if nfolds < 2
         return nothing
@@ -159,11 +184,11 @@ function _nfoldCV{T<:Float64}(regressor::Symbol, labels::Vector{T}, features::Ma
     end
     N = length(labels)
     ntest = _int(floor(N / nfolds))
-    inds = randperm(N)
+    inds = Random.randperm(N)
     R2s = zeros(nfolds)
     for i in 1:nfolds
         test_inds = falses(N)
-        test_inds[(i - 1) * ntest + 1 : i * ntest] = true
+        test_inds[(i - 1) * ntest + 1 : i * ntest] .= true
         train_inds = (!).(test_inds)
         test_features = features[inds[test_inds],:]
         test_labels = labels[inds[test_inds]]
@@ -189,7 +214,10 @@ function _nfoldCV{T<:Float64}(regressor::Symbol, labels::Vector{T}, features::Ma
     return R2s
 end
 
-nfoldCV_tree{T<:Float64}(labels::Vector{T}, features::Matrix, nfolds::Integer, maxlabels::Integer=5)      = _nfoldCV(:tree, labels, features, maxlabels, nfolds)
-nfoldCV_forest{T<:Float64}(labels::Vector{T}, features::Matrix, n_subfeatures::Integer, n_trees::Integer, nfolds::Integer, maxlabels::Integer=5, partial_sampling=0.7)  = _nfoldCV(:forest, labels, features, n_subfeatures, n_trees, maxlabels, partial_sampling, nfolds)
+nfoldCV_tree(labels::Vector{T}, features::Matrix, nfolds::Integer, maxlabels::Integer = 5) where T <: Float64 =
+    _nfoldCV(:tree, labels, features, maxlabels, nfolds)
+
+nfoldCV_forest(labels::Vector{T}, features::Matrix, n_subfeatures::Integer, n_trees::Integer, nfolds::Integer, maxlabels::Integer = 5, partial_sampling = 0.7) where T <: Float64 = 
+    _nfoldCV(:forest, labels, features, n_subfeatures, n_trees, maxlabels, partial_sampling, nfolds)
 
 

src/measures.jl

@@ -1,18 +1,20 @@
 include("tree.jl")
+import Random
+import Distributed
 
 # Convenience functions - make a Random Number Generator object
-mk_rng(rng::AbstractRNG) = rng
-mk_rng(seed::Int) = MersenneTwister(seed)
+mk_rng(rng::Random.AbstractRNG) = rng
+mk_rng(seed::Int) = Random.MersenneTwister(seed)
 
-function build_stump{T<:Float64}(labels::Vector{T}, features::Matrix; rng=Base.GLOBAL_RNG)
+function build_stump(labels::Vector{T}, features::Matrix; rng = Random.GLOBAL_RNG) where T <: Float64
     return build_tree(labels, features, 1, 0, 1)
 end
 
-function build_tree{T<:Float64}(
-        labels::Vector{T}, features::Matrix, min_samples_leaf=5, n_subfeatures=0,
-        max_depth=-1, min_samples_split=2, min_purity_increase=0.0;
-        rng=Base.GLOBAL_RNG)
-    rng = mk_rng(rng)::AbstractRNG
+function build_tree(
+        labels::Vector{T}, features::Matrix, min_samples_leaf = 5,
+        n_subfeatures = 0, max_depth = -1, min_samples_split = 2,
+        min_purity_increase = 0.0; rng = Random.GLOBAL_RNG) where T <: Float64
+    rng = mk_rng(rng)::Random.AbstractRNG
     if max_depth < -1
         error("Unexpected value for max_depth: $(max_depth) (expected: max_depth >= 0, or max_depth = -1 for infinite depth)")
     end
@@ -42,12 +44,15 @@ function build_tree{T<:Float64}(
     return _convert(t)
 end
 
-function build_forest{T<:Float64}(labels::Vector{T}, features::Matrix, n_subfeatures=0, n_trees=10, min_samples_leaf=5, partial_sampling=0.7, max_depth=-1; rng=Base.GLOBAL_RNG)
-    rng = mk_rng(rng)::AbstractRNG
+function build_forest(
+        labels::Vector{T}, features::Matrix, n_subfeatures = 0, n_trees = 10,
+        min_samples_leaf = 5, partial_sampling = 0.7, max_depth = -1;
+        rng = Random.GLOBAL_RNG) where T <: Float64
+    rng = mk_rng(rng)::Random.AbstractRNG
     partial_sampling = partial_sampling > 1.0 ? 1.0 : partial_sampling
     Nlabels = length(labels)
     Nsamples = _int(partial_sampling * Nlabels)
-    forest = @parallel (vcat) for i in 1:n_trees
+    forest = @Distributed.distributed (vcat) for i in 1:n_trees
         inds = rand(rng, 1:Nlabels, Nsamples)
         build_tree(labels[inds], features[inds,:], min_samples_leaf, n_subfeatures, max_depth; rng=rng)
     end