सीएनएन का उपयोग पूरी तरह से संभव है कि समय की श्रृंखला की भविष्यवाणी करने के लिए यह प्रतिगमन या वर्गीकरण हो। सीएनएन स्थानीय पैटर्न खोजने में अच्छे हैं और वास्तव में सीएनएन इस धारणा के साथ काम करते हैं कि स्थानीय पैटर्न हर जगह प्रासंगिक हैं। साथ ही सजा समय श्रृंखला और सिग्नल प्रोसेसिंग में एक प्रसिद्ध ऑपरेशन है। RNN पर एक और लाभ यह है कि वे गणना करने के लिए बहुत तेज़ हो सकते हैं क्योंकि उन्हें RNN क्रमिक प्रकृति के विपरीत समानांतर किया जा सकता है।
नीचे दिए गए कोड में मैं एक केस स्टडी दिखाऊंगा जहां आर केरस का उपयोग करके बिजली की मांग का अनुमान लगाना संभव है। ध्यान दें कि यह एक वर्गीकरण समस्या नहीं है (मेरे पास एक उदाहरण काम नहीं है) लेकिन एक वर्गीकरण समस्या को संभालने के लिए कोड को संशोधित करना मुश्किल नहीं है (एक रैखिक उत्पादन के बजाय एक सॉफ्टमैक्स आउटपुट का उपयोग करें और एक क्रॉस एन्ट्रॉपी लॉस)।
डेटासेट fpp2 लाइब्रेरी में उपलब्ध है:
library(fpp2)
library(keras)
data("elecdemand")
elec <- as.data.frame(elecdemand)
dm <- as.matrix(elec[, c("WorkDay", "Temperature", "Demand")])
आगे हम एक डेटा जनरेटर बनाते हैं। यह प्रशिक्षण प्रक्रिया के दौरान उपयोग किए जाने वाले प्रशिक्षण और सत्यापन डेटा के बैच बनाने के लिए उपयोग किया जाता है। ध्यान दें कि यह कोड मैनिंग प्रकाशनों की पुस्तक "डीप लर्निंग विथ आर" (और इसका वीडियो संस्करण "डीप लर्निंग विथ आर इन मोशन") में पाया गया एक डेटा जनरेटर का सरल संस्करण है।
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
)
अंत में, हम R टिप्पणियों में समझाया गया एक सरल प्रक्रिया का उपयोग करके 24 डेटा पॉइंट्स के अनुक्रम की भविष्यवाणी करने के लिए कुछ कोड बना सकते हैं।
####### 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)
और वोइला:
इतना भी बेकार नहीं।