public override void CalculateImpactAndReplacementValues(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node,
      IDataAnalysisProblemData problemData, IEnumerable<int> rows, out double impactValue, out double replacementValue, out double newQualityForImpactsCalculation,
      double qualityForImpactsCalculation = Double.NaN) {
      var classificationModel = (ISymbolicClassificationModel)model;
      var classificationProblemData = (IClassificationProblemData)problemData;

      if (double.IsNaN(qualityForImpactsCalculation))
        qualityForImpactsCalculation = CalculateQualityForImpacts(classificationModel, classificationProblemData, rows);

      replacementValue = CalculateReplacementValue(classificationModel, node, classificationProblemData, rows);
      var constantNode = new ConstantTreeNode(new Constant()) { Value = replacementValue };

      var cloner = new Cloner();
      var tempModel = cloner.Clone(classificationModel);
      var tempModelNode = (ISymbolicExpressionTreeNode)cloner.GetClone(node);

      var tempModelParentNode = tempModelNode.Parent;
      int i = tempModelParentNode.IndexOfSubtree(tempModelNode);
      tempModelParentNode.RemoveSubtree(i);
      tempModelParentNode.InsertSubtree(i, constantNode);

      OnlineCalculatorError errorState;
      var dataset = classificationProblemData.Dataset;
      var targetClassValues = dataset.GetDoubleValues(classificationProblemData.TargetVariable, rows);
      var estimatedClassValues = tempModel.GetEstimatedClassValues(dataset, rows);
      newQualityForImpactsCalculation = OnlineAccuracyCalculator.Calculate(targetClassValues, estimatedClassValues, out errorState);
      if (errorState != OnlineCalculatorError.None) newQualityForImpactsCalculation = 0.0;

      impactValue = qualityForImpactsCalculation - newQualityForImpactsCalculation;
    }
    public ISymbolicDataAnalysisModel Backtransform(ISymbolicDataAnalysisModel model, IEnumerable<ITransformation> transformations, string targetVariable) {
      var symbolicModel = (ISymbolicDataAnalysisModel)model.Clone();

      foreach (var transformation in transformations.Reverse()) {
        ApplyBacktransformation(transformation, symbolicModel.SymbolicExpressionTree, targetVariable);
      }

      return symbolicModel;
    }
Esempio n. 3
0
        protected void AddModelTreePicture(ExcelWorksheet modelWorksheet, ISymbolicDataAnalysisModel model)
        {
            SymbolicExpressionTreeChart modelTreePicture = new SymbolicExpressionTreeChart();

            modelTreePicture.Tree = model.SymbolicExpressionTree;
            string tmpFilename = Path.GetTempFileName();

            modelTreePicture.Width  = 1000;
            modelTreePicture.Height = 500;
            modelTreePicture.SaveImageAsEmf(tmpFilename);

            FileInfo fi = new FileInfo(tmpFilename);
            var      excelModelTreePic = modelWorksheet.Drawings.AddPicture("ModelTree", fi);

            excelModelTreePic.SetSize(50);
            excelModelTreePic.SetPosition(2, 0, 6, 0);
        }
Esempio n. 4
0
        protected override double CalculateQualityForImpacts(ISymbolicDataAnalysisModel model, IDataAnalysisProblemData problemData, IEnumerable <int> rows)
        {
            var classificationModel       = (ISymbolicClassificationModel)model;
            var classificationProblemData = (IClassificationProblemData)problemData;
            OnlineCalculatorError errorState;
            var dataset = problemData.Dataset;

            classificationModel.RecalculateModelParameters(classificationProblemData, rows);
            var targetClassValues            = dataset.GetDoubleValues(classificationProblemData.TargetVariable, rows);
            var originalClassValues          = classificationModel.GetEstimatedClassValues(dataset, rows);
            var qualityForImpactsCalculation = OnlineAccuracyCalculator.Calculate(targetClassValues, originalClassValues, out errorState);

            if (errorState != OnlineCalculatorError.None)
            {
                qualityForImpactsCalculation = 0.0;
            }
            return(qualityForImpactsCalculation);
        }
        public virtual void CalculateImpactAndReplacementValues(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable <int> rows,
                                                                out double impactValue, out double replacementValue, out double newQualityForImpactsCalculation,
                                                                double qualityForImpactsCalculation = double.NaN)
        {
            if (double.IsNaN(qualityForImpactsCalculation))
            {
                qualityForImpactsCalculation = CalculateQualityForImpacts(model, problemData, rows);
            }

            var cloner        = new Cloner();
            var tempModel     = cloner.Clone(model);
            var tempModelNode = (ISymbolicExpressionTreeNode)cloner.GetClone(node);

            var tempModelParentNode = tempModelNode.Parent;
            int i = tempModelParentNode.IndexOfSubtree(tempModelNode);

            double bestReplacementValue = 0.0;
            double bestImpactValue      = double.PositiveInfinity;

            newQualityForImpactsCalculation = qualityForImpactsCalculation; // initialize
            // try the potentially reasonable replacement values and use the best one
            foreach (var repValue in CalculateReplacementValues(node, model.SymbolicExpressionTree, model.Interpreter, problemData.Dataset, problemData.TrainingIndices))
            {
                tempModelParentNode.RemoveSubtree(i);

                var constantNode = new ConstantTreeNode(new Constant())
                {
                    Value = repValue
                };
                tempModelParentNode.InsertSubtree(i, constantNode);

                newQualityForImpactsCalculation = CalculateQualityForImpacts(tempModel, problemData, rows);

                impactValue = qualityForImpactsCalculation - newQualityForImpactsCalculation;
                if (impactValue < bestImpactValue)
                {
                    bestImpactValue      = impactValue;
                    bestReplacementValue = repValue;
                }
            }

            replacementValue = bestReplacementValue;
            impactValue      = bestImpactValue;
        }
