Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the cl-random-forest Reference Manual, version 0.1, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Dec 22 12:43:07 2020 GMT+0.
• Introduction | What cl-random-forest is all about | |
• Systems | The systems documentation | |
• Modules | The modules documentation | |
• Files | The files documentation | |
• Packages | The packages documentation | |
• Definitions | The symbols documentation | |
• Indexes | Concepts, functions, variables and data types |
* cl-random-forest [[http://quickdocs.org/cl-random-forest/][http://quickdocs.org/badge/cl-random-forest.svg]] [[https://github.com/masatoi/cl-random-forest/actions?query=workflow%3ACI][https://github.com/masatoi/cl-random-forest/workflows/CI/badge.svg]] Cl-random-forest is a implementation of Random Forest for multiclass classification and univariate regression written in Common Lisp. It also includes a implementation of Global Refinement of Random Forest (Ren, Cao, Wei and Sun. "Global Refinement of Random Forest" CVPR2015). This refinement makes faster and more accurate than standard Random Forest. ** Features and Limitations - Faster and more accurate than other major implementations such as scikit-learn (Python/Cython) or ranger (R/C++) | | scikit-learn | ranger | cl-random-forest | | MNIST | 96.95%, 41.72sec | 97.17%, 69.34sec | *98.29%*, *12.68sec* | | letter | 96.38%, 2.569sec | 96.42%, *1.828sec* | *97.32%*, 3.497sec | | covtype | 94.89%, 263.7sec | 83.95%, 139.0sec | *96.01%*, *103.9sec* | | usps | 93,47%, 3.583sec | 93.57%, 11.70sec | *94.96%*, *0.686sec* | - Supporting parallelization of training and prediction (tested on SBCL, CCL) - It also includes Global Pruning algorithm of Random Forest which can make the model extremely compact - Currently, multivariate regression is not implemented ** Installation In quicklisp’s local-projects directory, #+BEGIN_SRC git clone https://github.com/masatoi/cl-online-learning.git git clone https://github.com/masatoi/cl-random-forest.git #+END_SRC In Lisp, #+BEGIN_SRC lisp (ql:quickload :cl-random-forest) #+END_SRC When using Roswell, #+BEGIN_SRC ros install masatoi/cl-online-learning masatoi/cl-random-forest #+END_SRC ** Usage *** Classification **** Prepare training dataset A dataset consists of a target vector and a input data matrix. For classification, the target vector should be a fixnum simple-vector and the data matrix should be a 2-dimensional double-float array whose row corresponds one datum. Note that the target is a integer starting from 0. For example, the following dataset is valid for 4-class classification with 2-dimensional input. #+BEGIN_SRC lisp (defparameter *target* (make-array 11 :element-type 'fixnum :initial-contents '(0 0 1 1 2 2 2 3 3 3 3))) (defparameter *datamatrix* (make-array '(11 2) :element-type 'double-float :initial-contents '((-1.0d0 -2.0d0) (-2.0d0 -1.5d0) (1.0d0 -2.0d0) (3.0d0 -1.5d0) (-2.0d0 2.0d0) (-3.0d0 1.0d0) (-2.0d0 1.0d0) (3.0d0 2.0d0) (2.0d0 2.0d0) (1.0d0 2.0d0) (1.0d0 1.0d0)))) #+END_SRC [[./docs/img/clrf-example-simple.png]] **** Make Decision Tree To construct a decision tree, MAKE-DTREE function is available. This function receives the number of classes, the data matrix and the target vector and then returns a decision tree object. This function also receives optionally the max depth of the tree and the minimum number of samples in the region the tree divides and the number of trials of splits. #+BEGIN_SRC lisp (defparameter *n-class* 4) (defparameter *dtree* (make-dtree *n-class* *datamatrix* *target* :max-depth 5 :min-region-samples 1 :n-trial 10)) #+END_SRC Next, make a prediction from the constructed decision tree with PREDICT-DTREE function. For example, to predict the first datum in the data matrix with this decision tree, do as follows. #+BEGIN_SRC lisp (predict-dtree *dtree* *datamatrix* 0) ;; => 0 (correct class id) #+END_SRC To make predictions for the entire dataset and calculate the accuracy, use TEST-DTREE function. #+BEGIN_SRC lisp (test-dtree *dtree* *datamatrix* *target*) ;; Accuracy: 100.0%, Correct: 11, Total: 11 #+END_SRC **** Make Random Forest To construct a random forest, MAKE-FOREST function is available. In addition to the MAKE-DTREE function arguments, this function receives optionally the number of decision trees and the bagging ratio that is used for sampling from training data to construct each sub decision trees. #+BEGIN_SRC lisp (defparameter *forest* (make-forest *n-class* *datamatrix* *target* :n-tree 10 :bagging-ratio 1.0 :max-depth 5 :min-region-samples 1 :n-trial 10)) #+END_SRC Prediction and test of random forest are done in the almost same way as decision trees. PREDICT-FOREST function and TEST-FOREST function are available for each purpose. #+BEGIN_SRC lisp (predict-forest *forest* *datamatrix* 0) ;; => 0 (correct class id) (test-forest *forest* *datamatrix* *target*) ;; Accuracy: 100.0%, Correct: 11, Total: 11 #+END_SRC **** Global Refinement of Random Forest Cl-random-forest has a way to improve pre-trained random forest using global information between each decision trees. For this purpose, we make an another dataset from original dataset and pre-trained random forest. When an original datum input into the random forest, the datum enters into a region which corresponds one leaf node for each decision trees. The datum of the new dataset represents which position of leaf node the original datum entered for each decision tree. Then we train a linear classifier (AROW) using this new dataset and the original target. #+BEGIN_SRC lisp ;; Make refine learner (defparameter *forest-learner* (make-refine-learner *forest*)) ;; Make refine dataset (defparameter *forest-refine-dataset* (make-refine-dataset *forest* *datamatrix*)) ;; Train refine learner (train-refine-learner *forest-learner* *forest-refine-dataset* *target*) ;; Test refine learner (test-refine-learner *forest-learner* *forest-refine-dataset* *target*) #+END_SRC This TRAIN-REFINE-LEARNER function can be used to learn the dataset collectively, but it may be necessary to call this function several times until learning converges. TRAIN-REFINE-LEARNER-PROCESS function is used for training until converged. #+BEGIN_SRC lisp (train-refine-learner-process *forest-learner* *forest-refine-dataset* *target* *forest-refine-dev-dataset* *dev-target*) #+END_SRC **** Global Pruning of Random Forest ***** Pruning Global pruning is a method for compactization of the model size of the random forest using information of the global-refinement learner. A leaf node in a decision tree is no longer necessary when its corresponding element of the weight vector of the global-refinement learner has a small value norm. To prune a forest destructively, after training the global-refinement learner, run PRUNING! function. #+BEGIN_SRC lisp ;; Prune *forest* (pruning! *forest* *forest-learner* 0.1) #+END_SRC The third argument is pruning rate. In this case, 10% leaf nodes are deleted. ***** Re-learning After pruning, it is required to re-learn the global-refinement learner. #+BEGIN_SRC lisp ;; Re-learning of refine-learner (setf *forest-refine-dataset* (make-refine-dataset *forest* *datamatrix*)) (setf *forest-learner* (make-refine-learner *forest*)) (train-refine-learner *forest-learner* *forest-refine-dataset* *target*) (test-refine-learner *forest-learner* *forest-refine-dataset* *target*) #+END_SRC The following figure shows the accuracy for test dataset and the number of leaf nodes when repeating pruning and re-learning on the MNIST dataset. We can see that the performance hardly changes even if the number of leaf nodes decreases to about 1/10. [[./docs/img/clrf-mnist-pruning.png]] **** Parallelization The following several functions can be parallelized with [[https://lparallel.org/][lparallel]]. - MAKE-FOREST - MAKE-REGRESSION-FOREST - MAKE-REFINE-DATASET - TRAIN-REFINE-LEARNER To enable/disable parallelization, set lparallel's kernel object. For example, to enable parallelization with 4 threads, #+BEGIN_SRC lisp ;; Enable parallelization (setf lparallel:*kernel* (lparallel:make-kernel 4)) ;; Disable parallelization (setf lparallel:*kernel* nil) #+END_SRC *** Regression **** Prepare training dataset In case of classification, the target is a vector of integer values, whereas in regression is a vector of continuous values. #+BEGIN_SRC lisp (defparameter *n* 100) (defparameter *datamatrix* (let ((arr (make-array (list *n* 1) :element-type 'double-float))) (loop for i from 0 below *n* do (setf (aref arr i 0) (random-uniform (- pi) pi))) arr)) (defparameter *target* (let ((arr (make-array *n* :element-type 'double-float))) (loop for i from 0 below *n* do (setf (aref arr i) (+ (sin (aref *datamatrix* i 0)) (random-normal :sd 0.1d0)))) arr)) (defparameter *test* (let ((arr (make-array (list *n* 1) :element-type 'double-float))) (loop for i from 0 below *n* for x from (- pi) to pi by (/ (* 2 pi) *n*) do (setf (aref arr i 0) x)) arr)) (defparameter *test-target* (let ((arr (make-array *n* :element-type 'double-float))) (loop for i from 0 below *n* do (setf (aref arr i) (sin (aref *test* i 0)))) arr)) #+END_SRC **** Make Regression Tree #+BEGIN_SRC lisp ;; Make regression tree (defparameter *rtree* (make-rtree *datamatrix* *target* :max-depth 5 :min-region-samples 5 :n-trial 10)) ;; Testing (test-rtree *rtree* *test* *test-target*) ; RMSE: 0.09220732459820888d0 ;; Make a prediction for first data point of test dataset (predict-rtree *rtree* *test* 0) ; => -0.08374452528780077d0 #+END_SRC **** Make Random Forest for Regression #+BEGIN_SRC lisp ;; Make regression tree forest (defparameter *rforest* (make-regression-forest *datamatrix* *target* :n-tree 100 :bagging-ratio 0.6 :max-depth 5 :min-region-samples 5 :n-trial 10)) ;; Testing (test-regression-forest *rforest* *test* *test-target*) ; RMSE: 0.05006872795207973d0 ;; Make a prediction for first data point of test dataset (predict-regression-forest *rforest* *test* 0) ; => -0.16540771296145781d0 #+END_SRC [[./docs/img/clrf-regression.png]] ** Author Satoshi Imai (satoshi.imai@gmail.com) ** Licence This software is released under the MIT License, see LICENSE.txt.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
• The cl-random-forest system |
Satoshi Imai
MIT Licence
Random Forest and Global Refinement for Common Lisp
* cl-random-forest
[[http://quickdocs.org/cl-random-forest/][http://quickdocs.org/badge/cl-random-forest.svg]]
[[https://github.com/masatoi/cl-random-forest/actions?query=workflow%3ACI][https://github.com/masatoi/cl-random-forest/workflows/CI/badge.svg]]
Cl-random-forest is a implementation of Random Forest for multiclass classification and univariate regression written in Common Lisp. It also includes a implementation of Global Refinement of Random Forest (Ren, Cao, Wei and Sun. "Global Refinement of Random Forest" CVPR2015). This refinement makes faster and more accurate than standard Random Forest.
** Features and Limitations
- Faster and more accurate than other major implementations such as scikit-learn (Python/Cython) or ranger (R/C++)
| | scikit-learn | ranger | cl-random-forest |
| MNIST | 96.95%, 41.72sec | 97.17%, 69.34sec | *98.29%*, *12.68sec* |
| letter | 96.38%, 2.569sec | 96.42%, *1.828sec* | *97.32%*, 3.497sec |
| covtype | 94.89%, 263.7sec | 83.95%, 139.0sec | *96.01%*, *103.9sec* |
| usps | 93,47%, 3.583sec | 93.57%, 11.70sec | *94.96%*, *0.686sec* |
- Supporting parallelization of training and prediction (tested on SBCL, CCL)
- It also includes Global Pruning algorithm of Random Forest which can make the model extremely compact
- Currently, multivariate regression is not implemented
** Installation
In quicklisp’s local-projects directory,
#+BEGIN_SRC
git clone https://github.com/masatoi/cl-online-learning.git
git clone https://github.com/masatoi/cl-random-forest.git
#+END_SRC
In Lisp,
#+BEGIN_SRC lisp
(ql:quickload :cl-random-forest)
#+END_SRC
When using Roswell,
#+BEGIN_SRC
ros install masatoi/cl-online-learning masatoi/cl-random-forest
#+END_SRC
** Usage
*** Classification
**** Prepare training dataset
A dataset consists of a target vector and a input data matrix.
For classification, the target vector should be a fixnum simple-vector and the data matrix should be a 2-dimensional double-float array whose row corresponds one datum.
Note that the target is a integer starting from 0.
For example, the following dataset is valid for 4-class classification with 2-dimensional input.
#+BEGIN_SRC lisp
(defparameter *target*
(make-array 11 :element-type ’fixnum
:initial-contents ’(0 0 1 1 2 2 2 3 3 3 3)))
(defparameter *datamatrix*
(make-array ’(11 2)
:element-type ’double-float
:initial-contents ’((-1.0d0 -2.0d0)
(-2.0d0 -1.5d0)
(1.0d0 -2.0d0)
(3.0d0 -1.5d0)
(-2.0d0 2.0d0)
(-3.0d0 1.0d0)
(-2.0d0 1.0d0)
(3.0d0 2.0d0)
(2.0d0 2.0d0)
(1.0d0 2.0d0)
(1.0d0 1.0d0))))
#+END_SRC
[[./docs/img/clrf-example-simple.png]]
**** Make Decision Tree
To construct a decision tree, MAKE-DTREE function is available. This function receives the number of classes, the data matrix and the target vector and then returns a decision tree object. This function also receives optionally the max depth of the tree and the minimum number of samples in the region the tree divides and the number of trials of splits.
#+BEGIN_SRC lisp
(defparameter *n-class* 4)
(defparameter *dtree*
(make-dtree *n-class* *datamatrix* *target*
:max-depth 5 :min-region-samples 1 :n-trial 10))
#+END_SRC
Next, make a prediction from the constructed decision tree with PREDICT-DTREE function. For example, to predict the first datum in the data matrix with this decision tree, do as follows.
#+BEGIN_SRC lisp
(predict-dtree *dtree* *datamatrix* 0)
;; => 0 (correct class id)
#+END_SRC
To make predictions for the entire dataset and calculate the accuracy, use TEST-DTREE function.
#+BEGIN_SRC lisp
(test-dtree *dtree* *datamatrix* *target*)
;; Accuracy: 100.0%, Correct: 11, Total: 11
#+END_SRC
**** Make Random Forest
To construct a random forest, MAKE-FOREST function is available. In addition to the MAKE-DTREE function arguments, this function receives optionally the number of decision trees and the bagging ratio that is used for sampling from training data to construct each sub decision trees.
#+BEGIN_SRC lisp
(defparameter *forest*
(make-forest *n-class* *datamatrix* *target*
:n-tree 10 :bagging-ratio 1.0
:max-depth 5 :min-region-samples 1 :n-trial 10))
#+END_SRC
Prediction and test of random forest are done in the almost same way as decision trees. PREDICT-FOREST function and TEST-FOREST function are available for each purpose.
#+BEGIN_SRC lisp
(predict-forest *forest* *datamatrix* 0)
;; => 0 (correct class id)
(test-forest *forest* *datamatrix* *target*)
;; Accuracy: 100.0%, Correct: 11, Total: 11
#+END_SRC
**** Global Refinement of Random Forest
Cl-random-forest has a way to improve pre-trained random forest using global information between each decision trees.
For this purpose, we make an another dataset from original dataset and pre-trained random forest.
When an original datum input into the random forest, the datum enters into a region which corresponds one leaf node for each decision trees.
The datum of the new dataset represents which position of leaf node the original datum entered for each decision tree.
Then we train a linear classifier (AROW) using this new dataset and the original target.
#+BEGIN_SRC lisp
;; Make refine learner
(defparameter *forest-learner* (make-refine-learner *forest*))
;; Make refine dataset
(defparameter *forest-refine-dataset* (make-refine-dataset *forest* *datamatrix*))
;; Train refine learner
(train-refine-learner *forest-learner* *forest-refine-dataset* *target*)
;; Test refine learner
(test-refine-learner *forest-learner* *forest-refine-dataset* *target*)
#+END_SRC
This TRAIN-REFINE-LEARNER function can be used to learn the dataset collectively, but it may be necessary to call this function several times until learning converges. TRAIN-REFINE-LEARNER-PROCESS function is used for training until converged.
#+BEGIN_SRC lisp
(train-refine-learner-process *forest-learner* *forest-refine-dataset* *target*
*forest-refine-dev-dataset* *dev-target*)
#+END_SRC
**** Global Pruning of Random Forest
***** Pruning
Global pruning is a method for compactization of the model size of the random forest using information of the global-refinement learner. A leaf node in a decision tree is no longer necessary when its corresponding element of the weight vector of the global-refinement learner has a small value norm.
To prune a forest destructively, after training the global-refinement learner, run PRUNING! function.
#+BEGIN_SRC lisp
;; Prune *forest*
(pruning! *forest* *forest-learner* 0.1)
#+END_SRC
The third argument is pruning rate. In this case, 10% leaf nodes are deleted.
***** Re-learning
After pruning, it is required to re-learn the global-refinement learner.
#+BEGIN_SRC lisp
;; Re-learning of refine-learner
(setf *forest-refine-dataset* (make-refine-dataset *forest* *datamatrix*))
(setf *forest-learner* (make-refine-learner *forest*))
(train-refine-learner *forest-learner* *forest-refine-dataset* *target*)
(test-refine-learner *forest-learner* *forest-refine-dataset* *target*)
#+END_SRC
The following figure shows the accuracy for test dataset and the number of leaf nodes when repeating pruning and re-learning on the MNIST dataset. We can see that the performance hardly changes even if the number of leaf nodes decreases to about 1/10.
[[./docs/img/clrf-mnist-pruning.png]]
**** Parallelization
The following several functions can be parallelized with [[https://lparallel.org/][lparallel]].
- MAKE-FOREST
- MAKE-REGRESSION-FOREST
- MAKE-REFINE-DATASET
- TRAIN-REFINE-LEARNER
To enable/disable parallelization, set lparallel’s kernel object. For example, to enable parallelization with 4 threads,
#+BEGIN_SRC lisp
;; Enable parallelization
(setf lparallel:*kernel* (lparallel:make-kernel 4))
;; Disable parallelization
(setf lparallel:*kernel* nil)
#+END_SRC
*** Regression
**** Prepare training dataset
In case of classification, the target is a vector of integer values, whereas in regression is a vector of continuous values.
#+BEGIN_SRC lisp
(defparameter *n* 100)
(defparameter *datamatrix*
(let ((arr (make-array (list *n* 1) :element-type ’double-float)))
(loop for i from 0 below *n* do
(setf (aref arr i 0) (random-uniform (- pi) pi)))
arr))
(defparameter *target*
(let ((arr (make-array *n* :element-type ’double-float)))
(loop for i from 0 below *n* do
(setf (aref arr i) (+ (sin (aref *datamatrix* i 0))
(random-normal :sd 0.1d0))))
arr))
(defparameter *test*
(let ((arr (make-array (list *n* 1) :element-type ’double-float)))
(loop for i from 0 below *n*
for x from (- pi) to pi by (/ (* 2 pi) *n*)
do (setf (aref arr i 0) x))
arr))
(defparameter *test-target*
(let ((arr (make-array *n* :element-type ’double-float)))
(loop for i from 0 below *n* do
(setf (aref arr i) (sin (aref *test* i 0))))
arr))
#+END_SRC
**** Make Regression Tree
#+BEGIN_SRC lisp
;; Make regression tree
(defparameter *rtree*
(make-rtree *datamatrix* *target* :max-depth 5 :min-region-samples 5 :n-trial 10))
;; Testing
(test-rtree *rtree* *test* *test-target*)
; RMSE: 0.09220732459820888d0
;; Make a prediction for first data point of test dataset
(predict-rtree *rtree* *test* 0)
; => -0.08374452528780077d0
#+END_SRC
**** Make Random Forest for Regression
#+BEGIN_SRC lisp
;; Make regression tree forest
(defparameter *rforest*
(make-regression-forest *datamatrix* *target*
:n-tree 100 :bagging-ratio 0.6
:max-depth 5 :min-region-samples 5 :n-trial 10))
;; Testing
(test-regression-forest *rforest* *test* *test-target*)
; RMSE: 0.05006872795207973d0
;; Make a prediction for first data point of test dataset
(predict-regression-forest *rforest* *test* 0)
; => -0.16540771296145781d0
#+END_SRC
[[./docs/img/clrf-regression.png]]
** Author
Satoshi Imai (satoshi.imai@gmail.com)
** Licence
This software is released under the MIT License, see LICENSE.txt.
0.1
cl-random-forest.asd (file)
src (module)
Modules are listed depth-first from the system components tree.
• The cl-random-forest/src module |
cl-random-forest (system)
src/
Files are sorted by type and then listed depth-first from the systems components trees.
• Lisp files |
Next: The cl-random-forest/src/utils․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
cl-random-forest.asd
cl-random-forest (system)
Next: The cl-random-forest/src/random-forest․lisp file, Previous: The cl-random-forest․asd file, Up: Lisp files [Contents][Index]
src (module)
src/utils.lisp
Next: The cl-random-forest/src/reconstruction․lisp file, Previous: The cl-random-forest/src/utils․lisp file, Up: Lisp files [Contents][Index]
utils.lisp (file)
src (module)
src/random-forest.lisp
Next: The cl-random-forest/src/feature-importance․lisp file, Previous: The cl-random-forest/src/random-forest․lisp file, Up: Lisp files [Contents][Index]
random-forest.lisp (file)
src (module)
src/reconstruction.lisp
Previous: The cl-random-forest/src/reconstruction․lisp file, Up: Lisp files [Contents][Index]
random-forest.lisp (file)
src (module)
src/feature-importance.lisp
forest-feature-importance (function)
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
• The cl-random-forest-asd package | ||
• The cl-random-forest.utils package | ||
• The cl-random-forest package |
Next: The cl-random-forest․utils package, Previous: Packages, Up: Packages [Contents][Index]
cl-random-forest.asd
Next: The cl-random-forest package, Previous: The cl-random-forest-asd package, Up: Packages [Contents][Index]
utils.lisp (file)
clrf.utils
common-lisp
Previous: The cl-random-forest․utils package, Up: Packages [Contents][Index]
random-forest.lisp (file)
clrf
Definitions are sorted by export status, category, package, and then by lexicographic order.
• Exported definitions | ||
• Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
• Exported macros | ||
• Exported functions |
Next: Exported functions, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
utils.lisp (file)
utils.lisp (file)
utils.lisp (file)
utils.lisp (file)
random-forest.lisp (file)
Previous: Exported macros, Up: Exported definitions [Contents][Index]
utils.lisp (file)
utils.lisp (file)
random-forest.lisp (file)
reconstruction.lisp (file)
reconstruction.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
reconstruction.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
utils.lisp (file)
utils.lisp (file)
reconstruction.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
utils.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
• Internal macros | ||
• Internal functions | ||
• Internal structures |
Next: Internal functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
utils.lisp (file)
Next: Internal structures, Previous: Internal macros, Up: Internal definitions [Contents][Index]
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
Bagging classifiers induced over balanced bootstrap samples. Also known as Balanced Random Forest.
This implementation counts the number of examples in each class, which might be inefficient.
> In this work we provide such an explanation, and we conclude that
> in almost all imbalanced scenarios, practitioners should bag classifiers induced over
> balanced bootstrap samples.
Wallace, Byron C., et al. “Class imbalance, redux.”
2011 IEEE 11th International Conference on Data Mining (ICDM), 2011.
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
feature-importance.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
utils.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
feature-importance.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
reconstruction.lisp (file)
reconstruction.lisp (file)
random-forest.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
feature-importance.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
feature-importance.lisp (file)
feature-importance.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
random-forest.lisp (file)
Previous: Internal functions, Up: Internal definitions [Contents][Index]
random-forest.lisp (file)
structure-object (structure)
print-object (method)
dtree-n-class (function)
(setf dtree-n-class) (function)
dtree-class-count-array (function)
(setf dtree-class-count-array) (function)
dtree-datum-dim (function)
(setf dtree-datum-dim) (function)
dtree-datamatrix (function)
(setf dtree-datamatrix) (function)
dtree-target (function)
(setf dtree-target) (function)
dtree-root (function)
(setf dtree-root) (function)
dtree-max-depth (function)
(setf dtree-max-depth) (function)
dtree-min-region-samples (function)
(setf dtree-min-region-samples) (function)
dtree-n-trial (function)
(setf dtree-n-trial) (function)
dtree-gain-test (function)
(setf dtree-gain-test) (function)
dtree-remove-sample-indices? (function)
(setf dtree-remove-sample-indices?) (function)
dtree-save-parent-node? (function)
(setf dtree-save-parent-node?) (function)
dtree-tmp-arr1 (function)
(setf dtree-tmp-arr1) (function)
dtree-tmp-index1 (function)
(setf dtree-tmp-index1) (function)
dtree-tmp-arr2 (function)
(setf dtree-tmp-arr2) (function)
dtree-tmp-index2 (function)
(setf dtree-tmp-index2) (function)
dtree-best-arr1 (function)
(setf dtree-best-arr1) (function)
dtree-best-index1 (function)
(setf dtree-best-index1) (function)
dtree-best-arr2 (function)
(setf dtree-best-arr2) (function)
dtree-best-index2 (function)
(setf dtree-best-index2) (function)
dtree-max-leaf-index (function)
(setf dtree-max-leaf-index) (function)
dtree-id (function)
(setf dtree-id) (function)
random-forest.lisp (file)
structure-object (structure)
print-object (method)
forest-n-tree (function)
(setf forest-n-tree) (function)
forest-bagging-ratio (function)
(setf forest-bagging-ratio) (function)
forest-datamatrix (function)
(setf forest-datamatrix) (function)
forest-target (function)
(setf forest-target) (function)
forest-dtree-list (function)
(setf forest-dtree-list) (function)
forest-n-class (function)
(setf forest-n-class) (function)
forest-class-count-array (function)
(setf forest-class-count-array) (function)
forest-datum-dim (function)
(setf forest-datum-dim) (function)
forest-max-depth (function)
(setf forest-max-depth) (function)
forest-min-region-samples (function)
(setf forest-min-region-samples) (function)
forest-n-trial (function)
(setf forest-n-trial) (function)
forest-gain-test (function)
(setf forest-gain-test) (function)
forest-n-leaf (function)
(setf forest-n-leaf) (function)
forest-index-offset (function)
(setf forest-index-offset) (function)
random-forest.lisp (file)
structure-object (structure)
print-object (method)
node-sample-indices (function)
(setf node-sample-indices) (function)
node-n-sample (function)
(setf node-n-sample) (function)
node-depth (function)
(setf node-depth) (function)
node-test-attribute (function)
(setf node-test-attribute) (function)
node-test-threshold (function)
(setf node-test-threshold) (function)
node-information-gain (function)
(setf node-information-gain) (function)
node-parent-node (function)
(setf node-parent-node) (function)
node-left-node (function)
(setf node-left-node) (function)
node-right-node (function)
(setf node-right-node) (function)
node-dtree (function)
(setf node-dtree) (function)
node-leaf-index (function)
(setf node-leaf-index) (function)
Previous: Definitions, Up: Top [Contents][Index]
• Concept index | ||
• Function index | ||
• Variable index | ||
• Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
Jump to: | C F L M |
---|
Jump to: | C F L M |
---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
Jump to: | %
(
A B C D E F G L M N P R S T V W |
---|
Jump to: | %
(
A B C D E F G L M N P R S T V W |
---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
Jump to: | B C D G I L M N P R S T |
---|
Jump to: | B C D G I L M N P R S T |
---|
Previous: Variable index, Up: Indexes [Contents][Index]
Jump to: | C D F N P S |
---|
Jump to: | C D F N P S |
---|