Changeset 12762 for branches/HeuristicLab.Problems.GrammaticalOptimization/Evaluation/MainWindow.xaml.cs

Timestamp:

07/14/15 20:42:55 (9 years ago)

Author:

aballeit

Message:

#2283 GUI updates, Tree-chart, MCTS Version 2 (prune leaves)

File:

• branches/HeuristicLab.Problems.GrammaticalOptimization/Evaluation/MainWindow.xaml.cs (modified) (11 diffs)

branches/HeuristicLab.Problems.GrammaticalOptimization/Evaluation/MainWindow.xaml.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
-using System.Windows.Threading;
+using System.Collections.ObjectModel;
+using System.Threading;
+using System.Xml.Serialization;
 using Evaluation.ViewModel;
 using HeuristicLab.Algorithms.Bandits;
@@ -26 +12 @@
 using Microsoft.Research.DynamicDataDisplay;
 using Microsoft.Research.DynamicDataDisplay.DataSources;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+using Microsoft.Win32;
+using WpfTestSvgSample;
 
 namespace Evaluation
@@ -36 +32 @@
         private BackgroundWorker worker = new BackgroundWorker();
         private EvaluationViewModel vm;
-        private List<EvaluationStat> stats = new List<EvaluationStat>();
-
-        private Stack<EvaluationStat> newStats = new Stack<EvaluationStat>();
+
         private DispatcherTimer updateCollectionTimer;
 
+        private DrawingPage treeDrawingPage;
+
         public MainWindow()
         {
             InitializeComponent();
+            CenterWindowOnScreen();
             this.DataContext = vm = new EvaluationViewModel();
+            vm.MaxLen = 50;
+            vm.MaxEvaluations = 250000;
+            vm.NrRuns = 1;
+            vm.CurrentRunString = "0/1";
+            vm.Threads = 6;
+            vm.VerticalAxisString = "SolutionQuality";
+            vm.HorizontalAxisString = "Iteration";
             this.worker.WorkerSupportsCancellation = true;
             this.worker.DoWork += worker_DoWork;
@@ -54 +58 @@
             ////updateCollectionTimer.Tick += updateCollectionTimer_Tick;
             ////updateCollectionTimer.Start();
-
-            vm.HorizontalAxisString = "Evaluations";
-            vm.VerticalAxisString = "BestKnownQuality";
-
+        }
+
+        private void CenterWindowOnScreen()
+        {
+            double screenWidth = System.Windows.SystemParameters.PrimaryScreenWidth;
+            double screenHeight = System.Windows.SystemParameters.PrimaryScreenHeight;
+            double windowWidth = this.Width;
+            double windowHeight = this.Height;
+            this.Left = (screenWidth / 2) - (windowWidth / 2);
+            this.Top = (screenHeight / 2) - (windowHeight / 2);
         }
 
