Merge branch 'master' of https://github.com/chriswblake/Knowledge-Production-and-Control-of-a-Black-Box-Using-Machine-Learning

Christopher Blake · Christopher Blake · commit 4d927758000c · 2018-09-08T23:28:05.000+03:00
diff --git a/BlackBox/BlackBox/Samples/TrigFunctions.cs b/BlackBox/BlackBox/Samples/TrigFunctions.cs
@@ -14,7 +14,7 @@ public TrigFunctions()
             this.Name = "Trig Functions";
 
             //Define inputs
-            AddInput("x");
+            AddInput("angle");
 
             //Define outputs
             AddOutput("sin");
@@ -32,9 +32,10 @@ public override void Run()
             var o = Output;
 
             //Define relationship between outputs and inputs
-            o["sin"] = Math.Sin(Convert.ToDouble(i["x"]));
-            o["cos"] = Math.Cos(Convert.ToDouble(i["x"]));
-            o["tan"] = Math.Tan(Convert.ToDouble(i["x"]));
+            double radians = Convert.ToDouble(i["angle"])/180*Math.PI;
+            o["sin"] = Math.Sin(radians);
+            o["cos"] = Math.Cos(radians);
+            o["tan"] = Math.Tan(radians);
         }
     }
 }
diff --git a/KnowProdContBlackBox/KnowProdContBlackBox.Experiments/Experiment.cs b/KnowProdContBlackBox/KnowProdContBlackBox.Experiments/Experiment.cs
@@ -2,27 +2,50 @@
 using System.Collections.Generic;
 using System.Text;
 using System.IO;
