Changeset 12568


Ignore:
Timestamp:
07/01/15 21:06:50 (7 years ago)
Author:
arapeanu
Message:

#2288: Fixed bug in SymbolicDataAnalysisVariableImpactsAnalyzer (simplification before optimization) and in VariableInteractionNetworkView for computing the adjacency matrix and sorting the variable impacts matrix

Location:
branches/HeuristicLab.VariableInteractionNetworks
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/VariableInteractionNetworkView.cs

    r12321 r12568  
    8787            {
    8888                // TODO: Add code when content has been changed and is not null
    89                 viewHost2.Content = CalculateNodeImportance(CalculateAdjacencyMatrix());     
     89                viewHost2.Content = CalculateNodeImportance(CalculateAdjacencyMatrix());
    9090                var adjMatrix = CalculateAdjacencyMatrix();
    9191                viewHost1.Content = adjMatrix;
     
    110110        {
    111111            var runCollection = Content;
    112             var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
     112            var inputVariables = ((IRegressionProblemData)runCollection.First().Parameters["ProblemData"]).InputVariables.Select(x => x.Value).ToList();
     113            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).OrderBy(x => inputVariables.IndexOf(x.Key)).ToList();
    113114
    114115            var allVariableImpacts = runCollection.Select(run => (DoubleMatrix)run.Results[variableImpactResultName]);
     
    116117                                 from variableName in variableImpact.RowNames
    117118                                 select variableName).Distinct().ToArray();
     119           
     120            var vars = new List<Tuple<int, string>>();
     121           
     122            var allowedInputs = ((IRegressionProblemData)groupRunCollection[0].First().Parameters["ProblemData"]).AllowedInputVariables.ToList();
     123
    118124            var adjMatrix = new DoubleMatrix(variableNames.Length, variableNames.Length);
    119125
    120             adjMatrix.RowNames = groupRunCollection.Select(x => x.Key);
     126            for (int i = 0; i < adjMatrix.Rows; ++i)
     127            {
     128                int inputIndex = allowedInputs.FindIndex(x => x == variableNames[i]);
     129                vars.Add(new Tuple<int, string>(inputIndex, variableNames[i]));
     130            }
     131
     132            vars.Sort((a, b) => a.Item1.CompareTo(b.Item1));
     133
     134            for (int i = 0; i < adjMatrix.Rows; ++i)
     135            {
     136                variableNames[i] = vars[i].Item2;
     137            }
     138            adjMatrix.RowNames = variableNames;
    121139            adjMatrix.ColumnNames = adjMatrix.RowNames;
     140
    122141            for (int j = 0; j < groupRunCollection.Count; ++j)
    123142            {
    124143                var g = groupRunCollection[j];
     144               
    125145                var matrix = CalculateAdjacencyRows(g);
    126                 var variables = new List<Tuple<string, double>>();
    127                 var columnNames = matrix.ColumnNames.ToList();
     146                var variables = new List<double>();
    128147
    129148                for (int i = 0; i < matrix.Columns; ++i)
    130149                {
    131                     variables.Add(new Tuple<string, double>(columnNames[i], matrix[0, i]));
    132                 }
    133                 variables.Add(new Tuple<string, double>(g.Key, 0));
    134                 variables.Sort((a, b) => a.Item1.CompareTo(b.Item1));
     150                    variables.Add(matrix[0, i]);
     151                }
     152               
    135153                for (int i = 0; i < variables.Count; ++i)
    136154                {
    137                     adjMatrix[j, i] = variables[i].Item2;
    138 
     155                    if (i == j)
     156                    {
     157                        adjMatrix[i, i] = 0;
     158                        variables.Insert(i, 0);
     159                    }
     160                    else
     161                        adjMatrix[j, i] = variables[i];
    139162                }
    140163            }
     
    144167        private DoubleMatrix CalculateAdjacencyRows(IEnumerable<IRun> runs)
    145168        {
    146             IEnumerable<DoubleMatrix> allVariableImpacts = (from run in runs
    147                                                             select run.Results[variableImpactResultName]).Cast<DoubleMatrix>();
    148             var variableNames = (from variableImpact in allVariableImpacts
    149                                  from variableName in variableImpact.RowNames
    150                                  select variableName).Distinct().ToArray();
    151 
    152             List<string> variableNamesList = (from variableName in variableNames
    153                                               where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0))
    154                                               select variableName)
    155                                              .ToList();
    156 
    157169            var runNames = runs.Select(x => x.Name).ToArray();
    158170            var runsArray = runs.ToArray();
    159171            DoubleMatrix varImpactMatrix = CalculateVariableImpactMatrix(runsArray, runNames);
    160             var targetMatrix = new DoubleMatrix(1, variableNames.Length);
     172         
     173            var targetMatrix = new DoubleMatrix(1, varImpactMatrix.Rows);
    161174
    162175            for (int i = 0; i < varImpactMatrix.Rows; ++i)
     
    165178            }
    166179
    167             targetMatrix.RowNames = new[] { "Target" };
    168             targetMatrix.ColumnNames = variableNames;
    169 
     180            targetMatrix.RowNames = new[] { "Impacts" };
     181            targetMatrix.ColumnNames = varImpactMatrix.RowNames;
    170182            return targetMatrix;
    171183        }
     
    262274        }
    263275
    264         //adapted from RunCollectionVariableImpactView
     276        //modified from RunCollectionVariableImpactView
    265277        private DoubleMatrix CalculateVariableImpactMatrix(IRun[] runs, string[] runNames)
    266278        {
     
    307319                }
    308320            }
    309             return matrix;
     321
     322            // sort by median
     323            var sortedMatrix = (DoubleMatrix)matrix.Clone();
     324            var sortedIndexes = from i in Enumerable.Range(0, sortedMatrix.Rows)
     325                                orderby matrix[i, numberOfRuns]
     326                                select i;
     327
     328            int targetIndex = 0;
     329            foreach (var sourceIndex in sortedIndexes)
     330            {
     331                for (int c = 0; c < matrix.Columns; c++)
     332                    sortedMatrix[targetIndex, c] = matrix[sourceIndex, c];
     333                targetIndex++;
     334            }
     335            sortedMatrix.RowNames = sortedIndexes.Select(i => variableNamesList[i]);
     336
     337            var vars = new List<Tuple<int, string, double>>();
     338            var rowNames = sortedMatrix.RowNames.ToList();
     339
     340            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
     341            var inputs = ((IRegressionProblemData)groupRunCollection[0].First().Parameters["ProblemData"]).InputVariables.ToList();
     342            List<string> inp = (from input in inputs
     343                                select (input.ToString())).ToList();
     344
     345            for (int i = 0; i < sortedMatrix.Rows; ++i)
     346            {
     347                int inputIndex = inp.FindIndex(x => x == rowNames[i]);
     348                vars.Add(new Tuple<int, string, double>(inputIndex, rowNames[i], sortedMatrix[i, runNames.Length]));
     349            }
     350
     351                vars.Sort((a, b) => a.Item1.CompareTo(b.Item1));
     352               
     353            for (int i = 0; i < sortedMatrix.Rows; ++i)
     354            {
     355                sortedMatrix[i, runNames.Length] = vars[i].Item3;
     356                rowNames[i] = vars[i].Item2;
     357            }
     358            sortedMatrix.RowNames = rowNames;
     359
     360            return sortedMatrix;
    310361        }
    311362
  • branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks/3.3/Plugin.cs.frame

    r12462 r12568  
    4747  [PluginDependency("HeuristicLab.Problems.DataAnalysis.Symbolic", "3.4")]
    4848  [PluginDependency("HeuristicLab.Problems.DataAnalysis", "3.4")]
    49   [PluginDependency("HeuristicLab.Problems.Instances", "3.4")]
     49  [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
    5050  [PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "3.4")] 
    5151  public class Plugin : PluginBase {
  • branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks/3.3/SymbolicDataAnalysisVariableImpactsAnalyzer.cs

    r12460 r12568  
    1111using HeuristicLab.Problems.DataAnalysis.Symbolic;
    1212using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
     13using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    1314
    1415namespace HeuristicLab.VariableInteractionNetworks
     
    3334        private const string LastGenerationsParameterName = "LastGenerations";
    3435        private const string MaximumGenerationsParameterName = "MaximumGenerations";
    35         private const string OptimizedConstantsParameterName = "OptimizedConstants";
    36        
    37         private readonly SymbolicDataAnalysisExpressionTreeSimplifier simplifier;
    38         private readonly SymbolicRegressionSolutionImpactValuesCalculator impactsCalculator;
     36        private const string OptimizeConstantsParameterName = "OptimizeConstants";
     37        private const string PruneTreesParameterName = "PruneTrees";
     38
     39        private SymbolicDataAnalysisExpressionTreeSimplifier simplifier;
     40        private SymbolicRegressionSolutionImpactValuesCalculator impactsCalculator;
    3941
    4042        #region parameters
     
    8789            get { return (IFixedValueParameter<IntValue>)Parameters[LastGenerationsParameterName]; }
    8890        }
    89         public IFixedValueParameter<BoolValue> OptimizedParameter
    90         {
    91             get { return (IFixedValueParameter<BoolValue>)Parameters[OptimizedConstantsParameterName]; }
     91        public IFixedValueParameter<BoolValue> OptimizeConstantsParameter
     92        {
     93            get { return (IFixedValueParameter<BoolValue>)Parameters[OptimizeConstantsParameterName]; }
     94        }
     95        public IFixedValueParameter<BoolValue> PruneTreesParameter
     96        {
     97            get { return (IFixedValueParameter<BoolValue>)Parameters[PruneTreesParameterName]; }
    9298        }
    9399        private ILookupParameter<IntValue> MaximumGenerationsParameter
     
    119125            Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName));
    120126            Parameters.Add(new LookupParameter<DoubleLimit>(EstimationLimitsParameterName));
    121             Parameters.Add(new FixedValueParameter<IntValue>(MaxCOIterationsParameterName));         
     127            Parameters.Add(new FixedValueParameter<IntValue>(MaxCOIterationsParameterName));
    122128            Parameters.Add(new LookupParameter<DataTable>(VariableImpactsParameterName, "The relative variable relevance calculated as the average relative variable frequency over the whole run."));
    123129            Parameters.Add(new FixedValueParameter<PercentValue>(PercentageBestParameterName));
    124130            Parameters.Add(new FixedValueParameter<IntValue>(LastGenerationsParameterName));
    125             Parameters.Add(new FixedValueParameter<BoolValue>(OptimizedConstantsParameterName));
     131            Parameters.Add(new FixedValueParameter<BoolValue>(OptimizeConstantsParameterName, new BoolValue(false)));
     132            Parameters.Add(new FixedValueParameter<BoolValue>(PruneTreesParameterName, new BoolValue(false)));
    126133            Parameters.Add(new LookupParameter<IntValue>(MaximumGenerationsParameterName, "The maximum number of generations which should be processed."));
    127134
     135            impactsCalculator = new SymbolicRegressionSolutionImpactValuesCalculator();
    128136            simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
    129             impactsCalculator = new SymbolicRegressionSolutionImpactValuesCalculator();
    130137        }
    131138
     
    133140        protected SymbolicRegressionVariableImpactsAnalyzer(bool deserializing) : base(deserializing) { }
    134141
     142        [StorableHook(HookType.AfterDeserialization)]
     143        private void AfterDeserialization()
     144        {
     145            impactsCalculator = new SymbolicRegressionSolutionImpactValuesCalculator();
     146            simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
     147        }
     148
    135149        protected SymbolicRegressionVariableImpactsAnalyzer(SymbolicRegressionVariableImpactsAnalyzer original, Cloner cloner)
    136150            : base(original, cloner)
    137151        {
     152            impactsCalculator = new SymbolicRegressionSolutionImpactValuesCalculator();
     153            simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
    138154        }
    139155
     
    158174            int lastGen = LastGenerationsParameter.Value.Value;
    159175
    160             if (lastGen > maxGen)
    161                 lastGen = maxGen;
    162             if (maxGen - gen < lastGen)
     176            if (gen < maxGen - lastGen)
    163177                return base.Apply();
    164178
     
    176190            var estimationLimits = EstimationLimitsParameter.ActualValue; // lookup parameter => ActualValue
    177191            var percentageBest = PercentageBestParameter.Value.Value;
    178             var optimizedConstants = OptimizedParameter.Value.Value;
     192            var optimizeConstants = OptimizeConstantsParameter.Value.Value;
     193            var pruneTrees = PruneTreesParameter.Value.Value;
    179194
    180195            var allowedInputVariables = problemData.AllowedInputVariables.ToList();
     
    188203                VariableImpactsParameter.ActualValue = datatable;
    189204                results.Add(new Result("Average variable impacts", "The relative variable relevance calculated as the average relative variable frequency over the whole run.", new DataTable()));
    190                
     205
    191206                foreach (var v in allowedInputVariables)
    192207                {
     
    197212            datatable = VariableImpactsParameter.ActualValue;
    198213            int nTrees = (int)Math.Round(trees.Length * percentageBest);
    199 
    200             // simplify trees
    201             var simplifiedTrees = trees.Take(nTrees).Select(x => simplifier.Simplify(x));
     214            var bestTrees = trees.Take(nTrees).Select(x => (ISymbolicExpressionTree)x.Clone()).ToList();
     215
     216            if (optimizeConstants)
     217            {
     218                foreach (var tree in bestTrees)
     219                    SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData, problemData.TrainingIndices, applyLinearScaling, maxCOIterations, estimationLimits.Upper, estimationLimits.Lower);
     220            }
     221            var simplifiedTrees = bestTrees.Select(x => simplifier.Simplify(x)).ToList();
    202222            var variableCounts = problemData.AllowedInputVariables.ToDictionary(x => x, x => simplifiedTrees.Count(t => t.IterateNodesPrefix().Any(n => n is VariableTreeNode && ((VariableTreeNode)n).VariableName == x)));
    203             foreach (var simplifiedTree in simplifiedTrees)
    204             {
    205                 if (optimizedConstants == true)
    206                 {
    207                     SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, simplifiedTree, problemData, problemData.TrainingIndices, applyLinearScaling, maxCOIterations, estimationLimits.Upper, estimationLimits.Lower);
    208                 }
     223            for (int i = 0; i < simplifiedTrees.Count; ++i)
     224            {
     225                var simplifiedTree = simplifiedTrees[i];
     226
     227                if (pruneTrees)
     228                    simplifiedTree = SymbolicRegressionPruningOperator.Prune(simplifiedTree, impactsCalculator, interpreter, problemData, estimationLimits, problemData.TrainingIndices);
    209229
    210230                var quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, simplifiedTree, estimationLimits.Lower, estimationLimits.Upper, problemData, problemData.TrainingIndices, applyLinearScaling);
     
    216236                {
    217237                    var avgImpact = g.Average(x => impactsCalculator.CalculateImpactValue(model, x, problemData, problemData.TrainingIndices, quality));
     238                    if (double.IsNaN(avgImpact))
     239                        avgImpact = 0;
    218240                    variableImpacts[g.Key] += avgImpact;
    219241                }
     
    222244            foreach (var pair in variableImpacts)
    223245            {
    224                 datatable.Rows[pair.Key].Values.Add(pair.Value / variableCounts[pair.Key]);
     246                var v = variableCounts[pair.Key] > 0 ? pair.Value / variableCounts[pair.Key] : 0;
     247                datatable.Rows[pair.Key].Values.Add(v);
    225248            }
    226249            results["Average variable impacts"].Value = datatable;
Note: See TracChangeset for help on using the changeset viewer.