@@ -71 +81 @@
         void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
         {
-            if (stats.Count > 0)
-            {
-                TimeSpan timeNeeded = stats[stats.Count - 1].Time - stats[0].Time;
-                vm.EvaluationsPerSec = Math.Round(vm.Evaluations / timeNeeded.TotalSeconds, 2);
-            }
-            var ds = new EnumerableDataSource<EvaluationStat>(stats);
+            ButtonRun.IsEnabled = true;
+            TextBoxMaxEvaluations.IsEnabled = true;
+            TextBoxMaxLen.IsEnabled = true;
+            TextBoxRuns.IsEnabled = true;
+            TextBoxThreads.IsEnabled = true;
+        }
+
+        private void DrawCharts(Run run)
+        {
+            ClearChart();
+
+            var ds = new EnumerableDataSource<EvaluationStat>(run.EvaluationStats);
             ds.SetXMapping(x => x.Iteration);
             ds.SetYMapping(y => y.CurrentBestQuality);
@@ -85 +101 @@
             graph.AddToPlotter(ChartPlotter);
 
-            Debug.WriteLine("DONE");
-            ButtonRun.IsEnabled = true;
-        }
+            DrawTreeChart(run);
+        }
+
+        private void DrawTreeChart(Run run)
+        {
+            if (!string.IsNullOrEmpty(run.SvgFile))
+            {
+                treeDrawingPage.LoadDocument(run.SvgFile);
+            }
+        }
+
+
         void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
         {
@@ -95 +120 @@
         void worker_DoWork(object sender, DoWorkEventArgs e)
         {
+
             Type algorithmType = vm.SelectedAlgorithm;
 
@@ -108 +134 @@
                 policyInstance = new UCTPolicy();
             }
-            else if (policy == typeof (ThresholdAscentPolicy))
+            else if (policy == typeof(ThresholdAscentPolicy))
             {
                 policyInstance = new ThresholdAscentPolicy();
@@ -117 +143 @@
             }
 
-            vm.MaxLen = 1000;
-            vm.MaxEvaluations = 250000;
-
             vm.BestKnownQuality = problem.BestKnownQuality(vm.MaxLen);
 
-            vm.Evaluations = 0;
-            vm.CurrentBestQuality = 0;
-
-            stats.Clear();
-
-            SolverBase solver = null;
-
-            if (algorithmType == typeof(MonteCarloTreeSearch))
-            {
-                solver = new MonteCarloTreeSearch(problem, vm.MaxLen, random, policyInstance, new RandomSimulation(problem, random, vm.MaxLen));
-            }
-            else if (algorithmType == typeof(SequentialSearch))
-            {
-                solver = new SequentialSearch(problem, vm.MaxLen, random, 0,
-                    new HeuristicLab.Algorithms.Bandits.GrammarPolicies.GenericGrammarPolicy(problem, policyInstance));
-            }
-            else if (algorithmType == typeof(RandomSearch))
-            {
-                solver = new RandomSearch(problem, random, vm.MaxLen);
-            }
-            else if (algorithmType == typeof(StandardGP))
-            {
-                solver = new StandardGP(problem, random);
-            }
-            else if (algorithmType == typeof(OffspringSelectionGP))
-            {
-                solver = new OffspringSelectionGP(problem, random);
-            }
-
-            solver.FoundNewBestSolution += (sentence, quality) => vm.BestSolutionFoundAt = vm.Evaluations;
-            solver.SolutionEvaluated += (sentence, quality) =>
-            {
-                vm.Evaluations++;
-                if (vm.CurrentBestQuality < quality)
-                {
-                    vm.CurrentBestQuality = quality;
-                }
-                stats.Add(new EvaluationStat(DateTime.Now, vm.Evaluations, quality, vm.CurrentBestQuality));
-            };
-
-            solver.Run(vm.MaxEvaluations);
+            for (int i = 0; i < vm.NrRuns; i++)
+            {
+                vm.CurrentRunString = string.Format("{0}/{1}", i + 1, vm.NrRuns);
+                vm.Evaluations = 0;
+                vm.CurrentBestQuality = 0;
+
+                List<EvaluationStat> stats = new List<EvaluationStat>();
+
+                ISolver solver = null;
+
+                if (algorithmType == typeof(MonteCarloTreeSearch))
+                {
+                    solver = new MonteCarloTreeSearch(problem, vm.MaxLen, random, policyInstance, new RandomSimulation(problem, random, vm.MaxLen));
+                }
+                else if (algorithmType == typeof(SequentialSearch))
+                {
+                    solver = new SequentialSearch(problem, vm.MaxLen, random, 0,
+                        new HeuristicLab.Algorithms.Bandits.GrammarPolicies.GenericGrammarPolicy(problem, policyInstance));
+                }
+                else if (algorithmType == typeof(RandomSearch))
+                {
+                    solver = new RandomSearch(problem, random, vm.MaxLen);
+                }
+                else if (algorithmType == typeof(StandardGP))
+                {
+                    solver = new StandardGP(problem, random);
+                }
+                else if (algorithmType == typeof(OffspringSelectionGP))
+                {
+                    solver = new OffspringSelectionGP(problem, random);
+                }
+
+                solver.FoundNewBestSolution += (sentence, quality) =>
+                {
+                    vm.BestSolutionFoundAt = vm.Evaluations;
+                    vm.BestSolution = sentence;
+                };
+                solver.SolutionEvaluated += (sentence, quality) =>
+                {
+                    vm.Evaluations++;
+                    if (vm.CurrentBestQuality < quality)
+                    {
+                        vm.CurrentBestQuality = quality;
+                    }
+                    stats.Add(new EvaluationStat(DateTime.Now, vm.Evaluations, quality, vm.CurrentBestQuality));
+                };
+
+                solver.Run(vm.MaxEvaluations);
+
+
+                if (stats.Count > 0)
+                {
+                    TimeSpan totalTimeNeeded = stats[stats.Count - 1].Time - stats[0].Time;
+                    vm.EvaluationsPerSec = Math.Round(vm.Evaluations / totalTimeNeeded.TotalSeconds, 2);
+
+                    TimeSpan timeForBestSolution = stats[vm.BestSolutionFoundAt - 1].Time - stats[0].Time;
+
+                    Run run = new Run(i, vm.Evaluations, vm.CurrentBestQuality, vm.BestKnownQuality,
+                        vm.BestSolutionFoundAt, vm.BestSolution, vm.EvaluationsPerSec,
+                        totalTimeNeeded, timeForBestSolution, stats);
+
+
+                    MonteCarloTreeSearch mctsSolver = null;
+                    if (algorithmType == typeof(MonteCarloTreeSearch))
+                    {
+                        mctsSolver = (MonteCarloTreeSearch)solver;
+
+                        run.TreeInfos = mctsSolver.GetTreeInfos();
+
+                        byte[] output = mctsSolver.GenerateSvg();
+                        if (output.Length > 0)
+                        {
+                            run.SvgFile = string.Format("MCTS_SVG_#{0}_{1}.svg", i, DateTime.Now.Ticks);
+                            File.WriteAllBytes(run.SvgFile, mctsSolver.GenerateSvg());
+                        }
+                    }
+
+                    Dispatcher.BeginInvoke(new Action(() => vm.Runs.Add(run)));
+                }
+            }
+        }
+
+        private void ClearChart()
+        {
+            ChartPlotter.Children.RemoveAll<LineGraph>();
         }
 
         private void ButtonRun_OnClick(object sender, RoutedEventArgs e)
         {
-            ChartPlotter.Children.RemoveAll<LineGraph>();
+            ClearChart();
+            vm.Runs.Clear();
+            vm.CurrentRun = null;
             ButtonRun.IsEnabled = false;
+            TextBoxMaxEvaluations.IsEnabled = false;
+            TextBoxMaxLen.IsEnabled = false;
+            TextBoxRuns.IsEnabled = false;
+            TextBoxThreads.IsEnabled = false;
             worker.RunWorkerAsync();
         }
