Merge pull request #69 from bensadeghi/param_names

Param names

Author: bensadeghi

README.md

@@ -93,9 +93,9 @@ accuracy = nfoldCV_tree(labels, features, 0.9, 3)
 # min_samples_leaf: the minimum number of samples each leaf needs to have (default: 1)
 # min_samples_split: the minimum number of samples in needed for a split (default: 2)
 # min_purity_increase: minimum purity needed for a split (default: 0.0)
-# nsubfeatures: number of features to select at random (default: 0, keep all)
-nsubfeatures=0; maxdepth=-1; min_samples_leaf=1; min_samples_split=2; min_purity_increase=0.0;
-model = build_tree(labels, features, nsubfeatures, maxdepth, min_samples_leaf, min_samples_split, min_purity_increase)
+# n_subfeatures: number of features to select at random (default: 0, keep all)
+n_subfeatures=0; max_depth=-1; min_samples_leaf=1; min_samples_split=2; min_purity_increase=0.0;
+model = build_tree(labels, features, n_subfeatures, max_depth, min_samples_leaf, min_samples_split, min_purity_increase)
 
 ```
 Random Forest Classifier
@@ -112,12 +112,12 @@ apply_forest_proba(model, [5.9,3.0,5.1,1.9], ["setosa", "versicolor", "virginica
 accuracy = nfoldCV_forest(labels, features, 2, 10, 3, 0.5)
 
 # set of classification build_forest() parameters and respective default values
-# nsubfeatures: number of features to consider at random per split (default: 0, keep all)
-# ntrees: number of trees to train (default: 10)
-# partialsampling: fraction of samples to train each tree on (default: 0.7)
+# n_subfeatures: number of features to consider at random per split (default: 0, keep all)
+# n_trees: number of trees to train (default: 10)
+# partial_sampling: fraction of samples to train each tree on (default: 0.7)
 # max_depth: maximum depth of the decision trees (default: no maximum)
-nsubfeatures=0; ntrees=10; partialsampling=0.7; maxdepth=-1;
-model = build_forest(labels, features, nsubfeatures, ntrees, partialsampling, maxdepth)
+n_subfeatures=0; n_trees=10; partial_sampling=0.7; max_depth=-1;
+model = build_forest(labels, features, n_subfeatures, n_trees, partial_sampling, max_depth)
 ```
 Adaptive-Boosted Decision Stumps Classifier
 ```julia
@@ -153,9 +153,9 @@ r2 = nfoldCV_tree(labels, features, 3, 5)
 # min_samples_leaf: the minimum number of samples each leaf needs to have (default: 5)
 # min_samples_split: the minimum number of samples in needed for a split (default: 2)
 # min_purity_increase: minimum purity needed for a split (default: 0.0)
-# nsubfeatures: number of features to select at random (default: 0, keep all)
-min_samples_leaf = 5; nsubfeatures = 0; max_depth = -1; min_samples_split = 2; min_purity_increase = 0.0;
-model = build_tree(labels, features, min_samples_leaf, nsubfeatures, max_depth, min_samples_split, min_purity_increase)
+# n_subfeatures: number of features to select at random (default: 0, keep all)
+min_samples_leaf = 5; n_subfeatures = 0; max_depth = -1; min_samples_split = 2; min_purity_increase = 0.0;
+model = build_tree(labels, features, min_samples_leaf, n_subfeatures, max_depth, min_samples_split, min_purity_increase)
 
 ```
 Regression Random Forest
@@ -172,11 +172,11 @@ apply_forest(model, [-0.9,3.0,5.1,1.9,0.0])
 r2 = nfoldCV_forest(labels, features, 2, 10, 3, 5, 0.7)
 
 # set of regression build_forest() parameters and respective default values
-# nsubfeatures: number of features to consider at random per split (default: 0, keep all)
-# ntrees: number of trees to train (default: 10)
-# partialsampling: fraction of samples to train each tree on (default: 0.7)
+# n_subfeatures: number of features to consider at random per split (default: 0, keep all)
+# n_trees: number of trees to train (default: 10)
+# partial_sampling: fraction of samples to train each tree on (default: 0.7)
 # max_depth: maximum depth of the decision trees (default: no maximum)
 # min_samples_leaf: the minimum number of samples each leaf needs to have (default: 5)
