private static void decisionTree(double[][] inputs, int[] outputs)
{
// In our problem, we have 2 classes (samples can be either
// positive or negative), and 2 continuous-valued inputs.
DecisionTree tree = new DecisionTree(inputs: new[]
{
DecisionVariable.Continuous("X"),
DecisionVariable.Continuous("Y")
}, classes: 2);
C45Learning teacher = new C45Learning(tree);
// The C4.5 algorithm expects the class labels to
// range from 0 to k, so we convert -1 to be zero:
//
outputs = outputs.Apply(x => x < 0 ? 0 : x);
double error = teacher.Run(inputs, outputs);
// Classify the samples using the model
int[] answers = inputs.Apply(tree.Compute);
// Plot the results
ScatterplotBox.Show("Expected results", inputs, outputs);
ScatterplotBox.Show("Decision Tree results", inputs, answers)
.Hold();
}
/// <summary>
/// Creates a C# code for the tree.
/// </summary>
///
public void Write(DecisionTree tree, string className)
{
writer.WriteLine("// This file has been automatically generated by the");
writer.WriteLine("//");
writer.WriteLine("// Accord Machine Learning Library");
writer.WriteLine("// The Accord.NET Framework");
writer.WriteLine("// http://accord-framework.net");
writer.WriteLine("//");
writer.WriteLine();
writer.WriteLine("namespace DecisionTrees");
writer.WriteLine("{");
writer.WriteLine(" using System.CodeDom.Compiler;");
writer.WriteLine(" using System.Collections.Generic;");
writer.WriteLine();
writer.WriteLine(" /// <summary>");
writer.WriteLine(" /// Automatically generated decision tree.");
writer.WriteLine(" /// </summary>");
writer.WriteLine(" /// ");
writer.WriteLine(" [GeneratedCode(\"Accord.NET DecisionTree\", \"2.8\")]");
writer.WriteLine(" public static class {0}", className);
writer.WriteLine(" {");
writer.WriteLine();
writer.WriteLine(" /// <summary>");
writer.WriteLine(" /// Assigns a class label to a given input.");
writer.WriteLine(" /// </summary>");
writer.WriteLine(" /// ");
writer.WriteLine(" public static int Function(double[] input)");
writer.WriteLine(" {");
create(tree.Root, 3);
writer.WriteLine(" }");
writer.WriteLine(" }");
writer.WriteLine("}");
}
public static TrainingSet[] GenerateTrainingSets(IEnumerable<KeyValuePair<User, double[]>> studentsAndMarks, string[] normalRecords, string[] anomalies)
{
var countOfEntries = normalRecords.Length + anomalies.Length;
var inputData = new double[countOfEntries][];
var outputData = new int[countOfEntries];
var counter = 0;
foreach (var studentAndMarks in studentsAndMarks)
{
if (normalRecords.Contains(studentAndMarks.Key.OpenId))
{
inputData[counter] = studentAndMarks.Value;
outputData[counter++] = 1;
}
if (!anomalies.Contains(studentAndMarks.Key.OpenId))
{
continue;
}
inputData[counter] = studentAndMarks.Value;
outputData[counter++] = 0;
}
var countOfFeatures = studentsAndMarks.ElementAt(0).Value.Length;
var features = new DecisionVariable[countOfFeatures];
features[0] = new DecisionVariable("0", DecisionAttributeKind.Continuous, new AForge.DoubleRange(80, 1200));
for (var i = 1; i < countOfFeatures; i++)
{
features[i] = new DecisionVariable(i.ToString(), DecisionAttributeKind.Continuous, new AForge.DoubleRange(0, 10));
}
// Create the Decision tree with only 2 result values
var tree = new DecisionTree(features, 2);
// Creates a new instance of the C4.5 learning algorithm
var c45 = new C45Learning(tree);
// Learn the decision tree
var error = c45.Run(inputData, outputData);
// Split all data into normal and anomalies
var setOfNormalRecords = studentsAndMarks.Where(x => tree.Compute(x.Value) == 1);
var setOfAnomalies = studentsAndMarks.Where(x => tree.Compute(x.Value) == 0);
// Split normal records into 2 groups (one for training set and one for anomaly detection ocurency detection)
var setOfNormalRecordsList = setOfNormalRecords.ToList();
var splitCount = setOfNormalRecordsList.Count * 2 / 3;
var setOfNormalRecordsTr1 = setOfNormalRecordsList.GetRange(0, splitCount);
var setOfNormalRecordsTr2 = setOfNormalRecordsList.GetRange(splitCount, setOfNormalRecordsList.Count - splitCount);
// Create Training Sets
var trSetNormalFirst = CreateTrainingSetFromResources(setOfNormalRecordsTr1);
var trSetNormalSecond = CreateTrainingSetFromResources(setOfNormalRecordsTr2);
var trSetAnomalies = CreateTrainingSetFromResources(setOfAnomalies);
return new[] { trSetNormalFirst, trSetNormalSecond, trSetAnomalies };
}
public Codification GenerateDecisionTreeLib(DataTable data)
{
Codification b = new Codification(data);
DataTable symbols = b.Apply(data);
int[][] inputs = DataTableToMatrix(symbols, new string[] { "CAP SHAPE", "CAP SURFACE", "CAP COLOR",
"BRUISES", "ODOR", "GILL ATTACHMENT",
"GILL SPACING", "GILL SIZE", "GILL COLOR",
"STALK SHAPE", "STALK ROOT", "STALK SURFACE ABOVE RING",
"STALK SURFACE BELOW RING", "STALK COLOR ABOVE RING", "STALK COLOR BELOW RING",
"VEIL TYPE", "VEIL COLOR", "RING NUMBER",
"RING TYPE", "SPORE PRINT COLOR", "POPULATION",
"HABITAT" });
int[][] mOutputs = DataTableToMatrix(symbols, new string[] { "TYPE" });
int[] outputs = new int[mOutputs.Length];
for (int i = 0; i < mOutputs.Length; i++)
{
outputs[i] = mOutputs[i][0];
}
ID3Learning id3learning = new ID3Learning()
{
new DecisionVariable("CAP SHAPE", Mushroom.CAP_SHAPE.Length), //1
new DecisionVariable("CAP SURFACE", Mushroom.CAP_SURFACE.Length), //2
new DecisionVariable("CAP COLOR", Mushroom.CAP_COLOR.Length), //3
new DecisionVariable("BRUISES", Mushroom.BRUISES.Length), //4
new DecisionVariable("ODOR", Mushroom.ODOR.Length), //5
new DecisionVariable("GILL ATTACHMENT", Mushroom.GILL_ATTACHMENT.Length), //6
new DecisionVariable("GILL SPACING", Mushroom.GILL_SPACING.Length), //7
new DecisionVariable("GILL SIZE", Mushroom.GILL_SIZE.Length), //8
new DecisionVariable("GILL COLOR", Mushroom.GILL_COLOR.Length), //9
new DecisionVariable("STALK SHAPE", Mushroom.STALK_SHAPE.Length), //10
new DecisionVariable("STALK ROOT", Mushroom.STALK_ROOT.Length), //11
new DecisionVariable("STALK SURFACE ABOVE RING", Mushroom.STALK_SURFACE_ABOVE_RING.Length), //12
new DecisionVariable("STALK SURFACE BELOW RING", Mushroom.STALK_SURFACE_BELOW_RING.Length), //13
new DecisionVariable("STALK COLOR ABOVE RING", Mushroom.STALK_COLOR_ABOVE_RING.Length), //14
new DecisionVariable("STALK COLOR BELOW RING", Mushroom.STALK_COLOR_BELOW_RING.Length), //15
new DecisionVariable("VEIL TYPE", Mushroom.VEIL_TYPE.Length), //16
new DecisionVariable("VEIL COLOR", Mushroom.VEIL_COLOR.Length), //17
new DecisionVariable("RING NUMBER", Mushroom.RING_NUMBER.Length), //18
new DecisionVariable("RING TYPE", Mushroom.RING_TYPE.Length), //19
new DecisionVariable("SPORE PRINT COLOR", Mushroom.SPORE_PRINT_COLOR.Length), //20
new DecisionVariable("POPULATION", Mushroom.POPULATION.Length), //21
new DecisionVariable("HABITAT", Mushroom.HABITAT.Length) //22
};
decisionTreeLib = id3learning.Learn(inputs, outputs);
return(b);
}
public string getAnswer(Accord.MachineLearning.DecisionTrees.DecisionTree tree, DataTable trainingData, DataTable executionData, List <string> codFieldListComDsFlowResult, List <string> fieldValuesList)
{
trainingData.Merge(executionData);
Codification codebookExecution = new Codification(trainingData, codFieldListComDsFlowResult.ToArray());
// O primeiro codebook aqui deve ser o codebook original da árvore de decisão, o segundo codebook sim é o da execução.
// Validar com itens diferentes preenchidos na execução.
return(codebookExecution.Translate("DsFlowResult", tree.Compute(codebookExecution.Translate(fieldValuesList.ToArray()))));
}
public FormTreeRule(DecisionTree tree, Codification codification, string rule)
: this()
{
this.codification = codification;
// Show the learned tree in the view
decisionTreeView.SetTree(tree, codification);
decisionTreeView.viewRule(rule);
}
public FormTreeView(DecisionTree tree, Codification codification)
: this()
{
this.codification = codification;
// Show the learned tree in the view
decisionTreeView.SetTree(tree, codification);
if (tree != null && tree.Root != null)
CreateRuleList(tree.Root, "");
}
// Create tree
public void SetTree(DecisionTree tree, Codification codification)
{
this.treeSource = tree;
this.codification = codification;
treeView1.Nodes.Clear();
if (treeSource != null && treeSource.Root != null)
treeView1.Nodes.Add(convert(TreeSource.Root));
}
/// <summary>
/// Creates a new C4.5 learning algorithm.
/// </summary>
///
/// <param name="tree">The decision tree to be generated.</param>
///
public c45(DecisionTree tree)
{
this.tree = tree;
this.attributes = new bool[tree.InputCount];
this.inputRanges = new IntRange[tree.InputCount];
this.outputClasses = tree.OutputClasses;
this.maxHeight = attributes.Length;
for (int i = 0; i < inputRanges.Length; i++)
inputRanges[i] = tree.Attributes[i].Range.ToIntRange(false);
}
/***************************** Constructor *********************************/
public Classification(SortedList columnList, int classLabeCount)
{
// Initialize DecisionTree
decisionAttributes = new DecisionVariable[columnList.Count];
for (int i = 0; i < decisionAttributes.Length; i++)
{
decisionAttributes[i] = new DecisionVariable((string)columnList.GetByIndex(i), DecisionVariableKind.Continuous);
}
int classCount = classLabeCount;
descisionTree = new DecisionTree(decisionAttributes, classCount);
}
public static void CreateMitchellExample(out DecisionTree tree, out double[][] inputs, out int[] outputs)
{
DataTable data = new DataTable("Mitchell's Tennis Example");
data.Columns.Add("Day", typeof(string));
data.Columns.Add("Outlook", typeof(string));
data.Columns.Add("Temperature", typeof(double));
data.Columns.Add("Humidity", typeof(double));
data.Columns.Add("Wind", typeof(string));
data.Columns.Add("PlayTennis", typeof(string));
data.Rows.Add("D1", "Sunny", 85, 85, "Weak", "No");
data.Rows.Add("D2", "Sunny", 80, 90, "Strong", "No");
data.Rows.Add("D3", "Overcast", 83, 78, "Weak", "Yes");
data.Rows.Add("D4", "Rain", 70, 96, "Weak", "Yes");
data.Rows.Add("D5", "Rain", 68, 80, "Weak", "Yes");
data.Rows.Add("D6", "Rain", 65, 70, "Strong", "No");
data.Rows.Add("D7", "Overcast", 64, 65, "Strong", "Yes");
data.Rows.Add("D8", "Sunny", 72, 95, "Weak", "No");
data.Rows.Add("D9", "Sunny", 69, 70, "Weak", "Yes");
data.Rows.Add("D10", "Rain", 75, 80, "Weak", "Yes");
data.Rows.Add("D11", "Sunny", 75, 70, "Strong", "Yes");
data.Rows.Add("D12", "Overcast", 72, 90, "Strong", "Yes");
data.Rows.Add("D13", "Overcast", 81, 75, "Weak", "Yes");
data.Rows.Add("D14", "Rain", 71, 80, "Strong", "No");
// Create a new codification codebook to
// convert strings into integer symbols
Codification codebook = new Codification(data);
DecisionVariable[] attributes =
{
new DecisionVariable("Outlook", codebook["Outlook"].Symbols), // 3 possible values (Sunny, overcast, rain)
new DecisionVariable("Temperature", DecisionVariableKind.Continuous), // continuous values
new DecisionVariable("Humidity", DecisionVariableKind.Continuous), // continuous values
new DecisionVariable("Wind", codebook["Wind"].Symbols) // 2 possible values (Weak, strong)
};
int classCount = codebook["PlayTennis"].Symbols; // 2 possible values (yes, no)
tree = new DecisionTree(attributes, classCount);
C45Learning c45 = new C45Learning(tree);
// Extract symbols from data and train the classifier
DataTable symbols = codebook.Apply(data);
inputs = symbols.ToArray("Outlook", "Temperature", "Humidity", "Wind");
outputs = symbols.ToArray<int>("PlayTennis");
double error = c45.Run(inputs, outputs);
}
/// <summary>
/// Creates a new ID3 learning algorithm.
/// </summary>
///
/// <param name="tree">The decision tree to be generated.</param>
///
public ID3Learning(DecisionTree tree)
{
this.tree = tree;
this.inputRanges = new IntRange[tree.InputCount];
this.outputClasses = tree.OutputClasses;
this.attributes = new bool[tree.InputCount];
this.maxHeight = attributes.Length;
for (int i = 0; i < tree.Attributes.Count; i++)
if (tree.Attributes[i].Nature != DecisionVariableKind.Discrete)
throw new ArgumentException("id3 inputları hatalı geldi.");
for (int i = 0; i < inputRanges.Length; i++)
inputRanges[i] = tree.Attributes[i].Range.ToIntRange(false);
}
//
//You can use the following additional attributes as you write your tests:
//
//Use ClassInitialize to run code before running the first test in the class
//[ClassInitialize()]
//public static void MyClassInitialize(TestContext testContext)
//{
//}
//
//Use ClassCleanup to run code after all tests in a class have run
//[ClassCleanup()]
//public static void MyClassCleanup()
//{
//}
//
//Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize()
//{
//}
//
//Use TestCleanup to run code after each test has run
//[TestCleanup()]
//public void MyTestCleanup()
//{
//}
//
#endregion
public static void CreateMitchellExample(out DecisionTree tree, out int[][] inputs, out int[] outputs)
{
DataTable data = new DataTable("Mitchell's Tennis Example");
data.Columns.Add("Day", "Outlook", "Temperature", "Humidity", "Wind", "PlayTennis");
data.Rows.Add("D1", "Sunny", "Hot", "High", "Weak", "No");
data.Rows.Add("D2", "Sunny", "Hot", "High", "Strong", "No");
data.Rows.Add("D3", "Overcast", "Hot", "High", "Weak", "Yes");
data.Rows.Add("D4", "Rain", "Mild", "High", "Weak", "Yes");
data.Rows.Add("D5", "Rain", "Cool", "Normal", "Weak", "Yes");
data.Rows.Add("D6", "Rain", "Cool", "Normal", "Strong", "No");
data.Rows.Add("D7", "Overcast", "Cool", "Normal", "Strong", "Yes");
data.Rows.Add("D8", "Sunny", "Mild", "High", "Weak", "No");
data.Rows.Add("D9", "Sunny", "Cool", "Normal", "Weak", "Yes");
data.Rows.Add("D10", "Rain", "Mild", "Normal", "Weak", "Yes");
data.Rows.Add("D11", "Sunny", "Mild", "Normal", "Strong", "Yes");
data.Rows.Add("D12", "Overcast", "Mild", "High", "Strong", "Yes");
data.Rows.Add("D13", "Overcast", "Hot", "Normal", "Weak", "Yes");
data.Rows.Add("D14", "Rain", "Mild", "High", "Strong", "No");
// Create a new codification codebook to
// convert strings into integer symbols
Codification codebook = new Codification(data);
DecisionVariable[] attributes =
{
new DecisionVariable("Outlook", codebook["Outlook"].Symbols), // 3 possible values (Sunny, overcast, rain)
new DecisionVariable("Temperature", codebook["Temperature"].Symbols), // 3 possible values (Hot, mild, cool)
new DecisionVariable("Humidity", codebook["Humidity"].Symbols), // 2 possible values (High, normal)
new DecisionVariable("Wind", codebook["Wind"].Symbols) // 2 possible values (Weak, strong)
};
int classCount = codebook["PlayTennis"].Symbols; // 2 possible values (yes, no)
tree = new DecisionTree(attributes, classCount);
ID3Learning id3 = new ID3Learning(tree);
// Extract symbols from data and train the classifier
DataTable symbols = codebook.Apply(data);
inputs = symbols.ToIntArray("Outlook", "Temperature", "Humidity", "Wind");
outputs = symbols.ToIntArray("PlayTennis").GetColumn(0);
id3.Run(inputs, outputs);
}
//public static C45Model CreateC45Model(Codification codification)
//{
// int lastIndex = codification.Columns.Count - 1;
// List<DecisionVariable> attributes = new List<DecisionVariable>();
// for (int indexColumn = 0; indexColumn < lastIndex; indexColumn++)
// {
// attributes.Add(new DecisionVariable(codification.Columns[indexColumn].ColumnName,
// codification[indexColumn].Symbols));
// }
// C45Model model = new C45Model(new DecisionTree(attributes.ToArray(), 2));
// return model;
//}
//public C45Model(DecisionTree tree)
//{
// this.Tree = tree;
//}
// Trainning decision tree with C4.5 algorithm
public override void TrainningModel(TrainningData trainningData)
{
// Get data for trainning tree
Codification codification = trainningData.CodificationData;
double[][] inputs = trainningData.TrainningAttributes;
int[] outputs = trainningData.ClassificationAttribute;
// Create tree
this.Tree = this.CreateDecisionTree(codification);
//var attributes = DecisionVariable.FromCodebook(codification, inputColumns);
//DecisionTree tree = new DecisionTree(attributes, outputClasses: 5);
// Creates a new instance of the C4.5 learning algorithm
C45Learning c45 = new C45Learning(this.Tree);
// Learn the decision tree
double error = c45.Run(inputs, outputs);
}
public void LargeRunTest2()
{
Accord.Math.Random.Generator.Seed = 0;
int[,] random = Matrix.Random(1000, 10, 0.0, 10.0).ToInt32();
int[][] samples = random.ToJagged();
int[] outputs = new int[1000];
for (int i = 0; i < samples.Length; i++)
{
if (samples[i][0] > 5 || Tools.Random.NextDouble() > 0.85)
outputs[i] = 1;
}
DecisionVariable[] vars = new DecisionVariable[10];
for (int i = 0; i < vars.Length; i++)
vars[i] = new DecisionVariable("x" + i, 10);
DecisionTree tree = new DecisionTree(vars, 2);
var teacher = new ID3Learning(tree);
double error = teacher.Run(samples, outputs);
Assert.AreEqual(0, error);
var rules = DecisionSet.FromDecisionTree(tree);
Simplification simpl = new Simplification(rules)
{
Alpha = 0.05
};
error = simpl.ComputeError(samples.ToDouble(), outputs);
Assert.AreEqual(0, error);
double newError = simpl.Compute(samples.ToDouble(), outputs);
Assert.AreEqual(0.097, newError);
}
public Accord.MachineLearning.DecisionTrees.DecisionTree Learn(string[][] records, string[] columnNamesWithoutResult, ref Codification codebook)
{
DataTable data = new DataTable();
foreach (var columnName in records[0])
{
data.Columns.Add(columnName);
}
int rowsAdderCounter = 0;
foreach (var record in records)
{
if (rowsAdderCounter == 0)
{
rowsAdderCounter++;
continue;
}
data.Rows.Add(record);
}
double[][] inputs = data.ToJagged(columnNamesWithoutResult);
string[] labels = data.ToArray <string>(Constants.RESULT_COLUMN_NAME);
int[] outputs = codebook.Translate(Constants.RESULT_COLUMN_NAME, labels);
var teacher = new C45Learning();
foreach (var columnName in columnNamesWithoutResult)
{
DecisionVariable decVar = new DecisionVariable(columnName, DecisionVariableKind.Continuous);
teacher.Add(decVar);
}
Accord.MachineLearning.DecisionTrees.DecisionTree tree = teacher.Learn(inputs, outputs);
return(tree);
}
public Data.DecisionTree runDecisionSupport(int codTask, int totalExecutions, int classCount)
{
Data.DecisionTree decisionTree = new Data.DecisionTree();
// Utilizado se já existe uma árvore de decisão prévia criada, serve para reutilização de alguns parâmetros
Data.DecisionTree serializedTree = null;
// Verifica se já existe uma árvore gerada anteriormente
bool hasSerializedTree = decisionTree.Serialization.hasSerializedTree(codTask);
// Carregar a árvore existente
if (hasSerializedTree)
{
serializedTree = decisionTree.deserializeTree(codTask);
}
// Número total de execuções da tarefa
//int totalExecutions = getTotalExecutions(codTask);
Dictionary <dynamic, int> fieldSymbols = new Dictionary <dynamic, int>();
// Preenche o dicionário com a lista de campos do processo e a quantidade de símbolos para cada campo
fillSymbolsCount(codTask, ref fieldSymbols);
// Preenche a relevância dos campos de acordo com a taxa de variação e de nulos
setSymbolsRelevance(ref fieldSymbols, totalExecutions, codTask);
StringBuilder CodFieldListSB = new StringBuilder();
StringBuilder CodFieldListSBIsNull = new StringBuilder();
StringBuilder DsFieldNameList = new StringBuilder();
List <string> codFieldList = new List <string>();
// Prepara lista de campos
List <string> codFieldListComDsFlowResult = prepareFieldList(ref fieldSymbols, ref CodFieldListSB, ref CodFieldListSBIsNull, ref DsFieldNameList, ref codFieldList);
// Consulta os dados de treino
DataTable data = getData(codTask, CodFieldListSB, CodFieldListSBIsNull);
decisionTree.Data = data;
// Criando o objeto TRAINING
decisionTree.Training.setTrainingData(data);
// Preenchendo o VALIDATION do DecisionTree
decisionTree.Validation.setValidationData(data);
// ############################################# Passado para a classe Training.
// Passando o data para criação do codebook
// Converte em números inteiros as strings
Codification codebook = new Codification(data, codFieldListComDsFlowResult.ToArray());
// Montando a tabela de variáveis de decisão
List <DecisionVariable> decisionaVariableList = new List <DecisionVariable>();
foreach (KeyValuePair <dynamic, int> entry in fieldSymbols.Where(p => ((DecisionSupportField)p.Key).relevante == true))
{
DecisionSupportField c = entry.Key;
c.simbolos = entry.Value;
decisionaVariableList.Add(new DecisionVariable(c.codigo.ToString(), c.simbolos + 1)); // Adicionando + 1 do possível nulo
}
int qtdCamposRelevantes = fieldSymbols.Count(i => ((DecisionSupportField)i.Key).relevante == true);
DecisionVariable[] attributes = new DecisionVariable[qtdCamposRelevantes];
// Tabela de variáveis que impactam na decisão
attributes = decisionaVariableList.ToArray();
//List<string> DsFlowResults = getTaskResults(codTask);
// Número de possíveis resultados para a tarefa sendo analisada
//int classCount = DsFlowResults.Count;
// Cria a árvore de decisão
Accord.MachineLearning.DecisionTrees.DecisionTree tree = new Accord.MachineLearning.DecisionTrees.DecisionTree(attributes, classCount);
// Cria uma instância do algoritmo de aprendizado utilizado, o ID3
ID3Learning id3learning = new ID3Learning(tree);
// Traduz os dados de treino em simbolos inteiros utilizando o codebook
DataTable symbols = codebook.Apply(decisionTree.Training.TrainingData);
// Colunas de entrada
// *** Quantidade de colunas dos inputs deve ser o mesmo número de DecisionVariables(attributes)
int[][] inputs = symbols.ToArray <int>(codFieldList.ToArray());
// Coluna com a saída
int[] outputs = symbols.ToArray <int>("DsFlowResult");
// Aprendendo com as instâncias de treino
id3learning.Run(inputs, outputs);
// ############################################# Passado para a classe Training.
decisionTree.Tree = tree;
// Atribuindo as listas de códigos de campos e nomes ao objeto decisionTree
// Utilizado para manter o uso da palavra chave 'ref'
decisionTree.CodFieldListSB = CodFieldListSB;
decisionTree.CodFieldListSBIsNull = CodFieldListSBIsNull;
decisionTree.DsFieldNameList = DsFieldNameList;
decisionTree.codFieldList = codFieldList;
decisionTree.codFieldListComDsFlowResult = codFieldListComDsFlowResult;
decisionTree.fieldSymbols = fieldSymbols;
decisionTree.Codebook = codebook;
decisionTree.serializeTree(codTask);
return(decisionTree);
}
public static DecisionTree createNurseryExample(out double[][] inputs, out int[] outputs, int first)
{
string nurseryData = Resources.nursery;
string[] inputColumns =
{
"parents", "has_nurs", "form", "children",
"housing", "finance", "social", "health"
};
string outputColumn = "output";
DataTable table = new DataTable("Nursery");
table.Columns.Add(inputColumns);
table.Columns.Add(outputColumn);
string[] lines = nurseryData.Split(
new[] { Environment.NewLine }, StringSplitOptions.None);
foreach (var line in lines)
table.Rows.Add(line.Split(','));
Codification codebook = new Codification(table);
DataTable symbols = codebook.Apply(table);
inputs = symbols.ToArray(inputColumns);
outputs = symbols.ToArray<int>(outputColumn);
var attributes = DecisionVariable.FromCodebook(codebook, inputColumns);
var tree = new DecisionTree(attributes, outputClasses: 5);
C45Learning c45 = new C45Learning(tree);
double error = c45.Run(inputs.Submatrix(first), outputs.Submatrix(first));
Assert.AreEqual(0, error);
return tree;
}
public void ArgumentCheck1()
{
double[][] samples =
{
new [] { 0, 2, 4.0 },
new [] { 1, 5, 2.0 },
null,
new [] { 1, 5, 6.0 },
};
int[] outputs =
{
1, 1, 0, 0
};
DecisionVariable[] vars = new DecisionVariable[3];
for (int i = 0; i < vars.Length; i++)
vars[i] = DecisionVariable.Continuous(i.ToString());
DecisionTree tree = new DecisionTree(vars, 2);
var teacher = new C45Learning(tree);
bool thrown = false;
try { double error = teacher.Run(samples, outputs); }
catch (ArgumentNullException) { thrown = true; }
Assert.IsTrue(thrown);
}
static void Main(string[] args)
{
// Create a new reader, opening a given path
ExcelReader excel = new ExcelReader("Intake Inf Cohort 2017 - Training Set.xlsx");
ExcelReader excelTest = new ExcelReader("Intake Inf Cohort 2017 - Test Set.xlsx");
// Afterwards, we can query the file for all
// worksheets within the specified workbook:
string[] sheets = excel.GetWorksheetList();
string[] sheetsTest = excelTest.GetWorksheetList();
// Finally, we can request an specific sheet:
DataTable data = excel.GetWorksheet(sheets[0]);
DataTable dataTest = excelTest.GetWorksheet(sheets[0]);
// Loop through each column in data
foreach (DataColumn column in data.Columns)
{
// Replace empty with underscore
column.ColumnName = column.ColumnName.Replace(" ", "_");
}
// Create a new codification codebook to
// convert strings into integer symbols
Codification codibook = new Codification(data);
// Set codibook
Codification = codibook;
// Translate our training data into integer symbols using our codebook:
DataTable symbols = codibook.Apply(data);
int[][] inputs = symbols.ToJagged <int>(
codibook.Columns[5].ColumnName,
codibook.Columns[7].ColumnName,
codibook.Columns[8].ColumnName,
codibook.Columns[9].ColumnName,
codibook.Columns[12].ColumnName,
codibook.Columns[13].ColumnName,
codibook.Columns[14].ColumnName,
codibook.Columns[15].ColumnName,
codibook.Columns[16].ColumnName,
codibook.Columns[20].ColumnName,
codibook.Columns[29].ColumnName,
codibook.Columns[30].ColumnName,
codibook.Columns[34].ColumnName
);
int[] outputs = symbols.ToMatrix <int>(codibook.Columns[6].ColumnName).GetColumn(0);
// Create a teacher ID3 algorithm
var id3 = new ID3Learning()
{
new DecisionVariable(codibook.Columns[5].ColumnName, 2),
new DecisionVariable(codibook.Columns[7].ColumnName, codibook.Columns[7].NumberOfSymbols),
new DecisionVariable(codibook.Columns[8].ColumnName, codibook.Columns[8].NumberOfSymbols),
new DecisionVariable(codibook.Columns[9].ColumnName, 3),
new DecisionVariable(codibook.Columns[12].ColumnName, 10),
new DecisionVariable(codibook.Columns[13].ColumnName, 10),
new DecisionVariable(codibook.Columns[14].ColumnName, 10),
new DecisionVariable(codibook.Columns[15].ColumnName, 10),
new DecisionVariable(codibook.Columns[16].ColumnName, 2),
new DecisionVariable(codibook.Columns[20].ColumnName, 2),
new DecisionVariable(codibook.Columns[29].ColumnName, 2),
new DecisionVariable(codibook.Columns[30].ColumnName, 2),
new DecisionVariable(codibook.Columns[34].ColumnName, 2),
};
// Learn the training instances!
Accord.MachineLearning.DecisionTrees.DecisionTree tree = id3.Learn(inputs, outputs);
// Create a console table for display
ConsoleTable table = new ConsoleTable("Studentnumber", "Advice", "Conclusion");
// Loop through each row in data
foreach (DataRow row in dataTest.Rows)
{
// The tree can now be queried for new examples through
// its decide method. For example, we can create a query
int[] query = null;
try
{
query = codibook.Transform(new[, ]
{
{ codibook.Columns[5].ColumnName, row.ItemArray[5].ToString() },
{ codibook.Columns[7].ColumnName, row.ItemArray[7].ToString() },
{ codibook.Columns[8].ColumnName, row.ItemArray[8].ToString() },
{ codibook.Columns[9].ColumnName, row.ItemArray[9].ToString() },
{ codibook.Columns[12].ColumnName, row.ItemArray[12].ToString() },
{ codibook.Columns[13].ColumnName, row.ItemArray[13].ToString() },
{ codibook.Columns[14].ColumnName, row.ItemArray[14].ToString() },
{ codibook.Columns[15].ColumnName, row.ItemArray[15].ToString() },
{ codibook.Columns[16].ColumnName, row.ItemArray[16].ToString() },
{ codibook.Columns[20].ColumnName, row.ItemArray[20].ToString() },
{ codibook.Columns[29].ColumnName, row.ItemArray[29].ToString() },
{ codibook.Columns[30].ColumnName, row.ItemArray[30].ToString() },
{ codibook.Columns[34].ColumnName, row.ItemArray[34].ToString() },
});
}
catch (Exception)
{
// Show the result of skipped students
var studentnumber = row.ItemArray[0].ToString();
var advice = row.ItemArray[6].ToString();
var conclusion = "(Twijfel)";
table.AddRow(studentnumber, advice, conclusion);
continue;
}
// And then predict the label using
int predicted = tree.Decide(query);
// Any predictions off are ignored for consistency
if (predicted != -1)
{
// We can translate it back to strings using
string answer = codibook.Revert("advies", predicted);
// Show the result in the output
var studentnumber = row.ItemArray[0].ToString();
var advice = row.ItemArray[6].ToString();
var conclusion = answer;
table.AddRow(studentnumber, advice, conclusion);
}
else
{
// Show the result of skipped students
var studentnumber = row.ItemArray[0].ToString();
var advice = row.ItemArray[6].ToString();
var conclusion = "(Twijfel)";
table.AddRow(studentnumber, advice, conclusion);
}
}
// Write the table in console
table.Write();
// Read Key
Console.ReadKey();
}
public void IrisDatasetTest()
{
#region doc_iris
// In this example, we will process the famous Fisher's Iris dataset in
// which the task is to classify weather the features of an Iris flower
// belongs to an Iris setosa, an Iris versicolor, or an Iris virginica:
//
// - https://en.wikipedia.org/wiki/Iris_flower_data_set
//
// First, let's load the dataset into an array of text that we can process
string[][] text = Resources.iris_data.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries).Apply(x => x.Split(','));
// The first four columns contain the flower features
double[][] inputs = text.GetColumns(0, 1, 2, 3).To<double[][]>();
// The last column contains the expected flower type
string[] labels = text.GetColumn(4);
// Since the labels are represented as text, the first step is to convert
// those text labels into integer class labels, so we can process them
// more easily. For this, we will create a codebook to encode class labels:
//
var codebook = new Codification("Output", labels);
// With the codebook, we can convert the labels:
int[] outputs = codebook.Translate("Output", labels);
// Let's declare the names of our input variables:
DecisionVariable[] features =
{
new DecisionVariable("sepal length", DecisionVariableKind.Continuous),
new DecisionVariable("sepal width", DecisionVariableKind.Continuous),
new DecisionVariable("petal length", DecisionVariableKind.Continuous),
new DecisionVariable("petal width", DecisionVariableKind.Continuous),
};
// Now, we can finally create our tree for the 3 classes:
var tree = new DecisionTree(inputs: features, classes: 3);
// And we can use the C4.5 for learning:
var teacher = new C45Learning(tree);
// And finally induce the tree:
teacher.Learn(inputs, outputs);
// To get the estimated class labels, we can use
int[] predicted = tree.Decide(inputs);
// And the classification error can be computed as
double error = new ZeroOneLoss(outputs) // 0.0266
{
Mean = true
}.Loss(tree.Decide(inputs));
// Moreover, we may decide to convert our tree to a set of rules:
DecisionSet rules = tree.ToRules();
// And using the codebook, we can inspect the tree reasoning:
string ruleText = rules.ToString(codebook, "Output",
System.Globalization.CultureInfo.InvariantCulture);
// The output is:
string expected = @"Iris-setosa =: (petal length <= 2.45)
Iris-versicolor =: (petal length > 2.45) && (petal width <= 1.75) && (sepal length <= 7.05) && (sepal width <= 2.85)
Iris-versicolor =: (petal length > 2.45) && (petal width <= 1.75) && (sepal length <= 7.05) && (sepal width > 2.85)
Iris-versicolor =: (petal length > 2.45) && (petal width > 1.75) && (sepal length <= 5.95) && (sepal width > 3.05)
Iris-virginica =: (petal length > 2.45) && (petal width <= 1.75) && (sepal length > 7.05)
Iris-virginica =: (petal length > 2.45) && (petal width > 1.75) && (sepal length > 5.95)
Iris-virginica =: (petal length > 2.45) && (petal width > 1.75) && (sepal length <= 5.95) && (sepal width <= 3.05)
";
#endregion
Assert.AreEqual(0.026666666666666668, error, 1e-10);
Assert.AreEqual(4, tree.NumberOfInputs);
Assert.AreEqual(3, tree.NumberOfOutputs);
double newError = ComputeError(rules, inputs, outputs);
Assert.AreEqual(0.026666666666666668, newError, 1e-10);
Assert.AreEqual(expected, ruleText);
}
public void ConsistencyTest1()
{
int[,] random = Matrix.Random(1000, 10, 0, 10).ToInt32();
int[][] samples = random.ToArray();
int[] outputs = new int[1000];
for (int i = 0; i < samples.Length; i++)
{
if (samples[i][0] > 8)
outputs[i] = 1;
}
DecisionVariable[] vars = new DecisionVariable[10];
for (int i = 0; i < vars.Length; i++)
vars[i] = new DecisionVariable(i.ToString(), new IntRange(0,10));
DecisionTree tree = new DecisionTree(vars, 2);
ID3Learning teacher = new ID3Learning(tree);
double error = teacher.Run(samples, outputs);
Assert.AreEqual(0, error);
Assert.AreEqual(11, tree.Root.Branches.Count);
for (int i = 0; i < tree.Root.Branches.Count; i++)
Assert.IsTrue(tree.Root.Branches[i].IsLeaf);
}
public void ConstantDiscreteVariableTest()
{
DecisionTree tree;
int[][] inputs;
int[] outputs;
DataTable data = new DataTable("Degenerated Tennis Example");
data.Columns.Add("Day", "Outlook", "Temperature", "Humidity", "Wind", "PlayTennis");
data.Rows.Add("D1", "Sunny", "Hot", "High", "Weak", "No");
data.Rows.Add("D2", "Sunny", "Hot", "High", "Strong", "No");
data.Rows.Add("D3", "Overcast", "Hot", "High", "Weak", "Yes");
data.Rows.Add("D4", "Rain", "Hot", "High", "Weak", "Yes");
data.Rows.Add("D5", "Rain", "Hot", "Normal", "Weak", "Yes");
data.Rows.Add("D6", "Rain", "Hot", "Normal", "Strong", "No");
data.Rows.Add("D7", "Overcast", "Hot", "Normal", "Strong", "Yes");
data.Rows.Add("D8", "Sunny", "Hot", "High", "Weak", "No");
data.Rows.Add("D9", "Sunny", "Hot", "Normal", "Weak", "Yes");
data.Rows.Add("D10", "Rain", "Hot", "Normal", "Weak", "Yes");
data.Rows.Add("D11", "Sunny", "Hot", "Normal", "Strong", "Yes");
data.Rows.Add("D12", "Overcast", "Hot", "High", "Strong", "Yes");
data.Rows.Add("D13", "Overcast", "Hot", "Normal", "Weak", "Yes");
data.Rows.Add("D14", "Rain", "Hot", "High", "Strong", "No");
// Create a new codification codebook to
// convert strings into integer symbols
Codification codebook = new Codification(data);
DecisionVariable[] attributes =
{
new DecisionVariable("Outlook", codebook["Outlook"].Symbols), // 3 possible values (Sunny, overcast, rain)
new DecisionVariable("Temperature", codebook["Temperature"].Symbols), // 1 constant value (Hot)
new DecisionVariable("Humidity", codebook["Humidity"].Symbols), // 2 possible values (High, normal)
new DecisionVariable("Wind", codebook["Wind"].Symbols) // 2 possible values (Weak, strong)
};
int classCount = codebook["PlayTennis"].Symbols; // 2 possible values (yes, no)
bool thrown = false;
try
{
tree = new DecisionTree(attributes, classCount);
}
catch
{
thrown = true;
}
Assert.IsTrue(thrown);
attributes[1] = new DecisionVariable("Temperature", 2);
tree = new DecisionTree(attributes, classCount);
ID3Learning id3 = new ID3Learning(tree);
// Extract symbols from data and train the classifier
DataTable symbols = codebook.Apply(data);
inputs = symbols.ToArray<int>("Outlook", "Temperature", "Humidity", "Wind");
outputs = symbols.ToArray<int>("PlayTennis");
double error = id3.Run(inputs, outputs);
for (int i = 0; i < inputs.Length; i++)
{
int y = tree.Compute(inputs[i]);
Assert.AreEqual(outputs[i], y);
}
}
public static void CreateXORExample(out DecisionTree tree, out int[][] inputs, out int[] outputs)
{
inputs = new int[][]
{
new int[] { 1, 0, 0, 1 },
new int[] { 0, 1, 0, 0 },
new int[] { 0, 0, 0, 0 },
new int[] { 1, 1, 0, 0 },
new int[] { 0, 1, 1, 1 },
new int[] { 0, 0, 1, 1 },
new int[] { 1, 0, 1, 1 }
};
outputs = new int[]
{
1, 1, 0, 0, 1, 0, 1
};
DecisionVariable[] attributes =
{
new DecisionVariable("a1", 2),
new DecisionVariable("a2", 2),
new DecisionVariable("a3", 2),
new DecisionVariable("a4", 2)
};
int classCount = 2;
tree = new DecisionTree(attributes, classCount);
ID3Learning id3 = new ID3Learning(tree);
double error = id3.Run(inputs, outputs);
}
public string Decide(Accord.MachineLearning.DecisionTrees.DecisionTree tree, Codification codebook, params double[] query)
{
int predicted = tree.Decide(query);
return(codebook.Revert(Constants.RESULT_COLUMN_NAME, predicted));
}
public void same_input_different_output()
{
double[][] inputs = new double[][] {
new double[] { 1 },
new double[] { 0 },
new double[] { 2 },
new double[] { 3 },
new double[] { 0 },
};
int[] outputs = new int[] {
11,
00,
22,
33,
01
};
DecisionVariable[] variables = { new DecisionVariable("x", DecisionVariableKind.Continuous) };
DecisionTree decisionTree = new DecisionTree(variables, 34);
C45Learning c45Learning = new C45Learning(decisionTree)
{
Join = 10,
MaxHeight = 10
};
c45Learning.Run(inputs, outputs); // System.AggregateException thrown here
int[] actual = decisionTree.Decide(inputs);
Assert.AreEqual(11, actual[0]);
Assert.AreEqual(00, actual[1]);
Assert.AreEqual(22, actual[2]);
Assert.AreEqual(33, actual[3]);
Assert.AreEqual(00, actual[4]);
}
public void same_input_different_output_minimal()
{
double[][] inputs = new double[][] {
new double[] { 0 },
new double[] { 0 }
};
int[] outputs = new int[] {
1,
0
};
DecisionVariable[] variables = { new DecisionVariable("x", DecisionVariableKind.Continuous) };
DecisionTree decisionTree = new DecisionTree(variables, 2);
C45Learning c45Learning = new C45Learning(decisionTree);
c45Learning.Run(inputs, outputs); // System.AggregateException thrown here
Assert.AreEqual(decisionTree.Decide(new[] { 0 }), 0);
}
public void AttributeReuseTest1()
{
string[][] text = Resources.iris_data.Split(
new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries)
.Apply(x => x.Split(','));
double[][] inputs = new double[text.Length][];
for (int i = 0; i < inputs.Length; i++)
inputs[i] = text[i].First(4).Convert(s => Double.Parse(s, System.Globalization.CultureInfo.InvariantCulture));
string[] labels = text.GetColumn(4);
Codification codebook = new Codification("Label", labels);
int[] outputs = codebook.Translate("Label", labels);
DecisionVariable[] features =
{
new DecisionVariable("sepal length", DecisionVariableKind.Continuous),
new DecisionVariable("sepal width", DecisionVariableKind.Continuous),
new DecisionVariable("petal length", DecisionVariableKind.Continuous),
new DecisionVariable("petal width", DecisionVariableKind.Continuous),
};
DecisionTree tree = new DecisionTree(features, codebook.Columns[0].Symbols);
C45Learning teacher = new C45Learning(tree);
teacher.Join = 3;
double error = teacher.Run(inputs, outputs);
Assert.AreEqual(0.02, error, 1e-10);
DecisionSet rules = tree.ToRules();
double newError = ComputeError(rules, inputs, outputs);
Assert.AreEqual(0.02, newError, 1e-10);
string ruleText = rules.ToString(codebook,
System.Globalization.CultureInfo.InvariantCulture);
// TODO: implement this assertion properly, actually checking
// the text contents once the feature is completely finished.
Assert.AreEqual(600, ruleText.Length);
}
public void RunTest()
{
int[][] inputs =
{
new int[] { 0, 0 },
new int[] { 0, 1 },
new int[] { 1, 0 },
new int[] { 1, 1 },
};
int[] outputs = // xor
{
0,
1,
1,
0
};
DecisionVariable[] attributes =
{
new DecisionVariable("x", DecisionVariableKind.Discrete),
new DecisionVariable("y", DecisionVariableKind.Discrete),
};
DecisionTree tree = new DecisionTree(attributes, 2);
ID3Learning teacher = new ID3Learning(tree);
double error = teacher.Run(inputs, outputs);
Assert.AreEqual(0, error);
Assert.AreEqual(0, tree.Root.Branches.AttributeIndex); // x
Assert.AreEqual(2, tree.Root.Branches.Count);
Assert.IsNull(tree.Root.Value);
Assert.IsNull(tree.Root.Value);
Assert.AreEqual(0.0, tree.Root.Branches[0].Value); // x = [0]
Assert.AreEqual(1.0, tree.Root.Branches[1].Value); // x = [1]
Assert.AreEqual(tree.Root, tree.Root.Branches[0].Parent);
Assert.AreEqual(tree.Root, tree.Root.Branches[1].Parent);
Assert.AreEqual(2, tree.Root.Branches[0].Branches.Count);
Assert.AreEqual(2, tree.Root.Branches[1].Branches.Count);
Assert.IsTrue(tree.Root.Branches[0].Branches[0].IsLeaf);
Assert.IsTrue(tree.Root.Branches[0].Branches[1].IsLeaf);
Assert.IsTrue(tree.Root.Branches[1].Branches[0].IsLeaf);
Assert.IsTrue(tree.Root.Branches[1].Branches[1].IsLeaf);
Assert.AreEqual(0.0, tree.Root.Branches[0].Branches[0].Value); // y = [0]
Assert.AreEqual(1.0, tree.Root.Branches[0].Branches[1].Value); // y = [1]
Assert.AreEqual(0.0, tree.Root.Branches[1].Branches[0].Value); // y = [0]
Assert.AreEqual(1.0, tree.Root.Branches[1].Branches[1].Value); // y = [1]
Assert.AreEqual(0, tree.Root.Branches[0].Branches[0].Output); // 0 ^ 0 = 0
Assert.AreEqual(1, tree.Root.Branches[0].Branches[1].Output); // 0 ^ 1 = 1
Assert.AreEqual(1, tree.Root.Branches[1].Branches[0].Output); // 1 ^ 0 = 1
Assert.AreEqual(0, tree.Root.Branches[1].Branches[1].Output); // 1 ^ 1 = 0
}
public void LargeSampleTest1()
{
Accord.Math.Tools.SetupGenerator(0);
int[][] dataSamples = Matrix.Random(500, 3, 0, 10).ToInt32().ToArray();
int[] target = Matrix.Random(500, 1, 0, 2).ToInt32().GetColumn(0);
DecisionVariable[] features =
{
new DecisionVariable("Outlook", 10),
new DecisionVariable("Temperature", 10),
new DecisionVariable("Humidity", 10),
};
DecisionTree tree = new DecisionTree(features, 2);
ID3Learning id3Learning = new ID3Learning(tree);
double error = id3Learning.Run(dataSamples, target);
Assert.IsTrue(error < 0.2);
var code = tree.ToCode("MyTree");
Assert.IsNotNull(code);
Assert.IsTrue(code.Length > 0);
}
public void IncompleteDiscreteVariableTest()
{
DecisionTree tree;
int[][] inputs;
int[] outputs;
DataTable data = new DataTable("Degenerated Tennis Example");
data.Columns.Add("Day", "Outlook", "Temperature", "Humidity", "Wind", "PlayTennis");
data.Rows.Add("D1", "Sunny", "Hot", "High", "Weak", "No");
data.Rows.Add("D2", "Sunny", "Hot", "High", "Strong", "No");
data.Rows.Add("D3", "Overcast", "Hot", "High", "Weak", "Yes");
data.Rows.Add("D4", "Rain", "Mild", "High", "Weak", "Yes");
data.Rows.Add("D5", "Rain", "Cool", "Normal", "Weak", "Yes");
data.Rows.Add("D6", "Rain", "Cool", "Normal", "Strong", "No");
data.Rows.Add("D7", "Overcast", "Cool", "Normal", "Strong", "Yes");
data.Rows.Add("D8", "Sunny", "Mild", "High", "Weak", "No");
data.Rows.Add("D9", "Sunny", "Cool", "Normal", "Weak", "Yes");
data.Rows.Add("D10", "Rain", "Mild", "Normal", "Weak", "Yes");
data.Rows.Add("D11", "Sunny", "Mild", "Normal", "Strong", "Yes");
data.Rows.Add("D12", "Overcast", "Mild", "High", "Strong", "Yes");
data.Rows.Add("D13", "Overcast", "Hot", "Normal", "Weak", "Yes");
data.Rows.Add("D14", "Rain", "Mild", "High", "Strong", "No");
// Create a new codification codebook to
// convert strings into integer symbols
Codification codebook = new Codification(data);
DecisionVariable[] attributes =
{
new DecisionVariable("Outlook", codebook["Outlook"].Symbols+200), // 203 possible values, 200 undefined
new DecisionVariable("Temperature", codebook["Temperature"].Symbols), // 3 possible values (Hot, mild, cool)
new DecisionVariable("Humidity", codebook["Humidity"].Symbols), // 2 possible values (High, normal)
new DecisionVariable("Wind", codebook["Wind"].Symbols) // 2 possible values (Weak, strong)
};
int classCount = codebook["PlayTennis"].Symbols; // 2 possible values (yes, no)
tree = new DecisionTree(attributes, classCount);
ID3Learning id3 = new ID3Learning(tree);
// Extract symbols from data and train the classifier
DataTable symbols = codebook.Apply(data);
inputs = symbols.ToArray<int>("Outlook", "Temperature", "Humidity", "Wind");
outputs = symbols.ToArray<int>("PlayTennis");
double error = id3.Run(inputs, outputs);
Assert.AreEqual(203, tree.Root.Branches.Count);
Assert.IsTrue(tree.Root.Branches[100].IsLeaf);
Assert.IsNull(tree.Root.Branches[100].Output);
for (int i = 0; i < inputs.Length; i++)
{
int y = tree.Compute(inputs[i]);
Assert.AreEqual(outputs[i], y);
}
}
public void LargeSampleTest_WithRepetition()
{
Accord.Math.Tools.SetupGenerator(0);
int[][] dataSamples = Matrix.Random(500, 3, 0, 10).ToInt32().ToArray();
int[] target = Matrix.Random(500, 1, 0, 2).ToInt32().GetColumn(0);
DecisionVariable[] features =
{
new DecisionVariable("Outlook", 10),
new DecisionVariable("Temperature", 10),
new DecisionVariable("Humidity", 10),
};
DecisionTree tree = new DecisionTree(features, 2);
ID3Learning id3Learning = new ID3Learning(tree)
{
Rejection = false,
Join = 2 // every variable can join two times
};
double error = id3Learning.Run(dataSamples, target);
int height = tree.GetHeight();
Assert.AreEqual(6, height);
foreach (var node in tree)
{
if (node.IsLeaf)
Assert.IsNotNull(node.Output);
}
Assert.IsTrue(error < 0.15);
}
//
//You can use the following additional attributes as you write your tests:
//
//Use ClassInitialize to run code before running the first test in the class
//[ClassInitialize()]
//public static void MyClassInitialize(TestContext testContext)
//{
//}
//
//Use ClassCleanup to run code after all tests in a class have run
//[ClassCleanup()]
//public static void MyClassCleanup()
//{
//}
//
//Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize()
//{
//}
//
//Use TestCleanup to run code after each test has run
//[TestCleanup()]
//public void MyTestCleanup()
//{
//}
//
#endregion
public static void CreateMitchellExample(out DecisionTree tree, out int[][] inputs, out int[] outputs)
{
DataTable data = new DataTable("Mitchell's Tennis Example");
data.Columns.Add("Day", "Outlook", "Temperature", "Humidity", "Wind", "PlayTennis");
data.Rows.Add("D1", "Sunny", "Hot", "High", "Weak", "No");
data.Rows.Add("D2", "Sunny", "Hot", "High", "Strong", "No");
data.Rows.Add("D3", "Overcast", "Hot", "High", "Weak", "Yes");
data.Rows.Add("D4", "Rain", "Mild", "High", "Weak", "Yes");
data.Rows.Add("D5", "Rain", "Cool", "Normal", "Weak", "Yes");
data.Rows.Add("D6", "Rain", "Cool", "Normal", "Strong", "No");
data.Rows.Add("D7", "Overcast", "Cool", "Normal", "Strong", "Yes");
data.Rows.Add("D8", "Sunny", "Mild", "High", "Weak", "No");
data.Rows.Add("D9", "Sunny", "Cool", "Normal", "Weak", "Yes");
data.Rows.Add("D10", "Rain", "Mild", "Normal", "Weak", "Yes");
data.Rows.Add("D11", "Sunny", "Mild", "Normal", "Strong", "Yes");
data.Rows.Add("D12", "Overcast", "Mild", "High", "Strong", "Yes");
data.Rows.Add("D13", "Overcast", "Hot", "Normal", "Weak", "Yes");
data.Rows.Add("D14", "Rain", "Mild", "High", "Strong", "No");
// Create a new codification codebook to
// convert strings into integer symbols
Codification codebook = new Codification(data);
DecisionVariable[] attributes =
{
new DecisionVariable("Outlook", codebook["Outlook"].Symbols), // 3 possible values (Sunny, overcast, rain)
new DecisionVariable("Temperature", codebook["Temperature"].Symbols), // 3 possible values (Hot, mild, cool)
new DecisionVariable("Humidity", codebook["Humidity"].Symbols), // 2 possible values (High, normal)
new DecisionVariable("Wind", codebook["Wind"].Symbols) // 2 possible values (Weak, strong)
};
int classCount = codebook["PlayTennis"].Symbols; // 2 possible values (yes, no)
tree = new DecisionTree(attributes, classCount);
ID3Learning id3 = new ID3Learning(tree);
// Extract symbols from data and train the classifier
DataTable symbols = codebook.Apply(data);
inputs = symbols.ToArray<int>("Outlook", "Temperature", "Humidity", "Wind");
outputs = symbols.ToArray<int>("PlayTennis");
double error = id3.Run(inputs, outputs);
Assert.AreEqual(0, error);
foreach (DataRow row in data.Rows)
{
var x = codebook.Translate(row, "Outlook", "Temperature", "Humidity", "Wind");
int y = tree.Compute(x);
string actual = codebook.Translate("PlayTennis", y);
string expected = row["PlayTennis"] as string;
Assert.AreEqual(expected, actual);
}
{
string answer = codebook.Translate("PlayTennis",
tree.Compute(codebook.Translate("Sunny", "Hot", "High", "Strong")));
Assert.AreEqual("No", answer);
}
}
/// <summary>
/// Creates a new decision node.
/// </summary>
///
/// <param name="owner">The owner tree for this node.</param>
///
public DecisionNode(DecisionTree owner)
{
Owner = owner;
Comparison = ComparisonKind.None;
Branches = new DecisionBranchNodeCollection(this);
}
public void ArgumentCheck1()
{
int[][] samples =
{
new [] { 0, 2, 4 },
new [] { 1, 5, 2 },
null,
new [] { 1, 5, 6 },
};
int[] outputs =
{
1, 1, 0, 0
};
DecisionVariable[] vars = new DecisionVariable[3];
for (int i = 0; i < vars.Length; i++)
vars[i] = DecisionVariable.Discrete(i.ToString(), new IntRange(0, 10));
DecisionTree tree = new DecisionTree(vars, 2);
ID3Learning teacher = new ID3Learning(tree);
bool thrown = false;
try { double error = teacher.Run(samples, outputs); }
catch (ArgumentNullException) { thrown = true; }
Assert.IsTrue(thrown);
}
/// <summary>
/// Creates a new decision node.
/// </summary>
///
/// <param name="owner">The owner tree for this node.</param>
///
public DecisionNode(DecisionTree owner)
{
Owner = owner;
Comparison = ComparisonKind.None;
}
/// <summary>
/// Creates a new decision node.
/// </summary>
///
/// <param name="owner">The owner tree for this node.</param>
///
public DecisionNode(DecisionTree owner)
{
Owner = owner;
Comparison = ComparisonKind.None;
Branches = new DecisionBranchNodeCollection(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="DecisionTreeExpressionCreator"/> class.
/// </summary>
///
/// <param name="tree">The decision tree.</param>
///
internal DecisionTreeExpressionCreator(DecisionTree tree)
{
this.tree = tree;
}
/// <summary>
/// Creates and learns a Decision Tree to recognize the
/// previously loaded dataset using the current settings.
/// </summary>
///
private void btnCreate_Click(object sender, EventArgs e)
{
if (dgvLearningSource.DataSource == null)
{
MessageBox.Show("Please load some data first.");
return;
}
// Finishes and save any pending changes to the given data
dgvLearningSource.EndEdit();
// Creates a matrix from the entire source data table
double[,] table = (dgvLearningSource.DataSource as DataTable).ToMatrix(out columnNames);
// Get only the input vector values (first two columns)
double[][] inputs = table.GetColumns(0, 1).ToArray();
// Get only the output labels (last column)
int[] outputs = table.GetColumn(2).ToInt32();
// Specify the input variables
DecisionVariable[] variables =
{
new DecisionVariable("x", DecisionVariableKind.Continuous),
new DecisionVariable("y", DecisionVariableKind.Continuous),
};
// Create the discrete Decision tree
tree = new DecisionTree(variables, 2);
// Create the C4.5 learning algorithm
C45Learning c45 = new C45Learning(tree);
// Learn the decision tree using C4.5
double error = c45.Run(inputs, outputs);
// Show the learned tree in the view
decisionTreeView1.TreeSource = tree;
// Get the ranges for each variable (X and Y)
DoubleRange[] ranges = Matrix.Range(table, 0);
// Generate a Cartesian coordinate system
double[][] map = Matrix.CartesianProduct(
Matrix.Interval(ranges[0], 0.05),
Matrix.Interval(ranges[1], 0.05));
// Classify each point in the Cartesian coordinate system
double[] result = map.Apply(tree.Compute).ToDouble();
double[,] surface = map.ToMatrix().InsertColumn(result);
CreateScatterplot(zedGraphControl2, surface);
lbStatus.Text = "Learning finished! Click the other tabs to explore results!";
}