@@ -174 +247 @@
         private void ButtonPause_OnClick(object sender, RoutedEventArgs e)
         {
+            //if (vm.SelectedAlgorithm == typeof(MonteCarloTreeSearch))
+            //{
+            //    MonteCarloTreeSearch mcts = (MonteCarloTreeSearch)solver;
+            //    mcts.PauseContinue();
+            //    if (mcts.IsPaused)
+            //    {
+            //        ButtonPause.Content = "Continue";
+            //    }
+            //    else
+            //    {
+            //        ButtonPause.Content = "Pause";
+            //    }
+            //}
         }
 
@@ -183 +269 @@
         private void ComboBoxAlgorithms_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
         {
-            if (vm.SelectedAlgorithm == typeof(MonteCarloTreeSearch)
-                || vm.SelectedAlgorithm == typeof(SequentialSearch))
+            if (vm.SelectedAlgorithm == typeof(MonteCarloTreeSearch))
             {
                 ComboBoxPolicies.IsEnabled = true;
+                TabItemTree.IsEnabled = true;
+            }
+            else if (vm.SelectedAlgorithm == typeof(SequentialSearch))
+            {
+                ComboBoxPolicies.IsEnabled = true;
+                TabItemTree.IsEnabled = false;
             }
             else
             {
                 ComboBoxPolicies.IsEnabled = false;
-            }
+                TabItemTree.IsEnabled = false;
+            }
+        }
+
+        private void Window_Loaded(object sender, RoutedEventArgs e)
+        {
+            treeDrawingPage = treeDrawing.Content as DrawingPage;
+        }
+
+        private void ListBoxRuns_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (ListBoxRuns.SelectedItem != null)
+            {
+                vm.CurrentRun = (Run)ListBoxRuns.SelectedItem;
+                DrawCharts(vm.CurrentRun);
+            }
+        }
+
+        public void SaveToFile()
+        {
+            SaveFileDialog dlg = new SaveFileDialog();
+            dlg.FileName = "runs"; // Default file name
+            dlg.DefaultExt = ".xml"; // Default file extension
+
+            // Show save file dialog box
+            Nullable<bool> result = dlg.ShowDialog();
+
+            // Process save file dialog box results
+            if (result == true)
+            {
+                // Save document
+                string filename = dlg.FileName;
+
+                XmlSerializer serializer = new XmlSerializer(typeof(ObservableCollection<Run>));
+                using (TextWriter writer = new StreamWriter(filename))
+                {
+                    serializer.Serialize(writer, vm.Runs);
+                }
+            }
+
+        }
+
+        public void LoadFromFile()
+        {
+            OpenFileDialog dlg = new OpenFileDialog();
+
+            // Show save file dialog box
+            Nullable<bool> result = dlg.ShowDialog();
+
+            // Process save file dialog box results
+            if (result == true)
+            {
+                // Load document
+                string filename = dlg.FileName;
+
+                XmlSerializer deserializer = new XmlSerializer(typeof(ObservableCollection<Run>));
+                using (TextReader reader = new StreamReader(filename))
+                {
+                    object obj = deserializer.Deserialize(reader);
+                    vm.Runs = (ObservableCollection<Run>)obj;
+
+                }
+            }
+        }
+
+        private void LoadButton_OnClick(object sender, RoutedEventArgs e)
+        {
+           LoadFromFile();
+        }
+
+        private void SaveButton_OnClick(object sender, RoutedEventArgs e)
+        {
+            SaveToFile();
+        }
+
+        private void TabControlRunComparison_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            ////if (TabControlRunComparison.SelectedItem == TabItemChartRunComparison)
+            ////{
+            ////    ComparisonChartPlotter.Children.RemoveAll<LineGraph>();
+
+            ////    var ds = new EnumerableDataSource<EvaluationStat>(run.EvaluationStats);
+            ////    ds.SetXMapping(x => x.Iteration);
+            ////    ds.SetYMapping(y => y.CurrentBestQuality);
+
+            ////    LineGraph graph = new LineGraph(ds);
+
+            ////    graph.StrokeThickness = 2;
+            ////    graph.AddToPlotter(ChartPlotter);
+
+            ////}
         }
     }