Konwolucyjna sieć neuronowa dla szeregów czasowych?

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ę.

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:

• Prognozy szeregów czasowych i sieci neuronowe
• Sieci splotowe dla obrazów, mowy i szeregów czasowych
• Głębokie sieci neuronowe do prognozowania szeregów czasowych z zastosowaniami w ultra-krótkoterminowym prognozowaniu wiatru
• Konwolucyjne sieci obrotu akcjami
• Statystyczny arbitraż handlowy przy użyciu sieci neuronowych z opóźnieniem czasowym
• Klasyfikacja szeregów czasowych z wykorzystaniem wielokanałowych głębokich sieci neuronowych splotowych
• Sieci neuronowe do prognozowania szeregów czasowych
• Zastosowanie sieci neuronowych do wykrywania dryfu koncepcji na rynkach finansowych
• Kodowanie szeregów czasowych jako obrazów do kontroli wizualnej i klasyfikacji za pomocą kafelkowych konwekcyjnych sieci neuronowych
• Prognozowanie szeregów czasowych przy użyciu sumy konwertowej dyskretnej sieci neuronowej procesu
• Długoterminowe nawracające sieci splotowe do rozpoznawania i opisu wizualnego
• Badanie struktur splotowej sieci neuronowej i technik optymalizacji w zakresie rozpoznawania mowy

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.

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:

Nieźle.