Esempio n. 6
0
        public override void CalculateImpactAndReplacementValues(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node,
                                                                 IDataAnalysisProblemData problemData, IEnumerable <int> rows, out double impactValue, out double replacementValue, out double newQualityForImpactsCalculation,
                                                                 double qualityForImpactsCalculation = Double.NaN)
        {
            var regressionModel       = (ISymbolicRegressionModel)model;
            var regressionProblemData = (IRegressionProblemData)problemData;

            var dataset      = regressionProblemData.Dataset;
            var targetValues = dataset.GetDoubleValues(regressionProblemData.TargetVariable, rows);

            OnlineCalculatorError errorState;

            if (double.IsNaN(qualityForImpactsCalculation))
            {
                qualityForImpactsCalculation = CalculateQualityForImpacts(regressionModel, regressionProblemData, rows);
            }

            replacementValue = CalculateReplacementValue(regressionModel, node, regressionProblemData, rows);
            var constantNode = new ConstantTreeNode(new Constant())
            {
                Value = replacementValue
            };

            var cloner        = new Cloner();
            var tempModel     = cloner.Clone(regressionModel);
            var tempModelNode = (ISymbolicExpressionTreeNode)cloner.GetClone(node);

            var tempModelParentNode = tempModelNode.Parent;
            int i = tempModelParentNode.IndexOfSubtree(tempModelNode);

            tempModelParentNode.RemoveSubtree(i);
            tempModelParentNode.InsertSubtree(i, constantNode);

            var    estimatedValues = tempModel.GetEstimatedValues(dataset, rows);
            double r = OnlinePearsonsRCalculator.Calculate(targetValues, estimatedValues, out errorState);

            if (errorState != OnlineCalculatorError.None)
            {
                r = 0.0;
            }
            newQualityForImpactsCalculation = r * r;

            impactValue = qualityForImpactsCalculation - newQualityForImpactsCalculation;
        }
    protected void AddModelTreePicture(ExcelWorksheet modelWorksheet, ISymbolicDataAnalysisModel model) {
      SymbolicExpressionTreeChart modelTreePicture = new SymbolicExpressionTreeChart();
      modelTreePicture.Tree = model.SymbolicExpressionTree;
      string tmpFilename = Path.GetTempFileName();
      modelTreePicture.Width = 1000;
      modelTreePicture.Height = 500;
      modelTreePicture.SaveImageAsEmf(tmpFilename);

      FileInfo fi = new FileInfo(tmpFilename);
      var excelModelTreePic = modelWorksheet.Drawings.AddPicture("ModelTree", fi);
      excelModelTreePic.SetSize(50);
      excelModelTreePic.SetPosition(2, 0, 6, 0);
    }
 protected abstract double CalculateQualityForImpacts(ISymbolicDataAnalysisModel model, IDataAnalysisProblemData problemData, IEnumerable <int> rows);
 public abstract void CalculateImpactAndReplacementValues(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows, out double impactValue, out double replacementValue, out double newQualityForImpactsCalculation, double qualityForImpactsCalculation = double.NaN);
 public abstract double CalculateImpactValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows, double qualityForImpactsCalculation = double.NaN);
 public abstract double CalculateReplacementValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows);
 public override double CalculateImpactValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows, double qualityForImpactsCalculation = double.NaN) {
   double impactValue, replacementValue;
   double newQualityForImpactsCalculation;
   CalculateImpactAndReplacementValues(model, node, problemData, rows, out impactValue, out replacementValue, out newQualityForImpactsCalculation, qualityForImpactsCalculation);
   return impactValue;
 }
    public override double CalculateReplacementValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable<int> rows) {
      var classificationModel = (ISymbolicClassificationModel)model;
      var classificationProblemData = (IClassificationProblemData)problemData;

      return CalculateReplacementValue(node, classificationModel.SymbolicExpressionTree, classificationModel.Interpreter, classificationProblemData.Dataset, rows);
    }
 public abstract void CalculateImpactAndReplacementValues(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable <int> rows, out double impactValue, out double replacementValue, out double newQualityForImpactsCalculation, double qualityForImpactsCalculation = double.NaN);
 public abstract double CalculateImpactValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable <int> rows, double qualityForImpactsCalculation = double.NaN);
 public abstract double CalculateReplacementValue(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node, IDataAnalysisProblemData problemData, IEnumerable <int> rows);