+using System.Runtime.CompilerServices;
+using System.Diagnostics;
 
 namespace KnowProdContBlackBox.Experiments
 {
     public class Experiment
     {
-        protected string ResultsDir = System.IO.Path.GetFullPath(@"..\..\..\Results\");
+        //Properties
+        protected string ResultsDir
+        {
+            get
+            {
+                //Get path components
+                string basePath = Path.GetFullPath(@"..\..\..\Results\");
+                string className = GetClassName();
+                string methodName = GetCurrentMethodName(2);
+
+                //Combine
+                string result = Path.Combine(basePath, className, methodName);
+
+                //Create folder if missing
+                if (!Directory.Exists(result))
+                    Directory.CreateDirectory(result);
+
+                return result;
+            }
+        }
+        //protected string ResultsDir2 = System.IO.Path.GetFullPath(@"..\..\..\Results\");
 
-        //Constructor
-        public Experiment()
+        //Methods
+        private string GetClassName()
         {
-            //Determine name of folder
             string className = this.GetType().Name;
             className = className.Replace("Experiments", "");
             className = className.Replace("Experiment", "");
+            return className;
+        }
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private string GetCurrentMethodName(int stepsBack)
+        {
+            var st = new StackTrace();
+            var sf = st.GetFrame(1 + stepsBack);
 
-            //Update result dir
-            ResultsDir = Path.Combine(ResultsDir, className);
-
-            //Create folder if missing
-            if (!Directory.Exists(ResultsDir))
-                Directory.CreateDirectory(ResultsDir);
+            return sf.GetMethod().Name;
         }
     }
 }
diff --git a/KnowProdContBlackBox/KnowProdContBlackBox.Experiments/PolicyLearnerExperiments.cs b/KnowProdContBlackBox/KnowProdContBlackBox.Experiments/PolicyLearnerExperiments.cs
@@ -10,6 +10,8 @@
 using KnowledgeProduction;
 using IdManagement;
 using RLDT;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
 
 namespace KnowProdContBlackBox.Experiments
 {
@@ -193,5 +195,200 @@ public void LogicOperations(int iterations)
 
             return;
         }
+
+        [Theory]
+        //[InlineData(5)]
+        //[InlineData(10)]
+        //[InlineData(15)]
+        //[InlineData(20)]
+        //[InlineData(25)]
+        //[InlineData(30)]
+        //[InlineData(35)]
+        [InlineData(40)]
+        public void TrigFunctions(int passes)
+        {
+            double angleInterval = 1;
+
+            List<double> angles = new List<double> {};
+            for (double r = 0; r < 180; r += angleInterval)
+                angles.Add(r);
+            IdManager idManager = new IdManager();
+            BlackBox trigBlackBox = new BlackBoxModeling.Samples.TrigFunctions() { TimeInterval_ms = 10 };
+            DiscreteBlackBox discBlackBox = new DiscreteBlackBox(trigBlackBox, idManager);
+            ProducerBlackBox prodBlackBox = new ProducerBlackBox(discBlackBox, idManager);
+            Interpreter interpreter = new Interpreter(prodBlackBox) { MemorySize = passes * 2 };
+            PolicyLearner policyLearner = new PolicyLearner(interpreter, idManager);
+            Random rand = new Random();
+            trigBlackBox.Start();
+
+            #region Train
+            for (int i = 0; i < passes; i++)
+            {
+                //Change input
+                List<double> angles_noisy = GenerateNoisyData(angles, 0.001, 1).OrderBy(p => rand.NextDouble()).ToList();
+                foreach(double angle in angles_noisy)
+                {
+                    for (int j = 0; j < 1; j++)
+                    { 
+                        trigBlackBox.Input["angle"] = angle;
+
+                        //Wait until next sample time
+                        Thread.Sleep(trigBlackBox.TimeInterval_ms);
+                    }
+                }
+            }
+            #endregion
+
+            //Get Discretizers and Producers
+            var discAngle = discBlackBox.Discretizers["angle"];
+            var discSin = discBlackBox.Discretizers["sin"];
+            var discCos = discBlackBox.Discretizers["cos"];
+            var discTan = discBlackBox.Discretizers["tan"];
+            var prodAngle = prodBlackBox.Producers["angle"];
+            var prodSin = prodBlackBox.Producers["sin"];
+            var prodCos = prodBlackBox.Producers["cos"];
+            var prodTan = prodBlackBox.Producers["tan"];
+            Policy policySin = policyLearner.Policies["sin"];
+            Policy policyCos = policyLearner.Policies["cos"];
+            Policy policyTan = policyLearner.Policies["tan"];
+
+            //Check if training was sucessfull
+            //Assert.Equal(4, disc1.Bins.Count);
+            //Assert.Equal(4, disc2.Bins.Count);
+            //Assert.Equal(4, discand.Bins.Count);
+            //Assert.Equal(4, discor.Bins.Count);
+            //Assert.Equal(4, discxor.Bins.Count);
+            //Assert.Equal(4, discxor.Bins.Count);
+            //Assert.InRange(prod1.KnowInstances.Count, 8, 10);
+            //Assert.InRange(prod2.KnowInstances.Count, 8, 10);
+            //Assert.InRange(prodand.KnowInstances.Count, 8, 10);
+            //Assert.InRange(prodor.KnowInstances.Count, 8, 10);
+            //Assert.InRange(prodxor.KnowInstances.Count, 8, 10);
+
+            //Name Entities by their average
+            foreach(Bin theBin in discAngle.Bins)
+                idManager.SetName(theBin.BinID, theBin.Average.ToString("N2"));
+            foreach (Bin theBin in discSin.Bins)
+                idManager.SetName(theBin.BinID, theBin.Average.ToString("N2"));
+            foreach (Bin theBin in discCos.Bins)
+                idManager.SetName(theBin.BinID, theBin.Average.ToString("N2"));
+            foreach (Bin theBin in discTan.Bins)
+                idManager.SetName(theBin.BinID, theBin.Average.ToString("N2"));
+
+            //Calculate predicted values and error
+            Dictionary<double, Dictionary<string, double>> compResults = new Dictionary<double, Dictionary<string, double>>();
+            Dictionary<string, double> trigEntryTemplate = new Dictionary<string, double>();
+            trigEntryTemplate.Add("sin", double.NaN);
+            trigEntryTemplate.Add("cos", double.NaN);
+            trigEntryTemplate.Add("tan", double.NaN);
+            trigEntryTemplate.Add("sinPred", double.NaN);
+            trigEntryTemplate.Add("cosPred", double.NaN);
+            trigEntryTemplate.Add("tanPred", double.NaN);
+            trigEntryTemplate.Add("sinError", double.NaN);
+            trigEntryTemplate.Add("cosError", double.NaN);
+            trigEntryTemplate.Add("tanError", double.NaN);
+            for (double angle=0; angle <= 180; angle += angleInterval)
+            {
+                //Create entry in dictionaries
+                compResults.Add(angle, new Dictionary<string, double>(trigEntryTemplate));
+                double radians = angle / 180 * Math.PI;
+
+                //Get real values
+                compResults[angle]["sin"] = Math.Sin(radians);
+                compResults[angle]["cos"] = Math.Cos(radians);
+                compResults[angle]["tan"] = Math.Tan(radians);
+
+                //Convert angle to knowledge instance
+                Bin binAngle = discAngle.GetBin(angle);
+                KnowInstance ki = prodAngle.Get(binAngle.BinID);
+
+                #region Get predicted values
+                DataVector dv = new DataVector(new string[] {"angle"}, new object[] {ki});
+                //Sin
+                try
+                {
+                    KnowInstanceValue predKi_sin = (KnowInstanceValue) ((KnowInstanceWithMetaData)policySin.Classify_ByPolicy(dv, false)).InnerKnowInstance;
+                    Bin predBinSin = (Bin)predKi_sin.Content;
+                    compResults[angle]["sinPred"] = predBinSin.Average;
+                }
+                catch { }
+                //Cos
+                try
+                {
+                    KnowInstanceValue predKi_cos = (KnowInstanceValue)((KnowInstanceWithMetaData)policyCos.Classify_ByPolicy(dv, false)).InnerKnowInstance;
+                    Bin predBinCos = (Bin)predKi_cos.Content;
+                    compResults[angle]["cosPred"] = predBinCos.Average;
+                }
+                catch { }
+                //Tan
+                try
+                {
+                    KnowInstanceValue predKi_tan = (KnowInstanceValue)((KnowInstanceWithMetaData)policyTan.Classify_ByPolicy(dv, false)).InnerKnowInstance;
+                    Bin predBinTan = (Bin)predKi_tan.Content;
+                    compResults[angle]["tanPred"] = predBinTan.Average;
+                }
+                catch { }
+                #endregion
+
+                //Calculate error
+                compResults[angle]["sinError"] = compResults[angle]["sin"] - compResults[angle]["sinPred"];
+                compResults[angle]["cosError"] = compResults[angle]["cos"] - compResults[angle]["cosPred"];
+                compResults[angle]["tanError"] = compResults[angle]["tan"] - compResults[angle]["tanPred"];
+            }
+
+            //Save error results to csv
+            List<string> errorResults = new List<string>();
+            errorResults.Add("angle,sin,cos,tan,Predicted Sin,Predicted Cos,Predicted Tan, Error Sin, Error Cos, Error Tan");
+            foreach(var prediction in compResults)
+            {
+                double angle = prediction.Key;
+                string row = string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9}",
+                    angle,
+                    compResults[angle]["sin"],
+                    compResults[angle]["cos"],
+                    compResults[angle]["tan"],
+                    
+                    compResults[angle]["sinPred"],
+                    compResults[angle]["cosPred"],
+                    compResults[angle]["tanPred"],
+
+                    compResults[angle]["sinError"],
+                    compResults[angle]["cosError"],
+                    compResults[angle]["tanError"]
+                    );
+                errorResults.Add(row);
+            }
+            File.WriteAllLines(SavePath(passes + "_ErrorResults.csv"), errorResults.ToArray());
+
+            //Save training results to csv
+            File.WriteAllLines(SavePath(passes + "_angle.csv"), ToStringArray(prodAngle.KnowInstances.Values.ToList(), idManager));
+            File.WriteAllLines(SavePath(passes + "_sin.csv"), ToStringArray(prodSin.KnowInstances.Values.ToList(), idManager));
+            File.WriteAllLines(SavePath(passes + "_cos.csv"), ToStringArray(prodCos.KnowInstances.Values.ToList(), idManager));
+            File.WriteAllLines(SavePath(passes + "_tan.csv"), ToStringArray(prodTan.KnowInstances.Values.ToList(), idManager));
+
+            //Convert policies to html and save to file
+            string htmlTree = HtmlTools.ToHtml(policyLearner, idManager);
+            File.WriteAllText(SavePath(passes + "_decision_tree.html"), htmlTree);
+
+            return;
+        }
+
+        public string[] ToStringArray(List<KnowInstance> knowInstances, IdManager idManager)
+        {
+            List<string> csv = new List<string>();
+            csv.Add("ID,Name,Content");
+            foreach(KnowInstance ki in knowInstances)
+            {
+                KnowInstanceWithMetaData kim = new KnowInstanceWithMetaData(ki, idManager);
+                csv.Add(string.Format("{0},\"{1}\",\"{2}\"", kim.ID, kim.Name, ki.ContentToString()));
+            }
+
+            return csv.ToArray();
+        }
+        private string SavePath(string fileName)
+        {
+            return Path.Combine(this.ResultsDir, fileName);
+        }
+        
     }
 }
