Augmentation linéaire des données avec réinitialisation manuelle

J'ai un ensemble de données de série temporelle à augmentation linéaire d'un capteur, avec des plages de valeurs comprises entre 50 et 150. J'ai implémenté un algorithme de régression linéaire simple pour ajuster une ligne de régression sur ces données, et je prédis la date à laquelle la série atteindrait 120.

Tout fonctionne bien lorsque la série monte. Mais, il y a des cas où le capteur atteint environ 110 ou 115, et il est réinitialisé; dans de tels cas, les valeurs recommenceraient à, disons, 50 ou 60.

C'est là que je commence à faire face à des problèmes avec la ligne de régression, car elle commence à se déplacer vers le bas et à prédire l'ancienne date. Je pense que je ne devrais considérer que le sous-ensemble de données d'où il a été précédemment réinitialisé. Cependant, j'essaie de comprendre s'il existe des algorithmes disponibles qui prennent en compte ce cas.

Je suis nouveau dans la science des données, j'apprécierais que des pointeurs avancent.

Edit: les suggestions de nfmcclure appliquées

Avant d'appliquer les suggestions

Vous trouverez ci-dessous un instantané de ce que j'ai obtenu après la division de l'ensemble de données où la réinitialisation a lieu, et la pente de deux ensembles.

trouver la moyenne des deux pentes et tracer la ligne à partir de la moyenne.

Est-ce correct?

Je pensais que c'était un problème intéressant, alors j'ai écrit un échantillon de données et un estimateur de pente linéaire dans R. J'espère que cela vous aidera avec votre problème. Je vais faire quelques hypothèses, la plus importante est que vous souhaitez estimer une pente constante, donnée par certains segments dans vos données. Une autre hypothèse pour séparer les blocs de données linéaires est que la «réinitialisation» naturelle sera trouvée en comparant les différences consécutives et en trouvant celles qui sont des écarts standard X inférieurs à la moyenne. (J'ai choisi 4 sd, mais cela peut être changé)

Voici un tracé des données, et le code pour les générer est en bas.

Pour commencer, nous trouvons les pauses et ajustons chaque ensemble de valeurs y et enregistrons les pentes.

# Find the differences between adjacent points
diffs = y_data[-1] - y_data[-length(y_data)]
# Find the break points (here I use 4 s.d.'s)
break_points = c(0,which(diffs < (mean(diffs) - 4*sd(diffs))),length(y_data))
# Create the lists of y-values
y_lists = sapply(1:(length(break_points)-1),function(x){
  y_data[(break_points[x]+1):(break_points[x+1])]
})
# Create the lists of x-values
x_lists = lapply(y_lists,function(x) 1:length(x))
#Find all the slopes for the lists of points
slopes = unlist(lapply(1:length(y_lists), function(x) lm(y_lists[[x]] ~ x_lists[[x]])$coefficients[2]))

Voici les pistes: (3.309110, 4.419178, 3.292029, 4.531126, 3.675178, 4.294389)

Et nous pouvons simplement prendre la moyenne pour trouver la pente attendue (3.920168).

Edit: Prédire quand la série atteint 120

J'ai réalisé que je n'avais pas fini de prédire quand la série atteindrait 120. Si nous estimons la pente à m et que nous voyons une réinitialisation au temps t à une valeur x (x <120), nous pouvons prédire combien de temps il faudrait pour atteindre 120 par une algèbre simple.

Ici, t est le temps qu'il faudrait pour atteindre 120 après une réinitialisation, x est ce à quoi il se réinitialise et m est la pente estimée. Je ne vais même pas toucher au sujet des unités ici, mais c'est une bonne pratique de les travailler et de m'assurer que tout a un sens.

Modifier: création des exemples de données

Les données de l'échantillon seront composées de 100 points de bruit aléatoire avec une pente de 4 (nous espérons que nous l'estimerons). Lorsque les valeurs y atteignent un seuil, elles sont réinitialisées à 50. Le seuil est choisi au hasard entre 115 et 120 pour chaque réinitialisation. Voici le code R pour créer l'ensemble de données.

# Create Sample Data
set.seed(1001)
x_data = 1:100 # x-data
y_data = rep(0,length(x_data)) # Initialize y-data
y_data[1] = 50 
reset_level = sample(115:120,1) # Select initial cutoff
for (i in x_data[-1]){ # Loop through rest of x-data
  if(y_data[i-1]>reset_level){ # check if y-value is above cutoff
    y_data[i] = 50             # Reset if it is and
    reset_level = sample(115:120,1) # rechoose cutoff
  }else {
    y_data[i] = y_data[i-1] + 4 + (10*runif(1)-5) # Or just increment y with random noise
  }
}
plot(x_data,y_data) # Plot data

Votre problème est que les réinitialisations ne font pas partie de votre modèle linéaire. Vous devez soit couper vos données en différents fragments lors des réinitialisations, afin qu'aucune réinitialisation ne se produise dans chaque fragment, et vous pouvez adapter un modèle linéaire à chaque fragment. Ou vous pouvez créer un modèle plus compliqué qui permet des réinitialisations. Dans ce cas, soit l'heure d'apparition des réinitialisations doit être entrée manuellement dans le modèle, soit l'heure des réinitialisations doit être un paramètre libre dans le modèle qui est déterminé en ajustant le modèle aux données.