Konwolucyjna sieć neuronowa dla szeregów czasowych?

21

Chciałbym wiedzieć, czy istnieje kod do trenowania splotowej sieci neuronowej do przeprowadzania klasyfikacji szeregów czasowych.

Widziałem kilka ostatnich artykułów ( http://www.fer.unizg.hr/_download/repository/KDI-Djalto.pdf ), ale nie jestem pewien, czy coś istnieje lub czy sam to koduję.

łagodny
źródło
1
Człowieku, to bardzo dziwne. CNN to bardzo niesamowite narzędzie do obrazów (sygnałów) i prawie nie ma żadnych dokumentów na temat prognozowania zapasów przy ich użyciu ... Wszystko, co mogę znaleźć, to stare sieci neuronowe, które w tym czasie były bezużyteczne ...
MasterID

Odpowiedzi:

21

Jeśli potrzebujesz rozwiązania czarnej skrzynki typu open source, spróbuj spojrzeć na Weka , bibliotekę algorytmów ML. Ten facet używał również warstw kowalencyjnych w Wece i możesz edytować jego kod klasyfikacyjny, aby dopasować go do zadania klasyfikacji szeregów czasowych.

Co do kodowania własnego ... Pracuję nad tym samym problemem przy użyciu biblioteki Pythona, theano (zmodyfikuję ten post z linkiem do mojego kodu, jeśli wkrótce go złamie ). Oto pełna lista wszystkich artykułów, których będę używać, aby pomóc mi w dobrej godzinie przeszukiwania sieci:

Na początek możesz edytować znaleziony tutaj kod , aby sklasyfikować go według innej liczby kategorii lub edytować od klasyfikacji do regresji - zrobiłem to, usuwając ostatnią warstwę softmax i tworząc tylko jeden węzeł wyjściowy. Ćwiczyłem go na plasterkach funkcji takiej y=sin(x)jak test.

Alexander McFarlane
źródło
Tylko do Twojej wiadomości - w niektórych z nich znalazłem wiele błędów, więc nie stosuj ich na ślepo. W szczególności niektóre z nich nie są publikacjami. Jest to jednak dobry punkt wyjścia do nauki podstaw
Alexander McFarlane
Byłoby mile widziane, gdybyś mógł podzielić się swoją zdobytą wiedzą na temat tego, o których artykułach tu chodzi?
bicepjai
1

Jest całkowicie możliwe użycie CNN do prognozowania szeregów czasowych, czy to regresji, czy klasyfikacji. Sieci CNN są dobre w znajdowaniu wzorców lokalnych, aw rzeczywistości CNN działają przy założeniu, że wzorce lokalne są istotne wszędzie. Również splot jest dobrze znaną operacją w szeregach czasowych i przetwarzaniu sygnałów. Kolejną zaletą w stosunku do RNN jest to, że mogą być bardzo szybkie w obliczeniach, ponieważ można je zrównoleglać w przeciwieństwie do sekwencyjnego charakteru RNN.

W poniższym kodzie pokażę studium przypadku, w którym można przewidzieć zapotrzebowanie na energię elektryczną w R za pomocą keras. Zauważ, że to nie jest problem z klasyfikacją (nie miałem przydatnego przykładu), ale modyfikacja kodu w celu obsługi problemu z klasyfikacją nie jest trudna (użyj wyjścia softmax zamiast wyjścia liniowego i utraty entropii krzyżowej).

Zestaw danych jest dostępny w bibliotece fpp2:

library(fpp2)
library(keras)

data("elecdemand")

elec <- as.data.frame(elecdemand)

dm <- as.matrix(elec[, c("WorkDay", "Temperature", "Demand")])

Następnie tworzymy generator danych. Służy to do tworzenia partii danych szkoleniowych i walidacyjnych, które będą wykorzystywane podczas procesu szkoleniowego. Zauważ, że ten kod jest prostszą wersją generatora danych, znalezionego w książce „Deep Learning with R” (i jego wersji wideo „Deep Learning with R in Motion”) z publikacji manning.

data_gen <- function(dm, batch_size, ycol, lookback, lookahead) {

  num_rows <- nrow(dm) - lookback - lookahead
  num_batches <- ceiling(num_rows/batch_size)
  last_batch_size <- if (num_rows %% batch_size == 0) batch_size else num_rows %% batch_size
  i <- 1
  start_idx <- 1
  return(function(){
    running_batch_size <<- if (i == num_batches) last_batch_size else batch_size
    end_idx <- start_idx + running_batch_size - 1
    start_indices <- start_idx:end_idx

    X_batch <- array(0, dim = c(running_batch_size,
                                lookback,
                                ncol(dm)))
    y_batch <- array(0, dim = c(running_batch_size, 
                                length(ycol)))

    for (j in 1:running_batch_size){
      row_indices <- start_indices[j]:(start_indices[j]+lookback-1)
      X_batch[j,,] <- dm[row_indices,]
      y_batch[j,] <- dm[start_indices[j]+lookback-1+lookahead, ycol]
    }
    i <<- i+1
    start_idx <<- end_idx+1 
    if (i > num_batches){
      i <<- 1
      start_idx <<- 1
    }

    list(X_batch, y_batch)

  })
}

Następnie określamy niektóre parametry, które mają zostać przekazane do naszych generatorów danych (tworzymy dwa generatory, jeden do szkolenia, a drugi do sprawdzania poprawności).

lookback <- 72
lookahead <- 1
batch_size <- 168
ycol <- 3

Parametrem retrospekcji jest to, jak daleko w przeszłości chcemy spojrzeć, a wstecz, jak daleko w przyszłości chcemy przewidzieć.

Następnie podzieliliśmy nasz zestaw danych i utworzyliśmy dwa generatory:

train_dm <- dm [1: 15000,]

val_dm <- dm[15001:16000,]
test_dm <- dm[16001:nrow(dm),]

train_gen <- data_gen(
  train_dm,
  batch_size = batch_size,
  ycol = ycol,
  lookback = lookback,
  lookahead = lookahead
)


val_gen <- data_gen(
  val_dm,
  batch_size = batch_size,
  ycol = ycol,
  lookback = lookback,
  lookahead = lookahead
)

Następnie tworzymy sieć neuronową z warstwą splotową i trenujemy model:

model <- keras_model_sequential() %>%
  layer_conv_1d(filters=64, kernel_size=4, activation="relu", input_shape=c(lookback, dim(dm)[[-1]])) %>%
  layer_max_pooling_1d(pool_size=4) %>%
  layer_flatten() %>%
  layer_dense(units=lookback * dim(dm)[[-1]], activation="relu") %>%
  layer_dropout(rate=0.2) %>%
  layer_dense(units=1, activation="linear")


model %>% compile(
  optimizer = optimizer_rmsprop(lr=0.001),
  loss = "mse",
  metric = "mae"
)

val_steps <- 48

history <- model %>% fit_generator(
  train_gen,
  steps_per_epoch = 50,
  epochs = 50,
  validation_data = val_gen,
  validation_steps = val_steps
)

Na koniec możemy stworzyć kod, aby przewidzieć sekwencję 24 punktów danych za pomocą prostej procedury opisanej w komentarzach R.

####### How to create predictions ####################

#We will create a predict_forecast function that will do the following: 
#The function will be given a dataset that will contain weather forecast values and Demand values for the lookback duration. The rest of the MW values will be non-available and 
#will be "filled-in" by the deep network (predicted). We will do this with the test_dm dataset.

horizon <- 24

#Store all target values in a vector
goal_predictions <- test_dm[1:(lookback+horizon),ycol]
#get a copy of the dm_test
test_set <- test_dm[1:(lookback+horizon),]
#Set all the Demand values, except the lookback values, in the test set to be equal to NA.
test_set[(lookback+1):nrow(test_set), ycol] <- NA

predict_forecast <- function(model, test_data, ycol, lookback, horizon) {
  i <-1
  for (i in 1:horizon){
    start_idx <- i
    end_idx <- start_idx + lookback - 1
    predict_idx <- end_idx + 1
    input_batch <- test_data[start_idx:end_idx,]
    input_batch <- input_batch %>% array_reshape(dim = c(1, dim(input_batch)))
    prediction <- model %>% predict_on_batch(input_batch)
    test_data[predict_idx, ycol] <- prediction
  }

  test_data[(lookback+1):(lookback+horizon), ycol]
}

preds <- predict_forecast(model, test_set, ycol, lookback, horizon)

targets <- goal_predictions[(lookback+1):(lookback+horizon)]

pred_df <- data.frame(x = 1:horizon, y = targets, y_hat = preds)

i voila:

wprowadź opis zdjęcia tutaj

Nieźle.

kostas
źródło