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 ConstantNodeEditDialog(ISymbolicExpressionTreeNode node) { InitializeComponent(); oldValueTextBox.TabStop = false; // cannot receive focus using tab key NewNode = (ConstantTreeNode)node; InitializeFields(); }
private static void UpdateConstants(ISymbolicExpressionTree tree, double[] constants, bool updateVariableWeights) { int i = 0; foreach (var node in tree.Root.IterateNodesPrefix().OfType <SymbolicExpressionTreeTerminalNode>()) { ConstantTreeNode constantTreeNode = node as ConstantTreeNode; VariableTreeNodeBase variableTreeNodeBase = node as VariableTreeNodeBase; FactorVariableTreeNode factorVarTreeNode = node as FactorVariableTreeNode; if (constantTreeNode != null) { constantTreeNode.Value = constants[i++]; } else if (updateVariableWeights && variableTreeNodeBase != null) { variableTreeNodeBase.Weight = constants[i++]; } else if (factorVarTreeNode != null) { for (int j = 0; j < factorVarTreeNode.Weights.Length; j++) { factorVarTreeNode.Weights[j] = constants[i++]; } } } }
private ISymbolicExpressionTreeNode MakeProduct(ConstantTreeNode c, double weight) { var mul = new Multiplication(); var prod = mul.CreateTreeNode(); prod.AddSubtree(MakeConstantTreeNode(weight)); prod.AddSubtree(c); return(prod); }
private ConstantTreeNode MakeConstantTreeNode(double value) { Constant constant = new Constant(); constant.MinValue = value - 1; constant.MaxValue = value + 1; ConstantTreeNode constantTreeNode = (ConstantTreeNode)constant.CreateTreeNode(); constantTreeNode.Value = value; return(constantTreeNode); }
public InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView() : base() { InitializeComponent(); this.Caption = "Interactive Time-Series Prognosis Solution Simplifier"; constantNode = ((ConstantTreeNode)new Constant().CreateTreeNode()); ISymbolicExpressionTreeNode root = new ProgramRootSymbol().CreateTreeNode(); ISymbolicExpressionTreeNode start = new StartSymbol().CreateTreeNode(); root.AddSubtree(start); tempTree = new SymbolicExpressionTree(root); }
public InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView() : base() { InitializeComponent(); this.Caption = "Interactive Time-Series Prognosis Solution Simplifier"; constantNode = ((ConstantTreeNode) new Constant().CreateTreeNode()); ISymbolicExpressionTreeNode root = new ProgramRootSymbol().CreateTreeNode(); ISymbolicExpressionTreeNode start = new StartSymbol().CreateTreeNode(); root.AddSubtree(start); tempTree = new SymbolicExpressionTree(root); }
private static void UpdateConstants(ISymbolicExpressionTree tree, double[] constants) { int i = 0; foreach (var node in tree.Root.IterateNodesPrefix().OfType <SymbolicExpressionTreeTerminalNode>()) { ConstantTreeNode constantTreeNode = node as ConstantTreeNode; VariableTreeNode variableTreeNode = node as VariableTreeNode; if (constantTreeNode != null) { constantTreeNode.Value = constants[i++]; } else if (variableTreeNode != null) { variableTreeNode.Weight = constants[i++]; } } }
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; }
private TreeNode FillTreeNode(Expression expression) { TreeNode treeNode = new NullTreeNode(); if (expression is BinaryExpression binary) { treeNode = new BinaryTreeNode() { Operator = expression.NodeType, Left = FillTreeNode(binary.Left), Right = FillTreeNode(binary.Right), }; } else if (expression is MemberExpression) { treeNode = new AccessorTreeNode() { Accessor = expression.ToString() }; } else if (expression is ConstantExpression) { treeNode = new ConstantTreeNode() { Constant = expression.ToString() }; } else if (expression is MethodCallExpression methodCall) { treeNode = new MethodCallTreeNode() { Method = methodCall.Method.Name, Arguments = methodCall.Arguments.Select(x => x.ToString()).ToArray(), Accessor = methodCall.Object.ToString() }; } else if (expression is LambdaExpression lambdaExpr) { treeNode = FillTreeNode(lambdaExpr.Body); } return(treeNode); }
public static double OptimizeConstants(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable <int> rows, bool applyLinearScaling, int maxIterations, bool updateVariableWeights = true, double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue, bool updateConstantsInTree = true) { List <AutoDiff.Variable> variables = new List <AutoDiff.Variable>(); List <AutoDiff.Variable> parameters = new List <AutoDiff.Variable>(); List <string> variableNames = new List <string>(); AutoDiff.Term func; if (!TryTransformToAutoDiff(tree.Root.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out func)) { throw new NotSupportedException("Could not optimize constants of symbolic expression tree due to not supported symbols used in the tree."); } if (variableNames.Count == 0) { return(0.0); } AutoDiff.IParametricCompiledTerm compiledFunc = func.Compile(variables.ToArray(), parameters.ToArray()); List <SymbolicExpressionTreeTerminalNode> terminalNodes = null; if (updateVariableWeights) { terminalNodes = tree.Root.IterateNodesPrefix().OfType <SymbolicExpressionTreeTerminalNode>().ToList(); } else { terminalNodes = new List <SymbolicExpressionTreeTerminalNode>(tree.Root.IterateNodesPrefix().OfType <ConstantTreeNode>()); } //extract inital constants double[] c = new double[variables.Count]; { c[0] = 0.0; c[1] = 1.0; int i = 2; foreach (var node in terminalNodes) { ConstantTreeNode constantTreeNode = node as ConstantTreeNode; VariableTreeNode variableTreeNode = node as VariableTreeNode; if (constantTreeNode != null) { c[i++] = constantTreeNode.Value; } else if (updateVariableWeights && variableTreeNode != null) { c[i++] = variableTreeNode.Weight; } } } double[] originalConstants = (double[])c.Clone(); double originalQuality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling); alglib.lsfitstate state; alglib.lsfitreport rep; int info; IDataset ds = problemData.Dataset; double[,] x = new double[rows.Count(), variableNames.Count]; int row = 0; foreach (var r in rows) { for (int col = 0; col < variableNames.Count; col++) { x[row, col] = ds.GetDoubleValue(variableNames[col], r); } row++; } double[] y = ds.GetDoubleValues(problemData.TargetVariable, rows).ToArray(); int n = x.GetLength(0); int m = x.GetLength(1); int k = c.Length; alglib.ndimensional_pfunc function_cx_1_func = CreatePFunc(compiledFunc); alglib.ndimensional_pgrad function_cx_1_grad = CreatePGrad(compiledFunc); try { alglib.lsfitcreatefg(x, y, c, n, m, k, false, out state); alglib.lsfitsetcond(state, 0.0, 0.0, maxIterations); //alglib.lsfitsetgradientcheck(state, 0.001); alglib.lsfitfit(state, function_cx_1_func, function_cx_1_grad, null, null); alglib.lsfitresults(state, out info, out c, out rep); } catch (ArithmeticException) { return(originalQuality); } catch (alglib.alglibexception) { return(originalQuality); } //info == -7 => constant optimization failed due to wrong gradient if (info != -7) { UpdateConstants(tree, c.Skip(2).ToArray(), updateVariableWeights); } var quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling); if (!updateConstantsInTree) { UpdateConstants(tree, originalConstants.Skip(2).ToArray(), updateVariableWeights); } if (originalQuality - quality > 0.001 || double.IsNaN(quality)) { UpdateConstants(tree, originalConstants.Skip(2).ToArray(), updateVariableWeights); return(originalQuality); } return(quality); }
private ISymbolicExpressionTreeNode MakeProduct(ConstantTreeNode c, double weight) { var mul = new Multiplication(); var prod = mul.CreateTreeNode(); prod.AddSubtree(MakeConstantTreeNode(weight)); prod.AddSubtree(c); return prod; }
private static ITimeSeriesPrognosisSolution CreateAutoRegressiveSolution(ITimeSeriesPrognosisProblemData problemData, int timeOffset, out double rmsError, out double cvRmsError) { string targetVariable = problemData.TargetVariable; double[,] inputMatrix = new double[problemData.TrainingPartition.Size, timeOffset + 1]; var targetValues = problemData.Dataset.GetDoubleValues(targetVariable).ToList(); for (int i = 0, row = problemData.TrainingPartition.Start; i < problemData.TrainingPartition.Size; i++, row++) { for (int col = 0; col < timeOffset; col++) { inputMatrix[i, col] = targetValues[row - col - 1]; } } // set target values in last column for (int i = 0; i < inputMatrix.GetLength(0); i++) { inputMatrix[i, timeOffset] = targetValues[i + problemData.TrainingPartition.Start]; } if (inputMatrix.Cast <double>().Any(x => double.IsNaN(x) || double.IsInfinity(x))) { throw new NotSupportedException("Linear regression does not support NaN or infinity values in the input dataset."); } alglib.linearmodel lm = new alglib.linearmodel(); alglib.lrreport ar = new alglib.lrreport(); int nRows = inputMatrix.GetLength(0); int nFeatures = inputMatrix.GetLength(1) - 1; double[] coefficients = new double[nFeatures + 1]; // last coefficient is for the constant int retVal = 1; alglib.lrbuild(inputMatrix, nRows, nFeatures, out retVal, out lm, out ar); if (retVal != 1) { throw new ArgumentException("Error in calculation of linear regression solution"); } rmsError = ar.rmserror; cvRmsError = ar.cvrmserror; alglib.lrunpack(lm, out coefficients, out nFeatures); ISymbolicExpressionTree tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode()); ISymbolicExpressionTreeNode startNode = new StartSymbol().CreateTreeNode(); tree.Root.AddSubtree(startNode); ISymbolicExpressionTreeNode addition = new Addition().CreateTreeNode(); startNode.AddSubtree(addition); for (int i = 0; i < timeOffset; i++) { LaggedVariableTreeNode node = (LaggedVariableTreeNode) new LaggedVariable().CreateTreeNode(); node.VariableName = targetVariable; node.Weight = coefficients[i]; node.Lag = (i + 1) * -1; addition.AddSubtree(node); } ConstantTreeNode cNode = (ConstantTreeNode) new Constant().CreateTreeNode(); cNode.Value = coefficients[coefficients.Length - 1]; addition.AddSubtree(cNode); var interpreter = new SymbolicTimeSeriesPrognosisExpressionTreeInterpreter(problemData.TargetVariable); var model = new SymbolicTimeSeriesPrognosisModel(problemData.TargetVariable, tree, interpreter); var solution = model.CreateTimeSeriesPrognosisSolution((ITimeSeriesPrognosisProblemData)problemData.Clone()); return(solution); }
public static ISymbolicRegressionSolution CreateLinearRegressionSolution(IRegressionProblemData problemData, out double rmsError, out double cvRmsError) { var dataset = problemData.Dataset; string targetVariable = problemData.TargetVariable; IEnumerable <string> allowedInputVariables = problemData.AllowedInputVariables; IEnumerable <int> rows = problemData.TrainingIndices; double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows); if (inputMatrix.Cast <double>().Any(x => double.IsNaN(x) || double.IsInfinity(x))) { throw new NotSupportedException("Linear regression does not support NaN or infinity values in the input dataset."); } alglib.linearmodel lm = new alglib.linearmodel(); alglib.lrreport ar = new alglib.lrreport(); int nRows = inputMatrix.GetLength(0); int nFeatures = inputMatrix.GetLength(1) - 1; double[] coefficients = new double[nFeatures + 1]; // last coefficient is for the constant int retVal = 1; alglib.lrbuild(inputMatrix, nRows, nFeatures, out retVal, out lm, out ar); if (retVal != 1) { throw new ArgumentException("Error in calculation of linear regression solution"); } rmsError = ar.rmserror; cvRmsError = ar.cvrmserror; alglib.lrunpack(lm, out coefficients, out nFeatures); ISymbolicExpressionTree tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode()); ISymbolicExpressionTreeNode startNode = new StartSymbol().CreateTreeNode(); tree.Root.AddSubtree(startNode); ISymbolicExpressionTreeNode addition = new Addition().CreateTreeNode(); startNode.AddSubtree(addition); int col = 0; foreach (string column in allowedInputVariables) { VariableTreeNode vNode = (VariableTreeNode) new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable().CreateTreeNode(); vNode.VariableName = column; vNode.Weight = coefficients[col]; addition.AddSubtree(vNode); col++; } ConstantTreeNode cNode = (ConstantTreeNode) new Constant().CreateTreeNode(); cNode.Value = coefficients[coefficients.Length - 1]; addition.AddSubtree(cNode); SymbolicRegressionSolution solution = new SymbolicRegressionSolution(new SymbolicRegressionModel(tree, new SymbolicDataAnalysisExpressionTreeInterpreter()), (IRegressionProblemData)problemData.Clone()); solution.Model.Name = "Linear Regression Model"; solution.Name = "Linear Regression Solution"; return(solution); }