XG Boost gegen Random Forest für die Vorhersage von Zeitreihen-Regressionen

Ich verwende Rs Implementierung von XGboost und Random Forest, um Prognosen für den Umsatz für einen Tag im Voraus zu erstellen. Ich habe ungefähr 200 Zeilen und 50 Prädiktoren. (Wenn ich mit der Zeit weiter gehe, habe ich mehr Daten, also mehr Zeilen).

Das XGBoost-Modell mit den folgenden Parametern ist in Bezug auf den mittleren quadratischen Fehler 6% schlechter als ein Standard-Zufallswaldmodell. Darüber hinaus ist das Zufallswaldmodell etwas genauer als ein autoregressives Zeitreihen-Prognosemodell. (Ich habe Arimax noch nicht ausprobiert).

Für Xgboost habe ich versucht, eta auf 0,02 und num_rounds auf 8.000 zu ändern, aber jetzt dauert die Ausführung lange. Gibt es eine Anleitung, mit der ich die Prognosegenauigkeit des xgboost-Modells verbessern kann? Benutze ich die Multi-Core-Funktion richtig?

Ich habe das Gefühl, als würde ich mit einer geringen Auszahlung im Dunkeln herumgreifen. Wenn es hilft, verwende ich ein Core I7 mit 12 GB RAM unter Windows 7 Professional. Ich freue mich über Ihre Hilfe!

rf.mod = randomForest(act ~ ., data = train)
rf.pred = predict(rf.mod, newdata = test)
#####################################
train_x <- sparse.model.matrix(~., data = train[,2:ncol(train)])
train_y <- train$act
test_x <- sparse.model.matrix(~., data = test)

xgtrain <- xgb.DMatrix(data = train_x, label= train_y)
xgtest <- xgb.DMatrix(data = test_x)

num_rounds <- 1000 

evalgini <- function(preds, dtrain) {
  labels <- getinfo(dtrain, "label")
  err <- NormalizedGini(as.numeric(labels),as.numeric(preds))
  return(list(metric = "Gini", value = err))
}
param <- list("objective" = "reg:linear",
              "eta" = 0.2,
              "min_child_weight" = 5,
              "subsample" = .8,
              "colsample_bytree" = .8,
              "scale_pos_weight" = 1.0,
              "max_depth" = 8)
xg.mod <- xgb.train(params = param, data = xgtrain, feval = evalgini, nround=num_rounds, print.every.n = num_rounds, maximize = TRUE)
xg.pred <- predict(xg.mod ,xgtest)

Der einfachste Weg, die num_roundsOptimierung des Parameters durchzuführen, besteht darin, XGBoost dies für Sie tun zu lassen. Sie können den early_stopping_roundsParameter nin der trainMethode auf einstellen und das Modell beendet das Training, sobald der Fehler für nRunden nicht abgenommen hat .

Siehe dieses Beispiel aus dem Liberty Mutual Kaggle-Wettbewerb :

Wie im folgenden Code angegeben, müssen Sie auch den watchlistParameter verwenden, um ein vorzeitiges Stoppen zu ermöglichen.

    # You can write R code here and then click "Run" to run it on our platform

# The readr library is the best way to read and write CSV files in R
library(readr)
library(xgboost)
library(data.table)
library(Matrix)
library(caret)

# The competition datafiles are in the directory ../input
# Read competition data files:
train <- read_csv("../input/train.csv")
test <- read_csv("../input/test.csv")

# Generate output files with write_csv(), plot() or ggplot()
# Any files you write to the current directory get shown as outputs

# keep copy of ID variables for test and train data
train_Id <- train$Id
    test_Id <- test$Id

# response variable from training data
train_y <- train$Hazard

# predictor variables from training
train_x <- subset(train, select = -c(Id, Hazard))
train_x <- sparse.model.matrix(~., data = train_x)

# predictor variables from test
test_x <- subset(test, select = -c(Id))
test_x <- sparse.model.matrix(~., data = test_x)

# Set xgboost parameters
param <- list("objective" = "reg:linear",
              "eta" = 0.05,
              "min_child_weight" = 10,
              "subsample" = .8,
              "colsample_bytree" = .8,
              "scale_pos_weight" = 1.0,
              "max_depth" = 5)

# Using 5000 rows for early stopping. 
offset <- 5000
num_rounds <- 1000

# Set xgboost test and training and validation datasets
xgtest <- xgb.DMatrix(data = test_x)
xgtrain <- xgb.DMatrix(data = train_x[offset:nrow(train_x),], label= train_y[offset:nrow(train_x)])
xgval <-  xgb.DMatrix(data = train_x[1:offset,], label= train_y[1:offset])

# setup watchlist to enable train and validation, validation must be first for early stopping
watchlist <- list(val=xgval, train=xgtrain)
# to train with watchlist, use xgb.train, which contains more advanced features

# this will use default evaluation metric = rmse which we want to minimise
bst1 <- xgb.train(params = param, data = xgtrain, nround=num_rounds, print.every.n = 20, watchlist=watchlist, early.stop.round = 50, maximize = FALSE)