Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
02/01/21 18:33:07 (3 years ago)
Author:
pfleck
Message:

#3040 First draft additional vector aggregation symbols (distribution characteristics & time series dynamics)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs

    r17786 r17830  
    209209
    210210    public SymbolicDataAnalysisExpressionTreeVectorInterpreter()
    211       : this("SymbolicDataAnalysisExpressionTreeVectorInterpreter", "Interpreter for symbolic expression trees including vector arithmetic.") {
    212     }
     211      : this("SymbolicDataAnalysisExpressionTreeVectorInterpreter", "Interpreter for symbolic expression trees including vector arithmetic.") { }
    213212
    214213    protected SymbolicDataAnalysisExpressionTreeVectorInterpreter(string name, string description)
     
    752751          }
    753752
     753        #region Time Series Symbols
     754        case OpCodes.Median: {
     755            var cur = Evaluate(dataset, ref row, state, traceDict);
     756            cur = AggregateApply(cur,
     757              s => s,
     758              v => Statistics.Median(v));
     759            TraceEvaluation(currentInstr, cur);
     760            return cur;
     761          }
     762        case OpCodes.Quantile: {
     763            var cur = Evaluate(dataset, ref row, state, traceDict);
     764            var q = Evaluate(dataset, ref row, state, traceDict);
     765            cur = AggregateApply(cur,
     766              s => s,
     767              v => Statistics.Quantile(v, q.Scalar));
     768            TraceEvaluation(currentInstr, cur);
     769            return cur;
     770          }
     771
     772        case OpCodes.AbsoluteEnergy: {
     773            var cur = Evaluate(dataset, ref row, state, traceDict);
     774            cur = AggregateApply(cur,
     775              s => s * s,
     776              v => v.PointwisePower(2.0).Sum());
     777            TraceEvaluation(currentInstr, cur);
     778            return cur;
     779          }
     780
     781        case OpCodes.BinnedEntropy: {
     782            var cur = Evaluate(dataset, ref row, state, traceDict);
     783            var m = Evaluate(dataset, ref row, state, traceDict);
     784            cur = AggregateApply(cur,
     785              s => 0,
     786              v => {
     787                int bins = (int)Math.Round(m.Scalar);
     788                double minValue = v.Minimum();
     789                double maxValue = v.Maximum();
     790                double intervalWidth = (maxValue - minValue) / bins;
     791                int totalValues = v.Count;
     792                double sum = 0;
     793                for (int i = 0; i < Math.Max(bins, v.Count); i++) {
     794                  double binMin = minValue * i;
     795                  double binMax = binMin + intervalWidth;
     796                  double countBin = v.Map(e => (e > binMin && e < binMax) ? 1 : 0).Sum();
     797                  double percBin = countBin / totalValues;
     798                  sum += percBin * Math.Log(percBin);
     799                }
     800
     801                return sum;
     802              });
     803            TraceEvaluation(currentInstr, cur);
     804            return cur;
     805          }
     806        case OpCodes.HasLargeStandardDeviation: {
     807            var cur = Evaluate(dataset, ref row, state, traceDict);
     808            cur = AggregateApply(cur,
     809              s => 0,
     810              v => Statistics.PopulationStandardDeviation(v) > (Statistics.Maximum(v) - Statistics.Minimum(v)) / 2 ? 1 : 0);
     811            TraceEvaluation(currentInstr, cur);
     812            return cur;
     813          }
     814        case OpCodes.HasVarianceLargerThanStd: {
     815            var cur = Evaluate(dataset, ref row, state, traceDict);
     816            cur = AggregateApply(cur,
     817              s => 0,
     818              v => Statistics.PopulationVariance(v) > Statistics.StandardDeviation(v) ? 1 : 0);
     819            TraceEvaluation(currentInstr, cur);
     820            return cur;
     821          }
     822        case OpCodes.IsSymmetricLooking: {
     823            var cur = Evaluate(dataset, ref row, state, traceDict);
     824            cur = AggregateApply(cur,
     825              s => 0,
     826              v => Math.Abs(Statistics.Mean(v) - Statistics.Median(v)) < (Statistics.Maximum(v) - Statistics.Minimum(v)) / 2 ? 1 : 0);
     827            TraceEvaluation(currentInstr, cur);
     828            return cur;
     829          }
     830        case OpCodes.NumberDataPointsAboveMean: {
     831            var cur = Evaluate(dataset, ref row, state, traceDict);
     832            cur = AggregateApply(cur,
     833              s => 0,
     834              v => {
     835                double mean = Statistics.Mean(v);
     836                return v.Map(e => e > mean ? 1 : 0).Sum();
     837              });
     838            TraceEvaluation(currentInstr, cur);
     839            return cur;
     840          }
     841        case OpCodes.NumberDataPointsAboveMedian: {
     842            var cur = Evaluate(dataset, ref row, state, traceDict);
     843            cur = AggregateApply(cur,
     844              s => 0,
     845              v => {
     846                double median = Statistics.Median(v);
     847                return v.Map(e => e > median ? 1 : 0).Sum();
     848              });
     849            TraceEvaluation(currentInstr, cur);
     850            return cur;
     851          }
     852        case OpCodes.NumberDataPointsBelowMean: {
     853            var cur = Evaluate(dataset, ref row, state, traceDict);
     854            cur = AggregateApply(cur,
     855              s => 0,
     856              v => {
     857                double mean = Statistics.Mean(v);
     858                return v.Map(e => e < mean ? 1 : 0).Sum();
     859              });
     860            TraceEvaluation(currentInstr, cur);
     861            return cur;
     862          }
     863        case OpCodes.NumberDataPointsBelowMedian: {
     864            var cur = Evaluate(dataset, ref row, state, traceDict);
     865            cur = AggregateApply(cur,
     866              s => 0,
     867              v => {
     868                double median = Statistics.Median(v);
     869                return v.Map(e => e < median ? 1 : 0).Sum();
     870              });
     871            TraceEvaluation(currentInstr, cur);
     872            return cur;
     873          }
     874
     875        case OpCodes.ArimaModelCoefficients: {
     876            var cur = Evaluate(dataset, ref row, state, traceDict);
     877            var i = Evaluate(dataset, ref row, state, traceDict);
     878            var k = Evaluate(dataset, ref row, state, traceDict);
     879            cur = AggregateApply(cur,
     880              s => 0,
     881              v => throw new NotImplementedException(""));
     882            TraceEvaluation(currentInstr, cur);
     883            return cur;
     884          }
     885        case OpCodes.ContinuousWaveletTransformationCoefficients: {
     886            var cur = Evaluate(dataset, ref row, state, traceDict);
     887            var a = Evaluate(dataset, ref row, state, traceDict);
     888            var b = Evaluate(dataset, ref row, state, traceDict);
     889            cur = AggregateApply(cur,
     890              s => 0,
     891              v => throw new NotImplementedException(""));
     892            TraceEvaluation(currentInstr, cur);
     893            return cur;
     894          }
     895        case OpCodes.FastFourierTransformationCoefficient: {
     896            var cur = Evaluate(dataset, ref row, state, traceDict);
     897            var k = Evaluate(dataset, ref row, state, traceDict);
     898            cur = AggregateApply(cur,
     899              s => 0,
     900              v => throw new NotImplementedException(""));
     901            TraceEvaluation(currentInstr, cur);
     902            return cur;
     903          }
     904        case OpCodes.FirstIndexMax: {
     905            var cur = Evaluate(dataset, ref row, state, traceDict);
     906            cur = AggregateApply(cur,
     907              s => 0,
     908              v => (double)v.MaximumIndex() / v.Count);
     909            TraceEvaluation(currentInstr, cur);
     910            return cur;
     911          }
     912        case OpCodes.FirstIndexMin: {
     913            var cur = Evaluate(dataset, ref row, state, traceDict);
     914            cur = AggregateApply(cur,
     915              s => 0,
     916              v => (double)v.MinimumIndex() / v.Count);
     917            TraceEvaluation(currentInstr, cur);
     918            return cur;
     919          }
     920        case OpCodes.LastIndexMax: {
     921            var cur = Evaluate(dataset, ref row, state, traceDict);
     922            cur = AggregateApply(cur,
     923              s => 0,
     924              v => (double)(v.Count - DoubleVector.Build.DenseOfEnumerable(v.Reverse()).MaximumIndex()) / v.Count);
     925
     926            TraceEvaluation(currentInstr, cur);
     927            return cur;
     928          }
     929        case OpCodes.LastIndexMin: {
     930            var cur = Evaluate(dataset, ref row, state, traceDict);
     931            cur = AggregateApply(cur,
     932              s => 0,
     933              v => (double)(v.Count - DoubleVector.Build.DenseOfEnumerable(v.Reverse()).MinimumIndex()) / v.Count);
     934            TraceEvaluation(currentInstr, cur);
     935            return cur;
     936          }
     937        case OpCodes.LongestStrikeAboveMean: {
     938            var cur = Evaluate(dataset, ref row, state, traceDict);
     939            cur = AggregateApply(cur,
     940              s => 0,
     941              v => LongestStrikeAbove(v, Statistics.Mean(v)));
     942            TraceEvaluation(currentInstr, cur);
     943            return cur;
     944          }
     945        case OpCodes.LongestStrikeAboveMedian: {
     946            var cur = Evaluate(dataset, ref row, state, traceDict);
     947            cur = AggregateApply(cur,
     948              s => 0,
     949              v => LongestStrikeAbove(v, Statistics.Median(v)));
     950            TraceEvaluation(currentInstr, cur);
     951            return cur;
     952          }
     953        case OpCodes.LongestStrikeBelowMean: {
     954            var cur = Evaluate(dataset, ref row, state, traceDict);
     955            cur = AggregateApply(cur,
     956              s => 0,
     957              v => LongestStrikeBelow(v, Statistics.Mean(v)));
     958            TraceEvaluation(currentInstr, cur);
     959            return cur;
     960          }
     961        case OpCodes.LongestStrikeBelowMedian: {
     962            var cur = Evaluate(dataset, ref row, state, traceDict);
     963            cur = AggregateApply(cur,
     964              s => 0,
     965              v => LongestStrikeBelow(v, Statistics.Median(v)));
     966            TraceEvaluation(currentInstr, cur);
     967            return cur;
     968          }
     969        case OpCodes.LongestStrikePositive: {
     970            var cur = Evaluate(dataset, ref row, state, traceDict);
     971            cur = AggregateApply(cur,
     972              s => 0,
     973              v => LongestStrikeAbove(v, 0));
     974            TraceEvaluation(currentInstr, cur);
     975            return cur;
     976          }
     977        case OpCodes.LongestStrikeNegative: {
     978            var cur = Evaluate(dataset, ref row, state, traceDict);
     979            cur = AggregateApply(cur,
     980              s => 0,
     981              v => LongestStrikeAbove(v, 0));
     982            TraceEvaluation(currentInstr, cur);
     983            return cur;
     984          }
     985        case OpCodes.LongestStrikeZero: {
     986            var cur = Evaluate(dataset, ref row, state, traceDict);
     987            cur = AggregateApply(cur,
     988              s => 0,
     989              v => LongestStrikeEqual(v, 0));
     990            TraceEvaluation(currentInstr, cur);
     991            return cur;
     992          }
     993        case OpCodes.MeanAbsoluteChange: {
     994            var cur = Evaluate(dataset, ref row, state, traceDict);
     995            cur = AggregateApply(cur,
     996              s => 0,
     997              v => {
     998                double sum = 0.0;
     999                for (int i = 0; i < v.Count - 1; i++) {
     1000                  sum += Math.Abs(v[i + 1] - v[i]);
     1001                }
     1002
     1003                return sum / v.Count;
     1004              });
     1005            TraceEvaluation(currentInstr, cur);
     1006            return cur;
     1007          }
     1008        case OpCodes.MeanAbsoluteChangeQuantiles: {
     1009            var cur = Evaluate(dataset, ref row, state, traceDict);
     1010            var ql = Evaluate(dataset, ref row, state, traceDict);
     1011            var qu = Evaluate(dataset, ref row, state, traceDict);
     1012            cur = AggregateApply(cur,
     1013              s => 0,
     1014              v => {
     1015                var lowerBound = Statistics.Quantile(v, ql.Scalar);
     1016                var upperBound = Statistics.Quantile(v, qu.Scalar);
     1017                var inBounds = v.Select(e => e > lowerBound && e < upperBound).ToList();
     1018                double sum = 0.0;
     1019                int count = 0;
     1020                for (int i = 0; i < v.Count - 1; i++) {
     1021                  if (inBounds[i] && inBounds[i + 1]) {
     1022                    sum += Math.Abs(v[i + 1] - v[i]);
     1023                    count++;
     1024                  }
     1025                }
     1026
     1027                return sum / count;
     1028              });
     1029            TraceEvaluation(currentInstr, cur);
     1030            return cur;
     1031          }
     1032        case OpCodes.MeanAutocorrelation: {
     1033            var cur = Evaluate(dataset, ref row, state, traceDict);
     1034            cur = AggregateApply(cur,
     1035              s => 0,
     1036              v => {
     1037                double sum = 0.0;
     1038                double mean = Statistics.Mean(v);
     1039                for (int l = 0; l < v.Count; l++) {
     1040                  for (int i = 0; i < v.Count - l; i++) {
     1041                    sum += (v[i] - mean) * (v[i + l] - mean);
     1042                  }
     1043                }
     1044
     1045                return sum / (v.Count - 1) / Statistics.PopulationVariance(v);
     1046              });
     1047            TraceEvaluation(currentInstr, cur);
     1048            return cur;
     1049          }
     1050        case OpCodes.LaggedAutocorrelation: {
     1051            var cur = Evaluate(dataset, ref row, state, traceDict);
     1052            var lVal = Evaluate(dataset, ref row, state, traceDict);
     1053            cur = AggregateApply(cur,
     1054              s => 0,
     1055              v => {
     1056                double sum = 0.0;
     1057                int l = (int)Math.Round(lVal.Scalar);
     1058                double mean = Statistics.Mean(v);
     1059                for (int i = 0; i < v.Count - l; i++) {
     1060                  sum += (v[i] - mean) * (v[i + l] - mean);
     1061                }
     1062
     1063                return sum / Statistics.PopulationVariance(v);
     1064              });
     1065            TraceEvaluation(currentInstr, cur);
     1066            return cur;
     1067          }
     1068        case OpCodes.MeanSecondDerivateCentral: {
     1069            var cur = Evaluate(dataset, ref row, state, traceDict);
     1070            cur = AggregateApply(cur,
     1071              s => 0,
     1072              v => {
     1073                double sum = 0.0;
     1074                for (int i = 1; i < v.Count - 1; i++) {
     1075                  sum += (v[i - 1] - 2 * v[i] + v[i + 1]) / 2;
     1076                }
     1077
     1078                return sum / (v.Count - 2);
     1079              });
     1080            TraceEvaluation(currentInstr, cur);
     1081            return cur;
     1082          }
     1083        case OpCodes.NumberPeaksOfSize: {
     1084            var cur = Evaluate(dataset, ref row, state, traceDict);
     1085            var l = Evaluate(dataset, ref row, state, traceDict);
     1086            cur = AggregateApply(cur,
     1087              s => 0,
     1088              v => CountNumberOfPeaks(v, l.Scalar));
     1089            TraceEvaluation(currentInstr, cur);
     1090            return cur;
     1091          }
     1092        case OpCodes.LargeNumberOfPeaks: {
     1093            var cur = Evaluate(dataset, ref row, state, traceDict);
     1094            var l = Evaluate(dataset, ref row, state, traceDict);
     1095            var m = Evaluate(dataset, ref row, state, traceDict);
     1096            cur = AggregateApply(cur,
     1097              s => 0,
     1098              v => CountNumberOfPeaks(v, l.Scalar) > m.Scalar ? 1.0 : 0.0);
     1099            TraceEvaluation(currentInstr, cur);
     1100            return cur;
     1101          }
     1102        case OpCodes.TimeReversalAsymmetryStatistic: {
     1103            var cur = Evaluate(dataset, ref row, state, traceDict);
     1104            var l = Evaluate(dataset, ref row, state, traceDict);
     1105            cur = AggregateApply(cur,
     1106              s => 0,
     1107              v => {
     1108                int lag = (int)Math.Round(l.Scalar);
     1109                double sum = 0.0;
     1110                for (int i = 0; i < v.Count - 2 * lag; i++) {
     1111                  sum += Math.Pow(v[i + 2 * lag], 2) * v[i + lag] - v[i + lag] * Math.Pow(v[i], 2);
     1112                }
     1113
     1114                return sum / (v.Count - 2 * lag);
     1115              });
     1116            TraceEvaluation(currentInstr, cur);
     1117            return cur;
     1118          }
     1119        #endregion
     1120
    7541121        default:
    7551122          throw new NotSupportedException($"Unsupported OpCode: {currentInstr.opCode}");
    7561123      }
    7571124    }
     1125
     1126    private static int LongestStrikeAbove(DoubleVector v, double threshold) {
     1127      int longestStrike = 0, currentStrike = 0;
     1128      for (int i = 0; i < v.Count; i++) {
     1129        if (v[i] > threshold) {
     1130          currentStrike++;
     1131          longestStrike = Math.Max(longestStrike, currentStrike);
     1132        } else
     1133          currentStrike = 0;
     1134      }
     1135      return longestStrike;
     1136    }
     1137    private static int LongestStrikeBelow(DoubleVector v, double threshold) {
     1138      int longestStrike = 0, currentStrike = 0;
     1139      for (int i = 0; i < v.Count; i++) {
     1140        if (v[i] < threshold) {
     1141          currentStrike++;
     1142          longestStrike = Math.Max(longestStrike, currentStrike);
     1143        } else
     1144          currentStrike = 0;
     1145      }
     1146      return longestStrike;
     1147    }
     1148
     1149    private static int LongestStrikeEqual(DoubleVector v, double value, double epsilon = double.Epsilon) {
     1150      int longestStrike = 0, currentStrike = 0;
     1151      for (int i = 0; i < v.Count; i++) {
     1152        if (v[i].IsAlmost(epsilon)) {
     1153          currentStrike++;
     1154          longestStrike = Math.Max(longestStrike, currentStrike);
     1155        } else
     1156          currentStrike = 0;
     1157      }
     1158      return longestStrike;
     1159    }
     1160    private static int CountNumberOfPeaks(DoubleVector v, double heightDifference) {
     1161      int count = 0;
     1162      for (int i = 0; i < v.Count; i++) {
     1163        bool largerThanPrev = i == 0 || v[i] > v[i - 1] + heightDifference;
     1164        bool largerThanNext = i == v.Count - 1 || v[i] > v[i + 1] + heightDifference;
     1165        if (largerThanPrev && largerThanNext)
     1166          count++;
     1167      }
     1168      return count;
     1169    }
    7581170  }
    7591171}
Note: See TracChangeset for help on using the changeset viewer.