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 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 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 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 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 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); }
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 ConsistencyTest1_automatic() { int n = 10000; int[,] random = Matrix.Random(n, 10, 0.0, 11.0).ToInt32(); int[][] samples = random.ToJagged(); int[] outputs = new int[n]; for (int i = 0; i < samples.Length; i++) { if (samples[i][0] > 8) outputs[i] = 1; } ID3Learning teacher = new ID3Learning(); var tree = teacher.Learn(samples, outputs); double error = teacher.ComputeError(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); }
/// <summary> /// Создание дерева /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void btnCreate_Click(object sender, EventArgs e) { try { if (dgvLearningSource.DataSource == null) { MessageBox.Show("Загрузите данные"); return; } if (Tree_property.Property_View == true) { Tree_property.ShowDialog(); } // Завершаем операцию с DataGridView dgvLearningSource.EndEdit(); #region Алгоритм С4.5 /// ///Алгоритм С4.5 /// if (Tree_property.Alg == "C4.5") { // // создаем матрицу из data table double[,] sourceMatrix = (dgvLearningSource.DataSource as DataTable).ToMatrix(out sourceColumns); C45Learning c45; // получаем входные значения double[][] inputs = sourceMatrix.Submatrix(null, 0, Tree_property.Coun_In - 1).ToArray(); // получаем выходные значения int[] outputs = sourceMatrix.GetColumn(Tree_property.Coun_Out - 1).ToInt32(); DecisionVariable[] attributes = new DecisionVariable[Tree_property.Coun_In]; for (int j = 0; j < Tree_property.Coun_In; j++) { attributes[j] = new DecisionVariable(dgvLearningSource.Columns[j].Name, DecisionAttributeKind.Continuous); } // создаем дерево решений tree = new DecisionTree(attributes, 60); c45 = new C45Learning(tree); double error = c45.Run(inputs, outputs); } #endregion #region Алгоритм ID3 /// ///Алгоритм ID3 /// if (Tree_property.Alg == "ID3") { // создаем матрицу из дататыйбл int[][] arr = (dgvLearningSource.DataSource as DataTable).ToIntArray(sourceColumns); int[,] sourceMatrix = arr.ToMatrix(); //// получаем входные значения int[][] inputs = sourceMatrix.Submatrix(null, 0, Tree_property.Coun_In - 1).ToArray(); //// получаем выходные значения int[] outputs = sourceMatrix.GetColumn(Tree_property.Coun_In - 1); DecisionVariable[] attributes = new DecisionVariable[Tree_property.Coun_In]; for (int j = 0; j < Tree_property.Coun_In; j++) { attributes[j] = new DecisionVariable(j.ToString(), DecisionAttributeKind.Continuous); } // создаем дерево решений tree = new DecisionTree(attributes, 60); ID3Learning id3learning = new ID3Learning(tree); double error = id3learning.Run(inputs, outputs); } #endregion asd.Dispose(); asd.Close(); Drawing dr = new Drawing(); dr.recursion(tree.Root, tree.Root.Branches, 0); dr.Save_(); asd = new Tree_View(); asd.userControl11.Load_f(Application.StartupPath); System.Linq.Expressions.Expression df = tree.ToExpression(); // выбираем tabe page для просмотра дерева tabControl.SelectTab(tabOverview); // отображаем построенной дереыыо решений decisionTreeView1.TreeSource = tree; try { File.Copy(@".\Resources\recursion.png", @".\Resources\recursion2.png", true); } catch { } using (Stream s = File.OpenRead(@".\Resources\recursion2.png")) { pictureBox1.Image = Image.FromStream(s); } } catch (Exception t) { MessageBox.Show(t.Message); } }
// //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 string kararAgaci(DataTable tbl) { int classCount = 2; Codification codebook = new Codification(tbl); DecisionVariable[] attributes ={ new DecisionVariable("Clump Thickness",10), new DecisionVariable("Uniformity of Cell Size",10),new DecisionVariable("Uniformity of Cell Shape",10), new DecisionVariable("Marginal Adhesion",10),new DecisionVariable("Single Epithelial Cell Size",10), new DecisionVariable("Bare Nuclei",10),new DecisionVariable("Bland Chromatin",10), new DecisionVariable("Normal Nucleoli",10),new DecisionVariable("Mitoses",10), }; DecisionTree tree = new DecisionTree(attributes, classCount); ID3Learning id3learning = new ID3Learning(tree); // Translate our training data into integer symbols using our codebook: DataTable symbols = codebook.Apply(tbl); int[][] inputs = symbols.ToIntArray("Clump Thickness", "Uniformity of Cell Size", "Uniformity of Cell Shape", "Marginal Adhesion", "Single Epithelial Cell Size", "Bare Nuclei", "Bland Chromatin", "Normal Nucleoli", "Mitoses"); int[] outputs = symbols.ToIntArray("Class").GetColumn(0); // symbols. id3learning.Run(inputs, outputs); int[] query = codebook.Translate(inputlar[0], inputlar[1], inputlar[2], inputlar[3], inputlar[4], inputlar[5], inputlar[6], inputlar[7], inputlar[8]); int output = tree.Compute(query); string answer = codebook.Translate("Class", output); return answer; }
public void Run(String filename) { ReadFile(filename); // Create a new codification codebook to // convert strings into integer symbols Codification codebook = new Codification(data, inputColumns.ToArray()); // Translate our training data into integer symbols using our codebook: DataTable symbols = codebook.Apply(data); foreach (String s in inputColumns) CreateDic(s, symbols); CreateDic(outputColumn, symbols); int[][] inputs = (from p in symbols.AsEnumerable() select GetInputRow(p) ).Cast<int[]>().ToArray(); int[] outputs = (from p in symbols.AsEnumerable() select GetIndex(outputColumn, p[outputColumn].ToString())).Cast<int>().ToArray(); // Gather information about decision variables DecisionVariable[] attributes = GetDecisionVariables(); int classCount = GetCount(outputColumn); // 2 possible output values for playing tennis: yes or no //Create the decision tree using the attributes and classes DecisionTree tree = new DecisionTree(attributes, classCount); // Create a new instance of the ID3 algorithm ID3Learning id3learning = new ID3Learning(tree); //C45Learning c45learning = new C45Learning(tree); // Learn the training instances! id3learning.Run(inputs, outputs); //c45learning.Run(inputs2, outputs); /* string answer = codebook.Translate(outputColumn, tree.Compute(codebook.Translate("Sunny", "Hot", "High", "Strong"))); Console.WriteLine("Calculate for: Sunny, Hot, High, Strong"); Console.WriteLine("Answer: " + answer); */ var expression = tree.ToExpression(); Console.WriteLine(tree.ToCode("ClassTest")); DecisionSet rules = tree.ToRules(); Console.WriteLine(rules.ToString()); // Compiles the expression to IL var func = expression.Compile(); }
public void Run() { DataTable data = new DataTable("Mitchell's Tennis Example"); data.Columns.Add("Day"); data.Columns.Add("Outlook"); data.Columns.Add("Temperature"); data.Columns.Add("Humidity"); data.Columns.Add("Wind"); data.Columns.Add("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, "Outlook", "Temperature", "Humidity", "Wind", "PlayTennis"); // Translate our training data into integer symbols using our codebook: DataTable symbols = codebook.Apply(data); CreateDic("Outlook", symbols); CreateDic("Temperature", symbols); CreateDic("Humidity", symbols); CreateDic("Wind", symbols); CreateDic("PlayTennis", symbols); int[][] inputs = (from p in symbols.AsEnumerable() select new int[] { GetIndex("Outlook", p["Outlook"].ToString()), GetIndex("Temperature", p["Temperature"].ToString()), GetIndex("Humidity", p["Humidity"].ToString()), GetIndex("Wind", p["Wind"].ToString()) }).Cast<int[]>().ToArray(); int[] outputs = (from p in symbols.AsEnumerable() select GetIndex("PlayTennis", p["PlayTennis"].ToString())).Cast<int>().ToArray(); /* // Gather information about decision variables DecisionVariable[] attributes = { new DecisionVariable("Outlook", 3), // 3 possible values (Sunny, overcast, rain) new DecisionVariable("Temperature", 3), // 3 possible values (Hot, mild, cool) new DecisionVariable("Humidity", 2), // 2 possible values (High, normal) new DecisionVariable("Wind", 2) // 2 possible values (Weak, strong) }; */ DecisionVariable[] attributes = { new DecisionVariable("Outlook", GetCount("Outlook")), // 3 possible values (Sunny, overcast, rain) new DecisionVariable("Temperature", GetCount("Temperature")), // 3 possible values (Hot, mild, cool) new DecisionVariable("Humidity", GetCount("Humidity")), // 2 possible values (High, normal) new DecisionVariable("Wind", GetCount("Wind")) // 2 possible values (Weak, strong) }; int classCount = GetCount("PlayTennis"); // 2 possible output values for playing tennis: yes or no //Create the decision tree using the attributes and classes DecisionTree tree = new DecisionTree(attributes, classCount); // Create a new instance of the ID3 algorithm ID3Learning id3learning = new ID3Learning(tree); // Learn the training instances! id3learning.Run(inputs, outputs); string answer = codebook.Translate("PlayTennis", tree.Compute(codebook.Translate("Sunny", "Hot", "High", "Strong"))); Console.WriteLine("Calculate for: Sunny, Hot, High, Strong"); Console.WriteLine("Answer: " + answer); var expression = tree.ToExpression(); Console.WriteLine(tree.ToCode("ClassTest")); DecisionSet s = tree.ToRules(); Console.WriteLine(s.ToString()); // Compiles the expression to IL var func = expression.Compile(); }
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 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); }
// //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); } }
public void learn_test_automatic() { 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 }; ID3Learning teacher = new ID3Learning(); var tree = teacher.Learn(inputs, outputs); double error = teacher.ComputeError(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 }