Сверточная нейронная сеть для временных рядов?

Я хотел бы знать, существует ли код для обучения сверточной нейронной сети для классификации временных рядов.

Я видел несколько недавних работ ( http://www.fer.unizg.hr/_download/repository/KDI-Djalto.pdf ), но я не уверен, существует ли что-то или я должен написать это самостоятельно.

Если вам нужно решение черного ящика с открытым исходным кодом, попробуйте взглянуть на Weka , библиотеку Java алгоритмов ML. Этот парень также использовал Covolutional Layers в Weka, и вы можете редактировать его классификационный код в соответствии с задачей классификации временных рядов.

Что касается собственного кодирования ... Я работаю над той же проблемой, используя библиотеку python, theano (я отредактирую этот пост со ссылкой на мой код, если я скоро его взломаю ). Вот полный список всех статей, которые я буду использовать, чтобы помочь мне после хорошего поиска в Интернете:

• Прогнозирование временных рядов и нейронные сети
• Сверточные сети для изображений, речи и временных рядов
• Глубокие нейронные сети для прогнозирования временных рядов с приложениями в сверхкоротком прогнозировании ветра
• Сверточные сети для биржевой торговли
• Статистический арбитраж биржевой торговли с использованием нейронных сетей с задержкой
• Классификация временных рядов с использованием многоканальных глубоко сверточных нейронных сетей
• Нейронные сети для прогнозирования временных рядов
• Применение нейронных сетей для выявления концептуального дрейфа на финансовых рынках
• Кодирование временных рядов как изображений для визуального контроля и классификации с использованием плиточных сверточных нейронных сетей
• Прогнозирование временных рядов с использованием нейронной сети с дискретной суммой процессов свертки
• Долгосрочные рекуррентные сверточные сети для визуального распознавания и описания
• Изучение структур сверточных нейронных сетей и методов оптимизации распознавания речи

В качестве отправной точки вы можете отредактировать найденный здесь код, чтобы классифицировать его по разному количеству категорий, или отредактировать его от классификации к регрессии - я сделал это, удалив последний слой softmax и сделав только один выходной узел. Я обучил его на части функции, как y=sin(x)в качестве теста.

Вполне возможно использовать CNN для прогнозирования временных рядов, будь то регрессия или классификация. CNN хороши в поиске локальных шаблонов, и на самом деле CNN работают с предположением, что локальные шаблоны актуальны везде. Также свертка является хорошо известной операцией во временных рядах и обработке сигналов. Другое преимущество по сравнению с RNN состоит в том, что они могут быть очень быстрыми для вычисления, поскольку они могут быть распараллелены, в отличие от последовательной природы RNN.

В приведенном ниже коде я продемонстрирую пример, в котором можно предсказать спрос на электроэнергию в R с помощью керас. Обратите внимание, что это не проблема классификации (у меня не было удобного примера), но нетрудно изменить код для решения проблемы классификации (используйте вывод softmax вместо линейного вывода и перекрестную потерю энтропии).

Набор данных доступен в библиотеке fpp2:

library(fpp2)
library(keras)

data("elecdemand")

elec <- as.data.frame(elecdemand)

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

Далее мы создаем генератор данных. Это используется для создания пакетов данных обучения и проверки, которые будут использоваться в процессе обучения. Обратите внимание, что этот код является более простой версией генератора данных, найденного в книге «Глубокое обучение с R» (и видеоверсия «Глубокое обучение с R в движении») из публикаций Мэннинга.

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)

  })
}

Далее мы указываем некоторые параметры, которые должны быть переданы в наши генераторы данных (мы создаем два генератора, один для обучения и один для проверки).

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

Параметр обратного просмотра - это то, как далеко в прошлом мы хотим посмотреть, и прогноз того, как далеко в будущем мы хотим предсказать.

Затем мы разбиваем наш набор данных и создаем два генератора:

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
)

Далее мы создаем нейронную сеть со сверточным слоем и обучаем модель:

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
)

Наконец, мы можем создать некоторый код для прогнозирования последовательности из 24 точек данных, используя простую процедуру, объясненную в комментариях 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)

и вуаля:

Не так уж плохо.