-nsubfeatures=0; ntrees=10; min_samples_leaf=5; partialsampling=0.7; max_depth=-1;
-model = build_forest(labels, features, nsubfeatures, ntrees, min_samples_leaf, partialsampling, max_depth)
+n_subfeatures=0; n_trees=10; min_samples_leaf=5; partial_sampling=0.7; max_depth=-1;
+model = build_forest(labels, features, n_subfeatures, n_trees, min_samples_leaf, partial_sampling, max_depth)
 ```

src/classification/main.jl

@@ -70,24 +70,24 @@ function build_stump(labels::Vector, features::Matrix, weights=[0];
                 Leaf(majority_vote(r_labels), r_labels))
 end
 
-function build_tree(labels::Vector, features::Matrix, nsubfeatures=0, maxdepth=-1,
+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
-    if maxdepth < -1
-        error("Unexpected value for maxdepth: $(maxdepth) (expected: maxdepth >= 0, or maxdepth = -1 for infinite depth)")
+    if max_depth < -1
+        error("Unexpected value for max_depth: $(max_depth) (expected: max_depth >= 0, or max_depth = -1 for infinite depth)")
     end
-    if maxdepth == -1
-        maxdepth = typemax(Int64)
+    if max_depth == -1
+        max_depth = typemax(Int64)
     end
-    if nsubfeatures == 0
-        nsubfeatures = size(features, 2)
+    if n_subfeatures == 0
+        n_subfeatures = size(features, 2)
     end
     min_samples_leaf = Int64(min_samples_leaf)
     min_samples_split = Int64(min_samples_split)
     min_purity_increase = Float64(min_purity_increase)
     t = treeclassifier.fit(
-        features, labels, nsubfeatures, maxdepth,
+        features, labels, n_subfeatures, max_depth,
         min_samples_leaf, min_samples_split, min_purity_increase, 
         rng=rng)
 
@@ -191,23 +191,23 @@ 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, nsubfeatures=0, ntrees=10, partialsampling=0.7, maxdepth=-1; rng=Base.GLOBAL_RNG)
+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
-    partialsampling = partialsampling > 1.0 ? 1.0 : partialsampling
+    partial_sampling = partial_sampling > 1.0 ? 1.0 : partial_sampling
     Nlabels = length(labels)
-    Nsamples = _int(partialsampling * Nlabels)
-    forest = @parallel (vcat) for i in 1:ntrees
+    Nsamples = _int(partial_sampling * Nlabels)
+    forest = @parallel (vcat) for i in 1:n_trees
         inds = rand(rng, 1:Nlabels, Nsamples)
-        build_tree(labels[inds], features[inds,:], nsubfeatures, maxdepth;
+        build_tree(labels[inds], features[inds,:], n_subfeatures, max_depth;
                    rng=rng)
     end
     return Ensemble([forest;])
 end
 
 function apply_forest(forest::Ensemble, features::Vector)
-    ntrees = length(forest)
-    votes = Array{Any}(ntrees)
-    for i in 1:ntrees
+    n_trees = length(forest)
+    votes = Array{Any}(n_trees)
+    for i in 1:n_trees
         votes[i] = apply_tree(forest.trees[i], features)
     end
     if typeof(votes[1]) <: Float64
@@ -247,12 +247,12 @@ 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, niterations::Integer; rng=Base.GLOBAL_RNG)
+function build_adaboost_stumps(labels::Vector, features::Matrix, n_iterations::Integer; rng=Base.GLOBAL_RNG)
     N = length(labels)
     weights = ones(N) / N
     stumps = Node[]
     coeffs = Float64[]
-    for i in 1:niterations
+    for i in 1:n_iterations
         new_stump = build_stump(labels, features, weights; rng=rng)
         predictions = apply_tree(new_stump, features)
         err = _weighted_error(labels, predictions, weights)

src/measures.jl

@@ -86,11 +86,11 @@ function _nfoldCV(classifier::Symbol, labels, features, args...)
     if classifier == :tree
         pruning_purity = args[1]
     elseif classifier == :forest
-        nsubfeatures = args[1]
-        ntrees = args[2]
-        partialsampling = args[3]
+        n_subfeatures = args[1]
+        n_trees = args[2]
+        partial_sampling = args[3]
     elseif classifier == :stumps
-        niterations = args[1]
+        n_iterations = args[1]
     end
     N = length(labels)
     ntest = _int(floor(N / nfolds))
@@ -111,10 +111,10 @@ function _nfoldCV(classifier::Symbol, labels, features, args...)
             end
             predictions = apply_tree(model, test_features)
         elseif classifier == :forest
-            model = build_forest(train_labels, train_features, nsubfeatures, ntrees, partialsampling)
+            model = build_forest(train_labels, train_features, n_subfeatures, n_trees, partial_sampling)
             predictions = apply_forest(model, test_features)
         elseif classifier == :stumps
-            model, coeffs = build_adaboost_stumps(train_labels, train_features, niterations)
+            model, coeffs = build_adaboost_stumps(train_labels, train_features, n_iterations)
             predictions = apply_adaboost_stumps(model, coeffs, test_features)
         end
         cm = confusion_matrix(test_labels, predictions)
@@ -127,8 +127,8 @@ function _nfoldCV(classifier::Symbol, labels, features, args...)
 end
 
 nfoldCV_tree(labels::Vector, features::Matrix, pruning_purity::Real, nfolds::Integer)                                           = _nfoldCV(:tree, labels, features, pruning_purity, nfolds)
-nfoldCV_forest(labels::Vector, features::Matrix, nsubfeatures::Integer, ntrees::Integer, nfolds::Integer, partialsampling=0.7)  = _nfoldCV(:forest, labels, features, nsubfeatures, ntrees, partialsampling, nfolds)
-nfoldCV_stumps(labels::Vector, features::Matrix, niterations::Integer, nfolds::Integer)                                         = _nfoldCV(:stumps, labels, features, niterations, nfolds)
+nfoldCV_forest(labels::Vector, features::Matrix, n_subfeatures::Integer, n_trees::Integer, nfolds::Integer, partial_sampling=0.7)  = _nfoldCV(:forest, labels, features, n_subfeatures, n_trees, partial_sampling, nfolds)
+nfoldCV_stumps(labels::Vector, features::Matrix, n_iterations::Integer, nfolds::Integer)                                         = _nfoldCV(:stumps, labels, features, n_iterations, nfolds)
 
 ### Regression ###
 
@@ -152,10 +152,10 @@ function _nfoldCV{T<:Float64}(regressor::Symbol, labels::Vector{T}, features::Ma
     if regressor == :tree
         maxlabels = args[1]
     elseif regressor == :forest
-        nsubfeatures = args[1]
-        ntrees = args[2]
+        n_subfeatures = args[1]
+        n_trees = args[2]
         maxlabels = args[3]
-        partialsampling = args[4]
+        partial_sampling = args[4]
     end
     N = length(labels)
     ntest = _int(floor(N / nfolds))
@@ -173,7 +173,7 @@ function _nfoldCV{T<:Float64}(regressor::Symbol, labels::Vector{T}, features::Ma
             model = build_tree(train_labels, train_features, maxlabels, 0)
             predictions = apply_tree(model, test_features)
         elseif regressor == :forest
-            model = build_forest(train_labels, train_features, nsubfeatures, ntrees, maxlabels, partialsampling)
+            model = build_forest(train_labels, train_features, n_subfeatures, n_trees, maxlabels, partial_sampling)
             predictions = apply_forest(model, test_features)
         end
         err = mean_squared_error(test_labels, predictions)
@@ -190,6 +190,6 @@ function _nfoldCV{T<:Float64}(regressor::Symbol, labels::Vector{T}, features::Ma
 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, nsubfeatures::Integer, ntrees::Integer, nfolds::Integer, maxlabels::Integer=5, partialsampling=0.7)  = _nfoldCV(:forest, labels, features, nsubfeatures, ntrees, maxlabels, partialsampling, 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)
 
 

src/regression/main.jl

@@ -9,24 +9,24 @@ function build_stump{T<:Float64}(labels::Vector{T}, features::Matrix; rng=Base.G
 end
 
 function build_tree{T<:Float64}(
-        labels::Vector{T}, features::Matrix, min_samples_leaf=5, nsubfeatures=0,
+        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
     if max_depth < -1
-        error("Unexpected value for maxdepth: $(maxdepth) (expected: max_depth >= 0, or max_depth = -1 for infinite depth)")
+        error("Unexpected value for max_depth: $(max_depth) (expected: max_depth >= 0, or max_depth = -1 for infinite depth)")
     end
     if max_depth == -1
         max_depth = typemax(Int64)
     end
-    if nsubfeatures == 0
-        nsubfeatures = size(features, 2)
+    if n_subfeatures == 0
+        n_subfeatures = size(features, 2)
     end
     min_samples_leaf = Int64(min_samples_leaf)
     min_samples_split = Int64(min_samples_split)
     min_purity_increase = Float64(min_purity_increase)
     t = treeregressor.fit(
-        features, labels, nsubfeatures, max_depth,
+        features, labels, n_subfeatures, max_depth,
         min_samples_leaf, min_samples_split, min_purity_increase, 
         rng=rng)
 
@@ -42,14 +42,14 @@ function build_tree{T<:Float64}(
     return _convert(t)
 end
 
-function build_forest{T<:Float64}(labels::Vector{T}, features::Matrix, nsubfeatures=0, ntrees=10, min_samples_leaf=5, partialsampling=0.7, max_depth=-1; rng=Base.GLOBAL_RNG)
+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
-    partialsampling = partialsampling > 1.0 ? 1.0 : partialsampling
+    partial_sampling = partial_sampling > 1.0 ? 1.0 : partial_sampling
     Nlabels = length(labels)
-    Nsamples = _int(partialsampling * Nlabels)
-    forest = @parallel (vcat) for i in 1:ntrees
+    Nsamples = _int(partial_sampling * Nlabels)
+    forest = @parallel (vcat) for i in 1:n_trees
         inds = rand(rng, 1:Nlabels, Nsamples)
-        build_tree(labels[inds], features[inds,:], min_samples_leaf, nsubfeatures, max_depth; rng=rng)
+        build_tree(labels[inds], features[inds,:], min_samples_leaf, n_subfeatures, max_depth; rng=rng)
     end
     return Ensemble([forest;])
 end