Détection de crête dans les séries temporelles

Je suis actuellement en train de travailler sur un petit projet dans lequel je veux comparer deux séries chronologiques. La mesure de similarité est vraiment vague, ils sont considérés comme similaires si les deux séries ont à peu près la même forme.

Donc je me suis dit "eh Bien, si ils ont seulement besoin d'avoir la même forme, je viens de comparer les sommets des deux temps de la série, si les pics sont à la même position, alors sûrement le temps de la série sera similaire"

Mon problème maintenant est de trouver un bon algorithme pour la détection de crête. J'ai utilisé google, mais je n'en ai venu avec le papier Simple d'Algorithmes pour la Détection de Pic dans le Temps de la Série. Le problème est, les algorithmes décrits dans le présent document de travail bien avec vraiment extrême et mince pics, mais dans la plupart des cas, mon le temps de la série ont plutôt plat pics de sorte qu'ils ne seront pas détectés.

Quelqu'un sait où je pourrais trouver ou rechercher un algorithme qui permettrait de détecter les pics montré dans l'image suivante?

Détection de crête dans les séries temporelles

source d'informationauteur Sturmi12 | 2012-09-03

  1. 7

    Vous semblez il suffit de regarder pour l'inversion de la pente (à partir du positif au négatif, et vice-versa). Un accidenté de la java algo pourrait être (pas testé):

    List<Point> points = ... //all the points in your curve
List<Point> extremes = new ArrayList<Point> ();
double previous = null;
double previousSlope = 0;

for (Point p : points) {
    if (previous == null) { previous = p; continue; }
    double slope = p.getValue() - previous.getValue();
    if (slope * previousSlope < 0) { //look for sign changes
        extremes.add(previous);
    }
    previousSlope = slope;
    previous = p;
}

    Enfin, une bonne façon de mesurer la similarité est de corrélation. Dans votre cas, je regarde % déplacer corrélation (en d'autres termes, vous voulez que votre 2 de la série pour aller vers le haut ou vers le bas en même temps) - c'est généralement ce qui est fait dans la finance où vous calculer la corrélation entre les 2 actifs renvoie par exemple:

    • créer 2 nouvelles séries avec l' % déplacer pour chaque point de la série 2
    • calcul de la corrélation entre ces 2 séries

    Vous pouvez en lire plus à propos de les retours des corrélations ici par exemple. En résumé, si vos valeurs sont:

    Series 1  Series 2
 100        50
 98         49
 100        52
 102        54

    Les "retours" de la série seront:

    Series 1  Series 2
 -2.00%     -2.00%
 +2.04%     +6.12%
 +2.00%     +3.85%

    Et de calculer la corrélation de ces 2 retours de la série (dans cet exemple: 0,96) pour obtenir une mesure de combien les 2 courbes se ressemblent. Vous souhaiterez peut-être modifier le résultat de la variance (c'est à dire si une forme dispose d'un éventail beaucoup plus large que l'autre).

  2. 5

    Vous pouvez utiliser une locale très simple extrêmes détecteur:

    //those are your points:
double[] f = {1, 2, 3, 4, 5, 6, 5, 4, 7, 8, 9, 3, 1, 4, 6, 8, 9, 7, 4, 1};
List<Integer> ext = new ArrayList<Integer> ();
for (int i = 0; i<f.length-2; i++) {
  if ((f[i+1]-f[i])*(f[i+2]-f[i+1]) <= 0) { //changed sign?
    ext.add(i+1);
  }
}
//now you have the indices of the extremes in your list `ext`

    Cela fonctionne belle et lisse de la série. Si vous avez une certaine variation dans vos données, vous devez le mettre à travers un filtre passe-bas en premier. Très simple de mise en œuvre d'un filtre passe-bas serait la moyenne mobile (chaque point est remplacé par la moyenne de la plus proche des valeurs de k, où k est la taille de la fenêtre).

  3. 3

    La peakdet algorithme proposé par Eli Billauer fonctionne très bien et est facile à mettre en œuvre:

    http://www.billauer.co.il/peakdet.html

    L'algorithme fonctionne particulièrement bien avec des signaux bruités où les méthodes à l'aide de la dérivée première échouer.

  4. 1

    Si vous voulez quelque chose statistiquement plus saine, vous pourriez mesurer la de corrélation croisée entre les deux séries. Vous pouvez le vérifier Wikipediaou ce site.

  5. 0

    Je ne suis pas sûr à propos de la corrélation entre les séries temporelles ou pic spécifique des algorithmes de détection, mais voici un peu de crête maximale de détection de l'algorithme que j'ai écrit. Il ne détecte pas le minimum de sommets, mais pourrait facilement être étendu à faire en inversant les opérations dans la boucle for.

    List<XYDataItem> maxPoints = ... //list to store the maximums
XYDataItem leftPeakPoint = new XYDataItem(0, 0);
int leftPeakPointIndex = 0;
XYDataItem rightPeakPoint = new XYDataItem(0, 0);
boolean first = true;
int index = -1;
List<XYDataItem> pointList = (List<XYDataItem>) lrpSeries.getItems();
for (XYDataItem point : pointList) {
index++;
if (first) {
//initialize the first point
leftPeakPoint = point;
leftPeakPointIndex = index;
first = false;
continue;
}
if (leftPeakPoint.getYValue() < point.getYValue()) {
leftPeakPoint = point;
leftPeakPointIndex = index;
rightPeakPoint = point;
} else if (leftPeakPoint.getYValue() == point.getYValue()) {
rightPeakPoint = point;
} else {
//determine if we are coming down off of a peak by looking at the Y value of the point before the
//left most point that was detected as a part of a peak
if (leftPeakPointIndex > 0) {
XYDataItem prev = pointList.get(leftPeakPointIndex - 1);
//if two points back has a Y value that is less than or equal to the left peak point
//then we have found the end of the peak and we can process as such
if (prev.getYValue() <= leftPeakPoint.getYValue()) {
double peakx = rightPeakPoint.getXValue() - ((rightPeakPoint.getXValue() - leftPeakPoint.getXValue()) / 2D);
maxPoints.add(new XYDataItem(peakx, leftPeakPoint.getYValue()));
}
}
leftPeakPoint = point;
leftPeakPointIndex = index;
rightPeakPoint = point;
}
}

    Le résultat de ce centre le pic détecté sur les sections planes où la valeur Y de points de données consécutifs est la même. XYDataItem est juste une classe qui contient une valeur X et Y comme un double. Cela peut facilement être remplacé par quelque chose d'équivalent.