source: branches/HeuristicLab.Problems.GrammaticalOptimization/Evaluation/MainWindow.xaml.cs @ 12762

using System.Collections.ObjectModel;
using System.Threading;
using System.Xml.Serialization;
using Evaluation.ViewModel;
using HeuristicLab.Algorithms.Bandits;
using HeuristicLab.Algorithms.Bandits.BanditPolicies;
using HeuristicLab.Algorithms.GeneticProgramming;
using HeuristicLab.Algorithms.GrammaticalOptimization;
using HeuristicLab.Algorithms.MonteCarloTreeSearch;
using HeuristicLab.Algorithms.MonteCarloTreeSearch.Simulation;
using HeuristicLab.Problems.GrammaticalOptimization;
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
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        private BackgroundWorker worker = new BackgroundWorker();
        private EvaluationViewModel vm;

        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;
            this.worker.ProgressChanged += worker_ProgressChanged;
            this.worker.RunWorkerCompleted += worker_RunWorkerCompleted;

            ////updateCollectionTimer = new DispatcherTimer();
            ////updateCollectionTimer.Interval = TimeSpan.FromMilliseconds(100);
            ////updateCollectionTimer.Tick += updateCollectionTimer_Tick;
            ////updateCollectionTimer.Start();
        }

        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);
        }

        ////void updateCollectionTimer_Tick(object sender, EventArgs e)
        ////{
        ////    while (newStats.Count > 0)
        ////    {
        ////        EvaluationStat stat = newStats.Pop();
        ////        stats.Add(stat);
        ////    }
        ////}

        void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            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);

            LineGraph graph = new LineGraph(ds);

            graph.StrokeThickness = 2;
            graph.AddToPlotter(ChartPlotter);

            DrawTreeChart(run);
        }

        private void DrawTreeChart(Run run)
        {
            if (!string.IsNullOrEmpty(run.SvgFile))
            {
                treeDrawingPage.LoadDocument(run.SvgFile);
            }
        }


        void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            Debug.WriteLine(e.UserState);
        }

        void worker_DoWork(object sender, DoWorkEventArgs e)
        {

            Type algorithmType = vm.SelectedAlgorithm;

            ISymbolicExpressionTreeProblem problem = vm.SelectedProblem;

            Random random = new Random(DateTime.Now.Millisecond);

            Type policy = vm.SelectedPolicy;
            IBanditPolicy policyInstance = null;

            if (policy == typeof(UCTPolicy))
            {
                policyInstance = new UCTPolicy();
            }
            else if (policy == typeof(ThresholdAscentPolicy))
            {
                policyInstance = new ThresholdAscentPolicy();
            }
            else
            {
                policyInstance = (IBanditPolicy)Activator.CreateInstance(policy);
            }

            vm.BestKnownQuality = problem.BestKnownQuality(vm.MaxLen);

            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)
        {
            ClearChart();
            vm.Runs.Clear();
            vm.CurrentRun = null;
            ButtonRun.IsEnabled = false;
            TextBoxMaxEvaluations.IsEnabled = false;
            TextBoxMaxLen.IsEnabled = false;
            TextBoxRuns.IsEnabled = false;
            TextBoxThreads.IsEnabled = false;
            worker.RunWorkerAsync();
        }

        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";
            //    }
            //}
        }

        private void ButtonStop_OnClick(object sender, RoutedEventArgs e)
        {
            worker.CancelAsync();
        }

        private void ComboBoxAlgorithms_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            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);

            ////}
        }
    }
}