public VariableNodeEditDialog(ISymbolicExpressionTreeNode node) {
InitializeComponent();
oldValueTextBox.TabStop = false; // cannot receive focus using tab key
NewNode = (VariableTreeNode)node; // will throw an invalid cast exception if node is not of the correct type
InitializeFields();
}
public VariableNodeEditDialog(ISymbolicExpressionTreeNode node)
{
InitializeComponent();
oldValueTextBox.TabStop = false; // cannot receive focus using tab key
NewNode = (VariableTreeNode)node; // will throw an invalid cast exception if node is not of the correct type
InitializeFields();
}
public static IClassificationSolution CreateLinearDiscriminantAnalysisSolution(IClassificationProblemData problemData)
{
var dataset = problemData.Dataset;
string targetVariable = problemData.TargetVariable;
IEnumerable <string> allowedInputVariables = problemData.AllowedInputVariables;
IEnumerable <int> rows = problemData.TrainingIndices;
int nClasses = problemData.ClassNames.Count();
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 discriminant analysis does not support NaN or infinity values in the input dataset.");
}
// change class values into class index
int targetVariableColumn = inputMatrix.GetLength(1) - 1;
List <double> classValues = problemData.ClassValues.OrderBy(x => x).ToList();
for (int row = 0; row < inputMatrix.GetLength(0); row++)
{
inputMatrix[row, targetVariableColumn] = classValues.IndexOf(inputMatrix[row, targetVariableColumn]);
}
int info;
double[] w;
alglib.fisherlda(inputMatrix, inputMatrix.GetLength(0), allowedInputVariables.Count(), nClasses, out info, out w);
if (info < 1)
{
throw new ArgumentException("Error in calculation of linear discriminant analysis solution");
}
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 = w[col];
addition.AddSubtree(vNode);
col++;
}
var model = LinearDiscriminantAnalysis.CreateDiscriminantFunctionModel(tree, new SymbolicDataAnalysisExpressionTreeInterpreter(), problemData, rows);
SymbolicDiscriminantFunctionClassificationSolution solution = new SymbolicDiscriminantFunctionClassificationSolution(model, (IClassificationProblemData)problemData.Clone());
return(solution);
}
private void DfsStringGeneration(VariableTreeNode current, string s, List <string> builtStrings)
{
if (current.Children == null)
{
builtStrings.Add(s + current.Value);
return;
}
foreach (var node in current.Children)
{
DfsStringGeneration(node, s + current.Value, builtStrings);
}
}
/**
* void makeDataTree
*
* This function generates a tree based on the variables availible in the simulation. All input and
* output variables. This is used primarily for the Sinter Config GUI.
*
* Excel data isn't really organized in a tree, so this function is a little weird
* The most annoying piece of the process is that I want the Tree to go Sheet->Row->Col
* but Excel goes Sheet$Col$Row ie, column major order. Thanks Excel.
* * */
public override void makeDataTree()
{
o_dataTree = new VariableTree.VariableTree(parsePath, pathSeperator);
VariableTreeNode rootNode = new VariableTreeNode("root", "", pathSeperator);
Excel.Sheets xlWorksheets = (Excel.Sheets)o_xlWorkbook.Worksheets;
foreach (Excel.Worksheet xlWorksheet in xlWorksheets)
{
String sheetName = xlWorksheet.Name;
VariableTreeNode sheetNode = new VariableTreeNode(sheetName, sheetName, pathSeperator);
Excel.Range xlRange = xlWorksheet.UsedRange;
Excel.Range rows = xlRange.Rows;
Excel.Range cols = xlRange.Columns;
//Calculate the rows and columns locally, because having Excel do it takes a LONG time.
String rowStartS = parsePath(((Excel.Range)xlRange.Cells[1, 1]).Address)[0];
int rowStartI = Convert.ToInt32(rowStartS);
String colStartS = parsePath(((Excel.Range)xlRange.Cells[1, 1]).Address)[1];
int colStartI = NumberFromExcelColumn(colStartS);
for (int rr = 0; rr < rows.Count; ++rr)
{
String rowName = Convert.ToString(rowStartI + rr);
String rowPath = String.Format("{0}$*${1}", sheetName, rowName);
VariableTreeNode rowNode = new VariableTreeNode(rowName, rowPath, pathSeperator);
sheetNode.addChild(rowNode);
for (int cc = 0; cc < cols.Count; ++cc)
{
String colName = ExcelColumnFromNumber(colStartI + cc);
String colPath = String.Format("{0}${1}${2}", sheetName, colName, rowName);
VariableTreeNode colNode = new VariableTreeNode(colName, colPath, pathSeperator);
rowNode.addChild(colNode);
}
}
rootNode.addChild(sheetNode);
}
o_dataTree.rootNode = rootNode;
//Remove the Dummy Children (those are only required when doing incremental tree building
rootNode.traverse(rootNode, thisNode =>
{
if (thisNode.o_children.ContainsKey("DummyChild"))
{
thisNode.o_children.Remove("DummyChild");
}
});
}
private void explainTreeView_DragDrop(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent("WindowsForms10PersistentObject", false))
{
object data = e.Data.GetData("WindowsForms10PersistentObject");
BaseTreeNode sourceNode = data as BaseTreeNode;
if (sourceNode != null)
{
VariableTreeNode variableTreeNode = sourceNode as VariableTreeNode;
if (variableTreeNode != null)
{
ExpandAndShowVariable(new VariableSelector(variableTreeNode.Item));
}
}
}
}
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;
VariableTreeNode variableTreeNode = node as VariableTreeNode;
if (constantTreeNode != null)
{
constantTreeNode.Value = constants[i++];
}
else if (updateVariableWeights && variableTreeNode != null)
{
variableTreeNode.Weight = constants[i++];
}
}
}
/// <summary>
/// Called when the drop operation is performed on this text box
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Editor_DragDropHandler(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent("WindowsForms10PersistentObject", false))
{
object data = e.Data.GetData("WindowsForms10PersistentObject");
BaseTreeNode sourceNode = data as BaseTreeNode;
if (sourceNode != null)
{
VariableTreeNode variableNode = sourceNode as VariableTreeNode;
if (variableNode != null)
{
EditionTextBox.SelectedText = SetVariable(variableNode.Item);
}
else
{
StructureTreeNode structureTreeNode = sourceNode as StructureTreeNode;
if (structureTreeNode != null)
{
TextualExplanation text = new TextualExplanation();
Structure structure = structureTreeNode.Item;
CreateDefaultStructureValue(text, structure);
EditionTextBox.SelectedText = text.Text;
}
else
{
EditionTextBox.SelectedText = StripUseless(sourceNode.Model.FullName, WritingContext());
}
}
}
OLVListItem item = data as OLVListItem;
if (item != null)
{
IVariable variable = item.RowObject as IVariable;
if (variable != null)
{
EditionTextBox.SelectedText = SetVariable(variable);
}
}
}
}
public void DataTreeTest()
{
String sinterconf = Properties.Settings.Default.ExcelSinterJson;
String defaultsfile = null;
String infilename = Properties.Settings.Default.ExcelSinterInputs;
String outfilename = Properties.Settings.Default.ExcelSinterOutputs;
String canonicalOutputFilename = Properties.Settings.Default.ExcelSinterCanonicalOutputs;
ISimulation sim = startupSim(sinterconf, defaultsfile, infilename);
sinter_InteractiveSim a_sim = (sinter_InteractiveSim)sim; //Only works on Interactive sims
{
String nodePath = "height$C$2";
VariableTreeNode testNode = sim.dataTree.resolveNode(nodePath);
Assert.IsTrue(nodePath == testNode.path);
Assert.IsTrue(testNode.name == "C");
sinter_Variable tmp = new sinter_Variable();
tmp.init(a_sim, sinter_Variable.sinter_IOType.si_DOUBLE, new String[] { nodePath });
Assert.IsTrue((double)tmp.dfault == 74);
Assert.IsTrue(tmp.type == sinter_Variable.sinter_IOType.si_DOUBLE);
}
{
String nodePath = "height$B$2";
VariableTreeNode testNode = sim.dataTree.resolveNode(nodePath);
Assert.IsTrue(nodePath == testNode.path);
Assert.IsTrue(testNode.name == "B");
sinter_Variable tmp = new sinter_Variable();
tmp.init(a_sim, sinter_Variable.sinter_IOType.si_STRING, new String[] { nodePath });
Assert.IsTrue((String)tmp.dfault == "Leek");
Assert.IsTrue(tmp.type == sinter_Variable.sinter_IOType.si_STRING);
}
sim.closeSim();
}
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);
}
/// <summary>
/// Accepts a drop event
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
{
if (sourceNode is ShortcutTreeNode)
{
ShortcutTreeNode shortcut = sourceNode as ShortcutTreeNode;
if (shortcut.Item.Dictionary == Item.Dictionary)
{
Shortcut otherShortcut = (Shortcut)shortcut.Item.Duplicate();
Item.appendShortcuts(otherShortcut);
shortcut.Delete();
}
}
else if (sourceNode is ShortcutFolderTreeNode)
{
ShortcutFolderTreeNode folder = sourceNode as ShortcutFolderTreeNode;
if (folder.Item.Dictionary == Item.Dictionary)
{
ShortcutFolder otherFolder = (ShortcutFolder)folder.Item.Duplicate();
Item.appendFolders(otherFolder);
folder.Delete();
}
}
else if (sourceNode is RuleTreeNode)
{
RuleTreeNode rule = sourceNode as RuleTreeNode;
if (rule.Item.Dictionary == Item.Dictionary)
{
Shortcut shortcut = (Shortcut)acceptor.getFactory().createShortcut();
shortcut.CopyFrom(rule.Item);
Item.appendShortcuts(shortcut);
}
}
else if (sourceNode is FunctionTreeNode)
{
FunctionTreeNode function = sourceNode as FunctionTreeNode;
if (function.Item.Dictionary == Item.Dictionary)
{
Shortcut shortcut = (Shortcut)acceptor.getFactory().createShortcut();
shortcut.CopyFrom(function.Item);
Item.appendShortcuts(shortcut);
}
}
else if (sourceNode is ProcedureTreeNode)
{
ProcedureTreeNode procedure = sourceNode as ProcedureTreeNode;
if (procedure.Item.Dictionary == Item.Dictionary)
{
Shortcut shortcut = (Shortcut)acceptor.getFactory().createShortcut();
shortcut.CopyFrom(procedure.Item);
Item.appendShortcuts(shortcut);
}
}
else if (sourceNode is VariableTreeNode)
{
VariableTreeNode variable = sourceNode as VariableTreeNode;
if (variable.Item.Dictionary == Item.Dictionary)
{
Shortcut shortcut = (Shortcut)acceptor.getFactory().createShortcut();
shortcut.CopyFrom(variable.Item);
Item.appendShortcuts(shortcut);
}
}
}
}
public Symbol(int scope, VariableTreeNode node)
{
Scope = scope;
TreeNode = node ?? throw new ArgumentNullException(nameof(node));
}
/** Leftmost name in the path refers to child of "ThisNode"
*/
private VariableTreeNode findDataTreeNode(IList <String> pathArray, VariableTreeNode thisNode)
{
throw new NotImplementedException();
}
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);
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TimeLineControl_DragDrop(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent("WindowsForms10PersistentObject", false))
{
BaseTreeNode sourceNode = e.Data.GetData("WindowsForms10PersistentObject") as BaseTreeNode;
if (sourceNode != null)
{
VariableTreeNode variableNode = sourceNode as VariableTreeNode;
if (variableNode != null)
{
SubStep subStep = SubStepRelatedToMousePosition();
if (subStep != null)
{
// Create the default value
IValue value = null;
Expression expression = null;
string defaultValue = variableNode.Item.Default;
if (defaultValue != null)
{
const bool doSemanticalAnalysis = true;
const bool silent = true;
expression = new Parser().Expression(variableNode.Item, defaultValue,
AllMatches.INSTANCE, doSemanticalAnalysis, null, silent);
}
if (expression != null)
{
InterpretationContext context = new InterpretationContext {
UseDefaultValue = false
};
value = expression.GetExpressionValue(context, null);
}
if (value == null || value is EmptyValue)
{
Structure structureType = variableNode.Item.Type as Structure;
if (structureType != null)
{
const bool setDefaultValue = false;
value = new StructureValue(structureType, setDefaultValue);
}
}
// Create the action or the expectation according to the keyboard modifier keys
if (value != null)
{
if ((e.KeyState & Ctrl) != 0)
{
Expectation expectation = (Expectation)acceptor.getFactory().createExpectation();
expectation.ExpressionText = variableNode.Item.FullName + " == " + value.FullName;
subStep.appendExpectations(expectation);
}
else
{
Action action = (Action)acceptor.getFactory().createAction();
action.ExpressionText = variableNode.Item.FullName + " <- " + value.FullName;
subStep.appendActions(action);
}
}
else
{
MessageBox.Show(
Resources
.StaticTimeLineControl_TimeLineControl_DragDrop_Cannot_evaluate_variable_default_value,
Resources.StaticTimeLineControl_TimeLineControl_DragDrop_Cannot_create_event,
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
}
}
}
}
