aswi2021tri-musketyri-gitlab/Server/ServerApp/Predictor/PredictionController.cs @ 1f1235a8

//
// Author: Roman Kalivoda
//

using System;
using System.Collections.Generic;
using ServerApp.Connection.XMLProtocolHandler;
using ServerApp.Parser.Parsers;
using Newtonsoft.Json;
using ServerApp.WeatherPredictionParser;
using ServerApp.Parser.OutputInfo;
using System.Reflection;
using log4net;

namespace ServerApp.Predictor
{
    /// <summary>
    /// Implentation of the <c>IPredicitionController</c> interface.
    /// </summary>
    public class PredictionController : IPredictionController
    {
        private static readonly ILog _log = LogManager.GetLogger(typeof(PredictionController));

        /// <summary>
        /// Configuration of the <c>Predictor</c>
        /// </summary>
        private PredictorConfiguration Configuration;

        private List<IPredictor> Predictors;

        /// <summary>
        /// A reference to a data parser.
        /// </summary>
        private IDataParser DataParser;

        /// <summary>
        /// A feature extractor instance.
        /// </summary>
        private FeatureExtractor FeatureExtractor;

        /// <summary>
        /// A weather prediction parser service
        /// </summary>
        private IJsonParser weatherService;

        /// <summary>
        /// Instantiates new prediction controller.
        /// </summary>
        /// <param name="dataParser">A data parser used to get training data.</param>
        public PredictionController(IJsonParser weatherService, IDataParser dataParser, string pathToConfig = null)
        {
            _log.Info("Constructing a new PredictionController instance.");
            this.weatherService = weatherService;
            // load config or get the default one
            if (pathToConfig is null)
            {
                pathToConfig = PredictorConfiguration.DEFAULT_CONFIG_PATH;
            }
            try
            {
                string json = System.IO.File.ReadAllText(pathToConfig);
                this.Configuration = JsonConvert.DeserializeObject<PredictorConfiguration>(json);
            }
            catch (System.IO.IOException e)
            {
                Console.WriteLine("Warning: could not find a configuration file, creating a new one:");
                Console.WriteLine(e.Message.PadLeft(4));
                this.Configuration = PredictorConfiguration.GetDefaultConfig();
            }

            this.DataParser = dataParser;
            this.Predictors = new List<IPredictor>();
            this.FeatureExtractor = new FeatureExtractor(this.DataParser, this.Configuration);

            for (int i = 0; i < this.Configuration.PredictorCount; i++)
            {
                Predictors.Add(new NaiveBayesClassifier());
            }
            PredictorConfiguration.SaveConfig(PredictorConfiguration.DEFAULT_CONFIG_PATH, Configuration);
        }
        public List<string> GetPredictors()
        {
            return new List<string>(this.Configuration.BuildingsToAreas.Keys);
        }

        public void Load(string locationKey = null, string path = null)
        {
            if (locationKey is null)
            {
                throw new NotImplementedException();
            }
            else
            {
                throw new NotImplementedException();
            }
        }

        public Response Predict(Request request)
        {
            _log.Info($"Received a prediction request: endDate={request.useEndDate}, weather={request.useWeather}");
            DateTime start = new DateTime(year: request.start.year, month: request.start.month, day: request.start.day, hour: request.start.hour, minute: 0, second: 0);
            List<Prediction> predictions = new List<Prediction>();
            if (request.useEndDate)
            {
                DateTime end = new DateTime(year: request.end.year, month: request.end.month, day: request.end.day, hour: request.end.hour, minute: 0, second: 0);
                DateTime current = start;
                while (current < end)
                {
                    _log.Debug($"Predicting for date {current.Date.ToShortDateString()}");
                    while (current.Hour < Date.MAX_HOUR)
                    {
                        _log.Debug($"Predicting for time {current.TimeOfDay.ToString()}");
                        var prediction = PredictSingle(request, current);
                        predictions.Add(prediction);
                        current = current.AddHours(this.Configuration.TimeResolution);
                    }
                    current = current.AddHours(23 - current.Hour + Date.MIN_HOUR);
                }
            }
            else
            {
                _log.Debug("Predicting for single DateTime.");
                predictions.Add(PredictSingle(request, start));
            }
            var response = new Response();
            response.hoursPerSegment = Configuration.TimeResolution;
            response.predicitons = predictions.ToArray();
            _log.Debug($"Created a response.");
            return response;
        }

        private Prediction PredictSingle(Request request, DateTime current)
        {
            double[] predictedValues = new double[this.Configuration.BuildingsToAreas.Count];
            string[] predictedLabels = new string[this.Predictors.Count];
            for (int i = 0; i < this.Predictors.Count; i++)
            {
                if (request.useWeather)
                {
                    _log.Debug("Predicting for requested weather.");
                    predictedLabels[i] = this.Predictors[i].Predict(new ModelInput
                    {
                        Rain = (float)request.rain,
                        Temp = (float)request.temperature,
                        Wind = (float)request.wind,
                        Hour = current.Hour,
                        Time = current
                    });
                }
                else
                {
                    _log.Debug("Retrieving weather info from the weather service.");
                    weatherService.ParsePrediction();
                    WeatherInfo weatherInfo = weatherService.Predictions.Find(info => info.startTime.Equals(current));
                    if (weatherInfo is null)
                    {
                        predictedLabels[i] = null;
                    }
                    else
                    {
                        predictedLabels[i] = this.Predictors[i].Predict(new ModelInput
                        {
                            Rain = weatherInfo.rain,
                            Temp = (float)weatherInfo.temp,
                            Wind = (float)weatherInfo.wind,
                            Hour = current.Hour,
                            Time = current
                        });
                    }
                }
            }
            for (int i = 0; i < predictedValues.Length; i++)
            {
                predictedValues[i] = this.FeatureExtractor.LabelToRatio(predictedLabels[this.Configuration.BuildingsToAreas[TagInfo.buildings[i]]]);
            }

            Prediction prediction = new Prediction();
            prediction.dateTime = new Date
            {
                year = current.Year,
                month = current.Month,
                day = current.Day,
                hour = current.Hour
            };
            prediction.predictions = predictedValues;
            _log.Debug($"Created prediction for DateTime: {prediction.dateTime}");
            return prediction;
        }

        public void Train(string locationKey = null)
        {
            if (locationKey is null)
            // train all predictors
            {
                DataParser.Parse(DateTime.MinValue, DateTime.MaxValue, this.Configuration.TimeResolution, wholeDay: false);
                for (int i = 0; i < this.Predictors.Count; i++)
                {
                    // train on all available data
                    List<ModelInput> data = FeatureExtractor.PrepareTrainingInput(i);
                    Console.WriteLine("Training predictor with {0} samples.", data.Count);
                    this.Predictors[i].Fit(data);
                }
            }
            else
            // train specified predictor only
            {
                throw new NotImplementedException();
            }
        }


    }
}