diff --git a/KnowProdContBlackBox/KnowProdCont_BlackBox/HtmlTools.cs b/KnowProdContBlackBox/KnowProdCont_BlackBox/HtmlTools.cs
@@ -27,8 +27,8 @@ static public string ToHtml(PolicyLearner policyLearner, IdManager idManager)
             var treeSettingsConversion = new RLDT.DecisionTree.TreeSettings() { ShowBlanks = true, ShowSubScores = false };
             var treeSettingsDisplay = new RLDT.DecisionTree.TreeNode.TreeDisplaySettings() {
                 IncludeDefaultTreeStyling = false,
-                ValueDisplayProperty = "IdName",
-                LabelDisplayProperty = "IdName" };
+                ValueDisplayProperty = "Name",
+                LabelDisplayProperty = "Name" };
             string htmlTreeStyle = RLDT.DecisionTree.TreeNode.DefaultStyling;
             string htmlTrees = "";
             foreach (var p in policyLearner.Policies)
@@ -72,8 +72,11 @@ static public string ToVocabularyHtmlTable(List<KnowInstance> knowInstances, IdM
             s += "<th>Content</th>";
             s += "</tr>\n";
 
-            //Sort knowInstances by ID
-            knowInstances = knowInstances.OrderBy(p => p.ID).ToList();
+            //Sort knowInstances by name or ID
+            if(idManager != null)
+                knowInstances = knowInstances.OrderBy(p => new KnowInstanceWithMetaData(p, idManager).Name).ToList();
+            else
+                knowInstances = knowInstances.OrderBy(p => p.ID).ToList();
 
             //Content rows
             foreach (KnowInstance k in knowInstances)

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public TrigFunctions()`
`14`	`14`	`this.Name = "Trig Functions";`
`15`	`15`
`16`	`16`	`//Define inputs`
`17`		`- AddInput("x");`
	`17`	`+ AddInput("angle");`
`18`	`18`
`19`	`19`	`//Define outputs`
`20`	`20`	`AddOutput("sin");`
`@@ -32,9 +32,10 @@ public override void Run()`
`32`	`32`	`var o = Output;`
`33`	`33`
`34`	`34`	`//Define relationship between outputs and inputs`
`35`		`- o["sin"] = Math.Sin(Convert.ToDouble(i["x"]));`
`36`		`- o["cos"] = Math.Cos(Convert.ToDouble(i["x"]));`
`37`		`- o["tan"] = Math.Tan(Convert.ToDouble(i["x"]));`
	`35`	`+ double radians = Convert.ToDouble(i["angle"])/180*Math.PI;`
	`36`	`+ o["sin"] = Math.Sin(radians);`
	`37`	`+ o["cos"] = Math.Cos(radians);`
	`38`	`+ o["tan"] = Math.Tan(radians);`
`38`	`39`	`}`
`39`	`40`	`}`
`40`	`41`	`}`