Hello;
I need to know how works Islolation Forest Algorithm .
Please to send me documentations that allow me to well inderstand the fuction of Islolation Forest Algorithm . I will used it in classification. Also, I need some exmples of implementation of taht algorithm in JAVA.
Please to send documenations and codes in JAVA to my email ; [email protected]
Best regards
Here you get java code which is used in weka
weka.sourceforge.net/doc.packages/isolationForest/weka/classifiers/misc/IsolationForest.html
JAVA CODE :
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
/*
* IsolationForest.java
* Copyright (C) 2012-16 University of Waikato, Hamilton, New Zealand
*
*/
package weka.classifiers.misc;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Random;
import java.util.Vector;
import weka.classifiers.RandomizableClassifier;
import weka.core.Capabilities;
import weka.core.Capabilities.Capability;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.Option;
import weka.core.TechnicalInformation;
import weka.core.TechnicalInformation.Field;
import weka.core.TechnicalInformation.Type;
import weka.core.TechnicalInformationHandler;
import weka.core.Utils;
/**
*
*
*
*
*
*
* @author Eibe Frank ([email protected])
* @version $Revision$
*/
public class IsolationForest extends RandomizableClassifier implements
TechnicalInformationHandler, Serializable {
// For serialization
private static final long serialVersionUID = 5586674623147772788L;
// The set of trees
protected Tree[] m_trees = null;
// The number of trees
protected int m_numTrees = 100;
// The subsample size
protected int m_subsampleSize = 256;
/**
* Returns a string describing this filter
*/
public String globalInfo() {
return "Implements the isolation forest method for anomaly detection.\n\n"
+ "Note that this classifier is designed for anomaly detection, it is not designed for solving "
+ "two-class or multi-class classification problems!\n\n"
+ "The data is expected to have have a class attribute with one or two values, "
+ "which is ignored at training time. The distributionForInstance() "
+ "method returns (1 - anomaly score) as the first element in the distribution, "
+ "the second element (in the case of two classes) is the anomaly score.\n\nTo evaluate performance "
+ "of this method for a dataset where anomalies are known, simply "
+ "code the anomalies using the class attribute: normal cases should "
+ "correspond to the first value of the class attribute, anomalies to "
+ "the second one." + "\n\nFor more information, see:\n\n"
+ getTechnicalInformation().toString();
}
/**
* Returns an instance of a TechnicalInformation object, containing detailed
* information about the technical background of this class, e.g., paper
* reference or book this class is based on.
*
* @return the technical information about this class
*/
@Override
public TechnicalInformation getTechnicalInformation() {
TechnicalInformation result;
result = new TechnicalInformation(Type.INPROCEEDINGS);
result.setValue(Field.AUTHOR,
"Fei Tony Liu and Kai Ming Ting and Zhi-Hua Zhou");
result.setValue(Field.TITLE, "Isolation Forest");
result.setValue(Field.BOOKTITLE, "ICDM");
result.setValue(Field.YEAR, "2008");
result.setValue(Field.PAGES, "413-422");
result.setValue(Field.PUBLISHER, "IEEE Computer Society");
return result;
}
/**
* Returns the Capabilities of this filter.
*/
@Override
public Capabilities getCapabilities() {
Capabilities result = super.getCapabilities();
result.disableAll();
// attributes
result.enable(Capability.NUMERIC_ATTRIBUTES);
result.enable(Capability.DATE_ATTRIBUTES);
// class
result.enable(Capability.UNARY_CLASS);
result.enable(Capability.BINARY_CLASS);
result.enable(Capability.MISSING_CLASS_VALUES);
// instances
result.setMinimumNumberInstances(0);
return result;
}
/**
* Returns brief description of the classifier.
*/
@Override
public String toString() {
if (m_trees == null) {
return "No model built yet.";
} else {
return "Isolation forest for anomaly detection (" + m_numTrees + ", "
+ m_subsampleSize + ")";
}
}
/**
* Returns the tip text for this property
*
* @return tip text for this property suitable for displaying in the
* explorer/experimenter gui
*/
public String numTreesTipText() {
return "The number of trees to use in the forest.";
}
/**
* Get the value of numTrees.
*
* @return Value of numTrees.
*/
public int getNumTrees() {
return m_numTrees;
}
/**
* Set the value of numTrees.
*
* @param k value to assign to numTrees.
*/
public void setNumTrees(int k) {
m_numTrees = k;
}
/**
* Returns the tip text for this property
*
* @return tip text for this property suitable for displaying in the
* explorer/experimenter gui
*/
public String subsampleSizeTipText() {
return "The size of the subsample used to build each tree.";
}
/**
* Get the value of subsampleSize.
*
* @return Value of subsampleSize.
*/
public int getSubsampleSize() {
return m_subsampleSize;
}
/**
* Set the value of subsampleSize.
*
* @param n value to assign to subsampleSize.
*/
public void setSubsampleSize(int n) {
m_subsampleSize = n;
}
/**
* Lists the command-line options for this classifier.
*
* @return an enumeration over all possible options
*/
@Override
public Enumeration listOptions() {
Vector newVector = new Vector();
newVector.addElement(new Option(
"\tThe number of trees in the forest (default 100).", "I", 1,
"-I "));
newVector.addElement(new Option(
"\tThe subsample size for each tree (default 256).", "N", 1,
"-N "));
newVector.addAll(Collections.list(super.listOptions()));
return newVector.elements();
}
/**
* Gets options from this classifier.
*
* @return the options for the current setup
*/
@Override
public String[] getOptions() {
Vector result = new Vector();
result.add("-I");
result.add("" + getNumTrees());
result.add("-N");
result.add("" + getSubsampleSize());
Collections.addAll(result, super.getOptions());
return result.toArray(new String[result.size()]);
}
/**
* Parses a given list of options.
*
*
*
*
* @param options the list of options as an array of strings
* @throws Exception if an option is not supported
*/
@Override
public void setOptions(String[] options) throws Exception {
String tmpStr;
tmpStr = Utils.getOption('I', options);
if (tmpStr.length() != 0) {
m_numTrees = Integer.parseInt(tmpStr);
} else {
m_numTrees = 100;
}
tmpStr = Utils.getOption('N', options);
if (tmpStr.length() != 0) {
m_subsampleSize = Integer.parseInt(tmpStr);
} else {
m_subsampleSize = 256;
}
super.setOptions(options);
Utils.checkForRemainingOptions(options);
}
/**
* Builds the forest.
*/
@Override
public void buildClassifier(Instances data) throws Exception {
// Can classifier handle the data?
getCapabilities().testWithFail(data);
// Reduce subsample size if data is too small
if (data.numInstances() < m_subsampleSize) {
m_subsampleSize = data.numInstances();
}
// Generate trees
m_trees = new Tree[m_numTrees];
data = new Instances(data);
Random r = (data.numInstances() > 0) ? data
.getRandomNumberGenerator(m_Seed) : new Random(m_Seed);
for (int i = 0; i < m_numTrees; i++) {
data.randomize(r);
m_trees[i] = new Tree(new Instances(data, 0, m_subsampleSize), r, 0,
(int) Math.ceil(Utils.log2(data.numInstances())));
}
}
/**
* Returns the average path length of an unsuccessful search. Returns 0 if
* argument is less than or equal to 1
*/
public static double c(double n) {
if (n 1) {
scores[1] = 1.0 - scores[0];
}
return scores;
}
/**
* Main method for this class.
*/
public static void main(String[] args) {
runClassifier(new IsolationForest(), args);
}
/**
* Inner class for building and using an isolation tree.
*/
protected class Tree implements Serializable {
// For serialization
private static final long serialVersionUID = 7786674623147772711L;
// The size of the node
protected int m_size;
// The split attribute
protected int m_a;
// The split point
protected double m_splitPoint;
// The successors
protected Tree[] m_successors;
/**
* Constructs a tree from data
*/
protected Tree(Instances data, Random r, int height, int maxHeight) {
// Set size of node
m_size = data.numInstances();
// Stop splitting if necessary
if ((m_size minmax[1][j]) {
minmax[1][j] = inst.value(j);
}
}
}
for (int j = 0; j < data.numAttributes(); j++) {
if (j != data.classIndex()) {
if (minmax[0][j] < minmax[1][j]) {
al.add(j);
}
}
}
// Check whether any eligible attributes have been found
if (al.size() == 0) {
return;
} else {
// Randomly pick an attribute and split point
m_a = al.get(r.nextInt(al.size()));
m_splitPoint = (r.nextDouble() * (minmax[1][m_a] - minmax[0][m_a]))
+ minmax[0][m_a];
// Create sub trees
m_successors = new Tree[2];
for (int i = 0; i < 2; i++) {
Instances tempData = new Instances(data, data.numInstances());
for (int j = 0; j < data.numInstances(); j++) {
if ((i == 0) && (data.instance(j).value(m_a) < m_splitPoint)) {
tempData.add(data.instance(j));
}
if ((i == 1) && (data.instance(j).value(m_a) >= m_splitPoint)) {
tempData.add(data.instance(j));
}
}
tempData.compactify();
m_successors[i] = new Tree(tempData, r, height + 1, maxHeight);
}
}
}
/**
* Returns path length according to algorithm.
*/
protected double pathLength(Instance inst) {
if (m_successors == null) {
return c(m_size);
}
if (inst.value(m_a) < m_splitPoint) {
return m_successors[0].pathLength(inst) + 1.0;
} else {
return m_successors[1].pathLength(inst) + 1.0;
}
}
}
}
I ask other experts to give me more documentations and code Java to well understand Isolation Forest Algorithm.
thank you in advance
Moreover, if you have weka installed in your PC, then a file of size 10mb named weka.jar include all algorithms jar file.
Simply go to program in your PC where you installed(if) weka. Then find the weka folder.
I am very grateful to you Pr. Sachin Kumar. Thank you for sending me an email to my address [email protected] , I would like to collaborate with you in my next projects.
- Badges
- Science topic
- Similar topics
- Data Mining
- Classification